Create unique named labels.

* includes/sys/sdt.h (STAP_PROBEN_): New macros that take
advantage of __COUNTER__

1 files changed, 94 insertions, 65 deletions

diff --git a/includes/sys/sdt.h b/includes/sys/sdt.h
index ef0977ea..1d41d878 100644
--- a/includes/sys/sdt.h
+++ b/includes/sys/sdt.h
@@ -33,88 +33,94 @@ static char probe ## _ ## probe_name [strlen(#probe)+1] 	\
        = #probe; 				\
 static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {STAP_SENTINEL,(size_t)& probe ## _ ## probe_name[0],argc};
 
-#define STAP_LABEL_REF(probe) \
+// The goto _probe_ prevents the label from "drifting"
+#define STAP_LABEL_REF(probe, label)				    \
   if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
-    goto STAP_LABEL(probe,__LINE__);
+    goto label;
 
+// These baroque macros are used to create a unique label
 #define STAP_CONCAT(a,b) a ## b
-#define STAP_LABEL(p,n) \
-  STAP_CONCAT(_stapprobe1_ ## p ## _, n)
+#define STAP_LABEL_PREFIX(p) _stapprobe1_ ## p
+// __COUNTER__ is not present in gcc 4.1
+#if __GNUC__ == 4 && __GNUC_MINOR__ >= 3
+#define STAP_COUNTER  STAP_CONCAT(__,COUNTER__)
+#else
+#define STAP_COUNTER  STAP_CONCAT(__,LINE__)
+#endif
+#define STAP_LABEL(a,b) STAP_CONCAT(a,b) 
 
-// The goto _probe_ prevents the label from "drifting"
-#define STAP_PROBE(provider,probe)		\
- {__label__ STAP_LABEL(probe,__LINE__);			\
-STAP_LABEL(probe,__LINE__):				\
+#define STAP_PROBE_(probe,label)		\
+do { \
+label: \
   asm volatile ("nop");				\
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe)					 \
-}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE1(provider,probe,parm1)	\
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE1_(probe,label,parm1)		\
+do { \
   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);}
+label: \
+  asm volatile ("nop /* %0 */" :: "X"( arg1)); \
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE2(provider,probe,parm1,parm2)	\
-  {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE2_(probe,label,parm1,parm2)	\
+do { \
   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);}
+label: \
+  asm volatile ("nop /* %0 %1 */" :: "X"(arg1), "X"(arg2)); \
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \
- {__label__ STAP_LABEL(probe,__LINE__);				     \
+#define STAP_PROBE3_(probe,label,parm1,parm2,parm3)	\
+do { \
   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);}
+label:					   \
+  asm volatile ("nop /* %0 %1 %2 */" :: "X"(arg1), "X"(arg2), "X"(arg3)); \
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE4_(probe,label,parm1,parm2,parm3,parm4)	\
+do { \
   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);}
+label:				\
+  asm volatile ("nop /* %0 %1 %2 %3 */" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4)); \
+  STAP_PROBE_STRUCT(probe,(size_t)&& label)	\
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
-  {__label__ STAP_LABEL(probe,__LINE__);			  \
+#define STAP_PROBE5_(probe,label,parm1,parm2,parm3,parm4,parm5)	\
+do  { \
   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__):				\
+label:				\
   asm volatile ("nop /* %0 %1 %2 %3 %4 */" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6)	\
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE6_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6)	\
+do { \
   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__):				\
+label:				\
   asm volatile ("nop" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5), "X"(arg6)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7)	\
-  {__label__ STAP_LABEL(probe,__LINE__);			   \
+#define STAP_PROBE7_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7)	\
+do  { \
   volatile typeof((parm1)) arg1  __attribute__ ((unused)) = parm1; \
   volatile typeof((parm2)) arg2  __attribute__ ((unused)) = parm2; \
   volatile typeof((parm3)) arg3  __attribute__ ((unused)) = parm3; \
@@ -122,13 +128,13 @@ STAP_LABEL(probe,__LINE__):				\
   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__):				\
+label:				\
   asm volatile ("nop" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5), "X"(arg6), "X"(arg7)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8)	\
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE8_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
+do { \
   volatile typeof((parm1)) arg1  __attribute__ ((unused)) = parm1; \
   volatile typeof((parm2)) arg2  __attribute__ ((unused)) = parm2; \
   volatile typeof((parm3)) arg3  __attribute__ ((unused)) = parm3; \
@@ -137,13 +143,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; \
-STAP_LABEL(probe,__LINE__):				\
+label:				\
   asm volatile ("nop" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5), "X"(arg6), "X"(arg7), "X"(arg8)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9)	\
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE9_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
+do { \
   volatile typeof((parm1)) arg1  __attribute__ ((unused)) = parm1; \
   volatile typeof((parm2)) arg2  __attribute__ ((unused)) = parm2; \
   volatile typeof((parm3)) arg3  __attribute__ ((unused)) = parm3; \
@@ -153,13 +159,13 @@ STAP_LABEL(probe,__LINE__):				\
   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__):				\
+label:				\
   asm volatile ("nop" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5), "X"(arg6), "X"(arg7), "X"(arg8), "X"(arg9)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
 
-#define STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
- {__label__ STAP_LABEL(probe,__LINE__);				\
+#define STAP_PROBE10_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
+do { \
   volatile typeof((parm1)) arg1  __attribute__ ((unused)) = parm1; \
   volatile typeof((parm2)) arg2  __attribute__ ((unused)) = parm2; \
   volatile typeof((parm3)) arg3  __attribute__ ((unused)) = parm3; \
@@ -170,10 +176,33 @@ STAP_LABEL(probe,__LINE__):				\
   volatile typeof((parm8)) arg8  __attribute__ ((unused)) = parm8; \
   volatile typeof((parm9)) arg9  __attribute__ ((unused)) = parm9; \
   volatile typeof((parm10)) arg10  __attribute__ ((unused)) = parm9; \
-STAP_LABEL(probe,__LINE__):				\
+label:				\
   asm volatile ("nop" :: "X"(arg1), "X"(arg2), "X"(arg3), "X"(arg4), "X"(arg5), "X"(arg6), "X"(arg7), "X"(arg8), "X"(arg9), "X"(arg10)); \
-  STAP_PROBE_STRUCT(probe,(size_t)&& STAP_LABEL(probe,__LINE__)) \
-  STAP_LABEL_REF(probe);}
+  STAP_PROBE_STRUCT(probe,(size_t)&& label) \
+  STAP_LABEL_REF(probe,label);} while (0)
+
+#define STAP_PROBE(provider,probe,...)	\
+  STAP_PROBE_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE1(provider,probe,...)	\
+  STAP_PROBE1_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE2(provider,probe,...)	\
+  STAP_PROBE2_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE3(provider,probe,...)	\
+  STAP_PROBE3_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE4(provider,probe,...)	\
+  STAP_PROBE4_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE5(provider,probe,...)	\
+  STAP_PROBE5_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE6(provider,probe,...)	\
+  STAP_PROBE6_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE7(provider,probe,...)	\
+  STAP_PROBE7_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE8(provider,probe,...)	\
+  STAP_PROBE8_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE9(provider,probe,...)	\
+  STAP_PROBE9_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
+#define STAP_PROBE10(provider,probe,...)	\
+  STAP_PROBE10_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),__VA_ARGS__)
 
 #define DTRACE_PROBE(provider,probe) \
 STAP_PROBE(provider,probe)