From 4f81fb96fac15c8775b496f3665adcf3e8d43480 Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Mon, 26 Jan 2009 13:12:54 +0100 Subject: sdt.h: DTRACE_PROBE5 is STAP_PROBE5, not 4, likewise for 6. --- runtime/sdt.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 9fe7b176..6db23288 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -158,6 +158,6 @@ STAP_PROBE3(provider,probe,parm1,parm2,parm3) #define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) #define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4,parm5) +STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) #define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ -STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) +STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) -- cgit From f46d1b8ad2ff5e1f2355b2aefe2fe7a6ab54823c Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Mon, 26 Jan 2009 16:11:41 -0500 Subject: Fix syscall.exp. --- runtime/sdt.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 6db23288..88183461 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -32,7 +32,7 @@ static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section #define STAP_CONCAT(a,b) a ## b #define STAP_LABEL(p,n) \ - STAP_CONCAT(_probe_ ## p ## _, n) + STAP_CONCAT(_stapprobe1_ ## p ## _, n) // The goto _probe_ prevents the label from "drifting" #ifdef USE_STAP_PROBE -- cgit From 398a7882b05bded7f1d1116d4c06fe25aa7f5fea Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Tue, 27 Jan 2009 17:39:44 +0100 Subject: sdt.h (struct _probe_): Make probe_name a STAP_PROBE_STRUCT_ARG. --- runtime/sdt.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 88183461..2db2e3a0 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -22,13 +22,13 @@ struct _probe_ ## probe \ { \ int probe_type; \ - char *probe_name; \ + STAP_PROBE_STRUCT_ARG (probe_name); \ STAP_PROBE_STRUCT_ARG (probe_arg); \ }; \ -static char probe_name [strlen(#probe)+1] \ +static char probe ## _ ## probe_name [strlen(#probe)+1] \ __attribute__ ((section (".probes"))) \ = #probe; \ -static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,&probe_name[0],argc}; + static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(long)& probe ## _ ## probe_name[0],argc}; #define STAP_CONCAT(a,b) a ## b #define STAP_LABEL(p,n) \ -- cgit From ef91bdb61d3810da78a1730fc377f38a129998d6 Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Tue, 27 Jan 2009 17:42:48 +0100 Subject: sdt.h (STAP_PROBE): Use "g", not "r", for asm args. --- runtime/sdt.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 2db2e3a0..b36c6973 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -56,7 +56,7 @@ STAP_LABEL(probe,__LINE__): \ #define STAP_PROBE1(provider,probe,parm1) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1)); \ + asm volatile ("nop" :: "g"(arg1)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} @@ -71,7 +71,7 @@ STAP_LABEL(probe,__LINE__): \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1), "r"(arg2)); \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} @@ -87,7 +87,7 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1), "r"(arg2), "r"(arg3)); \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} @@ -104,7 +104,7 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1), "r"(arg2), "r"(arg3), "r"(arg4)); \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} @@ -122,7 +122,7 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1), "r"(arg2), "r"(arg3), "r"(arg4), "r"(arg5)); \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} @@ -141,7 +141,7 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "r"(arg1), "r"(arg2), "r"(arg3), "r"(arg4), "r"(arg5), "r"(arg6)); \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ goto STAP_LABEL(probe,__LINE__);} -- cgit From 0f336e95987931dd9fd35de02deee0ce682b987a Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Sun, 1 Feb 2009 21:22:21 -0500 Subject: Add .label("label") --- runtime/sdt.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index b36c6973..359ce4da 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -28,7 +28,7 @@ struct _probe_ ## probe \ static char probe ## _ ## probe_name [strlen(#probe)+1] \ __attribute__ ((section (".probes"))) \ = #probe; \ - static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(long)& probe ## _ ## probe_name[0],argc}; +static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(size_t)& probe ## _ ## probe_name[0],argc}; #define STAP_CONCAT(a,b) a ## b #define STAP_LABEL(p,n) \ -- cgit From 3d65f39002440cfdeeac94d7a7a6c9a7aead2e54 Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Mon, 2 Feb 2009 13:52:14 +0100 Subject: Add STAP_PROBE7, 8 and 9 variants to sdt.h. --- runtime/sdt.h | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 3 deletions(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 359ce4da..905074ad 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -134,7 +134,7 @@ STAP_LABEL(probe,__LINE__): \ _stap_probe_6 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6); #else #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ + {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ @@ -147,6 +147,69 @@ STAP_LABEL(probe,__LINE__): \ goto STAP_LABEL(probe,__LINE__);} #endif +#ifdef USE_STAP_PROBE +#define STAP_PROBE7(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7) \ + STAP_PROBE_STRUCT(probe,0,7) \ + _stap_probe_7 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7); +#else +#define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ + {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ + volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ + volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ + volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ + volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ + volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ + volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ +STAP_LABEL(probe,__LINE__): \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7)); \ + STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto STAP_LABEL(probe,__LINE__);} +#endif + +#ifdef USE_STAP_PROBE +#define STAP_PROBE8(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) \ + STAP_PROBE_STRUCT(probe,0,8) \ + _stap_probe_8 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7,(size_t)arg8); +#else +#define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ + {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ + volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ + volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ + volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ + volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ + volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ + volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ + volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ +STAP_LABEL(probe,__LINE__): \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8)); \ + STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto STAP_LABEL(probe,__LINE__);} +#endif + +#ifdef USE_STAP_PROBE +#define STAP_PROBE9(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) \ + STAP_PROBE_STRUCT(probe,0,9) \ + _stap_probe_9 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7,(size_t)arg8,(size_t)arg9); +#else +#define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ + {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ + volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ + volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ + volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ + volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ + volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ + volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ + volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ + volatile typeof((parm9)) arg9 __attribute__ ((unused)) = parm9; \ +STAP_LABEL(probe,__LINE__): \ + asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9)); \ + STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto STAP_LABEL(probe,__LINE__);} +#endif + #define DTRACE_PROBE(provider,probe) \ STAP_PROBE(provider,probe) #define DTRACE_PROBE1(provider,probe,parm1) \ @@ -157,7 +220,13 @@ STAP_PROBE2(provider,probe,parm1,parm2) STAP_PROBE3(provider,probe,parm1,parm2,parm3) #define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) -#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ +#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ +#define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) +#define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ +STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) +#define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ +STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) +#define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ +STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) -- cgit From 7b534f489ed3567d8a59e00eb4ba954697a97059 Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Sun, 15 Feb 2009 22:23:54 -0500 Subject: Handle c++ static user probes via .probe, c via .label. --- runtime/sdt.h | 146 +++++++++++++++++++--------------------------------------- 1 file changed, 47 insertions(+), 99 deletions(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 905074ad..f09d4346 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -18,7 +18,9 @@ #define STAP_SENTINEL 0x31425250 -#define STAP_PROBE_STRUCT(probe,type,argc) \ +// g++ 4.3.2 doesn't emit DW_TAG_label +#ifdef __cplusplus +#define STAP_PROBE_STRUCT(probe,argc) \ struct _probe_ ## probe \ { \ int probe_type; \ @@ -29,92 +31,68 @@ static char probe ## _ ## probe_name [strlen(#probe)+1] \ __attribute__ ((section (".probes"))) \ = #probe; \ static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(size_t)& probe ## _ ## probe_name[0],argc}; +#else +#define STAP_PROBE_STRUCT(probe,argc) +#endif + +#ifdef __cplusplus +#define STAP_LABEL_REF(probe) \ + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto STAP_LABEL(probe,__LINE__); +#else +#define STAP_LABEL_REF(probe) \ + volatile static int sentinel_ ## probe = 0; \ + if (__builtin_expect(sentinel_ ## probe < 0, 0)) \ + goto STAP_LABEL(probe,__LINE__); +#endif #define STAP_CONCAT(a,b) a ## b #define STAP_LABEL(p,n) \ STAP_CONCAT(_stapprobe1_ ## p ## _, n) // The goto _probe_ prevents the label from "drifting" -#ifdef USE_STAP_PROBE -#define STAP_PROBE(provider,probe) \ - STAP_PROBE_STRUCT(probe,0,0) \ - _stap_probe_0 (_probe_ ## probe.probe_name); -#else #define STAP_PROBE(provider,probe) \ -STAP_LABEL(probe,__LINE__): \ + { \ +STAP_LABEL(probe,__LINE__): \ asm volatile ("nop"); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__); -#endif + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe) \ +} -#ifdef USE_STAP_PROBE -#define STAP_PROBE1(provider,probe,arg1) \ - STAP_PROBE_STRUCT(probe,0,1) \ - _stap_probe_1 (_probe_ ## probe.probe_name,(size_t)arg1); -#else #define STAP_PROBE1(provider,probe,parm1) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + asm volatile ("nop /* %0 */" :: "g"( arg1)); \ + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE2(provider,probe,arg1,arg2) \ - STAP_PROBE_STRUCT(probe,0,2) \ - _stap_probe_2 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2); -#else #define STAP_PROBE2(provider,probe,parm1,parm2) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + asm volatile ("nop /* %0 %1 */" :: "g"(arg1), "g"(arg2)); \ + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE3(provider,probe,arg1,arg2,arg3) \ - STAP_PROBE_STRUCT(probe,0,3) \ - _stap_probe_3 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3); -#else #define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + asm volatile ("nop /* %0 %1 %2 */" :: "g"(arg1), "g"(arg2), "g"(arg3)); \ + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE4(provider,probe,arg1,arg2,arg3,arg4) \ - STAP_PROBE_STRUCT(probe,0,4) \ - _stap_probe_4 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4); -#else #define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + asm volatile ("nop /* %0 %1 %2 %3 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4)); \ + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE5(provider,probe,arg1,arg2,arg3,arg4,arg5) \ - STAP_PROBE_STRUCT(probe,0,5) \ - _stap_probe_5 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5); -#else #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ @@ -122,17 +100,10 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + asm volatile ("nop /* %0 %1 %2 %3 %4 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5)); \ + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE6(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6) \ - STAP_PROBE_STRUCT(probe,0,6) \ - _stap_probe_6 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6); -#else #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ @@ -142,16 +113,9 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ STAP_LABEL(probe,__LINE__): \ asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE7(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7) \ - STAP_PROBE_STRUCT(probe,0,7) \ - _stap_probe_7 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7); -#else #define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ @@ -162,16 +126,9 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ STAP_LABEL(probe,__LINE__): \ asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE8(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) \ - STAP_PROBE_STRUCT(probe,0,8) \ - _stap_probe_8 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7,(size_t)arg8); -#else #define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ @@ -183,16 +140,9 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ STAP_LABEL(probe,__LINE__): \ asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#ifdef USE_STAP_PROBE -#define STAP_PROBE9(provider,probe,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) \ - STAP_PROBE_STRUCT(probe,0,9) \ - _stap_probe_9 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5,(size_t)arg6,(size_t)arg7,(size_t)arg8,(size_t)arg9); -#else #define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ @@ -202,15 +152,13 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ - volatile typeof((parm9)) arg9 __attribute__ ((unused)) = parm9; \ + volatile typeof((parm9)) arg9 __attribute__ ((unused() = parm9; \ STAP_LABEL(probe,__LINE__): \ asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9)); \ - STAP_PROBE_STRUCT(probe,1,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__);} -#endif + STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ + STAP_LABEL_REF(probe);} -#define DTRACE_PROBE(provider,probe) \ +#define DTRACE_PROBE(__LINE__) \ STAP_PROBE(provider,probe) #define DTRACE_PROBE1(provider,probe,parm1) \ STAP_PROBE1(provider,probe,parm1) -- cgit From c21c8f1bde29655ff85541507692982a1ffb09bd Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Mon, 16 Feb 2009 11:55:02 +0100 Subject: Fix )( typo in sdt.h STAP_PROBE9 parm9. --- runtime/sdt.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index f09d4346..98a583dc 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -152,7 +152,7 @@ STAP_LABEL(probe,__LINE__): \ volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ - volatile typeof((parm9)) arg9 __attribute__ ((unused() = parm9; \ + volatile typeof((parm9)) arg9 __attribute__ ((unused)) = parm9; \ STAP_LABEL(probe,__LINE__): \ asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9)); \ STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ -- cgit From f5438dfc723aa0a8175efb03fe7096d393e86ee9 Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Mon, 16 Feb 2009 15:10:50 +0100 Subject: sdt.h (STAP_PROBE): Take provider and probe as arguments. --- runtime/sdt.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h index 98a583dc..2480d034 100644 --- a/runtime/sdt.h +++ b/runtime/sdt.h @@ -158,7 +158,7 @@ STAP_LABEL(probe,__LINE__): \ STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ STAP_LABEL_REF(probe);} -#define DTRACE_PROBE(__LINE__) \ +#define DTRACE_PROBE(provider,probe) \ STAP_PROBE(provider,probe) #define DTRACE_PROBE1(provider,probe,parm1) \ STAP_PROBE1(provider,probe,parm1) -- cgit From 818ba2bc05fc60bf33179e2be44c6745eb181a01 Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Tue, 17 Feb 2009 16:49:12 +0100 Subject: Move sdt.h to includes/sys and use in tests. --- runtime/sdt.h | 180 ---------------------------------------------------------- 1 file changed, 180 deletions(-) delete mode 100644 runtime/sdt.h (limited to 'runtime/sdt.h') diff --git a/runtime/sdt.h b/runtime/sdt.h deleted file mode 100644 index 2480d034..00000000 --- a/runtime/sdt.h +++ /dev/null @@ -1,180 +0,0 @@ -// Copyright (C) 2005-2009 Red Hat Inc. -// Copyright (C) 2006 Intel Corporation. -// -// This file is part of systemtap, and is free software. You can -// redistribute it and/or modify it under the terms of the GNU General -// Public License (GPL); either version 2, or (at your option) any -// later version. - -#include - -#if _LP64 -#define STAP_PROBE_STRUCT_ARG(arg) \ - __uint64_t arg; -#else -#define STAP_PROBE_STRUCT_ARG(arg) \ - long arg __attribute__ ((aligned(8))); -#endif - -#define STAP_SENTINEL 0x31425250 - -// g++ 4.3.2 doesn't emit DW_TAG_label -#ifdef __cplusplus -#define STAP_PROBE_STRUCT(probe,argc) \ -struct _probe_ ## probe \ -{ \ - int probe_type; \ - STAP_PROBE_STRUCT_ARG (probe_name); \ - STAP_PROBE_STRUCT_ARG (probe_arg); \ -}; \ -static char probe ## _ ## probe_name [strlen(#probe)+1] \ - __attribute__ ((section (".probes"))) \ - = #probe; \ -static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(size_t)& probe ## _ ## probe_name[0],argc}; -#else -#define STAP_PROBE_STRUCT(probe,argc) -#endif - -#ifdef __cplusplus -#define STAP_LABEL_REF(probe) \ - if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__); -#else -#define STAP_LABEL_REF(probe) \ - volatile static int sentinel_ ## probe = 0; \ - if (__builtin_expect(sentinel_ ## probe < 0, 0)) \ - goto STAP_LABEL(probe,__LINE__); -#endif - -#define STAP_CONCAT(a,b) a ## b -#define STAP_LABEL(p,n) \ - STAP_CONCAT(_stapprobe1_ ## p ## _, n) - -// The goto _probe_ prevents the label from "drifting" -#define STAP_PROBE(provider,probe) \ - { \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop"); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe) \ -} - -#define STAP_PROBE1(provider,probe,parm1) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop /* %0 */" :: "g"( arg1)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE2(provider,probe,parm1,parm2) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop /* %0 %1 */" :: "g"(arg1), "g"(arg2)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop /* %0 %1 %2 */" :: "g"(arg1), "g"(arg2), "g"(arg3)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop /* %0 %1 %2 %3 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ - volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop /* %0 %1 %2 %3 %4 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ - volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ - volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ - volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ - volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ - volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ - volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ - volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ - volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ - volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ - {volatile typeof((parm1)) arg1 __attribute__ ((unused)) = parm1; \ - volatile typeof((parm2)) arg2 __attribute__ ((unused)) = parm2; \ - volatile typeof((parm3)) arg3 __attribute__ ((unused)) = parm3; \ - volatile typeof((parm4)) arg4 __attribute__ ((unused)) = parm4; \ - volatile typeof((parm5)) arg5 __attribute__ ((unused)) = parm5; \ - volatile typeof((parm6)) arg6 __attribute__ ((unused)) = parm6; \ - volatile typeof((parm7)) arg7 __attribute__ ((unused)) = parm7; \ - volatile typeof((parm8)) arg8 __attribute__ ((unused)) = parm8; \ - volatile typeof((parm9)) arg9 __attribute__ ((unused)) = parm9; \ -STAP_LABEL(probe,__LINE__): \ - asm volatile ("nop" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9)); \ - STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \ - STAP_LABEL_REF(probe);} - -#define DTRACE_PROBE(provider,probe) \ -STAP_PROBE(provider,probe) -#define DTRACE_PROBE1(provider,probe,parm1) \ -STAP_PROBE1(provider,probe,parm1) -#define DTRACE_PROBE2(provider,probe,parm1,parm2) \ -STAP_PROBE2(provider,probe,parm1,parm2) -#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \ -STAP_PROBE3(provider,probe,parm1,parm2,parm3) -#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ -STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) -#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ -STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) -#define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ -STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) -#define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ -STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) -#define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ -STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) -- cgit