Convert .mark to .statement(0x) instead of .statement(foo.c:N)

1 files changed, 55 insertions, 64 deletions

diff --git a/runtime/sduprobes.h b/runtime/sduprobes.h
index b91dea93..efa25be7 100644
--- a/runtime/sduprobes.h
+++ b/runtime/sduprobes.h
@@ -9,23 +9,23 @@
 #include <string.h>
 
 #if _LP64
-#define STAP_PROBE_STRUCT_ARG			\
-  __uint64_t probe_arg;
+#define STAP_PROBE_STRUCT_ARG(arg)		\
+  __uint64_t arg;
 #else
-#define STAP_PROBE_STRUCT_ARG			\
-  long probe_arg __attribute__ ((aligned(8)));		 
+#define STAP_PROBE_STRUCT_ARG(arg)		\
+  long arg __attribute__ ((aligned(8)));		 
 #endif
 
 #define STAP_PROBE_STRUCT(probe,type,argc)	\
 struct _probe_ ## probe				\
 {						\
   char probe_name [strlen(#probe)+1];		\
-  int  probe_type;				\
-  STAP_PROBE_STRUCT_ARG				\
+  int probe_type;		\
+  STAP_PROBE_STRUCT_ARG	(probe_arg);		\
 };						\
  static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {#probe,type,argc};
 
-#ifndef USE_STAP_DEBUGINFO_PROBE
+#ifdef USE_STAP_PROBE
 #define STAP_PROBE(provider,probe)		\
   STAP_PROBE_STRUCT(probe,0,0)			\
   _stap_probe_0 (_probe_ ## probe.probe_name);
@@ -34,108 +34,99 @@ struct _probe_ ## probe				\
 _probe_ ## probe:				\
   asm volatile ("nop");				\
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
 
-#ifndef USE_STAP_DEBUGINFO_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) probe ## _arg1 = parm1; \
 _probe_ ## probe:				\
-  asm volatile ("nop");				\
-  volatile typeof(parm1) arg1 = parm1;		\
+   asm volatile ("nop" :: "r"(probe ## _arg1)); \
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
-  asm volatile ("# %0" :: "r"(arg1));		\
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
 
-#ifndef USE_STAP_DEBUGINFO_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) probe ## _arg1 = parm1; \
+  volatile typeof(parm2) probe ## _arg2 = parm2; \
 _probe_ ## probe:				\
-  asm volatile ("nop");				\
-  volatile typeof(parm1) arg1 = parm1;		\
-  volatile typeof(parm2) arg2 = parm2;		\
+  asm volatile ("nop" :: "r"(probe ## _arg1), "r"(probe ## _arg2)); \
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe)\
-  asm volatile ("# %0" :: "r"(arg1));		\
-  asm volatile ("# %0" :: "r"(arg2));		\
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
-#ifndef USE_STAP_DEBUGINFO_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) probe ## _arg1 = parm1; \
+  volatile typeof(parm2) probe ## _arg2 = parm2; \
+  volatile typeof(parm3) probe ## _arg3 = parm3; \
 _probe_ ## probe:				\
-  asm volatile ("nop");				\
-  volatile typeof(parm1) arg1 = parm1;		\
-  volatile typeof(parm2) arg2 = parm2;		\
-  volatile typeof(parm3) arg3 = parm3;		\
+  asm volatile ("nop" :: "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3)); \
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
-  asm volatile ("# %0" :: "r"(arg1));		\
-  asm volatile ("# %0" :: "r"(arg2));		\
-  asm volatile ("# %0" :: "r"(arg3));		\
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
-#ifndef USE_STAP_DEBUGINFO_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) \
+#define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
+  volatile typeof(parm1) probe ## _arg1 = parm1; \
+  volatile typeof(parm2) probe ## _arg2 = parm2; \
+  volatile typeof(parm3) probe ## _arg3 = parm3; \
+  volatile typeof(parm4) probe ## _arg4 = parm4; \
 _probe_ ## probe:				\
-  asm volatile ("nop");				\
-  volatile typeof(parm1) arg1 = parm1;		\
-  volatile typeof(parm2) arg2 = parm2;		\
-  volatile typeof(parm3) arg3 = parm3;		\
-  volatile typeof(parm4) arg4 = parm4;		\
+  asm volatile ("nop" "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3), "r"(probe ## _arg4));		\
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
-  asm volatile ("# %0" :: "r"(arg1));		\
-  asm volatile ("# %0" :: "r"(arg2));		\
-  asm volatile ("# %0" :: "r"(arg3));		\
-  asm volatile ("# %0" :: "r"(arg4));		\
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
-#ifndef USE_STAP_DEBUGINFO_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) probe ## _arg1 = parm1; \
+  volatile typeof(parm2) probe ## _arg2 = parm2; \
+  volatile typeof(parm3) probe ## _arg3 = parm3; \
+  volatile typeof(parm4) probe ## _arg4 = parm4; \
+  volatile typeof(parm5) probe ## _arg5 = parm5; \
 _probe_ ## probe:				\
-  asm volatile ("nop");				\
-  volatile typeof(parm1) arg1 = parm1;		\
-  volatile typeof(parm2) arg2 = parm2;		\
-  volatile typeof(parm3) arg3 = parm3;		\
-  volatile typeof(parm4) arg4 = parm4;		\
-  volatile typeof(parm5) arg5 = parm5;		\
+  asm volatile ("nop" "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3), "r"(probe ## _arg4), "r"(probe ## _arg5)); \
   STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
-  asm volatile ("# %0" :: "r"(arg1));		\
-  asm volatile ("# %0" :: "r"(arg2));		\
-  asm volatile ("# %0" :: "r"(arg3));		\
-  asm volatile ("# %0" :: "r"(arg4));		\
-  asm volatile ("# %0" :: "r"(arg5));		\
-  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+  if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \
+     goto _probe_ ## probe;
 #endif
 
-#define DTRACE_PROBE1(provider,probe,parm1,parm2,parm3,parm4,parm5) \
-STAP_PROBE1(provider,probe,parm1,parm2,parm3,parm4,parm5)
-#define DTRACE_PROBE2(provider,probe,parm1,parm2,parm3,parm4,parm5) \
-STAP_PROBE2(provider,probe,parm1,parm2,parm3,parm4,parm5) 
-#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3,parm4,parm5) \
-STAP_PROBE3(provider,probe,parm1,parm2,parm3,parm4,parm5) 
-#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4,parm5) \
-STAP_PROBE4(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_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)