Support debuginfo static uprobes.

2 files changed, 119 insertions, 29 deletions

diff --git a/runtime/ChangeLog b/runtime/ChangeLog
index 93ee18d2..51d8d933 100644
--- a/runtime/ChangeLog
+++ b/runtime/ChangeLog
@@ -1,3 +1,7 @@
+2008-11-26  Stan Cox  <scox@redhat.com>
+
+	* sduprobes.h (STAP_PROBE1): Add USE_STAP_DEBUGINFO_PROBE.
+
 2008-11-26  Frank Ch. Eigler  <fche@elastic.org>
 
 	PR 4886.
diff --git a/runtime/sduprobes.h b/runtime/sduprobes.h
index b2c32e43..934f19e0 100644
--- a/runtime/sduprobes.h
+++ b/runtime/sduprobes.h
@@ -6,51 +6,137 @@
 // Public License (GPL); either version 2, or (at your option) any
 // later version.
 
-#include <stdlib.h>
 #include <string.h>
 extern int _stap_probe_sentinel;
 
-#define STAP_PROBE_START()		      \
-  char *stap_sdt = getenv("SYSTEMTAP_SDT"); \
-  if (stap_sdt != NULL)		\
+#define STAP_PROBE_START()			\
+  char *stap_sdt = getenv("SYSTEMTAP_SDT");	\
+  if (stap_sdt != NULL)				\
      _stap_probe_start ()
 
-#define STAP_PROBE_STRUCT(probe,argc) \
-struct _probe_ ## probe  \
-{				 \
-  char probe_name [strlen(#probe)+1]; \
-  int arg_count;		 \
-}; \
-static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {#probe,argc};
 
-#define STAP_PROBE(provider,probe) \
-STAP_PROBE_STRUCT(probe,0)	   \
-  if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_0 (_probe_ ## probe.probe_name);
+#if _LP64
+#define STAP_PROBE_STRUCT_ARG			\
+  __uint64_t probe_arg;
+#else
+#define STAP_PROBE_STRUCT_ARG			\
+  long probe_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				\
+};						\
+ static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {#probe,type,argc};
+
+#ifndef USE_STAP_DEBUGINFO_PROBE
+#define STAP_PROBE(provider,probe)		\
+  STAP_PROBE_STRUCT(probe,0,0)			\
+  if (__builtin_expect(_stap_probe_sentinel, 0))\
+     _stap_probe_0 (_probe_ ## probe.probe_name);
+#else
+#define STAP_PROBE(provider,probe)		\
+_probe_ ## probe:				\
+  asm volatile ("nop");				\
+  STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe)
+#endif
 
-#define STAP_PROBE1(provider,probe,arg1) \
-STAP_PROBE_STRUCT(probe,1)	   \
-  if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_1 (_probe_ ## probe.probe_name,(size_t)arg1);
 
+#ifndef USE_STAP_DEBUGINFO_PROBE
+#define STAP_PROBE1(provider,probe,arg1)	\
+  STAP_PROBE_STRUCT(probe,0,1)			\
+  if (__builtin_expect(_stap_probe_sentinel, 0))\
+     _stap_probe_1 (_probe_ ## probe.probe_name,(size_t)arg1);
+#else
+#define STAP_PROBE1(provider,probe,parm1)	\
+_probe_ ## probe:				\
+  asm volatile ("nop");				\
+  volatile typeof(parm1) arg1 = parm1;		\
+  STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
+  asm volatile ("# %0" :: "r"(arg1));		\
+  asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
+#endif
 
-#define STAP_PROBE2(provider,probe,arg1,arg2) \
-STAP_PROBE_STRUCT(probe,2)	   \
+
+#ifndef USE_STAP_DEBUGINFO_PROBE
+#define STAP_PROBE2(provider,probe,arg1,arg2)	\
+  STAP_PROBE_STRUCT(probe,0,2)			\
   if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_2 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2);
+     _stap_probe_2 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2);
+#else
+#define STAP_PROBE2(provider,probe,parm1,parm2)	\
+_probe_ ## probe:				\
+  asm volatile ("nop");				\
+  volatile typeof(parm1) arg1 = parm1;		\
+  volatile typeof(parm2) arg2 = parm2;		\
+  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)));
+#endif
 
+#ifndef USE_STAP_DEBUGINFO_PROBE
 #define STAP_PROBE3(provider,probe,arg1,arg2,arg3) \
-STAP_PROBE_STRUCT(probe,3)	   \
+  STAP_PROBE_STRUCT(probe,0,3)			\
   if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_3 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3);
+     _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) \
+_probe_ ## probe:				\
+  asm volatile ("nop");				\
+  volatile typeof(parm1) arg1 = parm1;		\
+  volatile typeof(parm2) arg2 = parm2;		\
+  volatile typeof(parm3) arg3 = parm3;		\
+  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)));
+#endif
 
+#ifndef USE_STAP_DEBUGINFO_PROBE
 #define STAP_PROBE4(provider,probe,arg1,arg2,arg3,arg4)	\
-STAP_PROBE_STRUCT(probe,4)	   \
+  STAP_PROBE_STRUCT(probe,0,4)			\
   if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_4 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4);
+     _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) \
+_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;		\
+  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)));
+#endif
 
+#ifndef USE_STAP_DEBUGINFO_PROBE
 #define STAP_PROBE5(provider,probe,arg1,arg2,arg3,arg4,arg5)	\
-STAP_PROBE_STRUCT(probe,5)	   \
-  if (__builtin_expect(_stap_probe_sentinel, 0)) \
-    _stap_probe_5 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5);
+  STAP_PROBE_STRUCT(probe,0,5)			\
+  if (__builtin_expect(_stap_probe_sentinel, 0))\
+     _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) \
+_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;		\
+  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)));
+#endif