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

7 files changed, 154 insertions, 113 deletions

diff --git a/ChangeLog b/ChangeLog
index 9a852834..6eba60bb 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2008-12-16  Stan Cox  <scox@redhat.com>
+
+	* tapsets.cxx (dwarf_builder::build): Consider alignment when
+	fetching .probes values.  Convert .mark to .statement(0x) instead
+	of .statement(foo.c:N)
+
 2008-12-11  Dave Brolley  <brolley@redhat.com>
 
 	PR7087
diff --git a/runtime/ChangeLog b/runtime/ChangeLog
index 3f88bae2..7026b276 100644
--- a/runtime/ChangeLog
+++ b/runtime/ChangeLog
@@ -1,3 +1,7 @@
+2008-12-16  Stan Cox  <scox@redhat.com>
+
+	* sduprobes.h (STAP_PROBE): Add synthetic reference to probe label.
+
 2008-12-09  Frank Ch. Eigler  <fche@elastic.org>
 
 	* time.c (_stp_gettimeofday_ns): Protect some more against freq=0.
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) 
diff --git a/tapsets.cxx b/tapsets.cxx
index 4d9a021d..0efaf455 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -3856,7 +3856,8 @@ query_cu (Dwarf_Die * cudie, void * arg)
           // Verify that a raw address matches the beginning of a
           // statement. This is a somewhat lame check that the address
           // is at the start of an assembly instruction.
-          if (q->has_statement_num)
+	  // Avoid for now since this thwarts a probe on a statement in a macro
+          if (0 && q->has_statement_num)
             {
               Dwarf_Addr queryaddr = q->statement_num_val;
               dwarf_line_t address_line(dwarf_getsrc_die(cudie, queryaddr));
@@ -5297,14 +5298,14 @@ dwarf_builder::build(systemtap_session & sess,
     location->components[0]->arg = new literal_string(sess.cmd);
     ((literal_map_t&)parameters)[location->components[0]->functor] = location->components[0]->arg;
     Dwarf_Addr bias;
-    Elf* elf = (dwarf_getelf (dwfl_module_getdwarf (dw->module, &bias))
-		?: dwfl_module_getelf (dw->module, &bias));
+    Elf* elf = dwfl_module_getelf (dw->module, &bias);
     size_t shstrndx;
 
     Elf_Scn *probe_scn = NULL;
     dwfl_assert ("getshstrndx", elf_getshstrndx (elf, &shstrndx));
     __uint64_t probe_arg = 0;
     int probe_type = no_debuginfo;
+    char *probe_name;
     // Find the .probes section where the static probe label and arg are stored
     while ((probe_scn = elf_nextscn (elf, probe_scn)))
       {
@@ -5314,23 +5315,24 @@ dwarf_builder::build(systemtap_session & sess,
 
 	if (strcmp (elf_strptr (elf, shstrndx, shdr->sh_name), ".probes") != 0)
 	  continue;
-	Elf_Data *pdata = elf_getdata (probe_scn, NULL);
+	Elf_Data *pdata = elf_getdata_rawchunk (elf, shdr->sh_offset, shdr->sh_size, ELF_T_BYTE);
 	assert (pdata != NULL);
 	size_t probe_scn_offset = 0;
 	while (probe_scn_offset < pdata->d_size)
 	  {
-	    char *probe_name = (char*)pdata->d_buf + probe_scn_offset;
-	    probe_scn_offset += strlen(probe_name);
-	    probe_scn_offset += sizeof(int) - (probe_scn_offset % sizeof(int));
-	    probe_type = *(((char*)pdata->d_buf + probe_scn_offset));
+	    probe_name = (char*)pdata->d_buf + probe_scn_offset;
+	    probe_scn_offset += strlen(probe_name) + 1;
+	    if (probe_scn_offset % (sizeof(int)))
+	      probe_scn_offset += sizeof(int) - (probe_scn_offset % sizeof(int));
+	    probe_type = *((int*)((char*)pdata->d_buf + probe_scn_offset));
 	    probe_scn_offset += sizeof(int);
-	    probe_arg = *((__uint32_t*)((char*)pdata->d_buf + probe_scn_offset));
-	    probe_arg <<= 32;
-	    probe_arg |= *((__uint32_t*)((char*)pdata->d_buf + probe_scn_offset + 4));
+	    if (probe_scn_offset % (sizeof(__uint64_t)))
+	      probe_scn_offset += sizeof(__uint64_t) - (probe_scn_offset % sizeof(__uint64_t));
+	    probe_arg = *((__uint64_t*)((char*)pdata->d_buf + probe_scn_offset));
 	    if (strcmp (location->components[1]->arg->tok->content.c_str(), probe_name) == 0)
 	      break;
-	    probe_scn_offset += sizeof(__uint64_t);
-	    probe_scn_offset += sizeof(__uint64_t)*2 - (probe_scn_offset % (sizeof(__uint64_t)*2));
+	    if (probe_scn_offset % (sizeof(__uint64_t)*2))
+	      probe_scn_offset = (probe_scn_offset + sizeof(__uint64_t)*2) - (probe_scn_offset % (sizeof(__uint64_t)*2));
 	  }
       }
 
@@ -5378,7 +5380,6 @@ dwarf_builder::build(systemtap_session & sess,
     size_t cuhl;
     Dwarf_Off noff = 0;
     const char *probe_file = "@sduprobes.c";
-    int probe_line;
     // Find where the probe instrumentation landing points are defined
     while (dwarf_nextcu (dwarf, off = noff, &noff, &cuhl, NULL, NULL, NULL) == 0)
       {
@@ -5386,6 +5387,8 @@ dwarf_builder::build(systemtap_session & sess,
 	Dwarf_Die *cudie = dwarf_offdie (dwarf, off + cuhl, &cudie_mem);
 	if (cudie == NULL)
 	  continue;
+	if (0)
+	  printf("2 diename=%s module_name=%s probe_type=%d probe_arg=%#Lx\n",dwarf_diename(&cudie_mem),module_name.c_str(), (int)probe_type, (long long)probe_arg);
 	if (probe_type == no_debuginfo)
 	  {
 	    if (strncmp (dwarf_diename(&cudie_mem), "sduprobes", 9) == 0)
@@ -5393,15 +5396,6 @@ dwarf_builder::build(systemtap_session & sess,
 		break;
 	      }
 	  }
-	else
-	  {
-	    Dwarf_Line *dwarf_line = dwarf_getsrc_die (cudie, probe_arg);
-	    if (dwarf_line == NULL)
-	      continue;
-	    dwarf_lineno (dwarf_line, &probe_line);
-	    probe_file = (dwarf_diename(&cudie_mem) ?: "<unknown>");
-	    break;
-	  }
       }
     location->components[1]->functor = TOK_STATEMENT;
     if (probe_type == no_debuginfo)
@@ -5414,11 +5408,9 @@ dwarf_builder::build(systemtap_session & sess,
       }
     else
       {
-	char *pline;
-	if (asprintf (&pline, "*@%s:%d", probe_file, probe_line + 1) < 0)
-	  return;
-	location->components[1]->arg = new literal_string(pline);
+	location->components[1]->arg = new literal_number((int)probe_arg);
       }
+
     ((literal_map_t&)parameters)[TOK_STATEMENT] = location->components[1]->arg;
     dw->module = 0;
   }
diff --git a/testsuite/ChangeLog b/testsuite/ChangeLog
index 8e174efc..dc91a215 100644
--- a/testsuite/ChangeLog
+++ b/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2008-12-16  Stan Cox  <scox@redhat.com>
+
+	* systemtap.base/static_uprobes.exp: Generate our own probes file.
+
 2008-12-09  Frank Ch. Eigler  <fche@elastic.org>
 
 	PR6961.
diff --git a/testsuite/systemtap.base/static_uprobes.exp b/testsuite/systemtap.base/static_uprobes.exp
index 78641d3f..f3f26d8a 100644
--- a/testsuite/systemtap.base/static_uprobes.exp
+++ b/testsuite/systemtap.base/static_uprobes.exp
@@ -8,6 +8,7 @@ set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags=
 set fp [open $sup_srcpath "w"]
 puts $fp "
 #include <stdlib.h>
+#define USE_STAP_PROBE 1
 #include \"sduprobes.h\"
 
 foo ()
@@ -24,12 +25,13 @@ bar (int i)
 
 baz (int i, char* s)
 {
+  STAP_PROBE1(tstlabel,label0,i);
   if (i == 0)
     i = 1000;
   STAP_PROBE2(tstlabel,label3,i,s);
 }
 
-buz ()
+buz (int parm)
 {
 }
 
@@ -39,6 +41,7 @@ main ()
   foo();
   bar(2);
   baz(3,\"abc\");
+  buz(4);
 }
 "
 close $fp
@@ -52,33 +55,85 @@ if { $res != "" } {
     pass "compiling static_uprobes.c"
 }
 
+set fp [open "[pwd]/static_uprobes.stp" "w"]
+puts $fp "
+probe process(\"static_uprobes.x\").mark(\"label0\") 
+{ 
+  printf(\"In label0 probe %#x\\n\", \$arg1)
+}
+probe process(\"static_uprobes.x\").mark(\"label1\") 
+{ 
+  printf(\"In label1 probe\\n\")
+}
+probe process(\"static_uprobes.x\").mark(\"label2\") 
+{ 
+  printf(\"In label2 probe %#x\\n\", \$arg1)
+}
+probe process(\"static_uprobes.x\").mark(\"label3\") 
+{ 
+  printf(\"In label3 probe %#x %#x\\n\", \$arg1, \$arg2)
+}
+"
+close $fp
+
 set ok 0
-spawn stap -c $sup_exepath $srcdir/$subdir/static_uprobes.stp
+verbose -log "spawn stap -c $sup_exepath [pwd]/static_uprobes.stp"
+spawn stap -c $sup_exepath [pwd]/static_uprobes.stp
 expect {
     -timeout 180
     -re {In label1 probe} { incr ok; exp_continue }
     -re {In label2 probe 0x2} { incr ok; exp_continue }
+    -re {In label0 probe 0x3} { incr ok; exp_continue }
     -re {In label3 probe 0x3 0x[0-9a-f][0-9a-f]} { incr ok; exp_continue }
     timeout { fail "$test (timeout)" }
     eof { }
 }
 
+if {$ok == 4} { pass "$test" } { fail "$test ($ok)" }
+set ok 0
+
 # Now do a debuginfo style probe of the above test
 
 set fp [open "[pwd]/static_uprobes.sh" "w"]
 puts $fp "
 ed $sup_srcpath <<HERE
-1a
-#define USE_STAP_DEBUGINFO_PROBE 1
+/USE_STAP_PROBE/d
+/buz/+1
+a
+  DTRACE_PROBE1(tstlabel,label4,parm);
 .
 w
 q
-HERE
 "
 close $fp
 spawn sh [pwd]/static_uprobes.sh
 
-set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags=-g additional_flags=$env(SYSTEMTAP_RUNTIME)/sduprobes.c"
+set fp [open "[pwd]/static_uprobes.stp" "w"]
+puts $fp "
+probe process(\"static_uprobes.x\").mark(\"label0\") 
+{ 
+  printf(\"In label0 probe %#x\\n\", \$label0_arg1)
+}
+probe process(\"static_uprobes.x\").mark(\"label1\") 
+{ 
+  printf(\"In label1 probe\\n\")
+}
+probe process(\"static_uprobes.x\").mark(\"label2\") 
+{
+  printf(\"In label2 probe %#x\\n\", \$label2_arg1)
+}
+probe process(\"static_uprobes.x\").mark(\"label3\") 
+{ 
+  printf(\"In label3 probe %#x %#x\\n\", \$label3_arg1, \$label3_arg2)
+}
+probe process(\"static_uprobes.x\").mark(\"label4\")
+{ 
+  printf(\"In label4 dtrace probe %#x\\n\", \$label4_arg1)
+}
+"
+close $fp
+
+set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags=-g additional_flags=-O additional_flags=$env(SYSTEMTAP_RUNTIME)/sduprobes.c"
 set res [target_compile $sup_srcpath $sup_exepath executable $sup_flags]
 if { $res != "" } {
     verbose "target_compile failed: $res" 2
@@ -88,16 +143,19 @@ if { $res != "" } {
     pass "compiling sduprobes.c -g"
 }
 
-spawn stap -c $sup_exepath $srcdir/$subdir/static_uprobes.stp
+verbose -log "spawn stap -c $sup_exepath [pwd]/static_uprobes.stp"
+spawn stap -c $sup_exepath [pwd]/static_uprobes.stp
 expect {
     -timeout 180
     -re {In label1 probe} { incr ok; exp_continue }
     -re {In label2 probe 0x2} { incr ok; exp_continue }
+    -re {In label0 probe 0x3} { incr ok; exp_continue }
     -re {In label3 probe 0x3 0x[0-9a-f][0-9a-f]} { incr ok; exp_continue }
+    -re {In label4 dtrace probe 0x4} { incr ok; exp_continue }
     timeout { fail "$test (timeout)" }
     eof { }
 }
 
 wait
 
-if {$ok == 6} { pass "$test" } { fail "$test ($ok)" }
+if {$ok == 5} { pass "$test" } { fail "$test ($ok)" }
diff --git a/testsuite/systemtap.base/static_uprobes.stp b/testsuite/systemtap.base/static_uprobes.stp
deleted file mode 100644
index b9de197e..00000000
--- a/testsuite/systemtap.base/static_uprobes.stp
+++ /dev/null
@@ -1,14 +0,0 @@
-probe process("static_uprobes.x").mark("label1") 
-{ 
-  printf("In label1 probe\n")
-}
-
-probe process("static_uprobes.x").mark("label2") 
-{ 
-  printf("In label2 probe %#x\n", $arg1)
-}
-
-probe process("static_uprobes.x").mark("label3") 
-{ 
-  printf("In label3 probe %#x %#x\n", $arg1, $arg2)
-}