Valgrind, an open-source memory debugger

CVS commit by nethercote: 

Previously, if the command given to Valgrind didn't exist, the 'stat -c'
suid/sgid test failed, and the startup script aborted with an ugly message.
I've changed it so that it first checks that the program exists in the user's
path (as determined by 'which'), and aborts if not.

This was quite fiddly to get right;  yell if I've broken anything.


  M +37 -24    valgrind.in   1.34


--- valgrind/coregrind/valgrind.in  #1.33:1.34
@@ -110,26 +110,38 @@
 fi
 
-which_prog="`which $1`"
+# Check that the program looks ok
+is_prog=0
 
-# Ensure the program isn't statically linked.
 if [ $# != 0 ] ; then
-   case `file "$which_prog"` in
-   *"statically linked"*)
-     echo "\`$which_prog' is statically linked"
-     echo "Valgrind only works on dynamically linked executables;  your"
-     echo "program must rely on at least one shared object for Valgrind"
-     echo "to work with it.  Read FAQ #5 for more information."
-     exit 1 ;;
-   esac
-fi
 
-# Ensure that there is no suid or sgid flag
-if [ `stat -c %a "$which_prog"` -gt 2000 ] ; then
-  echo "\`$which_prog' is suid/sgid."
-  echo "Valgrind can't handle these executables, as it"
-  echo "requires the LD_PRELOAD feature in order to work."
-  echo ""
-  echo "Remove those flags and try again."
-  exit 1
+   # Ensure the program exists.  Ignore any error messages from 'which'.
+   which_prog=`which $1 2> /dev/null`
+   if [ z$which_prog = z ] ; then
+       echo "'$1' not found in \$PATH, aborting."
+       exit
+   fi
+
+   # Ensure the program isn't statically linked.
+   if [ $# != 0 ] ; then
+      case `file "$which_prog"` in
+      *"statically linked"*)
+        echo "\`$which_prog' is statically linked"
+        echo "Valgrind only works on dynamically linked executables;  your"
+        echo "program must rely on at least one shared object for Valgrind"
+        echo "to work with it.  Read FAQ #5 for more information."
+        exit 1 ;;
+      esac
+   fi
+
+   # Ensure that there is no suid or sgid flag
+   if [ `stat -c %a "$which_prog"` -gt 2000 ] ; then
+     echo "\`$which_prog' is suid/sgid."
+     echo "Valgrind can't handle these executables, as it"
+     echo "requires the LD_PRELOAD feature in order to work."
+     echo ""
+     echo "Remove those flags and try again."
+     exit 1
+   fi
+   is_prog=1
 fi
 
@@ -150,11 +162,12 @@
 #export LD_DEBUG
     
-# If no command given, act like -h was given so vg_main.c prints out
-# the usage string.  And pass to 'exec' tha name of any program -- it doesn't
-# matter which -- because it won't be run anyway (we use 'true').
-if [ $# != 0 ] ; then
+# Actually run the program, under Valgrind's control
+if [ $is_prog = 1 ] ; then
    exec "$@"
 else
-   VG_ARGS="$VG_ARGS -h" 
+   # If no command given, act like -h was given so vg_main.c prints out the
+   # usage string.  And pass to 'exec' the name of any program -- it doesn't
+   # matter which -- because it won't be run anyway (we use 'true').
+   VG_ARGS="$VG_ARGS -h"
    exec true
 fi

Hi,

I just checked my skin with Valgrind CVS and Suse 9.0,
and now I have the problem that the skin doesn't generate
dumps any more.

I have in SK_(post_clo_init):

...
    VG_(sprintf)(filename, "%s.%d", dump_file_base, VG_(getpid)());
    fd = VG_(open)(filename, VKI_O_WRONLY|VKI_O_TRUNC, 0);
    if (-1 == fd) { 
	fd = VG_(open)(filename, VKI_O_CREAT|VKI_O_WRONLY,
		       VKI_S_IRUSR|VKI_S_IWUSR);
	if (-1 == fd) {
	    file_err(); 
	}
    }
    VG_(close)(fd);
...

to truncate/create the dump file.
With strace, I see this for this part of code:

getpid()                                = 13270
open("/home/weidendo/dumps/cachegrind.out.13270", O_WRONLY|O_TRUNC) = -1 
ENOENT
(No such file or directory)
close(-2)                               = -1 EBADF (Bad file descriptor)

Obviously, strace correctly gives back -1 for
	fd = VG_(open)(filename, VKI_O_WRONLY|VKI_O_TRUNC, 0);
but my skin gets -2 (Ok, that's a small bug to call close(-2), but still...).
But it should get -1, too ?!?

Josef

On Thu, 2003-10-30 at 02:01, Josef Weidendorfer wrote:
> I just checked my skin with Valgrind CVS and Suse 9.0,
> and now I have the problem that the skin doesn't generate
> dumps any more.

Sorry, I changed the return code for VG_(open)() so it returns -ve error
code (errno) rather than simply -1.  You can either use "if (fd < 0)" or
maybe something like "if (fd == -VKI_EEXIST) { ... } else { ... }".

> getpid()                                = 13270
> open("/home/weidendo/dumps/cachegrind.out.13270", O_WRONLY|O_TRUNC) = -1 ENOENT (No such file or directory)
> close(-2)                               = -1 EBADF (Bad file descriptor)
> 
> Obviously, strace correctly gives back -1 for
>         fd = VG_(open)(filename, VKI_O_WRONLY|VKI_O_TRUNC, 0);
> but my skin gets -2 (Ok, that's a small bug to call close(-2), but still...).
> But it should get -1, too ?!?

No.  strace is (somewhat) lying - the syscall is returning -2, not -1. 
If you were using libc, then open() would return -1 and set errno to 2
(ENOENT).  But since we're going straight to the kernel and don't have
errno, VG_(open) is directly returning the negative error code (-2 ==
ENOENT).

	J

On Thu, 30 Oct 2003, Jeremy Fitzhardinge wrote:

> No.  strace is (somewhat) lying - the syscall is returning -2, not -1.
> If you were using libc, then open() would return -1 and set errno to 2
> (ENOENT).  But since we're going straight to the kernel and don't have
> errno, VG_(open) is directly returning the negative error code (-2 ==
> ENOENT).

The different views of syscalls -- glibc's view vs. the kernel's view --
has tripped me up before.  Generally, the kernel returns a negative error
value, and then glibc puts that in errno (but positive), and returns -1
from the call.  There are some cases where the kernel vs. glibc difference
is bigger -- I think mmap, brk and getcwd are examples.

N

Ok.

I have no problem with this semantic change of return codes
(libc vs. kernel). But this is a source incompatible change in the
skin API. Can we raise the skin major version for it?

Josef

On Thursday 30 October 2003 11:35, Nicholas Nethercote wrote:
> On Thu, 30 Oct 2003, Jeremy Fitzhardinge wrote:
> > No.  strace is (somewhat) lying - the syscall is returning -2, not -1.
> > If you were using libc, then open() would return -1 and set errno to 2
> > (ENOENT).  But since we're going straight to the kernel and don't have
> > errno, VG_(open) is directly returning the negative error code (-2 ==
> > ENOENT).
>
> The different views of syscalls -- glibc's view vs. the kernel's view --
> has tripped me up before.  Generally, the kernel returns a negative error
> value, and then glibc puts that in errno (but positive), and returns -1
> from the call.  There are some cases where the kernel vs. glibc difference
> is bigger -- I think mmap, brk and getcwd are examples.
>
> N
>
>
> -------------------------------------------------------
> This SF.net email is sponsored by: SF.net Giveback Program.
> Does SourceForge.net help you be more productive?  Does it
> help you create better code?   SHARE THE LOVE, and help us help
> YOU!  Click Here: http://sourceforge.net/donate/
> _______________________________________________
> Valgrind-developers mailing list
> Valgrind-developers@...
> https://lists.sourceforge.net/lists/listinfo/valgrind-developers

On Thu, 30 Oct 2003, Josef Weidendorfer wrote:

> I have no problem with this semantic change of return codes
> (libc vs. kernel). But this is a source incompatible change in the
> skin API. Can we raise the skin major version for it?

Done.

I think it makes sense to change the major version number only once
between each "release".  Eg., if a release is made, and then two,
separate, incompatible changes are made before the next release, only
change the version number once.  Thus external skins would be targetted to
match official "releases" (by "release" I guess that means any time Julian
puts up a new tarball on the website).  Does this seem reasonable?

N

On Thursday 30 October 2003 13:37, Nicholas Nethercote wrote:
> On Thu, 30 Oct 2003, Josef Weidendorfer wrote:
> > I have no problem with this semantic change of return codes
> > (libc vs. kernel). But this is a source incompatible change in the
> > skin API. Can we raise the skin major version for it?
>
> Done.
>
> I think it makes sense to change the major version number only once
> between each "release".  Eg., if a release is made, and then two,
> separate, incompatible changes are made before the next release, only
> change the version number once.  Thus external skins would be targetted to
> match official "releases" (by "release" I guess that means any time Julian
> puts up a new tarball on the website).  Does this seem reasonable?

Of course. I almost added something like this to the last mail.
If somebody is using VG CVS, he's always on his own.

Josef

CVS commit by mueller: 

make it really silent


  M +1 -1      valgrind.in   1.35


--- valgrind/coregrind/valgrind.in  #1.34:1.35
@@ -105,5 +105,5 @@
 # an environment variable.
 
-if getconf GNU_LIBPTHREAD_VERSION | grep -qi NPTL 2>/dev/null; then
+if getconf GNU_LIBPTHREAD_VERSION 2>/dev/null | grep -qi NPTL 2>/dev/null; then
    LD_ASSUME_KERNEL=2.4.1
    export LD_ASSUME_KERNEL

CVS commit by mueller: 

for some reason I need that to make it compile on suse 9
MERGE TO STABLE


  M +1 -1      vg_unsafe.h   1.18


--- valgrind/coregrind/vg_unsafe.h  #1.17:1.18
@@ -38,5 +38,5 @@
 #include <sys/utsname.h>  /* for uname */
 #include <sys/time.h>     /* for struct timeval & struct timezone */
-#ifdef KERNEL_2_6
+#if defined(KERNEL_2_6) || defined(KERNEL_2_4)
 /* ugly hack to avoid that kernel headers redefine stuff from sys/time.h */
 #define _LINUX_TIME_H

CVS commit by mueller: 

there have been reports that "stat" is not portable enough.

MERGE TO STABLE


  M +10 -9     valgrind.in   1.36


--- valgrind/coregrind/valgrind.in  #1.35:1.36
@@ -131,16 +131,17 @@
         echo "to work with it.  Read FAQ #5 for more information."
         exit 1 ;;
+     # ensure that there are no setuid or gid flags
+      *:\ set?id\ ELF*)
+     echo "\`$which_prog' is suid/sgid."
+        echo "Valgrind can't handle these executables, as it"
+        echo "requires the LD_PRELOAD feature in order to work."
+        echo ""
+        echo "Remove those flags and try again."
+        echo ""
+        exit 1
+        ;;
       esac
    fi
 
-   # Ensure that there is no suid or sgid flag
-   if [ `stat -c %a "$which_prog"` -gt 2000 ] ; then
-     echo "\`$which_prog' is suid/sgid."
-     echo "Valgrind can't handle these executables, as it"
-     echo "requires the LD_PRELOAD feature in order to work."
-     echo ""
-     echo "Remove those flags and try again."
-     exit 1
-   fi
    is_prog=1
 fi

CVS commit by fitzhardinge: 

Fix --trace-malloc=yes, by using client-side VALGRIND_INTERNAL_PRINTF
to print the allocation traces rather than trying to directly use
VG_(printf).


  M +8 -8      vg_replace_malloc.c   1.12


--- valgrind/coregrind/vg_replace_malloc.c  #1.11:1.12
@@ -134,5 +134,5 @@ void VG_(replacement_malloc_print_debug_
 #define MALLOC_TRACE(format, args...)  \
    if (VG_(clo_trace_malloc))          \
-      VG_(printf)(format, ## args )
+      VALGRIND_INTERNAL_PRINTF(format, ## args )
 
 #define MAYBE_SLOPPIFY(n)           \
@@ -158,5 +158,5 @@ void* fff ( Int n ) \
       v = VG_(arena_malloc)(VG_AR_CLIENT, n); \
    } \
-   MALLOC_TRACE(" = %p\n", v ); \
+   MALLOC_TRACE(" = %p", v ); \
    return v; \
 }
@@ -177,5 +177,5 @@ ALLOC( _ZnajRKSt9nothrow_t, SK_(__builti
 void fff ( void* p ) \
 { \
-   MALLOC_TRACE(#fff "[simd=%d](%p)\n",  \
+   MALLOC_TRACE(#fff "[simd=%d](%p)",  \
                 (UInt)VG_(is_running_on_simd_CPU)(), p ); \
    if (p == NULL)  \
@@ -206,5 +206,5 @@ void* calloc ( UInt nmemb, UInt size )
       v = VG_(arena_calloc)(VG_AR_CLIENT, VG_(clo_alignment), nmemb, size);
    }
-   MALLOC_TRACE(" = %p\n", v );
+   MALLOC_TRACE(" = %p", v );
    return v;
 }
@@ -224,5 +224,5 @@ void* realloc ( void* ptrV, Int new_size
       free(ptrV);
       if (VG_(clo_trace_malloc)) 
-         VG_(printf)(" = 0\n" );
+         VG_(printf)(" = 0" );
       return NULL;
    }   
@@ -232,5 +232,5 @@ void* realloc ( void* ptrV, Int new_size
       v = VG_(arena_realloc)(VG_AR_CLIENT, ptrV, VG_(clo_alignment), new_size);
    }
-   MALLOC_TRACE(" = %p\n", v );
+   MALLOC_TRACE(" = %p", v );
    return v;
 }
@@ -250,5 +250,5 @@ void* memalign ( Int alignment, Int n )
       v = VG_(arena_malloc_aligned)(VG_AR_CLIENT, alignment, n);
    }
-   MALLOC_TRACE(" = %p\n", v );
+   MALLOC_TRACE(" = %p", v );
    return v;
 }
@@ -309,5 +309,5 @@ Int malloc_usable_size ( void* p )
       pszB = VG_(arena_payload_szB)(VG_AR_CLIENT, p);
    }
-   MALLOC_TRACE(" = %d\n", pszB );
+   MALLOC_TRACE(" = %d", pszB );
 
    return pszB;

CVS commit by mueller: 

fix 'make dist'.


  M +1 -0      Makefile.am   1.59


--- valgrind/coregrind/Makefile.am  #1.58:1.59
@@ -89,4 +89,5 @@
         vg_constants.h          \
         vg_symtab2.h            \
+        vg_unistd.h             \
         vg_symtypes.h           \
         vg_unsafe.h

CVS commit by nethercote: 

Add missing printf and pre_mem_read to rt_sigtimedwait(), thanks to Thomas
Lussnig <lussnig@...>.

MERGE TO STABLE


  M +4 -0      vg_syscalls.c   1.52


--- valgrind/coregrind/vg_syscalls.c  #1.51:1.52
@@ -3958,4 +3958,8 @@ PRE(rt_sigtimedwait)
    /* int sigtimedwait(const  sigset_t  *set,  siginfo_t  *info,
       const struct timespec timeout); */
+   MAYBE_PRINTF("sigtimedwait ( %p, %p, timeout )\n", arg1, arg2);
+   if (arg1 != (UInt)NULL) 
+      SYSCALL_TRACK( pre_mem_read,  tid, "sigtimedwait(set)",  arg1,
+                     sizeof(vki_ksigset_t));
    if (arg2 != (UInt)NULL)
       SYSCALL_TRACK( pre_mem_write, tid, "sigtimedwait(info)", arg2,

CVS commit by nethercote: 

Make the startup static and suid checks follow symlinks.

Also a couple of minor formatting changes.


  M +6 -6      valgrind.in   1.37


--- valgrind/coregrind/valgrind.in  #1.36:1.37
@@ -118,11 +118,11 @@
    which_prog=`which $1 2> /dev/null`
    if [ z$which_prog = z ] ; then
-       echo "'$1' not found in \$PATH, aborting."
-       exit
+      echo "'$1' not found in \$PATH, aborting."
+      exit
    fi
 
-   # Ensure the program isn't statically linked.
    if [ $# != 0 ] ; then
-      case `file "$which_prog"` in
+      case `file -L "$which_prog"` in       # must follow symlinks, hence -L
+      # Ensure the program isn't statically linked.
       *"statically linked"*)
         echo "\`$which_prog' is statically linked"
@@ -131,7 +131,7 @@
         echo "to work with it.  Read FAQ #5 for more information."
         exit 1 ;;
-     # ensure that there are no setuid or gid flags
+      # Ensure that there are no setuid or gid flags
       *:\ set?id\ ELF*)
-     echo "\`$which_prog' is suid/sgid."
+        echo "\`$which_prog' is suid/sgid."
         echo "Valgrind can't handle these executables, as it"
         echo "requires the LD_PRELOAD feature in order to work."

CVS commit by nethercote: 

Implemented PUSH/POP %{FS,GS}, and PUSH %CS (Nb: there is no POP %CS).  Based
on patches from Adam Gundy and Tom Hughes.

MERGE TO STABLE


  M +51 -44    vg_to_ucode.c   1.106

CVS commit by nethercote: 

Move var declarations to start of block, for older versions of gcc.

MERGE TO STABLE


  M +2 -2      vg_to_ucode.c   1.107


--- valgrind/coregrind/vg_to_ucode.c  #1.106:1.107
@@ -3597,6 +3597,6 @@ static 
 void dis_push_segreg ( UCodeBlock* cb, UInt sreg, Int sz )
 {
-    vg_assert(sz == 4);
     Int t1 = newTemp(cb), t2 = newTemp(cb);
+    vg_assert(sz == 4);
     uInstr2(cb, GETSEG, 2, ArchRegS, sreg,  TempReg, t1);
     uInstr2(cb, GET,    4, ArchReg,  R_ESP, TempReg, t2);
@@ -3612,6 +3612,6 @@ static
 void dis_pop_segreg ( UCodeBlock* cb, UInt sreg, Int sz )
 {
-   vg_assert(sz == 4);
    Int t1 = newTemp(cb), t2 = newTemp(cb);
+   vg_assert(sz == 4);
    uInstr2(cb, GET,    4, ArchReg, R_ESP,    TempReg,  t2);
    uInstr2(cb, LOAD,   2, TempReg, t2,       TempReg,  t1);

CVS commit by jseward: 

If we bomb out due to not finding the executable, print our invokation
name.  Before:

   'ssss' not found in $PATH, aborting.

After:

   ./Inst/bin/valgrind: 'ssss' not found in $PATH, aborting.

(Already in STABLE).


  M +1 -1      valgrind.in   1.38


--- valgrind/coregrind/valgrind.in  #1.37:1.38
@@ -118,5 +118,5 @@
    which_prog=`which $1 2> /dev/null`
    if [ z$which_prog = z ] ; then
-      echo "'$1' not found in \$PATH, aborting."
+      echo "$0: '$1' not found in \$PATH, aborting."
       exit
    fi

CVS commit by helio: 

- Fix for kernel 2.6. __user need definition.


  M +3 -0      vg_intercept.c   1.23


--- valgrind/coregrind/vg_intercept.c  #1.22:1.23
@@ -62,4 +62,7 @@
 #include <sys/ipc.h>
 #include <sys/msg.h>
+#ifdef KERNEL_2_6
+#include <linux/compiler.h>
+#endif
 #include <asm/ipc.h>            /* for ipc_kludge */
 #include <sys/poll.h>

CVS commit by helio: 

- Fix for kernel 2.6. __user need definition.


  M +3 -0      vg_unsafe.h   1.19


--- valgrind/coregrind/vg_unsafe.h  #1.18:1.19
@@ -51,4 +51,7 @@
 #include <net/if_arp.h>   /* for struct arpreq */
 #include <net/route.h>    /* for struct rtentry */
+#ifdef KERNEL_2_6
+#include <linux/compiler.h> /* for __user definition */
+#endif
 #include <asm/ipc.h>      /* for struct ipc_kludge */
 #include <linux/msg.h>    /* for struct msgbuf */

CVS commit by nethercote: 

Don't print this debug msg if -q is on.

MERGE TO STABLE


  M +1 -1      vg_main.c   1.119


--- valgrind/coregrind/vg_main.c  #1.118:1.119
@@ -1271,5 +1271,5 @@ static void process_cmd_line_options ( v
    }
 
-   if (VG_(clo_log_to) != VgLogTo_Fd) {
+   if (VG_(clo_verbosity) > 0 && VG_(clo_log_to) != VgLogTo_Fd) {
       VG_(message)(Vg_UserMsg, "");
       VG_(message)(Vg_UserMsg,

CVS commit by fitzhardinge: 

Fix some (bone-headed) loose ends left by my last checkin.  "make regtest"
actually works this time.


  M +11 -15    vg_proxylwp.c   1.4
  M +6 -5      vg_syscalls.c   1.55


--- valgrind/coregrind/vg_proxylwp.c  #1.3:1.4
@@ -372,20 +372,15 @@ static void proxy_fork_cleanup(ThreadId 
    }
 
-   /* Create a proxy for calling thread
+   /* Create a proxy for calling thread.
       
-      We need to temporarily set the state back to Runnable for
-      proxy_create's benefit.
+      Since fork() is non-blocking, the thread status should already
+      be Runnable.
     */
+   vg_assert(VG_(is_valid_tid)(tid));
+   vg_assert(VG_(threads)[tid].proxy == NULL);
+   vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
 
-   {
-      ThreadState *tst = VG_(get_ThreadState)(tid);
-
-      vg_assert(tst->proxy == NULL);
-      vg_assert(tst->status == VgTs_WaitSys);
-      tst->status = VgTs_Runnable;
       VG_(proxy_create)(tid);
       VG_(proxy_setsigmask)(tid);
-      tst->status = VgTs_WaitSys;
-   }
 }
 
@@ -443,5 +438,6 @@ void VG_(proxy_handlesig)(const vki_ksig
          eax contains the correct syscall return value, and the new
          state is effectively PXS_SysDone. */
-      vg_assert(px->state == PXS_RunSyscall || px->state == PXS_SysDone);
+      vg_assert(px->state == PXS_RunSyscall ||
+                px->state == PXS_SysDone);
       px->state = PXS_SysDone;
       px->tst->m_eax = eax;

--- valgrind/coregrind/vg_syscalls.c  #1.54:1.55
@@ -4436,5 +4436,8 @@ Bool VG_(pre_syscall) ( ThreadId tid )
          syscall_done = True;
       } else if (sys->may_block) {
-         /* issue to worker */
+         /* Issue to worker.  If we're waiting on the syscall because
+            it's in the hands of the ProxyLWP, then set the thread
+            state to WaitSys. */
+         tst->status = VgTs_WaitSys;
          VG_(sys_issue)(tid);
       } else {
@@ -4453,8 +4456,6 @@ Bool VG_(pre_syscall) ( ThreadId tid )
    VGP_POPCC(VgpCoreSysWrap);
 
-   /* If we're waiting on the syscall because it's in the hands of the
-      ProxyLWP, then set the thread state to WaitSys. */
-   if (!syscall_done)
-      tst->status = VgTs_WaitSys;
+   vg_assert(( syscall_done && tst->status == VgTs_Runnable) ||
+             (!syscall_done && tst->status == VgTs_WaitSys ));
 
    return syscall_done;

CVS commit by nethercote: 

Be quieter.


  M +1 -1      vg_proxylwp.c   1.5


--- valgrind/coregrind/vg_proxylwp.c  #1.4:1.5
@@ -1054,5 +1054,5 @@ void VG_(proxy_delete)(ThreadId tid, Boo
    res = proxy_wait(proxy, True, &status);
 
-   if (!res || status != 0)
+   if ((!res || status != 0) && VG_(clo_verbosity) > 1)
       VG_(printf)("proxy %d for tid %d exited status %d, res %d\n",
                   lwp, tid, status, res);

CVS commit by nethercote: 

Remove local shellshort function, use the standard VG_(ssort).


  M +8 -52     vg_symtab2.c   1.56


--- valgrind/coregrind/vg_symtab2.c  #1.55:1.56
@@ -384,53 +384,9 @@ void safeCopy ( UChar* dst, UInt maxlen,
 /*------------------------------------------------------------*/
 
-static void shellsort(void *base, UInt nmemb, UInt sz, Int (*compare)(void *a, void *b))
-{
-   /* Magic numbers due to Janet Incerpi and Robert Sedgewick. */
-   static const Int incs[16] = { 1, 3, 7, 21, 48, 112, 336, 861, 1968,
-                                 4592, 13776, 33936, 86961, 198768, 
-                                 463792, 1391376 };
-   Int lo = 0;
-   Int hi = nmemb-1;
-   Int bigN;
-   Int hp;
-   Char *cp = (Char *)base;
-   Char tmp[sz];
-
-   bigN = hi - lo + 1;
-   if (bigN < 2)
-      return;
-   hp = 0;
-   while (hp < 16 && incs[hp] < bigN)
-      hp++;
-   hp--;
-   vg_assert(0 <= hp && hp < 16);
-
-   for (; hp >= 0; hp--) {
-      Int i, h;
-      
-      h = incs[hp];
-      i = lo + h;
-      for (i = lo+h; i <= hi; i++) {
-         Int j;
-         VG_(memcpy)(&tmp, &cp[i * sz], sz);
-
-         j = i;
-         while ((*compare)((void *)&cp[(j-h) * sz], (void *)&tmp) > 0) {
-            VG_(memcpy)(&cp[j * sz], &cp[(j-h) * sz], sz);
-            j = j - h;
-            if (j <= (lo + h - 1))
-               break;
-         }
-         VG_(memcpy)(&cp[j * sz], &tmp, sz);
-      }
-   }
-}
-
 /* Sort the symtab by starting address, and emit warnings if any
-   symbols have overlapping address ranges.  We use that old chestnut,
-   shellsort.  Mash the table around so as to establish the property
-   that addresses are in order and the ranges to not overlap.  This
-   facilitates using binary search to map addresses to symbols when we
-   come to query the table.
+   symbols have overlapping address ranges.  Mash the table around so as to
+   establish the property that addresses are in order and the ranges to not
+   overlap.  This facilitates using binary search to map addresses to
+   symbols when we come to query the table.
 */
 static Int compare_RiSym(void *va, void *vb) {
@@ -453,5 +409,5 @@ void canonicaliseSymtab ( SegInfo* si )
       return;
 
-   shellsort(si->symtab, si->symtab_used, sizeof(*si->symtab), compare_RiSym);
+   VG_(ssort)(si->symtab, si->symtab_used, sizeof(*si->symtab), compare_RiSym);
 
   cleanup_more:
@@ -581,5 +537,5 @@ void canonicaliseScopetab ( SegInfo* si 
 
    /* Sort by start address. */
-   shellsort(si->scopetab, si->scopetab_used, sizeof(*si->scopetab), 
+   VG_(ssort)(si->scopetab, si->scopetab_used, sizeof(*si->scopetab), 
              compare_ScopeRange);
 
@@ -653,5 +609,5 @@ void canonicaliseLoctab ( SegInfo* si )
 
    /* Sort by start address. */
-   shellsort(si->loctab, si->loctab_used, sizeof(*si->loctab), compare_RiLoc);
+   VG_(ssort)(si->loctab, si->loctab_used, sizeof(*si->loctab), compare_RiLoc);
 
    /* If two adjacent entries overlap, truncate the first. */

CVS commit by nethercote: 


Greatly improved the symbol table reading code.  It was a kludgy, accreted
mess.  Pulled the symbol table reading bit out of vg_read_lib_symbols() into
read_symtab(), in the process removing the awful twice-only loop used to read
the symbol table and the dynamic symbol table.  Factored out the code used to
find sections of interest (eg. .strtab, .symtab, .stabs, .plt, etc), replacing
nine (yes, nine) individual and slightly differing searches.  

It's now much easier to understand, 132 lines shorter, and provides a better
base for easily doing more complicated debug stuff, eg. when we start reading
in all the debugging info (such as .debug_info for dwarf2).


  M +250 -342  vg_symtab2.c   1.57

CVS commit by nethercote: 

Support posix_memalign properly.


  M +4 -0      vg_replace_malloc.c   1.14


--- valgrind/coregrind/vg_replace_malloc.c  #1.13:1.14
@@ -291,4 +291,8 @@ int __posix_memalign ( void **memptr, UI
 }
 
+# define weak_alias(name, aliasname) \
+  extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
+weak_alias(__posix_memalign, posix_memalign);
+
 Int malloc_usable_size ( void* p )
 {

CVS commit by mueller: 

implement statfs64, utimes and clock_gettime


  M +42 -1     vg_syscalls.c   1.57
  M +2 -1      vg_unsafe.h   1.20


--- valgrind/coregrind/vg_syscalls.c  #1.56:1.57
@@ -4053,5 +4053,14 @@ PRE(statfs)
    MAYBE_PRINTF("statfs ( %p, %p )\n",arg1,arg2);
    SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs(path)", arg1 );
-   SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)", 
+   SYSCALL_TRACK( pre_mem_write, tid, "statfs(buf)", 
+                  arg2, sizeof(struct statfs) );
+}
+
+PRE(statfs64)
+{
+   /* int statfs64(const char *path, struct statfs *buf); */
+   MAYBE_PRINTF("statfs64 ( %p, %p )\n",arg1,arg2);
+   SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs64(path)", arg1 );
+   SYSCALL_TRACK( pre_mem_write, tid, "statfs64(buf)", 
                   arg2, sizeof(struct statfs) );
 }
@@ -4062,4 +4071,9 @@ POST(statfs)
 }
 
+POST(statfs64)
+{
+   VG_TRACK( post_mem_write, arg2, sizeof(struct statfs64) );
+}
+
 PRE(symlink)
 {
@@ -4282,4 +4296,28 @@ POST(adjtimex)
 }
 
+PRE(clock_gettime)
+{
+    /* int clock_gettime(clockid_t clk_id, struct timespec *tp); */
+    MAYBE_PRINTF("clock_gettime(%d, %p)\n" ,arg1,arg2);
+    SYSCALL_TRACK(pre_mem_write, tid, "clock_gettime(tp)",
+                   arg2, sizeof(struct timespec));
+}
+
+POST(clock_gettime)
+{
+    if (!VG_(is_kerror)(res) && res == 0)
+       VG_TRACK( post_mem_write, arg2, sizeof(struct timespec) );
+}
+
+PRE(utimes)
+{
+    /* int utimes(const char *filename, struct timeval *tvp); */
+    MAYBE_PRINTF("utimes ( %p, %p )\n", arg1,arg2);
+    SYSCALL_TRACK( pre_mem_read_asciiz, tid, "utimes(filename)", arg1 );
+    if (arg2 != (UInt)NULL)
+         SYSCALL_TRACK( pre_mem_read, tid, "utimes(tvp)", arg2,
+                       sizeof(struct timeval) );
+}
+
 #define SIGNAL_SIMULATION       1
 
@@ -4657,4 +4695,5 @@ static const struct sys_info sys_info[] 
    SYSBA(stat,                  False),
    SYSBA(statfs,                False),
+   SYSBA(statfs64,              False),
    SYSB_(symlink,               True),
    SYSBA(stat64,                False),
@@ -4668,4 +4707,5 @@ static const struct sys_info sys_info[] 
    SYSBA(uname,                 False),
    SYSB_(utime,                 True),
+   SYSB_(utimes,                False),
    SYSBA(waitpid,               True),
    SYSBA(wait4,                 True),
@@ -4673,4 +4713,5 @@ static const struct sys_info sys_info[] 
    SYSB_(prctl,                 True),
    SYSBA(adjtimex,              False),
+   SYSBA(clock_gettime,         False),
 
    /* new signal handling makes these normal blocking syscalls */

--- valgrind/coregrind/vg_unsafe.h  #1.19:1.20
@@ -91,5 +91,6 @@
 #include <sys/types.h>
 
-#include <sys/statfs.h>
+#include <asm/statfs.h>
+#undef statfs
 
 #include <sys/sysinfo.h>

CVS commit by mueller: 

raise sanity limit to pass coreutils testsuite

MERGE TO STABLE


  M +2 -2      vg_main.c   1.123


--- valgrind/coregrind/vg_main.c  #1.122:1.123
@@ -904,7 +904,7 @@ static void process_cmd_line_options ( v
            sp --;
            if (*sp == 0) break;
-           if (++ctr >= 1000)
+           if (++ctr >= 2000)
               args_grok_error(
-                 "suspiciously many (1000) env[] entries; giving up");
+                 "suspiciously many (2000) env[] entries; giving up");
            
        }

CVS commit by mueller: 

be less verbose by default


  M +4 -3      vg_symtab2.c   1.58


--- valgrind/coregrind/vg_symtab2.c  #1.57:1.58
@@ -1184,4 +1184,5 @@ void VG_(unload_symbols) ( Addr start, U
    }
 
+   if (VG_(clo_verbosity) > 1)
    VG_(message)(Vg_UserMsg, 
                 "discard syms in %s due to munmap()",

CVS commit by mueller: 

make use of statfs64 and make code blocks adjacent


  M +6 -6      vg_syscalls.c   1.58


--- valgrind/coregrind/vg_syscalls.c  #1.57:1.58
@@ -4057,4 +4057,9 @@ PRE(statfs)
 }
 
+POST(statfs)
+{
+   VG_TRACK( post_mem_write, arg2, sizeof(struct statfs) );
+}
+
 PRE(statfs64)
 {
@@ -4063,10 +4068,5 @@ PRE(statfs64)
    SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs64(path)", arg1 );
    SYSCALL_TRACK( pre_mem_write, tid, "statfs64(buf)", 
-                  arg2, sizeof(struct statfs) );
-}
-
-POST(statfs)
-{
-   VG_TRACK( post_mem_write, arg2, sizeof(struct statfs) );
+                  arg2, sizeof(struct statfs64) );
 }

On Wed, 19 Nov 2003, Dirk Mueller wrote:

> CVS commit by mueller:
>
> implement statfs64, utimes and clock_gettime

The HEAD now doesn't compile on my machine:

  vg_syscalls.c: In function `before_statfs64':
  vg_syscalls.c:4070: sizeof applied to an incomplete type
  vg_syscalls.c: In function `after_statfs64':
  vg_syscalls.c:4075: sizeof applied to an incomplete type

Also, not printing the "discarding..." message will, I think, break some
regression tests.  These problems may also apply to the stable branch.
Can you fix them?  Thanks.  And don't forget to run the regression tests
before committing :)

N

On Wednesday 19 November 2003 10:59, Nicholas Nethercote wrote:

> > implement statfs64, utimes and clock_gettime
>   vg_syscalls.c: In function `before_statfs64':
>   vg_syscalls.c:4070: sizeof applied to an incomplete type

Ok, same question to you: where is statfs64 defined for you? for me its in 
asm/statfs.h

Its a bit tricky to use this here since normally you're supposed to do this 
via the D_FILE_OFFSET_BITS define, which we can't do since we want the old 
32bit version and the 64bit version. 

somehow we need a script that calculates the magic values of sizeof() etc and 
then just import that header file with the list of #define's . Including 
nonstandard kernel headers is just too unportable, even for valgrind. 
>
> Also, not printing the "discarding..." message will, I think, break some
> regression tests.  These problems may also apply to the stable branch.

Well, make regtest prints 0 failures for me. do you see some? where?

> Can you fix them?  Thanks.  And don't forget to run the regression tests
> before committing :)

Of course I did that. 0 failures in branch, all failed in HEAD, but thats 
because HEAD does not even work on /bin/true for me.

On Wed, 19 Nov 2003, Dirk Mueller wrote:

> Ok, same question to you: where is statfs64 defined for you? for me its in
> asm/statfs.h

bits/statfs.h

> Its a bit tricky to use this here since normally you're supposed to do this
> via the D_FILE_OFFSET_BITS define, which we can't do since we want the old
> 32bit version and the 64bit version.
>
> somehow we need a script that calculates the magic values of sizeof() etc and
> then just import that header file with the list of #define's . Including
> nonstandard kernel headers is just too unportable, even for valgrind.
> >
> > Also, not printing the "discarding..." message will, I think, break some
> > regression tests.  These problems may also apply to the stable branch.
>
> Well, make regtest prints 0 failures for me. do you see some? where?

Sorry, my mistake.

> Of course I did that. 0 failures in branch, all failed in HEAD, but thats
> because HEAD does not even work on /bin/true for me.

Sorry for the mis-accusation.

What's the problem with HEAD -- it doesn't work on your machine at all?
Have you told Jeremy?  (well, I guess he knows now...)

N

CVS commit by mueller: 

add CVTPD2PS support, based on patch by Josef Weidendorfer

MERGE TO STABLE


  M +8 -0      vg_to_ucode.c   1.108


--- valgrind/coregrind/vg_to_ucode.c  #1.107:1.108
@@ -4761,4 +4761,12 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
+   /* CVTPD2PS -- convert two doubles to two floats. */
+   if (sz == 2 &&
+       insn[0] == 0x0F && insn[1] == 0x5A) {
+      eip = dis_SSE3_reg_or_mem ( cb, sorb, eip+2, 16, "cvtpd2ps",
+                                 0x66, insn[0], insn[1] );
+      goto decode_success;
+   }
+
    /* SQRTPD: square root of packed double. */
    if (sz == 2

On Wednesday 19 November 2003 16:18, Nicholas Nethercote wrote:

> What's the problem with HEAD -- it doesn't work on your machine at all?
> Have you told Jeremy?  (well, I guess he knows now...)

This happens: 

==25531== Memcheck, a memory error detector for x86-linux.
==25531== Copyright (C) 2002-2003, and GNU GPL'd, by Julian Seward.
==25531== Using valgrind-HEAD, a program supervision framework for x86-linux.
==25531== Copyright (C) 2000-2003, and GNU GPL'd, by Julian Seward.
==25531== Estimated CPU clock rate is 1540 MHz
==25531== For more details, rerun with: -v
==25531== 
==25531== 
==25531== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25531== malloc/free: in use at exit: 0 bytes in 0 blocks.
==25531== malloc/free: 103 allocs, 103 frees, 7925 bytes allocated.
==25531== For a detailed leak analysis,  rerun with: --leak-check=yes
==25531== For counts of detected errors, rerun with: -v
--25531-- TID 1: proxy LWP 0 exited with status 0


valgrind: vg_proxylwp.c:1360 (vgPlain_proxy_sanity): Assertion `sane' failed.
==25531==    at 0x4017A01E: vgPlain_skin_assert_fail (vg_mylibc.c:1102)
==25531==    by 0x4017A01D: assert_fail (vg_mylibc.c:1098)
==25531==    by 0x4017A0A8: vgPlain_core_assert_fail (vg_mylibc.c:1109)
==25531==    by 0x4017E89B: vgPlain_proxy_sanity (vg_proxylwp.c:1360)
==25531==    by 0x40175060: vgPlain_do_sanity_checks (vg_main.c:2051)
==25531==    by 0x4017484A: vgPlain_main (vg_main.c:1699)

sched status:

Thread 1: status = Runnable, associated_mx = 0x0, associated_cv = 0x0
==25531==    at 0x40171A33: vgPlain___libc_freeres_wrapper 
(vg_intercept.c:177)
==25531==    by 0x40271057: __GI_exit (in /lib/i686/libc.so.6)
==25531==    by 0x8048A9D: (within /bin/true)
==25531==    by 0x4025AD16: __libc_start_main (in /lib/i686/libc.so.6)
==25531==    by 0x80488C0: (within /bin/true)


Note: see also the FAQ.txt in the source distribution.
It contains workarounds to several common problems.

If that doesn't help, please report this bug to: jseward@...

In the bug report, send all the above text, the valgrind
version, and what Linux distro you are using.  Thanks.



It works when I use --assume-2.4=yes, but I don't consider this switch to be a 
good idea. can't we detect whatever weird kernel feature we now need at 
runtime?

On Wed, 2003-11-19 at 09:11, Dirk Mueller wrote:
> It works when I use --assume-2.4=yes, but I don't consider this switch to be a 
> good idea. can't we detect whatever weird kernel feature we now need at 
> runtime?

The intent is that the valgrind wrapper script use --assume-2.4=yes when
it detects a SuSE kernel - I hadn't got around to it.  Perhaps I should
rename the option to --broken-suse-kernel=yes.

	J

On Wednesday 19 November 2003 18:44, Jeremy Fitzhardinge wrote:

> The intent is that the valgrind wrapper script use --assume-2.4=yes when
> it detects a SuSE kernel - I hadn't got around to it.  Perhaps I should
> rename the option to --broken-suse-kernel=yes.

Maybe you can elaborate in more detail what is broken?

On Wed, 2003-11-19 at 09:47, Dirk Mueller wrote:
> On Wednesday 19 November 2003 18:44, Jeremy Fitzhardinge wrote:
> 
> > The intent is that the valgrind wrapper script use --assume-2.4=yes when
> > it detects a SuSE kernel - I hadn't got around to it.  Perhaps I should
> > rename the option to --broken-suse-kernel=yes.
> 
> Maybe you can elaborate in more detail what is broken?

V does a feature test to see if its running on a 2.6-like kernel, which
is what it would prefer.  SuSE passes those feature tests because
they've extended their 2.4 kernel to include the new NPTL syscalls (like
RH).  Unfortunately they seem subtly broken, and even though the
syscalls works and take the new args, they behave differently.  The
message you posted suggests that at least one proxy LWP just evaporated
without notifying anyone of its death.

On standard 2.4 kernels and RH 2.4 kernels it works OK without
--assume-2.4=yes - it really is just for SuSE kernels (and perhaps other
vendors with hacked up 2.4 kernels).

	J

On Wed, 19 Nov 2003, Jeremy Fitzhardinge wrote:

> Perhaps I should rename the option to --broken-suse-kernel=yes.

Much better, I find --assume-2.4 confusing.  Or, to be consistent with
--workaround-gcc296-bugs, --workaround-suse81-bugs (or whatever the
version is)?

N

On Wednesday 19 November 2003 21:07, Nicholas Nethercote wrote:

> Much better, I find --assume-2.4 confusing.  Or, to be consistent with
> --workaround-gcc296-bugs, --workaround-suse81-bugs (or whatever the
> version is)?

I agree, but can we first investigate if this is really a bug in the SuSE 
kernel? If I'd have a test app I could pass it to the kernel developers or 
verify it against the spec. 

I might try building one myself, just in case somebody has already done this 
work..

CVS commit by mueller: 

SHUFPD support

MERGE TO STABLE
CCMAIL: 68588-done@...


  M +7 -0      vg_to_ucode.c   1.109


--- valgrind/coregrind/vg_to_ucode.c  #1.108:1.109
@@ -3927,4 +3927,11 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
+   /* SHUFPD */
+   if (sz == 2 && insn[0] == 0x0F && insn[1] == 0xC6) {
+      eip = dis_SSE3_reg_or_mem_Imm8 ( cb, sorb, eip+2, 16, "shufpd",
+                                           0x66, insn[0], insn[1] );
+      goto decode_success;
+   }
+
    /* SHUFPS */
    if (insn[0] == 0x0F && insn[1] == 0xC6) {

CVS commit by mueller: 

make it compile on non-C90 compilers. Thanks for the patch.
CCMAIL: 68525-done@...


  M +5 -3      vg_symtab2.c   1.59


--- valgrind/coregrind/vg_symtab2.c  #1.58:1.59
@@ -673,4 +673,6 @@ void read_symtab( SegInfo* si, Char* tab
    Addr  sym_addr;
    RiSym risym;
+   Char* t0;
+   Char* name;
    
    if (o_strtab == NULL || o_symtab == NULL) {
@@ -785,8 +787,8 @@ void read_symtab( SegInfo* si, Char* tab
 
       /* If we reach here, it's an interesting symbol; record it. */
-      Char* t0 = sym->st_name 
+      t0 = sym->st_name 
                     ? (Char*)(o_strtab+sym->st_name) 
                     : (Char*)"NONAME";
-      Char *name = VG_(addStr) ( si, t0, -1 );
+      name = VG_(addStr) ( si, t0, -1 );
       vg_assert(name != NULL
                 /* && 0==VG_(strcmp)(t0,&vg_strtab[nmoff]) */ );

CVS commit by nethercote: 

Printing usage message to stdout instead of stderr, which seems to be the
standard thing to do.


  M +8 -5      vg_main.c   1.124


--- valgrind/coregrind/vg_main.c  #1.123:1.124
@@ -536,7 +536,9 @@ Bool   VG_(clo_demangle)       = True;
 Bool   VG_(clo_trace_children) = False;
 
-/* See big comment in vg_include.h for meaning of these three. */
+/* See big comment in vg_include.h for meaning of these three.
+   fd is initially stdout, for --help, but gets moved to stderr by default
+   immediately afterwards. */
 VgLogTo VG_(clo_log_to)        = VgLogTo_Fd;
-Int     VG_(clo_logfile_fd)    = 2;
+Int     VG_(clo_logfile_fd)    = 1;
 Char*   VG_(clo_logfile_name)  = NULL;
 
@@ -770,5 +772,6 @@ static void process_cmd_line_options ( v
 #  define ISSPACE(cc)      ((cc) == ' ' || (cc) == '\t' || (cc) == '\n')
 
-   eventually_logfile_fd = VG_(clo_logfile_fd);
+   /* log to stderr by default, but usage message goes to stdout */
+   eventually_logfile_fd = 2; 
 
    /* Once logging is started, we can safely send messages pertaining
@@ -1177,8 +1180,8 @@ static void process_cmd_line_options ( v
       nature of it is.  Oh the wonder of Unix streams. */
 
-   /* So far we should be still attached to stderr, so we can show on
+   /* So far we should be still attached to stdout, so we can show on
       the terminal any problems to do with processing command line
       opts. */
-   vg_assert(VG_(clo_logfile_fd) == 2 /* stderr */);
+   vg_assert(VG_(clo_logfile_fd) == 1 /* stdout */);
    vg_assert(VG_(logging_to_filedes) == True);

CVS commit by mueller: 

add prefetch(w) support - the 3dnow! version of it. doesn't hurt
supporting and its very easy.

MERGE TO STABLE


  M +17 -6     vg_to_ucode.c   1.110


--- valgrind/coregrind/vg_to_ucode.c  #1.109:1.110
@@ -6364,5 +6364,7 @@ static Addr disInstr ( UCodeBlock* cb, A
       /* =-=-=-=-=-=-=-=-=- MMXery =-=-=-=-=-=-=-=-=-=-= */
 
+      case 0x0D: /* PREFETCH / PREFETCHW - 3Dnow!ery*/
       case 0x18: /* PREFETCHT0/PREFETCHT1/PREFETCHT2/PREFETCHNTA */
+      
          vg_assert(sz == 4);
          modrm = getUChar(eip);
@@ -6376,4 +6378,12 @@ static Addr disInstr ( UCodeBlock* cb, A
          if (dis) {
             UChar* hintstr;
+            if(opc == 0x0D) {
+               switch (gregOfRM(modrm)) {
+                  case 0: hintstr = ""; break;
+                  case 1: hintstr = "w"; break;
+                  default: goto decode_failure;
+               }
+            }
+            else {
             switch (gregOfRM(modrm)) {
                case 0: hintstr = "nta"; break;
@@ -6382,4 +6392,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                case 3: hintstr = "t2"; break;
                default: goto decode_failure;
+               }
             }
             VG_(printf)("prefetch%s ...\n", hintstr);

CVS commit by mueller: 

test for PARENT_SETTID support in clone() of the kernel instead
of testing for presence of NPTL by assuming that sys_futex is only
implemented when its a NPTL patched kernel.


  M +0 -2      vg_include.h   1.157
  M +0 -9      vg_main.c   1.126
  M +20 -21    vg_proxylwp.c   1.6


--- valgrind/coregrind/vg_include.h  #1.156:1.157
@@ -244,6 +244,4 @@ extern Char* VG_(clo_weird_hacks);
    signals. */
 extern Int   VG_(clo_signal_polltime);
-/* Assume we're running on a plain 2.4 kernel */
-extern Bool  VG_(clo_assume_24);
 
 /* Low latency syscalls and signals */

--- valgrind/coregrind/vg_main.c  #1.125:1.126
@@ -570,7 +570,4 @@ static Bool   VG_(clo_wait_for_gdb)   = 
 Int    VG_(clo_signal_polltime) = 50;
 
-/* If true, assume we're running on a plain 2.4 kernel */
-Bool   VG_(clo_assume_24) = False;
-
 /* These flags reduce thread wakeup latency on syscall completion and
    signal delivery, respectively.  The downside is possible unfairness. */
@@ -678,5 +675,4 @@ static void usage ( void )
 "    --lowlat-syscalls=no|yes  improve wake-up latency when a thread's\n"
 "                              syscall completes [no]\n"
-"    --assume-2.4=no|yes       assume we're running on a 2.4 kernel [no]\n"
 "\n"
 "  %s tool user options:\n";
@@ -1126,9 +1122,4 @@ static void process_cmd_line_options ( v
       else if (VG_CLO_STREQ(argv[i], "--lowlat-syscalls=no"))
          VG_(clo_lowlat_syscalls) = False;
-
-      else if (VG_CLO_STREQ(argv[i], "--assume-2.4=yes"))
-         VG_(clo_assume_24) = True;
-      else if (VG_CLO_STREQ(argv[i], "--assume-2.4=no"))
-         VG_(clo_assume_24) = False;
 
       else if (VG_CLO_STREQN(13, argv[i], "--stop-after="))

--- valgrind/coregrind/vg_proxylwp.c  #1.5:1.6
@@ -883,5 +883,5 @@ static Int do_futex(void *addr, Int op, 
 #define VKI_FUTEX_REQUEUE       3
 
-static Int have_futex = -1;     /* -1 -> unknown */
+static Int have_settid = -1;    /* -1 -> unknown */
 
 /*
@@ -895,19 +895,15 @@ static Int proxy_clone(ProxyLWP *proxy)
    Int ret;
 
-   if (VG_(clo_assume_24))
-      have_futex = 0;
-
-   if (have_futex == -1)
-      have_futex = do_futex(NULL, VKI_FUTEX_WAKE, 0, NULL, NULL) != -VKI_ENOSYS;
-
-   if (have_futex) {
+   if (have_settid != 0) {
       ret = VG_(clone)(proxylwp, 
                        LWP_stack(proxy),
                        VKI_CLONE_FS | VKI_CLONE_FILES | VKI_CLONE_VM |
-                       VKI_CLONE_SIGHAND | VKI_CLONE_THREAD | 
-                       VKI_CLONE_PARENT_SETTID |
-                       VKI_CLONE_CHILD_CLEARTID | VKI_CLONE_DETACHED, 
+                       VKI_CLONE_SIGHAND | VKI_CLONE_THREAD /*| 
+                       VKI_CLONE_PARENT_SETTID 
+                       VKI_CLONE_CHILD_CLEARTID | VKI_CLONE_DETACHED*/, 
                        proxy, &proxy->lwp, &proxy->lwp);
-   } else {
+      if ( have_settid < 0 && !proxy->lwp ) {
+         have_settid = 0;
+         proxy->lwp = ret;
       VG_(do_signal_routing) = True; /* XXX True, it seems kernels
                                         which have futex also have
@@ -915,5 +911,6 @@ static Int proxy_clone(ProxyLWP *proxy)
                                         it would be nice to test it
                                         directly. */
-
+       }
+   } else {
       ret = VG_(clone)(proxylwp, 
                        LWP_stack(proxy),
@@ -932,12 +929,12 @@ static Bool proxy_wait(ProxyLWP *proxy, 
    Bool ret = False;
 
-   if (have_futex == -1)
+   if (have_settid == -1)
       return False;
 
-   if (have_futex) {
+   if (have_settid) {
       if (block) {
          Int lwp = proxy->lwp;
 
-         while(proxy->lwp != 0)
+         if(proxy->lwp != 0)
             do_futex(&proxy->lwp, VKI_FUTEX_WAIT, lwp, NULL, NULL);
 
@@ -985,4 +982,6 @@ void VG_(proxy_create)(ThreadId tid)
    proxy->tid = tid;
    proxy->tst = tst;
+   proxy->exitcode = 0;
+   proxy->lwp = 0;
    proxy->siginfo.si_signo = 0;
    proxy->frommain = VG_(safe_fd)(p[0]);
@@ -1313,5 +1312,5 @@ void VG_(proxy_sanity)(void)
       ThreadState *tst = &VG_(threads)[tid];
       ProxyLWP *px;
-      Int status;
+      Int status = 0;
       Int ret;

CVS commit by fitzhardinge: 

Fix up the have_settid test so it works on both plain 2.4 and 2.6 kernels.
I think this will also work on SuSE kernels.


  M +26 -12    vg_proxylwp.c   1.7


--- valgrind/coregrind/vg_proxylwp.c  #1.6:1.7
@@ -893,5 +893,7 @@ static Int have_settid = -1;	/* -1 -> un
 static Int proxy_clone(ProxyLWP *proxy)
 {
-   Int ret;
+   Int ret = -1;
+
+   proxy->lwp = -1;
 
    if (have_settid != 0) {
@@ -899,18 +901,30 @@ static Int proxy_clone(ProxyLWP *proxy)
                        LWP_stack(proxy),
                        VKI_CLONE_FS | VKI_CLONE_FILES | VKI_CLONE_VM |
-                       VKI_CLONE_SIGHAND | VKI_CLONE_THREAD /*| 
-                       VKI_CLONE_PARENT_SETTID 
-                       VKI_CLONE_CHILD_CLEARTID | VKI_CLONE_DETACHED*/, 
+                       VKI_CLONE_SIGHAND | VKI_CLONE_THREAD | 
+                       VKI_CLONE_PARENT_SETTID |
+                       VKI_CLONE_CHILD_CLEARTID | VKI_CLONE_DETACHED,
                        proxy, &proxy->lwp, &proxy->lwp);
-      if ( have_settid < 0 && !proxy->lwp ) {
+
+      if ( have_settid == -1 && (ret < 0 || proxy->lwp == 0) ) {
          have_settid = 0;
+         
+         /* Assume that not having parent_settid also means that we've
+            got 2.4-style signal handling, which means we need to do
+            more work. */
+         VG_(do_signal_routing) = True;
+
+         if (ret > 0) {
+            /* If clone actually succeeded and just ignored the
+               CLONE_PARENT_SETTID flag, then use the LWP it created
+               for us. */
          proxy->lwp = ret;
-         VG_(do_signal_routing) = True; /* XXX True, it seems kernels
-                                        which have futex also have
-                                        sensible signal handling, but
-                                        it would be nice to test it
-                                        directly. */
        }
-   } else {
+       }
+   }
+
+   if (ret < 0) {
+      vg_assert(have_settid == 0);
+      vg_assert(proxy->lwp == -1);
+
       ret = VG_(clone)(proxylwp, 
                        LWP_stack(proxy),

CVS commit by mueller: 

reverting last commit, which broke all of valgrind.


  M +4 -3      vg_proxylwp.c   1.8


--- valgrind/coregrind/vg_proxylwp.c  #1.7:1.8
@@ -895,6 +895,4 @@ static Int proxy_clone(ProxyLWP *proxy)
    Int ret = -1;
 
-   proxy->lwp = -1;
-
    if (have_settid != 0) {
       ret = VG_(clone)(proxylwp, 
@@ -921,9 +919,11 @@ static Int proxy_clone(ProxyLWP *proxy)
          }
        }
+       else 
+           have_settid = 1;
    }
 
    if (ret < 0) {
       vg_assert(have_settid == 0);
-      vg_assert(proxy->lwp == -1);
+      vg_assert(proxy->lwp == 0);
 
       ret = VG_(clone)(proxylwp,

CVS commit by nethercote: 

Fix comment


  M +1 -1      vg_to_ucode.c   1.111


--- valgrind/coregrind/vg_to_ucode.c  #1.110:1.111
@@ -2209,5 +2209,5 @@ void codegen_LODS ( UCodeBlock* cb, Int 
 
 
-/* Template for REPNE SCAS<sz>, _not_ preceded by a REP prefix. */
+/* Template for SCAS<sz>, _not_ preceded by a REP prefix. */
 static 
 void codegen_SCAS ( UCodeBlock* cb, Int sz )

On Thu, 27 Nov 2003, Dirk Mueller wrote:

> CVS commit by mueller:
>
> reverting last commit, which broke all of valgrind.

Once you guys have worked this out (the current HEAD looks ok on my
RH9/2.4.19 box, BTW), can one of you please remove references to the
--assume-2.4 option from the docs?  Thanks.

N

CVS commit by nethercote: 


Fixed up REP-prefix handling majorly.  Factored out *lots* of repetitive code,
so much so that the file is now 280 lines shorter.  This despite me also adding
support for LOOP{E,NE} (thanks to Abhijit Menon-Sen).  Also added support for
CMPS[lw], which was missing.  Adding more REP-prefix instructions in the future
will now be much easier.

As part of this, I moved the D-flag fetch outside of the REP loops.  This might
make programs that use REP prefixes a lot go faster.


  M +139 -415  vg_to_ucode.c   1.112


--- valgrind/coregrind/vg_to_ucode.c  #1.111:1.112
@@ -1807,182 +1807,55 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
 }
 
-
-/* Template for REPE CMPS<sz>.  Assumes this insn is the last one in
-   the basic block, and so emits a jump to the next insn. */
-static 
-void codegen_REPE_CMPS ( UCodeBlock* cb, Int sz, Addr eip, Addr eip_next )
+static __inline__
+void dis_JMP_d32( UCodeBlock* cb, Addr d32 )
 {
-   Int tc,  /* ECX */
-       td,  /* EDI */   ts, /* ESI */
-       tdv, /* (EDI) */ tsv /* (ESI) */;
-
-   tdv = newTemp(cb);
-   tsv = newTemp(cb);
-   td = newTemp(cb);
-   ts = newTemp(cb);
-   tc = newTemp(cb);
-
-   uInstr2(cb, GET,   4, ArchReg, R_ECX, TempReg, tc);
-   uInstr2(cb, JIFZ,  4, TempReg, tc,    Literal, 0);
-   uLiteral(cb, eip_next);
-   uInstr1(cb, DEC,   4, TempReg, tc);
-   uInstr2(cb, PUT,   4, TempReg, tc,    ArchReg, R_ECX);
-
-   uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, GET,   4, ArchReg, R_ESI, TempReg, ts);
-
-   uInstr2(cb, LOAD, sz, TempReg, td,    TempReg, tdv);
-   uInstr2(cb, LOAD, sz, TempReg, ts,    TempReg, tsv);
-
-   uInstr2(cb, SUB,  sz, TempReg, tdv,   TempReg, tsv);
-   setFlagsFromUOpcode(cb, SUB);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tdv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tdv);
-
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, tdv);
-        uInstr0(cb, CALLM_E, 0);
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tdv);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, tdv,    TempReg, td);
-   uInstr2(cb, ADD,   4, TempReg, tdv,    TempReg, ts);
-
-   uInstr2(cb, PUT,   4, TempReg, td,     ArchReg, R_EDI);
-   uInstr2(cb, PUT,   4, TempReg, ts,     ArchReg, R_ESI);
-
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip);
-   uCond(cb, CondZ);
-   uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
    uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip_next);
+   uLiteral(cb, d32);
    uCond(cb, CondAlways);
 }
 
+/*------------------------------------------------------------*/
+/*--- Disassembling string ops (including REP prefixes)    ---*/
+/*------------------------------------------------------------*/
 
-/* Template for REPNE SCAS<sz>.  Assumes this insn is the last one in
-   the basic block, and so emits a jump to the next insn. */
+/* Code shared by all the string ops */
 static 
-void codegen_REPNE_SCAS ( UCodeBlock* cb, Int sz, Addr eip, Addr eip_next )
+void dis_string_op_increment(UCodeBlock* cb, Int sz, Int t_inc)
 {
-   Int ta /* EAX */, tc /* ECX */, td /* EDI */, tv;
-   ta = newTemp(cb);
-   tc = newTemp(cb);
-   tv = newTemp(cb);
-   td = newTemp(cb);
-
-   uInstr2(cb, GET,   4, ArchReg, R_ECX, TempReg, tc);
-   uInstr2(cb, JIFZ,  4, TempReg, tc,    Literal, 0);
-   uLiteral(cb, eip_next);
-   uInstr1(cb, DEC,   4, TempReg, tc);
-   uInstr2(cb, PUT,   4, TempReg, tc,    ArchReg, R_ECX);
-
-   uInstr2(cb, GET,  sz, ArchReg, R_EAX, TempReg, ta);
-   uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, LOAD, sz, TempReg, td,    TempReg, tv);
-   /* next uinstr kills ta, but that's ok -- don't need it again */
-   uInstr2(cb, SUB,  sz, TempReg, tv,    TempReg, ta);
-   setFlagsFromUOpcode(cb, SUB);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tv);
+   uInstr0 (cb, CALLM_S, 0);
+   uInstr2 (cb, MOV,   4, Literal, 0, TempReg, t_inc);
    uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tv);
+   uInstr1 (cb, PUSH,  4, TempReg, t_inc);
 
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
+   uInstr1  (cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
    uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
 
-   uInstr1(cb, POP,   4, TempReg, tv);
+   uInstr1(cb, POP,   4, TempReg, t_inc);
    uInstr0(cb, CALLM_E, 0);
 
    if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tv);
+      uInstr2(cb, SHL, 4, Literal, 0, TempReg, t_inc);
       uLiteral(cb, sz/2);
    }
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, td);
-   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip);
-   uCond(cb, CondNZ);
-   uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip_next);
-   uCond(cb, CondAlways);
 }
 
-/* Template for REPE SCAS<sz>.  Assumes this insn is the last one in
-   the basic block, and so emits a jump to the next insn. */
 static 
-void codegen_REPE_SCAS ( UCodeBlock* cb, Int sz, Addr eip, Addr eip_next )
+void dis_string_op( UCodeBlock* cb, void (*dis_OP)( UCodeBlock*, Int, Int ), 
+                    Int sz, Char* name, UChar sorb )
 {
-   Int ta /* EAX */, tc /* ECX */, td /* EDI */, tv;
-   ta = newTemp(cb);
-   tc = newTemp(cb);
-   tv = newTemp(cb);
-   td = newTemp(cb);
-
-   uInstr2(cb, GET,   4, ArchReg, R_ECX, TempReg, tc);
-   uInstr2(cb, JIFZ,  4, TempReg, tc,    Literal, 0);
-   uLiteral(cb, eip_next);
-   uInstr1(cb, DEC,   4, TempReg, tc);
-   uInstr2(cb, PUT,   4, TempReg, tc,    ArchReg, R_ECX);
-
-   uInstr2(cb, GET,  sz, ArchReg, R_EAX, TempReg, ta);
-   uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, LOAD, sz, TempReg, td,    TempReg, tv);
-   /* next uinstr kills ta, but that's ok -- don't need it again */
-   uInstr2(cb, SUB,  sz, TempReg, tv,    TempReg, ta);
-   setFlagsFromUOpcode(cb, SUB);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tv);
-
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, tv);
-   uInstr0(cb, CALLM_E, 0);
-
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tv);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, td);
-   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip);
-   uCond(cb, CondZ);
-   uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip_next);
-   uCond(cb, CondAlways);
+   Int t_inc = newTemp(cb);
+   vg_assert(sorb == 0);
+   dis_string_op_increment(cb, sz, t_inc);
+   dis_OP( cb, sz, t_inc );
+   if (dis) VG_(printf)("%s%c\n", name, nameISize(sz));
 }
 
 
-/* Template for REPE MOVS<sz>.  Assumes this insn is the last one in
-   the basic block, and so emits a jump to the next insn. */
 static 
-void codegen_REPE_MOVS ( UCodeBlock* cb, Int sz, Addr eip, Addr eip_next )
+void dis_MOVS ( UCodeBlock* cb, Int sz, Int t_inc )
 {
-   Int ts /* ESI */, tc /* ECX */, td /* EDI */, tv;
-   tc = newTemp(cb);
-   td = newTemp(cb);
-   ts = newTemp(cb);
-   tv = newTemp(cb);
-
-   uInstr2(cb, GET,   4, ArchReg, R_ECX, TempReg, tc);
-   uInstr2(cb, JIFZ,  4, TempReg, tc,    Literal, 0);
-   uLiteral(cb, eip_next);
-   uInstr1(cb, DEC,   4, TempReg, tc);
-   uInstr2(cb, PUT,   4, TempReg, tc,    ArchReg, R_ECX);
+   Int tv = newTemp(cb);   /* value being copied */
+   Int td = newTemp(cb);   /* EDI */
+   Int ts = newTemp(cb);   /* ESI */
 
    uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
@@ -1990,48 +1863,32 @@ void codegen_REPE_MOVS ( UCodeBlock* cb,
 
    uInstr2(cb, LOAD,  sz, TempReg, ts,    TempReg, tv);
-   uInstr2(cb, STORE, sz, TempReg, tv,    TempReg, td);
+   uInstr2(cb, STORE,sz, TempReg, tv,    TempReg, td);
 
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tv);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, td);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, ts);
 
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
+   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
+   uInstr2(cb, PUT,   4, TempReg, ts,    ArchReg, R_ESI);
+}
 
-   uInstr1(cb, POP,   4, TempReg, tv);
-        uInstr0(cb, CALLM_E, 0);
+static 
+void dis_LODS ( UCodeBlock* cb, Int sz, Int t_inc )
+{
+   Int ta = newTemp(cb);   /* EAX */
+   Int ts = newTemp(cb);   /* ESI */
 
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tv);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, td);
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, ts);
+   uInstr2(cb, GET,    4, ArchReg, R_ESI, TempReg, ts);
+   uInstr2(cb, LOAD,  sz, TempReg, ts,    TempReg, ta);
+   uInstr2(cb, PUT,   sz, TempReg, ta,    ArchReg, R_EAX);
 
-   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, ts);
    uInstr2(cb, PUT,   4, TempReg, ts,    ArchReg, R_ESI);
-
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip);
-   uCond(cb, CondAlways);
 }
 
-
-/* Template for REPE STOS<sz>.  Assumes this insn is the last one in
-   the basic block, and so emits a jump to the next insn. */
 static 
-void codegen_REPE_STOS ( UCodeBlock* cb, Int sz, Addr eip, Addr eip_next )
+void dis_STOS ( UCodeBlock* cb, Int sz, Int t_inc )
 {
-   Int ta /* EAX */, tc /* ECX */, td /* EDI */;
-   ta = newTemp(cb);
-   tc = newTemp(cb);
-   td = newTemp(cb);
-
-   uInstr2(cb, GET,    4, ArchReg, R_ECX, TempReg, tc);
-   uInstr2(cb, JIFZ,   4, TempReg, tc,    Literal, 0);
-   uLiteral(cb, eip_next);
-   uInstr1(cb, DEC,    4, TempReg, tc);
-   uInstr2(cb, PUT,    4, TempReg, tc,    ArchReg, R_ECX);
+   Int ta = newTemp(cb);   /* EAX */
+   Int td = newTemp(cb);   /* EDI */
 
    uInstr2(cb, GET,   sz, ArchReg, R_EAX, TempReg, ta);
@@ -2039,38 +1896,15 @@ void codegen_REPE_STOS ( UCodeBlock* cb,
    uInstr2(cb, STORE, sz, TempReg, ta,    TempReg, td);
 
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, ta);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, ta);
-
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, ta);
-        uInstr0(cb, CALLM_E, 0);
-
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, ta);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, ta,    TempReg, td);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, td);
    uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
-
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, eip);
-   uCond(cb, CondAlways);
 }
 
-
-/* Template for CMPS<sz>, _not_ preceded by a REP prefix. */
 static 
-void codegen_CMPS ( UCodeBlock* cb, Int sz )
+void dis_CMPS ( UCodeBlock* cb, Int sz, Int t_inc )
 {
-   Int td,  /* EDI */   ts, /* ESI */
-       tdv, /* (EDI) */ tsv /* (ESI) */;
-   tdv = newTemp(cb);
-   tsv = newTemp(cb);
-   td  = newTemp(cb);
-   ts  = newTemp(cb);
+   Int tdv = newTemp(cb);  /* (EDI) */
+   Int tsv = newTemp(cb);  /* (ESI) */
+   Int td  = newTemp(cb);  /*  EDI  */
+   Int ts  = newTemp(cb);  /*  ESI  */
 
    uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
@@ -2083,60 +1917,6 @@ void codegen_CMPS ( UCodeBlock* cb, Int 
    setFlagsFromUOpcode(cb, SUB);
 
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tdv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tdv);
-
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, tdv);
-        uInstr0(cb, CALLM_E, 0);
-
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tdv);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, tdv,    TempReg, td);
-   uInstr2(cb, ADD,   4, TempReg, tdv,    TempReg, ts);
-
-   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
-   uInstr2(cb, PUT,   4, TempReg, ts,    ArchReg, R_ESI);
-}
-
-
-/* Template for MOVS<sz>, _not_ preceded by a REP prefix. */
-static 
-void codegen_MOVS ( UCodeBlock* cb, Int sz )
-{
-   Int tv, /* the value being copied */
-       td, /* EDI */ ts /* ESI */;
-   tv = newTemp(cb);
-   td = newTemp(cb);
-   ts = newTemp(cb);
-
-   uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, GET,   4, ArchReg, R_ESI, TempReg, ts);
-
-   uInstr2(cb, LOAD,  sz, TempReg, ts,    TempReg, tv);
-   uInstr2(cb, STORE, sz, TempReg, tv,    TempReg, td);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tv);
-
-   uInstr1(cb, CALLM, 0, Lit16,   VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, tv);
-        uInstr0(cb, CALLM_E, 0);
-
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tv);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, td);
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, ts);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, td);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, ts);
 
    uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
@@ -2144,104 +1924,60 @@ void codegen_MOVS ( UCodeBlock* cb, Int 
 }
 
-
-/* Template for STOS<sz>, _not_ preceded by a REP prefix. */
 static 
-void codegen_STOS ( UCodeBlock* cb, Int sz )
+void dis_SCAS ( UCodeBlock* cb, Int sz, Int t_inc )
 {
-   Int ta /* EAX */, td /* EDI */;
-   ta = newTemp(cb);
-   td = newTemp(cb);
+   Int ta  = newTemp(cb);  /*  EAX  */
+   Int td  = newTemp(cb);  /*  EDI  */
+   Int tdv = newTemp(cb);  /* (EDI) */
 
    uInstr2(cb, GET,   sz, ArchReg, R_EAX, TempReg, ta);
    uInstr2(cb, GET,    4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, STORE, sz, TempReg, ta,    TempReg, td);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, ta);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, ta);
-
-   uInstr1(cb, CALLM, 0, Lit16, VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, ta);
-        uInstr0(cb, CALLM_E, 0);
+   uInstr2(cb, LOAD, sz, TempReg, td,    TempReg, tdv);
+   /* next uinstr kills ta, but that's ok -- don't need it again */
+   uInstr2(cb, SUB,  sz, TempReg, tdv,   TempReg, ta);
+   setFlagsFromUOpcode(cb, SUB);
 
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, ta);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, ta,    TempReg, td);
+   uInstr2(cb, ADD,   4, TempReg, t_inc, TempReg, td);
    uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
 }
 
 
-/* Template for LODS<sz>, _not_ preceded by a REP prefix. */
-static 
-void codegen_LODS ( UCodeBlock* cb, Int sz )
-{
-   Int ta /* EAX */, ts /* ESI */;
-   ta = newTemp(cb);
-   ts = newTemp(cb);
-
-   uInstr2(cb, GET,    4, ArchReg, R_ESI, TempReg, ts);
-   uInstr2(cb, LOAD,  sz, TempReg, ts,    TempReg, ta);
-   uInstr2(cb, PUT,   sz, TempReg, ta,    ArchReg, R_EAX);
-
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, ta);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, ta);
-
-   uInstr1(cb, CALLM, 0, Lit16,   VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
-
-   uInstr1(cb, POP,   4, TempReg, ta);
-        uInstr0(cb, CALLM_E, 0);
-
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, ta);
-      uLiteral(cb, sz/2);
-   }
-   uInstr2(cb, ADD,   4, TempReg, ta,    TempReg, ts);
-   uInstr2(cb, PUT,   4, TempReg, ts,    ArchReg, R_ESI);
-}
-
-
-/* Template for SCAS<sz>, _not_ preceded by a REP prefix. */
+/* Wrap the appropriate string op inside a REP/REPE/REPNE.
+   We assume the insn is the last one in the basic block, and so emit a jump
+   to the next insn, rather than just falling through. */
 static 
-void codegen_SCAS ( UCodeBlock* cb, Int sz )
+void dis_REP_op ( UCodeBlock* cb, Int cond,
+                  void (*dis_OP)(UCodeBlock*, Int, Int),
+                  Int sz, Addr eip, Addr eip_next, Char* name )
 {
-   Int ta /* EAX */, td /* EDI */, tv;
-   ta = newTemp(cb);
-   tv = newTemp(cb);
-   td = newTemp(cb);
+   Int t_inc = newTemp(cb);
+   Int tc    = newTemp(cb);  /*  ECX  */
 
-   uInstr2(cb, GET,  sz, ArchReg, R_EAX, TempReg, ta);
-   uInstr2(cb, GET,   4, ArchReg, R_EDI, TempReg, td);
-   uInstr2(cb, LOAD, sz, TempReg, td,    TempReg, tv);
-   /* next uinstr kills ta, but that's ok -- don't need it again */
-   uInstr2(cb, SUB,  sz, TempReg, tv,    TempReg, ta);
-   setFlagsFromUOpcode(cb, SUB);
+   dis_string_op_increment(cb, sz, t_inc);
 
-   uInstr0(cb, CALLM_S, 0);
-   uInstr2(cb, MOV,   4, Literal, 0,     TempReg, tv);
-   uLiteral(cb, 0);
-   uInstr1(cb, PUSH,  4, TempReg, tv);
+   uInstr2 (cb, GET,   4, ArchReg, R_ECX, TempReg, tc);
+   uInstr2 (cb, JIFZ,  4, TempReg, tc,    Literal, 0);
+   uLiteral(cb, eip_next);
+   uInstr1 (cb, DEC,   4, TempReg, tc);
+   uInstr2 (cb, PUT,   4, TempReg, tc,    ArchReg, R_ECX);
 
-   uInstr1(cb, CALLM, 0, Lit16,   VGOFF_(helper_get_dirflag));
-   uFlagsRWU(cb, FlagD, FlagsEmpty, FlagsEmpty);
+   dis_OP  (cb, sz, t_inc);
 
-   uInstr1(cb, POP,   4, TempReg, tv);
-        uInstr0(cb, CALLM_E, 0);
+   if (cond == CondAlways) {
+      dis_JMP_d32  (cb, eip);
+   } else {
+      uInstr1      (cb, JMP,   0, Literal, 0);
+      uLiteral     (cb, eip);
+      uCond        (cb, cond);
+      uFlagsRWU    (cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
 
-   if (sz == 4 || sz == 2) {
-      uInstr2(cb, SHL, 4, Literal, 0, TempReg, tv);
-      uLiteral(cb, sz/2);
+      dis_JMP_d32  (cb, eip_next);
    }
-   uInstr2(cb, ADD,   4, TempReg, tv,    TempReg, td);
-   uInstr2(cb, PUT,   4, TempReg, td,    ArchReg, R_EDI);
+   if (dis) VG_(printf)("%s%c\n", name, nameISize(sz));
 }
 
+/*------------------------------------------------------------*/
+/*--- Arithmetic, etc.                                     ---*/
+/*------------------------------------------------------------*/
 
 /* (I)MUL E, G.  Supplied eip points to the modR/M byte. */
@@ -5111,4 +4847,6 @@ static Addr disInstr ( UCodeBlock* cb, A
       break;
 
+   case 0xE0: /* LOOPNE disp8 */
+   case 0xE1: /* LOOPE  disp8 */
    case 0xE2: /* LOOP disp8 */
       /* Again, the docs say this uses ECX/CX as a count depending on
@@ -5123,7 +4861,19 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, JIFZ, 4, TempReg, t1,    Literal, 0);
       uLiteral(cb, eip);
+
+      if (opc == 0xE2) {   /* LOOP */
       uInstr1(cb, JMP,  0, Literal, 0);
       uLiteral(cb, d32);
       uCond(cb, CondAlways);
+      } else {             /* LOOPE/LOOPNE */
+         uInstr1(cb, JMP,  0, Literal, 0);
+         uLiteral(cb, eip);
+         uCond(cb, (opc == 0xE1 ? CondNZ : CondZ));
+         uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
+
+         uInstr1(cb, JMP,  0, Literal, 0);
+         uLiteral(cb, d32);
+         uCond(cb, CondAlways);
+      }
       *isEnd = True;
       if (dis)
@@ -5700,54 +5450,29 @@ static Addr disInstr ( UCodeBlock* cb, A
    /* ------------------------ SCAS et al ----------------- */
 
-   case 0xA4: /* MOVSb, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_MOVS ( cb, 1 );
-      if (dis) VG_(printf)("movsb\n");
-      break;
-   case 0xA5: /* MOVSv, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_MOVS ( cb, sz );
-      if (dis) VG_(printf)("movs%c\n", nameISize(sz));
+   case 0xA4: /* MOVS, no REP prefix */
+   case 0xA5: 
+      dis_string_op( cb, dis_MOVS, ( opc == 0xA4 ? 1 : sz ), "movs", sorb );
       break;
 
    case 0xA6: /* CMPSb, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_CMPS ( cb, 1 );
-      if (dis) VG_(printf)("cmpsb\n");
+   case 0xA7:
+      dis_string_op( cb, dis_CMPS, ( opc == 0xA6 ? 1 : sz ), "cmps", sorb );
       break;
 
-   case 0xAA: /* STOSb, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_STOS ( cb, 1 );
-      if (dis) VG_(printf)("stosb\n");
-      break;
-   case 0xAB: /* STOSv, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_STOS ( cb, sz );
-      if (dis) VG_(printf)("stos%c\n", nameISize(sz));
+   case 0xAA: /* STOS, no REP prefix */
+   case 0xAB:
+      dis_string_op( cb, dis_STOS, ( opc == 0xAA ? 1 : sz ), "stos", sorb );
       break;
 
-   case 0xAC: /* LODSb, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_LODS ( cb, 1 );
-      if (dis) VG_(printf)("lodsb\n");
-      break;
-   case 0xAD: /* LODSv, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_LODS ( cb, sz );
-      if (dis) VG_(printf)("lods%c\n", nameISize(sz));
+   case 0xAC: /* LODS, no REP prefix */
+   case 0xAD:
+      dis_string_op( cb, dis_LODS, ( opc == 0xAC ? 1 : sz ), "lods", sorb );
       break;
 
-   case 0xAE: /* SCASb, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_SCAS ( cb, 1 );
-      if (dis) VG_(printf)("scasb\n");
+   case 0xAE: /* SCAS, no REP prefix */
+   case 0xAF:
+      dis_string_op( cb, dis_SCAS, ( opc == 0xAE ? 1 : sz ), "scas", sorb );
       break;
 
-   case 0xAF: /* SCASl, no REP prefix */
-      vg_assert(sorb == 0);
-      codegen_SCAS ( cb, sz );
-      if (dis) VG_(printf)("scas;\n");
-      break;
 
    case 0xFC: /* CLD */
@@ -5791,7 +5516,6 @@ static Addr disInstr ( UCodeBlock* cb, A
       if (abyte == 0xAE || abyte == 0xAF) { /* REPNE SCAS<sz> */
          if (abyte == 0xAE) sz = 1;
-         codegen_REPNE_SCAS ( cb, sz, eip_orig, eip );
+         dis_REP_op ( cb, CondNZ, dis_SCAS, sz, eip_orig, eip, "repne scas" );
          *isEnd = True;         
-         if (dis) VG_(printf)("repne scas%c\n", nameISize(sz));
       }
       else {
@@ -5801,5 +5525,7 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
-   case 0xF3: { /* REPE prefix insn */
+   /* REP/REPE prefix insn (for SCAS and CMPS, 0xF3 means REPE,
+      for the rest, it means REP) */
+   case 0xF3: { 
       Addr eip_orig = eip - 1;
       vg_assert(sorb == 0);
@@ -5807,36 +5534,33 @@ static Addr disInstr ( UCodeBlock* cb, A
       if (abyte == 0x66) { sz = 2; abyte = getUChar(eip); eip++; }
 
-      if (abyte == 0xA4 || abyte == 0xA5) { /* REPE MOV<sz> */
+      if (abyte == 0xA4 || abyte == 0xA5) { /* REP MOV<sz> */
          if (abyte == 0xA4) sz = 1;
-         codegen_REPE_MOVS ( cb, sz, eip_orig, eip );
+         dis_REP_op ( cb, CondAlways, dis_MOVS, sz, eip_orig, eip, "rep movs" );
          *isEnd = True;
-         if (dis) VG_(printf)("repe mov%c\n", nameISize(sz));
       }
       else 
       if (abyte == 0xA6 || abyte == 0xA7) { /* REPE CMP<sz> */
          if (abyte == 0xA6) sz = 1;
-         codegen_REPE_CMPS ( cb, sz, eip_orig, eip );
+         dis_REP_op ( cb, CondZ, dis_CMPS, sz, eip_orig, eip, "repe cmps" );
          *isEnd = True;
-         if (dis) VG_(printf)("repe cmps%c\n", nameISize(sz));
       } 
       else
-      if (abyte == 0xAA || abyte == 0xAB) { /* REPE STOS<sz> */
+      if (abyte == 0xAA || abyte == 0xAB) { /* REP STOS<sz> */
          if (abyte == 0xAA) sz = 1;
-         codegen_REPE_STOS ( cb, sz, eip_orig, eip );
+         dis_REP_op ( cb, CondAlways, dis_STOS, sz, eip_orig, eip, "rep stos" );
          *isEnd = True;
-         if (dis) VG_(printf)("repe stos%c\n", nameISize(sz));
       }
       else
       if (abyte == 0xAE || abyte == 0xAF) { /* REPE SCAS<sz> */
          if (abyte == 0xAE) sz = 1;
-         codegen_REPE_SCAS ( cb, sz, eip_orig, eip );
+         dis_REP_op ( cb, CondZ, dis_SCAS, sz, eip_orig, eip, "repe scas" );
          *isEnd = True;         
-         if (dis) VG_(printf)("repe scas%c\n", nameISize(sz));
       }
       else
-      if (abyte == 0x90) { /* REPE NOP (PAUSE) */
-         if (dis) VG_(printf)("repe nop (P4 pause)\n");
+      if (abyte == 0x90) { /* REP NOP (PAUSE) */
+         if (dis) VG_(printf)("rep nop (P4 pause)\n");
          /* do nothing; apparently a hint to the P4 re spin-wait loop */
-      } else {
+      } 
+      else {
          goto decode_failure;
       }

CVS commit by mueller: 

fix alignment checking of __posix_memalign. merging to stable.


  M +2 -2      vg_replace_malloc.c   1.15


--- valgrind/coregrind/vg_replace_malloc.c  #1.14:1.15
@@ -276,7 +276,7 @@ int __posix_memalign ( void **memptr, UI
     void *mem;
 
-    /* Test whether the SIZE argument is valid.  It must be a power of
+    /* Test whether the alignment argument is valid.  It must be a power of
        two multiple of sizeof (void *).  */
-    if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
+    if (alignment % sizeof (void *) != 0 || (alignment & (alignment - 1)) != 0)
        return VKI_EINVAL /*22*/ /*EINVAL*/;

CVS commit by nethercote: 

Factor out repeated code for LOOP{E,NE}


  M +4 -10     vg_to_ucode.c   1.113


--- valgrind/coregrind/vg_to_ucode.c  #1.112:1.113
@@ -4861,19 +4861,13 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, JIFZ, 4, TempReg, t1,    Literal, 0);
       uLiteral(cb, eip);
-
-      if (opc == 0xE2) {   /* LOOP */
-         uInstr1(cb, JMP,  0, Literal, 0);
-         uLiteral(cb, d32);
-         uCond(cb, CondAlways);
-      } else {             /* LOOPE/LOOPNE */
+      if (opc == 0xE0 || opc == 0xE1) {   /* LOOPE/LOOPNE */
          uInstr1(cb, JMP,  0, Literal, 0);
          uLiteral(cb, eip);
          uCond(cb, (opc == 0xE1 ? CondNZ : CondZ));
          uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
-
+      }
          uInstr1(cb, JMP,  0, Literal, 0);
          uLiteral(cb, d32);
          uCond(cb, CondAlways);
-      }
       *isEnd = True;
       if (dis)

CVS commit by nethercote: 

Fixed test in section finding code that was broken for .plt and .got sections.
Thanks to Tom Hughes for the patch.


  M +4 -7      vg_symtab2.c   1.60


--- valgrind/coregrind/vg_symtab2.c  #1.59:1.60
@@ -983,15 +983,12 @@ Bool vg_read_lib_symbols ( SegInfo* si )
             if (0 != sec_data) \
                VG_(core_panic)("repeated section!\n"); \
-            if (in_exec) { \
+            if (in_exec) \
                sec_data = (type)(si->offset + shdr[i].sh_addr); \
-               sec_size = shdr[i].sh_size; \
-            } else { \
+            else \
                sec_data = (type)(oimage + shdr[i].sh_offset); \
                sec_size = shdr[i].sh_size; \
-            } \
             TRACE_SYMTAB( "%18s: %p .. %p\n", \
                           sec_name, sec_data, sec_data + sec_size - 1); \
-            if ( sec_size  + (UChar*)sec_data > n_oimage + (UChar*)oimage) \
-            { \
+            if ( shdr[i].sh_offset + sec_size > n_oimage ) { \
                VG_(symerr)("   section beyond image end?!"); \
                goto out; \

CVS commit by nethercote: 

Add gettid() syscall.


  M +7 -0      vg_syscalls.c   1.60


--- valgrind/coregrind/vg_syscalls.c  #1.59:1.60
@@ -1937,4 +1937,10 @@ PRE(getpid)
 }
 
+PRE(gettid)
+{
+   /* pid_t gettid(void); */
+   MAYBE_PRINTF("gettid ()\n");
+}
+
 PRE(getpgid)
 {
@@ -4636,4 +4642,5 @@ static const struct sys_info sys_info[] 
    SYSB_(getgid32,              False),
    SYSB_(getpid,                False),
+   SYSB_(gettid,                False),
    SYSB_(getpgid,               False),
    SYSB_(getpgrp,               False),

In message <20031201140013.1B7969396@...>
        Nicholas Nethercote <njn25@...> wrote:

> +PRE(gettid)
> +{
> +   /* pid_t gettid(void); */
> +   MAYBE_PRINTF("gettid ()\n");
> +}

That may stop valgrind complaining, but it doesn't really do what
anybody expects as it will return the same value in all threads. In
particular a signal sent to the returned value will not go to the
right thread.

The way I've done it in my NPTL patch, which is just about complete
now, is to mark it as a blocking system call so that it is executed
in the proxy LWP which means that it will get a unique ID for each
thread, and that signals sent to that ID will get routed to the right
thread in valgrind.

Jeremy wasn't entirely sure that my solution was a good idea, or even
that it was worth trying to implement it at all at the moment. He had
some concerns about people managing to kill a proxy LWP with nasty
consequences.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Mon, 1 Dec 2003, Tom Hughes wrote:

> > +PRE(gettid)
> > +{
> > +   /* pid_t gettid(void); */
> > +   MAYBE_PRINTF("gettid ()\n");
> > +}
>
> That may stop valgrind complaining, but it doesn't really do what
> anybody expects as it will return the same value in all threads. In
> particular a signal sent to the returned value will not go to the
> right thread.
>
> The way I've done it in my NPTL patch, which is just about complete
> now, is to mark it as a blocking system call so that it is executed
> in the proxy LWP which means that it will get a unique ID for each
> thread, and that signals sent to that ID will get routed to the right
> thread in valgrind.
>
> Jeremy wasn't entirely sure that my solution was a good idea, or even
> that it was worth trying to implement it at all at the moment. He had
> some concerns about people managing to kill a proxy LWP with nasty
> consequences.

Ah.  Should I back out the changes?  In HEAD and stable branch?

N

In message <Pine.SOL.4.58.0312011423120.13180@...>
        Nicholas Nethercote <njn25@...> wrote:

> Ah.  Should I back out the changes?  In HEAD and stable branch?

Possibly. I'd be interested to know how the original submitter was
triggering the problem. Although RH9 does use gettid for certain
things I thought that it only did so when the TLS/NPTL version of
the C library was in use, and valgrind can't use that at the moment.

The main place that the C library seems to use it is raise() and
that also uses tkill() which he hasn't mentioned in the bug report.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

CVS commit by nethercote: 

Backing out bogus support for gettid() I added yesterday.


  M +0 -7      vg_syscalls.c   1.61


--- valgrind/coregrind/vg_syscalls.c  #1.60:1.61
@@ -1937,10 +1937,4 @@ PRE(getpid)
 }
 
-PRE(gettid)
-{
-   /* pid_t gettid(void); */
-   MAYBE_PRINTF("gettid ()\n");
-}
-
 PRE(getpgid)
 {
@@ -4642,5 +4636,4 @@ static const struct sys_info sys_info[] 
    SYSB_(getgid32,              False),
    SYSB_(getpid,                False),
-   SYSB_(gettid,                False),
    SYSB_(getpgid,               False),
    SYSB_(getpgrp,               False),

On Mon, 2003-12-01 at 06:23, Nicholas Nethercote wrote:
> Ah.  Should I back out the changes?  In HEAD and stable branch?

Yeah, I think so.  Without knowing the details of why this came up, the
missing gettid is probably a symptom of some other problem.  As Tom
said, just calling gettid probably isn't producing any useful results,
and there's no sensible way you can use the tid anyway.

	J

CVS commit by nethercote: 

Grouped options in the usage message so they're a bit easier to understand.


  M +23 -26    vg_main.c   1.127


--- valgrind/coregrind/vg_main.c  #1.126:1.127
@@ -637,7 +637,6 @@ static void usage ( void )
 "usage: valgrind [options] prog-and-args\n"
 "\n"
-"  core user options, with defaults in [ ], are:\n"
+"  common user options for all Valgrind tools, with defaults in [ ]:\n"
 "    --tool=<name>             Use the Valgrind tool named <name> [memcheck]\n"
-
 "    --help                    show this message\n"
 "    --version                 show version\n"
@@ -645,7 +643,20 @@ static void usage ( void )
 "    -q --quiet                run silently; only print error msgs\n"
 "    -v --verbose              be more verbose, incl counts of errors\n"
-
 "    --trace-children=no|yes   Valgrind-ise child processes? [no]\n"
-
+"    --track-fds=no|yes        Track open file descriptors? [no]\n"
+"\n"
+"  uncommon user options for all Valgrind tools:\n"
+"    --run-libc-freeres=no|yes Free up glibc memory at exit? [yes]\n"
+"    --weird-hacks=hack1,hack2,...  [none]\n"
+"         recognised hacks are: ioctl-VTIME truncate-writes lax-ioctls\n"
+"    --signal-polltime=<time>  time, in mS, we should poll for signals.\n"
+"                              Only applies for older kernels which need\n"
+"                              signal routing [50]\n"
+"    --lowlat-signals=no|yes   improve wake-up latency when a thread receives\n"
+"                              a signal [no]\n"
+"    --lowlat-syscalls=no|yes  improve wake-up latency when a thread's\n"
+"                              syscall completes [no]\n"
+"\n"
+"  user options for Valgrind tools that report errors:\n"
 "    --logfile-fd=<number>     file descriptor for messages [2=stderr]\n"
 "    --logfile=<file>          log messages to <file>.pid<pid>\n"
@@ -659,27 +669,13 @@ static void usage ( void )
 "    --gen-suppressions=no|yes print suppressions for errors detected [no]\n"
 
-"    --track-fds=no|yes        Track open file descriptors? [no]\n"
-
 "    --gdb-attach=no|yes       start GDB when errors detected? [no]\n"
 "    --gdb-path=/path/to/gdb   path to the GDB to use [/usr/bin/gdb]\n"
 "    --input-fd=<number>       file descriptor for (gdb) input [0=stdin]\n"
-
-"    --run-libc-freeres=no|yes Free up glibc memory at exit? [yes]\n"
-"    --weird-hacks=hack1,hack2,...  [none]\n"
-"         recognised hacks are: ioctl-VTIME truncate-writes lax-ioctls\n"
-"    --signal-polltime=<time>  time, in mS, we should poll for signals.\n"
-"                              Only applies for older kernels which need\n"
-"                              signal routing [50]\n"
-"    --lowlat-signals=no|yes   improve wake-up latency when a thread receives\n"
-"                              a signal [no]\n"
-"    --lowlat-syscalls=no|yes  improve wake-up latency when a thread's\n"
-"                              syscall completes [no]\n"
 "\n"
-"  %s tool user options:\n";
-
+"  user options for %s:\n";
 
    Char* usage2 = 
 "\n"
-"  core options for debugging Valgrind itself are:\n"
+"  debugging options for all Valgrind tools:\n"
 "    --sanity-level=<number>   level of sanity checking to do [1]\n"
 "    --single-step=no|yes      translate each instr separately? [no]\n"
@@ -695,10 +691,11 @@ static void usage ( void )
 "    --stop-after=<number>     switch to real CPU after executing\n"
 "                              <number> basic blocks [infinity]\n"
-"    --dump-error=<number>     show translation for basic block\n"
-"                              associated with <number>'th\n"
-"                              error context [0=don't show any]\n"
 "    --wait-for-gdb=yes|no     pause on startup to wait for gdb attach\n"
 "\n"
-"  %s tool debugging options:\n";
+"  debugging options for Valgrind tools that report errors\n"
+"    --dump-error=<number>     show translation for basic block associated\n"
+"                              with <number>'th error context [0=show none]\n"
+"\n"
+"  debugging options for %s:\n";
 
    Char* usage3 =

CVS commit by mueller: 

allow absolute paths to be specified when "which" is not found.
CCMAIL: 69140-done@...


  M +5 -1      valgrind.in   1.40


--- valgrind/coregrind/valgrind.in  #1.39:1.40
@@ -110,5 +110,9 @@
    # Ensure the program exists.  Ignore any error messages from 'which'.
    which_prog=`which $1 2> /dev/null`
-   if [ z$which_prog = z ] ; then
+   if [ z$which_prog = z ] && (echo "$1" | grep -q '/'); then
+      which_prog=$1
+   fi
+
+   if  [ z$which_prog = z ]; then
       echo "$0: '$1' not found in \$PATH, aborting."
       exit

CVS commit by mueller: 

in C, casting of lvalues is illegal.


  M +1 -1      vg_syscalls.c   1.63


--- valgrind/coregrind/vg_syscalls.c  #1.62:1.63
@@ -816,5 +816,5 @@ static Bool fd_allowed(Int fd, const Cha
 
 #define SYSNO   (tst->m_eax)            /* in PRE(x)  */
-#define res     ((Int)tst->m_eax)       /* in POST(x) */
+#define res     (tst->m_eax)    /* in POST(x) */
 #define arg1    (tst->m_ebx)
 #define arg2    (tst->m_ecx)

CVS commit by fitzhardinge: 

Patch from Tom Hughes: make --gdb-attach=yes work when a program is
killed by a fatal signal.


  M +6 -1      vg_signals.c   1.52


--- valgrind/coregrind/vg_signals.c  #1.51:1.52
@@ -1388,4 +1388,9 @@ static void vg_default_action(const vki_
       }
       
+      if (VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) {
+         ThreadState* tst = & VG_(threads)[ tid ];      
+         VG_(swizzle_esp_then_start_GDB)( tst->m_eip, tst->m_esp, tst->m_ebp );
+      }
+
       if (VG_(fatal_signal_set)) {
          VG_(fatal_sigNo) = sigNo;

CVS commit by jseward: 

Print "object doesn't have a %s" all on one line.


  M +4 -2      vg_symtab2.c   1.61


--- valgrind/coregrind/vg_symtab2.c  #1.60:1.61
@@ -677,6 +677,8 @@ void read_symtab( SegInfo* si, Char* tab
 
    if (o_strtab == NULL || o_symtab == NULL) {
-      VG_(symerr)("object doesn't have a ");
-      VG_(symerr)(tab_name);
+      Char buf[80];
+      vg_assert(VG_(strlen)(tab_name) < 40);
+      VG_(sprintf)(buf, "   object doesn't have a %s", tab_name);
+      VG_(symerr)(buf);
       return;
    }

CVS commit by jseward: 

Reword warning message emitted by fd_allowed() to make it a little clearer.


  M +6 -4      vg_syscalls.c   1.64


--- valgrind/coregrind/vg_syscalls.c  #1.63:1.64
@@ -784,8 +784,10 @@ static Bool fd_allowed(Int fd, const Cha
 {
    if (fd < 0 || fd > VG_MAX_FD || fd == VG_(clo_logfile_fd)) {
-      VG_(message)(Vg_UserMsg, "Warning: bad use of file descriptor %d in syscall %s()",
+      VG_(message)(Vg_UserMsg, 
+         "Warning: invalid file descriptor %d in syscall %s()",
                    fd, syscall);
       if (fd == VG_(clo_logfile_fd))
-         VG_(message)(Vg_UserMsg, "   Use --logfile-fd=<number> to select an alternative "
+         VG_(message)(Vg_UserMsg, 
+            "   Use --logfile-fd=<number> to select an alternative "
                       "logfile fd.");
       if (VG_(clo_verbosity) > 1) {

CVS commit by jseward: 

Patch in a DWARF1 (obsolete) line number reader, from the stable (2.0)
branch.  Apparently the Lahey Fortran compiler emits DWARF1 line
number info.


  M +299 -2    vg_dwarf.c   1.2
  M +23 -7     vg_symtab2.c   1.62
  M +10 -1     vg_symtab2.h   1.3


--- valgrind/coregrind/vg_dwarf.c  #1.1:1.2
@@ -1,4 +1,4 @@
 /*--------------------------------------------------------------------*/
-/*--- Read DWARF2 debug info.                    vg_symtab_dwarf.c ---*/
+/*--- Read DWARF2 debug info.                           vg_dwarf.c ---*/
 /*--------------------------------------------------------------------*/
 
@@ -532,5 +532,302 @@ void VG_(read_debuginfo_dwarf2) ( SegInf
 }
 
+
+/*------------------------------------------------------------*/
+/*--- Read DWARF1 format line number info.                 ---*/
+/*------------------------------------------------------------*/
+
+/* DWARF1 appears to be redundant, but nevertheless the Lahey Fortran
+   compiler generates it.
+*/
+
+/* The following three enums (dwarf_tag, dwarf_form, dwarf_attribute)
+   are taken from the file include/elf/dwarf.h in the GNU gdb-6.0
+   sources, which are Copyright 1992, 1993, 1995, 1999 Free Software
+   Foundation, Inc and naturally licensed under the GNU General Public
+   License version 2 or later. 
+*/
+
+/* Tag names and codes.  */
+
+enum dwarf_tag {
+    TAG_padding                 = 0x0000,
+    TAG_array_type              = 0x0001,
+    TAG_class_type              = 0x0002,
+    TAG_entry_point             = 0x0003,
+    TAG_enumeration_type        = 0x0004,
+    TAG_formal_parameter        = 0x0005,
+    TAG_global_subroutine       = 0x0006,
+    TAG_global_variable         = 0x0007,
+                                /* 0x0008 -- reserved */
+                                /* 0x0009 -- reserved */
+    TAG_label                   = 0x000a,
+    TAG_lexical_block           = 0x000b,
+    TAG_local_variable          = 0x000c,
+    TAG_member                  = 0x000d,
+                                /* 0x000e -- reserved */
+    TAG_pointer_type            = 0x000f,
+    TAG_reference_type          = 0x0010,
+    TAG_compile_unit            = 0x0011,
+    TAG_string_type             = 0x0012,
+    TAG_structure_type          = 0x0013,
+    TAG_subroutine              = 0x0014,
+    TAG_subroutine_type         = 0x0015,
+    TAG_typedef                 = 0x0016,
+    TAG_union_type              = 0x0017,
+    TAG_unspecified_parameters  = 0x0018,
+    TAG_variant                 = 0x0019,
+    TAG_common_block            = 0x001a,
+    TAG_common_inclusion        = 0x001b,
+    TAG_inheritance             = 0x001c,
+    TAG_inlined_subroutine      = 0x001d,
+    TAG_module                  = 0x001e,
+    TAG_ptr_to_member_type      = 0x001f,
+    TAG_set_type                = 0x0020,
+    TAG_subrange_type           = 0x0021,
+    TAG_with_stmt               = 0x0022,
+
+    /* GNU extensions */
+
+    TAG_format_label            = 0x8000,  /* for FORTRAN 77 and Fortran 90 */
+    TAG_namelist                = 0x8001,  /* For Fortran 90 */
+    TAG_function_template       = 0x8002,  /* for C++ */
+    TAG_class_template          = 0x8003   /* for C++ */
+};
+
+/* Form names and codes.  */
+
+enum dwarf_form {
+    FORM_ADDR   = 0x1,
+    FORM_REF    = 0x2,
+    FORM_BLOCK2 = 0x3,
+    FORM_BLOCK4 = 0x4,
+    FORM_DATA2  = 0x5,
+    FORM_DATA4  = 0x6,
+    FORM_DATA8  = 0x7,
+    FORM_STRING = 0x8
+};
+
+/* Attribute names and codes.  */
+
+enum dwarf_attribute {
+    AT_sibling                  = (0x0010|FORM_REF),
+    AT_location                 = (0x0020|FORM_BLOCK2),
+    AT_name                     = (0x0030|FORM_STRING),
+    AT_fund_type                = (0x0050|FORM_DATA2),
+    AT_mod_fund_type            = (0x0060|FORM_BLOCK2),
+    AT_user_def_type            = (0x0070|FORM_REF),
+    AT_mod_u_d_type             = (0x0080|FORM_BLOCK2),
+    AT_ordering                 = (0x0090|FORM_DATA2),
+    AT_subscr_data              = (0x00a0|FORM_BLOCK2),
+    AT_byte_size                = (0x00b0|FORM_DATA4),
+    AT_bit_offset               = (0x00c0|FORM_DATA2),
+    AT_bit_size                 = (0x00d0|FORM_DATA4),
+                                /* (0x00e0|FORM_xxxx) -- reserved */
+    AT_element_list             = (0x00f0|FORM_BLOCK4),
+    AT_stmt_list                = (0x0100|FORM_DATA4),
+    AT_low_pc                   = (0x0110|FORM_ADDR),
+    AT_high_pc                  = (0x0120|FORM_ADDR),
+    AT_language                 = (0x0130|FORM_DATA4),
+    AT_member                   = (0x0140|FORM_REF),
+    AT_discr                    = (0x0150|FORM_REF),
+    AT_discr_value              = (0x0160|FORM_BLOCK2),
+                                /* (0x0170|FORM_xxxx) -- reserved */
+                                /* (0x0180|FORM_xxxx) -- reserved */
+    AT_string_length            = (0x0190|FORM_BLOCK2),
+    AT_common_reference         = (0x01a0|FORM_REF),
+    AT_comp_dir                 = (0x01b0|FORM_STRING),
+        AT_const_value_string   = (0x01c0|FORM_STRING),
+        AT_const_value_data2    = (0x01c0|FORM_DATA2),
+        AT_const_value_data4    = (0x01c0|FORM_DATA4),
+        AT_const_value_data8    = (0x01c0|FORM_DATA8),
+        AT_const_value_block2   = (0x01c0|FORM_BLOCK2),
+        AT_const_value_block4   = (0x01c0|FORM_BLOCK4),
+    AT_containing_type          = (0x01d0|FORM_REF),
+        AT_default_value_addr   = (0x01e0|FORM_ADDR),
+        AT_default_value_data2  = (0x01e0|FORM_DATA2),
+        AT_default_value_data4  = (0x01e0|FORM_DATA4),
+        AT_default_value_data8  = (0x01e0|FORM_DATA8),
+        AT_default_value_string = (0x01e0|FORM_STRING),
+    AT_friends                  = (0x01f0|FORM_BLOCK2),
+    AT_inline                   = (0x0200|FORM_STRING),
+    AT_is_optional              = (0x0210|FORM_STRING),
+        AT_lower_bound_ref      = (0x0220|FORM_REF),
+        AT_lower_bound_data2    = (0x0220|FORM_DATA2),
+        AT_lower_bound_data4    = (0x0220|FORM_DATA4),
+        AT_lower_bound_data8    = (0x0220|FORM_DATA8),
+    AT_private                  = (0x0240|FORM_STRING),
+    AT_producer                 = (0x0250|FORM_STRING),
+    AT_program                  = (0x0230|FORM_STRING),
+    AT_protected                = (0x0260|FORM_STRING),
+    AT_prototyped               = (0x0270|FORM_STRING),
+    AT_public                   = (0x0280|FORM_STRING),
+    AT_pure_virtual             = (0x0290|FORM_STRING),
+    AT_return_addr              = (0x02a0|FORM_BLOCK2),
+    AT_abstract_origin          = (0x02b0|FORM_REF),
+    AT_start_scope              = (0x02c0|FORM_DATA4),
+    AT_stride_size              = (0x02e0|FORM_DATA4),
+        AT_upper_bound_ref      = (0x02f0|FORM_REF),
+        AT_upper_bound_data2    = (0x02f0|FORM_DATA2),
+        AT_upper_bound_data4    = (0x02f0|FORM_DATA4),
+        AT_upper_bound_data8    = (0x02f0|FORM_DATA8),
+    AT_virtual                  = (0x0300|FORM_STRING),
+
+    /* GNU extensions.  */
+
+    AT_sf_names                 = (0x8000|FORM_DATA4),
+    AT_src_info                 = (0x8010|FORM_DATA4),
+    AT_mac_info                 = (0x8020|FORM_DATA4),
+    AT_src_coords               = (0x8030|FORM_DATA4),
+    AT_body_begin               = (0x8040|FORM_ADDR),
+    AT_body_end                 = (0x8050|FORM_ADDR)
+};
+
+/* end of enums taken from gdb-6.0 sources */
+
+void VG_(read_debuginfo_dwarf1) ( 
+        SegInfo* si, 
+        UChar* dwarf1d, Int dwarf1d_sz, 
+        UChar* dwarf1l, Int dwarf1l_sz )
+{
+   UInt   stmt_list;
+   Bool   stmt_list_found;
+   Int    die_offset, die_szb, at_offset;
+   UShort die_kind, at_kind;
+   UChar* at_base;
+   UChar* src_filename;
+
+   if (0) 
+      VG_(printf)("read_debuginfo_dwarf1 ( %p, %d, %p, %d )\n",
+                  dwarf1d, dwarf1d_sz, dwarf1l, dwarf1l_sz );
+
+   /* This loop scans the DIEs. */
+   die_offset = 0;
+   while (True) {
+      if (die_offset >= dwarf1d_sz) break;
+
+      die_szb  = *(Int*)(dwarf1d + die_offset);
+      die_kind = *(UShort*)(dwarf1d + die_offset + 4);
+
+      /* We're only interested in compile_unit DIEs; ignore others. */
+      if (die_kind != TAG_compile_unit) {
+         die_offset += die_szb;
+         continue; 
+      }
+
+      if (0) 
+         VG_(printf)("compile-unit DIE: offset %d, tag 0x%x, size %d\n", 
+                     die_offset, (Int)die_kind, die_szb );
+
+      /* We've got a compile_unit DIE starting at (dwarf1d +
+         die_offset+6).  Try and find the AT_name and AT_stmt_list
+         attributes.  Then, finally, we can read the line number info
+         for this source file. */
+
+      /* The next 3 are set as we find the relevant attrs. */
+      src_filename    = NULL;
+      stmt_list_found = False;
+      stmt_list       = 0;
+
+      /* This loop scans the Attrs inside compile_unit DIEs. */
+      at_base = dwarf1d + die_offset + 6;
+      at_offset = 0;
+      while (True) {
+         if (at_offset >= die_szb-6) break;
+
+         at_kind = *(UShort*)(at_base + at_offset);
+         if (0) VG_(printf)("atoffset %d, attag 0x%x\n", 
+                            at_offset, (Int)at_kind );
+         at_offset += 2; /* step over the attribute itself */
+         /* We have to examine the attribute to figure out its
+            length. */
+         switch (at_kind) {
+            case AT_stmt_list:
+            case AT_language:
+            case AT_sibling:
+               if (at_kind == AT_stmt_list) {
+                  stmt_list_found = True;
+                  stmt_list = *(Int*)(at_base+at_offset);
+               }
+               at_offset += 4; break;
+            case AT_high_pc:
+            case AT_low_pc: 
+               at_offset += sizeof(void*); break;
+            case AT_name: 
+            case AT_producer:
+            case AT_comp_dir:
+               /* Zero terminated string, step over it. */
+               if (at_kind == AT_name)
+                  src_filename = at_base + at_offset;
+               while (at_offset < die_szb-6 && at_base[at_offset] != 0)
+                  at_offset++;
+               at_offset++;
+               break;
+            default: 
+               VG_(printf)("Unhandled DWARF-1 attribute 0x%x\n", 
+                           (Int)at_kind );
+               VG_(core_panic)("Unhandled DWARF-1 attribute");
+         } /* switch (at_kind) */
+      } /* looping over attributes */
+
+      /* So, did we find the required stuff for a line number table in
+         this DIE?  If yes, read it. */
+      if (stmt_list_found /* there is a line number table */
+          && src_filename != NULL /* we know the source filename */
+         ) {
+         /* Table starts:
+               Length: 
+                  4 bytes, includes the entire table
+               Base address: 
+                  unclear (4? 8?), assuming native pointer size here.
+            Then a sequence of triples
+               (source line number -- 32 bits
+                source line column -- 16 bits
+                address delta -- 32 bits)
+         */
+         Addr   base;
+         Int    len;
+         Char*  curr_filenm;
+         UChar* ptr;
+         UInt   prev_line, prev_delta;
+
+         curr_filenm = VG_(addStr) ( si, src_filename, -1 );
+         prev_line = prev_delta = 0;
+
+         ptr = dwarf1l + stmt_list;
+         len  =        *(Int*)ptr;    ptr += sizeof(Int);
+         base = (Addr)(*(void**)ptr); ptr += sizeof(void*);
+         len -= (sizeof(Int) + sizeof(void*));
+         while (len > 0) {
+            UInt   line;
+            UShort col;
+            UInt   delta;
+            line = *(UInt*)ptr;  ptr += sizeof(UInt);
+            col = *(UShort*)ptr;  ptr += sizeof(UShort);
+            delta = *(UShort*)ptr;  ptr += sizeof(UInt);
+            if (0) VG_(printf)("line %d, col %d, delta %d\n", 
+                               line, (Int)col, delta );
+            len -= (sizeof(UInt) + sizeof(UShort) + sizeof(UInt));
+
+            if (delta > 0 && prev_line > 0) {
+               if (0) VG_(printf) ("     %d  %d-%d\n",
+                                   prev_line, prev_delta, delta-1);
+               VG_(addLineInfo) ( si, curr_filenm, 
+                                  base + prev_delta, base + delta,
+                                  prev_line, 0 );
+            }
+            prev_line = line;
+            prev_delta = delta;
+         }        
+      }  
+
+      /* Move on the the next DIE. */
+      die_offset += die_szb;
+
+   } /* Looping over DIEs */
+
+}
+
+
 /*--------------------------------------------------------------------*/
-/*--- end                                        vg_symtab_dwarf.c ---*/
+/*--- end                                               vg_dwarf.c ---*/
 /*--------------------------------------------------------------------*/

--- valgrind/coregrind/vg_symtab2.c  #1.61:1.62
@@ -969,4 +969,6 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       UChar*     stabstr      = NULL; /* .stabstr      (stabs)  */
       UChar*     debug_line   = NULL; /* .debug_line   (dwarf2) */
+      UChar*     dwarf1d      = NULL; /* .debug        (dwarf1) */
+      UChar*     dwarf1l      = NULL; /* .line         (dwarf1) */
 
       /* Section sizes, in bytes */
@@ -978,8 +980,12 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       UInt       stabstr_sz      = 0;
       UInt       debug_line_sz   = 0;
+      UInt       dwarf1d_sz      = 0;
+      UInt       dwarf1l_sz      = 0;
+
+      Bool       has_debuginfo = False;
 
       /* Find all interesting sections */
       for (i = 0; i < ehdr->e_shnum; i++) {
-         #define FIND(sec_name, sec_data, sec_size, in_exec, type) \
+#        define FIND(sec_name, sec_data, sec_size, in_exec, type) \
          if (0 == VG_(strcmp)(sec_name, sh_strtab + shdr[i].sh_name)) { \
             if (0 != sec_data) \
@@ -1008,9 +1014,11 @@ Bool vg_read_lib_symbols ( SegInfo* si )
          else FIND(".stabstr",      stabstr,      stabstr_sz,    0, UChar*)
          else FIND(".debug_line",   debug_line,   debug_line_sz, 0, UChar*)
+         else FIND(".debug",        dwarf1d,      dwarf1d_sz,    0, UChar*)
+         else FIND(".line",         dwarf1l,      dwarf1l_sz,    0, UChar*)
 
          else FIND(".got",         si->got_start, si->got_size,  1, Addr)
          else FIND(".plt",         si->plt_start, si->plt_size,  1, Addr)
 
-         #undef FIND
+#        undef FIND
          
          /* Check some sizes */
@@ -1029,10 +1037,18 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       /* Read the stabs and/or dwarf2 debug information, if any. */
       if (stab != NULL && stabstr != NULL) {
-         VG_(read_debuginfo_stabs) ( si, stab, stab_sz, stabstr, stabstr_sz );
-
-      } else if (debug_line) {
+         has_debuginfo = True;
+         VG_(read_debuginfo_stabs) ( si, stab, stab_sz, 
+                                         stabstr, stabstr_sz );
+      }
+      if (debug_line) {
+         has_debuginfo = True;
          VG_(read_debuginfo_dwarf2) ( si, debug_line, debug_line_sz );
-
-      } else {
+      }
+      if (dwarf1d && dwarf1l) {
+         has_debuginfo = True;
+         VG_(read_debuginfo_dwarf1) ( si, dwarf1d, dwarf1d_sz, 
+                                          dwarf1l, dwarf1l_sz );
+      } 
+      if (!has_debuginfo) {
          VG_(symerr)("   object doesn't have any debug info");
          goto out;

--- valgrind/coregrind/vg_symtab2.h  #1.2:1.3
@@ -186,5 +186,14 @@ void VG_(read_debuginfo_stabs) ( SegInfo
    DWARF2 reader
    -------------------- */
-void VG_(read_debuginfo_dwarf2) ( SegInfo* si, UChar* dwarf2, Int dwarf2_sz );
+void VG_(read_debuginfo_dwarf2) ( SegInfo* si, 
+                                  UChar* dwarf2, Int dwarf2_sz );
+
+/* --------------------
+   DWARF1 reader
+   -------------------- */
+void VG_(read_debuginfo_dwarf1) ( SegInfo* si, 
+                                  UChar* dwarf1d, Int dwarf1d_sz, 
+                                  UChar* dwarf1l, Int dwarf1l_sz );
+
 
 #endif /* _VG_SYMTYPE_H */

CVS commit by jseward: 

Increase the max size of the translation cache from 200k average bbs to
300k average bbs.  Programs on the size of OOo (680m17) are thrashing the
cache at the smaller size, creating large numbers of retranslations and
wasting significant time as a result.


  M +2 -2      vg_transtab.c   1.25


--- valgrind/coregrind/vg_transtab.c  #1.24:1.25
@@ -50,5 +50,5 @@ static /* const */ Int vg_tc_sector_szB 
 /* Number of entries in the translation table.  This must be a prime
    number in order to make the hashing work properly. */
-#define VG_TT_SIZE /*5281*/ /*100129*/ 200191 /*250829*/
+#define VG_TT_SIZE /*5281*/ /*100129*/ /*200191*/ /*250829*/ 300007
 
 /* Do an LRU pass when the translation table becomes this full. */
@@ -652,5 +652,5 @@ void VG_(init_tt_tc) ( void )
    /* Ensure the calculated value is not way crazy. */
    vg_assert(vg_tc_sector_szB >= 200000);
-   vg_assert(vg_tc_sector_szB <= 6000000);
+   vg_assert(vg_tc_sector_szB <= 8000000);
 
    for (s = 0; s < VG_TC_N_SECTORS; s++) {

CVS commit by mueller: 

patch by Jim Meyering: redirect error output to stderr, and exit with nonzero
exit code upon failure.


  M +18 -18    valgrind.in   1.41


--- valgrind/coregrind/valgrind.in  #1.40:1.41
@@ -80,10 +80,10 @@
 tool_so="vgskin_${tool}.so"
 if [ ! -r "$tooldir/$tool_so" ] ; then
-   echo
-   echo "Tool error:"
-   echo "  The shared library \`$tool_so' for the chosen"
-   echo "  tool \`$tool' could not be found in"
-   echo "  $tooldir"
-   echo
+   echo >&2
+   echo "Tool error:" >&2
+   echo "  The shared library \`$tool_so' for the chosen" >&2
+   echo "  tool \`$tool' could not be found in" >&2
+   echo "  $tooldir" >&2
+   echo >&2
    exit 1
 fi
@@ -115,6 +115,6 @@
 
    if  [ z$which_prog = z ]; then
-      echo "$0: '$1' not found in \$PATH, aborting."
-      exit
+      echo "$0: '$1' not found in \$PATH, aborting." >&2
+      exit 1
    fi
 
@@ -123,17 +123,17 @@
       # Ensure the program isn't statically linked.
       *"statically linked"*)
-        echo "\`$which_prog' is statically linked"
-        echo "Valgrind only works on dynamically linked executables;  your"
-        echo "program must rely on at least one shared object for Valgrind"
-        echo "to work with it.  Read FAQ #5 for more information."
+        echo "\`$which_prog' is statically linked" >&2
+        echo "Valgrind only works on dynamically linked executables;  your" >&2
+        echo "program must rely on at least one shared object for Valgrind" >&2
+        echo "to work with it.  Read FAQ #5 for more information." >&2
         exit 1 ;;
       # Ensure that there are no setuid or gid flags
       *:\ set?id\ ELF*)
-        echo "\`$which_prog' is suid/sgid."
-        echo "Valgrind can't handle these executables, as it"
-        echo "requires the LD_PRELOAD feature in order to work."
-        echo ""
-        echo "Remove those flags and try again."
-        echo ""
+        echo "\`$which_prog' is suid/sgid." >&2
+        echo "Valgrind can't handle these executables, as it" >&2
+        echo "requires the LD_PRELOAD feature in order to work." >&2
+        echo "" >&2
+        echo "Remove those flags and try again." >&2
+        echo "" >&2
         exit 1
         ;;

CVS commit by fitzhardinge: 

Make symbol prefix matching table driver, and be a bit more careful
about overrunning the ends of names.


  M +34 -15    vg_symtab2.c   1.64


--- valgrind/coregrind/vg_symtab2.c  #1.63:1.64
@@ -408,28 +408,47 @@ static RiSym *prefersym(RiSym *a, RiSym 
 {
    Int pfx;
+   Int lena, lenb;
+   Int i;
+   static const struct {
+      const Char *prefix;
+      Int len;
+   } prefixes[] = {
+#define PFX(x)  { x, sizeof(x)-1 }
+      /* order from longest to shortest */
+      PFX("__GI___libc_"),
+      PFX("__GI___"),
+      PFX("__libc_"),
+      PFX("__GI__"),
+      PFX("__GI_"),
+      PFX("__"),
+#undef PFX
+   };
+
+   lena = VG_(strlen)(a->name);
+   lenb = VG_(strlen)(b->name);
 
    /* rearrange so that a is the long one */
-   if (VG_(strlen)(a->name) < VG_(strlen)(b->name)) {
+   if (lena < lenb) {
       RiSym *t;
+      Int lt;
 
       t = a;
       a = b;
       b = t;
+
+      lt = lena;
+      lena = lenb;
+      lenb = lt;
    }
 
-   pfx = 0;
+   for(i = pfx = 0; i < sizeof(prefixes)/sizeof(*prefixes); i++) {
+      Int pfxlen = prefixes[i].len;
    
-   if      (VG_(memcmp)(a->name, "__GI___libc_", 12) == 0)
-      pfx = 12;
-   else if (VG_(memcmp)(a->name, "__libc_", 7) == 0)
-      pfx = 7;
-   else if (VG_(memcmp)(a->name, "__GI___", 7) == 0)
-      pfx = 7;
-   else if (VG_(memcmp)(a->name, "__GI__", 6) == 0)
-      pfx = 6;
-   else if (VG_(memcmp)(a->name, "__GI_", 5) == 0)
-      pfx = 5;
-   else if (VG_(memcmp)(a->name, "__", 2) == 0)
-      pfx = 2;
+      if (pfxlen < lena &&
+          VG_(memcmp)(a->name, prefixes[i].prefix, pfxlen) == 0) {
+         pfx = pfxlen;
+         break;
+      }
+   }
 
    if (pfx != 0 && VG_(strcmp)(a->name + pfx, b->name) == 0)

CVS commit by fitzhardinge: 

Change the --track-fds code to use VG_AR_CORE rather than
VG_(malloc)/(strdup), which puts things into VG_AR_SKIN.


  M +9 -2      vg_mylibc.c   1.59
  M +7 -7      vg_syscalls.c   1.66


--- valgrind/coregrind/vg_mylibc.c  #1.58:1.59
@@ -969,6 +969,13 @@ __inline__ Char* VG_(arena_strdup) ( Are
 {
    Int   i;
-   Int   len = VG_(strlen)(s) + 1;
-   Char* res = VG_(arena_malloc) (aid, len);
+   Int   len;
+   Char* res;
+
+   if (s == NULL)
+      return NULL;
+
+   len = VG_(strlen)(s) + 1;
+   res = VG_(arena_malloc) (aid, len);
+
    for (i = 0; i < len; i++)
       res[i] = s[i];

--- valgrind/coregrind/vg_syscalls.c  #1.65:1.66
@@ -292,5 +292,5 @@ Char *resolve_fname(Int fd)
       return NULL;
 
-   return ((buf[0] == '/') ? VG_(strdup)(buf) : NULL);
+   return ((buf[0] == '/') ? VG_(arena_strdup)(VG_AR_CORE, buf) : NULL);
 }
 
@@ -312,6 +312,6 @@ void record_fd_close(Int tid, Int fd)
             i->next->prev = i->prev;
          if(i->pathname) 
-            VG_(free) (i->pathname);
-         VG_(free) (i);
+            VG_(arena_free) (VG_AR_CORE, i->pathname);
+         VG_(arena_free) (VG_AR_CORE, i);
          fd_count--;
          break;
@@ -340,5 +340,5 @@ void record_fd_open(Int tid, Int fd, cha
    while (i) {
       if (i->fd == fd) {
-         if (i->pathname) VG_(free)(i->pathname);
+         if (i->pathname) VG_(arena_free)(VG_AR_CORE, i->pathname);
          break;
       }
@@ -348,5 +348,5 @@ void record_fd_open(Int tid, Int fd, cha
    /* Not already one: allocate an OpenFd */
    if (i == NULL) {
-      i = VG_(malloc)(sizeof(OpenFd));
+      i = VG_(arena_malloc)(VG_AR_CORE, sizeof(OpenFd));
 
       i->prev = NULL;
@@ -3351,5 +3351,5 @@ POST(open)
    } else {
       if(VG_(clo_track_fds))
-         record_fd_open(tid, res, VG_(strdup)((Char*)arg1));
+         record_fd_open(tid, res, VG_(arena_strdup)(VG_AR_CORE, (Char*)arg1));
    }
    MAYBE_PRINTF("%d\n",res);
@@ -3395,5 +3395,5 @@ POST(creat)
    } else {
       if(VG_(clo_track_fds))
-         record_fd_open(tid, res, VG_(strdup)((Char*)arg1));
+         record_fd_open(tid, res, VG_(arena_strdup)(VG_AR_CORE, (Char*)arg1));
    }
    MAYBE_PRINTF("%d\n",res);

CVS commit by fitzhardinge: 

Remove coregrind/vg_valgrinq_dummy.c


  R            vg_valgrinq_dummy.c   1.5

CVS commit by rjwalsh: 

Ignore internal Valgrind file descriptors.


  M +3 -0      vg_syscalls.c   1.69


--- valgrind/coregrind/vg_syscalls.c  #1.68:1.69
@@ -312,4 +312,7 @@ void record_fd_close(Int tid, Int fd)
    OpenFd *i = allocated_fds;
 
+   if (fd > VG_MAX_FD)
+      return;                   /* Valgrind internal */
+
    while(i) {
       if(i->fd == fd) {

CVS commit by fitzhardinge: 

Fix a bug in the last VG_(max_fd) change; VG_(safe_fd) doesn't work before
VG_(max_fd) has been set up.


  M +6 -6      vg_main.c   1.132
  M +2 -0      vg_mylibc.c   1.62


--- valgrind/coregrind/vg_main.c  #1.131:1.132
@@ -155,5 +155,5 @@ Int VG_(main_pgrp);
 
 /* Maximum allowed application-visible file descriptor */
-Int VG_(max_fd);
+Int VG_(max_fd) = -1;
 
 /* Words. */
@@ -1404,9 +1404,4 @@ void VG_(main) ( const KickstartParams *
    vg_assert(VG_(clstk_end) == VG_(client_end));
 
-   if (kp->vgexecfd != -1)
-      VG_(vgexecfd) = VG_(safe_fd)(kp->vgexecfd);
-   if (kp->clexecfd != -1)
-      VG_(clexecfd) = VG_(safe_fd)(kp->clexecfd);
-
    if (0) {
       if (VG_(have_ssestate))
@@ -1438,4 +1433,9 @@ void VG_(main) ( const KickstartParams *
    VG_(setrlimit)(VKI_RLIMIT_NOFILE, &rl);
 
+   if (kp->vgexecfd != -1)
+      VG_(vgexecfd) = VG_(safe_fd)(kp->vgexecfd);
+   if (kp->clexecfd != -1)
+      VG_(clexecfd) = VG_(safe_fd)(kp->clexecfd);
+
    /* Read /proc/self/maps into a buffer.  Must be before:
       - SK_(pre_clo_init)(): so that if it calls VG_(malloc)(), any mmap'd

--- valgrind/coregrind/vg_mylibc.c  #1.61:1.62
@@ -1204,4 +1204,6 @@ Int VG_(safe_fd)(Int oldfd)
    Int newfd;
 
+   vg_assert(VG_(max_fd) != -1);
+
    newfd = VG_(fcntl)(oldfd, VKI_F_DUPFD, VG_(max_fd)+1);
    if (newfd != -1)

CVS commit by fitzhardinge: 

VG_(clo_pointercheck) is a Bool, which is a byte.


  M +4 -4      vg_dispatch.S   1.14


--- valgrind/coregrind/vg_dispatch.S  #1.13:1.14
@@ -78,6 +78,6 @@
 
         /* check to see if we're doing pointer checking */
-        movl    VG_(clo_pointercheck), %eax
-        testl   %eax,%eax
+        movb    VG_(clo_pointercheck), %al
+        testb   %al,%al
         jz      1f
         
@@ -148,6 +148,6 @@
         
 run_innerloop_exit:
-        movl    VG_(clo_pointercheck), %ebx
-        testl   %ebx,%ebx
+        movb    VG_(clo_pointercheck), %bl
+        testb   %bl,%bl
         jz      1f

CVS commit by fitzhardinge: 

Also remove vgpreload_*.so from LD_PRELOAD when we're not tracing
children.


  M +3 -0      vg_syscalls.c   1.71


--- valgrind/coregrind/vg_syscalls.c  #1.70:1.71
@@ -1690,4 +1690,7 @@ PRE(execve)
          VG_(mash_colon_env)(ld_preload_str, buf);
 
+         VG_(sprintf)(buf, "%s*/vgpreload_*.so", VG_(libdir));
+         VG_(mash_colon_env)(ld_preload_str, buf);
+
          VG_(sprintf)(buf, "%s*", VG_(libdir));
          VG_(mash_colon_env)(ld_library_path_str, buf);

CVS commit by fitzhardinge: 

Make --trace-codegen start printing from the first basic block, rather
than the second.


  M +1 -1      vg_translate.c   1.65


--- valgrind/coregrind/vg_translate.c  #1.64:1.65
@@ -2387,5 +2387,5 @@ void VG_(translate) ( /*IN*/  ThreadId t
       before --trace-codegen= style printing takes effect. */
    notrace_until_done
-      = VG_(overall_in_count) > notrace_until_limit;
+      = VG_(overall_in_count) >= notrace_until_limit;
 
    seg = VG_(find_segment)(orig_addr);

CVS commit by fitzhardinge: 

Don't print prediction info for branches if we're not generating it.


  M +3 -0      vg_from_ucode.c   1.70


--- valgrind/coregrind/vg_from_ucode.c  #1.69:1.70
@@ -93,4 +93,7 @@ static JumpPred static_pred(Condcode con
 static const Char *predstr(JumpPred p)
 {
+   if (!VG_(clo_branchpred))
+      return "";
+
    switch(p) {
    default:

CVS commit by fitzhardinge: 

Fix typo in VG_(munmap)() error checking, which made it never remove
any Segment mappings.


  M +1 -1      vg_mylibc.c   1.63


--- valgrind/coregrind/vg_mylibc.c  #1.62:1.63
@@ -307,5 +307,5 @@ Int VG_(munmap)( void* start, Int length
 {
    Int res = VG_(do_syscall)(__NR_munmap, (UInt)start, (UInt)length );
-   if (!VG_(is_kerror))
+   if (!VG_(is_kerror)(res))
       VG_(unmap_range)((Addr)start, length);
    return VG_(is_kerror)(res) ? -1 : 0;

CVS commit by jseward: 

Make the debug printing in the symbol redirect machinery, easier to
understand.


  M +22 -13    vg_symtab2.c   1.66


--- valgrind/coregrind/vg_symtab2.c  #1.65:1.66
@@ -1912,4 +1912,8 @@ void VG_(mini_stack_dump) ( Addr eips[],
 /*------------------------------------------------------------*/
 
+/* Set to True for debug printing. */
+static const Bool verbose_redir = False;
+
+
 /* resolved redirections, indexed by from_addr */
 typedef struct _CodeRedirect {
@@ -1986,5 +1990,4 @@ static Bool resolve_redir(CodeRedirect *
 {
    Bool resolved;
-   static const Bool verbose = False;
 
    vg_assert(si != NULL);
@@ -1997,6 +2000,6 @@ static Bool resolve_redir(CodeRedirect *
    resolved = (redir->from_addr != 0) && (redir->to_addr != 0);
 
-   if (verbose)
-      VG_(printf)("trying to resolve %s:%s / %s:%s against %s:%s\n",
+   if (0 && verbose_redir)
+      VG_(printf)("   consider FROM binding %s:%s -> %s:%s in %s(%s)\n",
                   redir->from_lib, redir->from_sym,
                   redir->to_lib, redir->to_sym,
@@ -2010,7 +2013,7 @@ static Bool resolve_redir(CodeRedirect *
       if (match_lib(redir->from_lib, si)) {
          redir->from_addr = reverse_search_one_symtab(si, redir->from_sym);
-         if (verbose)
-            VG_(printf)("match lib %s passed; from_addr=%p\n", 
-                        redir->from_lib, redir->from_addr);
+         if (verbose_redir && redir->from_addr != 0)
+            VG_(printf)("   bind FROM: %p = %s:%s\n", 
+                        redir->from_addr,redir->from_lib, redir->from_sym );
       }
    }
@@ -2021,7 +2024,8 @@ static Bool resolve_redir(CodeRedirect *
       if (match_lib(redir->to_lib, si)) {
          redir->to_addr = reverse_search_one_symtab(si, redir->to_sym);
-         if (verbose)
-            VG_(printf)("match lib %s passed; to_addr=%p\n", 
-                        redir->to_lib, redir->to_addr);
+         if (verbose_redir && redir->to_addr != 0)
+            VG_(printf)("   bind   TO: %p = %s:%s\n", 
+                        redir->to_addr,redir->to_lib, redir->to_sym );
+
       }
    }
@@ -2029,5 +2033,5 @@ static Bool resolve_redir(CodeRedirect *
    resolved = (redir->from_addr != 0) && (redir->to_addr != 0);
 
-   if (verbose)
+   if (0 && verbose_redir)
       VG_(printf)("resolve_redir: %s:%s from=%p %s:%s to=%p\n",
                   redir->from_lib, redir->from_sym, redir->from_addr, 
@@ -2035,6 +2039,6 @@ static Bool resolve_redir(CodeRedirect *
 
    if (resolved) {
-      if (VG_(clo_verbosity) > 2 || verbose) {
-         VG_(message)(Vg_DebugMsg, "redir resolved (%s:%s=%p -> ",
+      if (VG_(clo_verbosity) > 2 || verbose_redir) {
+         VG_(message)(Vg_DebugMsg, "  redir resolved (%s:%s=%p -> ",
                       redir->from_lib, redir->from_sym, redir->from_addr);
          VG_(message)(Vg_DebugMsg, "                %s:%s=%p)",
@@ -2061,4 +2065,8 @@ static void resolve_seg_redirs(SegInfo *
    CodeRedirect *redir, *next;
 
+   if (verbose_redir)
+      VG_(printf)("Considering redirs to/from %s(soname=%s)\n",
+                  si->filename, si->soname);
+
    /* visit each unresolved redir - if it becomes resolved, then
       remove it from the unresolved list */

CVS commit by jseward: 

Use the redir machinery to forcibly remap stpcpy in libc.so.6 to our
own version in mac_replace_strmem.c.  We have to do this the hard way
because overenthusiastic PLT bypassing in glibc means the usual
symbol-override stuff doesn't work.  IOW, for the usual reason that we
have to use the redir machinery at all.

This makes many programs run much more quietly on SuSE 9.


  M +11 -5     vg_symtab2.c   1.67


--- valgrind/coregrind/vg_symtab2.c  #1.66:1.67
@@ -2107,4 +2107,9 @@ void VG_(add_redirect_sym)(const Char *f
    redir->to_addr = 0;
 
+   if (VG_(clo_verbosity) >= 2)
+      VG_(message)(Vg_UserMsg, 
+                   "REDIRECT %s(%s) to %s(%s)",
+                   from_lib, from_sym, to_lib, to_sym);
+
    if (!resolve_redir_allsegs(redir)) {
       /* can't resolve immediately; add to list */
@@ -2164,11 +2169,12 @@ void VG_(setup_code_redirect_table) ( vo
       VG_(add_redirect_sym)("soname:libc.so.6",         redirects[i].from,
                             "soname:libpthread.so.0",   redirects[i].to);
-
-      if (VG_(clo_verbosity) >= 2)
-         VG_(message)(Vg_UserMsg, 
-                      "REPLACING libc(%s) with libpthread(%s)",
-                      redirects[i].from, redirects[i].to);
    }
 
+   /* Overenthusiastic use of PLT bypassing by the glibc people also
+      means we need to patch the following functions to our own
+      implementations of said, in mac_replace_strmem.c.
+    */
+   VG_(add_redirect_sym)("soname:libc.so.6", "stpcpy",
+                         "*vgpreload_memcheck.so*", "stpcpy");
 }

CVS commit by jseward: 

For whatever reason, ld-2.3.2.so (ld-linux.so.2) seems to have its own
PLT-bypassed versions of stpcpy and strchr.  Subvert them.


  M +5 -0      vg_symtab2.c   1.68


--- valgrind/coregrind/vg_symtab2.c  #1.67:1.68
@@ -2177,4 +2177,9 @@ void VG_(setup_code_redirect_table) ( vo
    VG_(add_redirect_sym)("soname:libc.so.6", "stpcpy",
                          "*vgpreload_memcheck.so*", "stpcpy");
+
+   VG_(add_redirect_sym)("soname:ld-linux.so.2", "stpcpy",
+                         "*vgpreload_memcheck.so*", "stpcpy");
+   VG_(add_redirect_sym)("soname:ld-linux.so.2", "strchr",
+                         "*vgpreload_memcheck.so*", "strchr");
 }

CVS commit by jseward: 

resolve_redir(): when a redirect is resolved, if the source has
already been translated, discard that translation.  Otherwise the
redirect will never take effect.


  M +27 -3     vg_symtab2.c   1.69


--- valgrind/coregrind/vg_symtab2.c  #1.68:1.69
@@ -2046,7 +2046,31 @@ static Bool resolve_redir(CodeRedirect *
       }
       
-      if (VG_(search_transtab)(redir->from_addr) != 0)
-         VG_(message)(Vg_DebugMsg, "!!!! adding redirect to already called function %s (%p -> %p)!!!",
-                      redir->from_sym, redir->from_addr, redir->to_addr);
+      if (VG_(search_transtab)(redir->from_addr) != 0) {
+        /* For some given (from, to) redir, the "from" function got
+           called before the .so containing "to" became available.  We
+           know this because there is already a translation for the
+           entry point of the original "from".  So the redirect will
+           never actually take effect unless that translation is
+           discarded.  
+
+           Note, we only really need to discard the first bb of the
+           old entry point, and so we avoid the problem of having to
+           figure out how big that bb was -- since it is at least 1
+           byte of original code, we can just pass 1 as the original
+           size to invalidate_translations() and it will indeed get
+           rid of the translation. 
+
+           Note, this is potentially expensive -- discarding
+           translations causes complete unchaining.  
+         */
+         if (VG_(clo_verbosity) > 2) {
+            VG_(message)(Vg_UserMsg,   
+               "Discarding translation due to redirect of already called function" );
+            VG_(message)(Vg_UserMsg,
+                "   %s (%p -> %p)",
+                redir->from_sym, redir->from_addr, redir->to_addr );
+         }
+         VG_(invalidate_translations)(redir->from_addr, 1, True);
+      }
 
       VG_(SkipList_Insert)(&sk_resolved_redir, redir);

CVS commit by fitzhardinge: 

Fix nasty use after free bug revealed by last munmap fix.
Unexport split_segment; it isn't needed elsewhere.
(Something still wrong with munmap.)


  M +0 -1      vg_include.h   1.163
  M +18 -11    vg_memory.c   1.47
  M +1 -2      vg_symtab2.c   1.70


--- valgrind/coregrind/vg_include.h  #1.162:1.163
@@ -1581,5 +1581,4 @@ extern Addr VG_(find_map_space)(Addr bas
 extern Segment *VG_(find_segment)(Addr a);
 extern Segment *VG_(next_segment)(Segment *);
-extern Segment *VG_(split_segment)(Addr a);
 
 extern Bool     VG_(seg_contains)(const Segment *s, Addr ptr, UInt size);

--- valgrind/coregrind/vg_memory.c  #1.46:1.47
@@ -143,4 +143,7 @@ Segment *VG_(split_segment)(Addr a)
    ns->len -= delta;
 
+   if (s->filename != NULL)
+      ns->filename = VG_(arena_strdup)(VG_AR_CORE, s->filename);
+
    if (ns->symtab != NULL)
       VG_(symtab_incref)(ns->symtab);
@@ -157,15 +160,17 @@ void VG_(unmap_range)(Addr addr, UInt le
    Segment *s;
    Segment *next;
-   static const Bool debug = False || mem_debug;
-   Addr end = addr+len;
+   static const Bool debug = True || mem_debug;
+   Addr end;
 
    if (len == 0)
       return;
 
+   len = PGROUNDUP(len);
+   vg_assert(addr == PGROUNDDN(addr));
+
    if (debug)
       VG_(printf)("unmap_range(%p, %d)\n", addr, len);
 
-   len = PGROUNDUP(addr+len)-PGROUNDDN(addr);
-   addr = PGROUNDDN(addr);
+   end = addr+len;
 
    /* Everything must be page-aligned */
@@ -183,5 +188,5 @@ void VG_(unmap_range)(Addr addr, UInt le
       if (debug)
          VG_(printf)("unmap: addr=%p-%p s=%p ->addr=%p-%p len=%d\n",
-                     addr, addr+len, s, s->addr, s->addr+s->len, s->len);
+                     addr, end, s, s->addr, seg_end, s->len);
 
       if (!VG_(seg_overlaps)(s, addr, len)) {
@@ -218,10 +223,12 @@ void VG_(unmap_range)(Addr addr, UInt le
          Int delta = (addr+len) - s->addr;
 
+         if (debug)
+            VG_(printf)("  case 3: s->addr=%p s->len=%d delta=%d\n", s->addr, s->len, delta);
+
          s->addr += delta;
          s->offset += delta;
          s->len -= delta;
 
-         if (debug)
-            VG_(printf)("  case 3: s->addr=%p s->len=%d delta=%d\n", s->addr, s->len, delta);
+         vg_assert(s->len != 0);
       } else if (addr > s->addr && end < seg_end) {
          /* [addr, addr+len) is contained within a single segment
@@ -246,6 +253,6 @@ void VG_(unmap_range)(Addr addr, UInt le
 }
 
-/* If possible, merge segment with its neighbours - some segments,
-   including s, may be destroyed in the process */
+/* Return true if two segments are adjacent and mergable (s1 is
+   assumed to have a lower ->addr than s2) */
 static inline Bool neighbours(Segment *s1, Segment *s2)
 {
@@ -274,6 +281,6 @@ static inline Bool neighbours(Segment *s
 }
 
-/* Merge segments in the address range if they're adjacent and
-   compatible */
+/* If possible, merge segment with its neighbours - some segments,
+   including s, may be destroyed in the process */
 static void merge_segments(Addr a, UInt len)
 {

--- valgrind/coregrind/vg_symtab2.c  #1.69:1.70
@@ -1209,6 +1209,5 @@ SegInfo *VG_(read_seg_symbols) ( Segment
    si->size     = seg->len;
    si->foffset  = seg->offset;
-   si->filename = VG_(arena_malloc)(VG_AR_SYMTAB, 1 + VG_(strlen)(seg->filename));
-   VG_(strcpy)(si->filename, seg->filename);
+   si->filename = VG_(arena_strdup)(VG_AR_SYMTAB, seg->filename);
 
    si->ref = 1;

In message <20031222104300.2D450942B@...>
        Jeremy Fitzhardinge <jeremy@...> wrote:

> Fix nasty use after free bug revealed by last munmap fix.
> Unexport split_segment; it isn't needed elsewhere.
> (Something still wrong with munmap.)

I'd just found that and was about to report it ;-)

> -   static const Bool debug = False || mem_debug;
> -   Addr end = addr+len;
> +   static const Bool debug = True || mem_debug;
> +   Addr end;

Did you actually mean to commit that?

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

CVS commit by jseward: 

De-anonymise a union so as to un-break compilation on gcc-2.95.


  M +11 -11    vg_proxylwp.c   1.10


--- valgrind/coregrind/vg_proxylwp.c  #1.9:1.10
@@ -197,5 +197,5 @@ struct PX_Reply {
       Int               syscallno;      /* system call completed */
       vki_ksiginfo_t    siginfo;        /* signal */
-   };
+   } u;
 };
 
@@ -512,5 +512,5 @@ static Int proxylwp(void *v)
             sigreply.tid = px->tid;
             sigreply.req = PX_Signal;
-            sigreply.siginfo = px->siginfo;
+            sigreply.u.siginfo = px->siginfo;
 
             if (!send_reply(&sigreply)) {
@@ -554,5 +554,5 @@ static Int proxylwp(void *v)
                   non-restartable syscalls?  Does it matter?
                */
-               reply.syscallno = tst->syscallno;
+               reply.u.syscallno = tst->syscallno;
 
                tst->m_eax = -VKI_ERESTARTSYS;
@@ -599,5 +599,5 @@ static Int proxylwp(void *v)
                reply should already be set up, including return in eax. */
             vg_assert(reply.req == PX_RunSyscall);
-            vg_assert(reply.syscallno == tst->syscallno);
+            vg_assert(reply.u.syscallno == tst->syscallno);
             vg_assert(tst->status == VgTs_WaitSys);
             px->state = PXS_IntReply;
@@ -608,5 +608,5 @@ static Int proxylwp(void *v)
                back. */
             vg_assert(reply.req == PX_RunSyscall);
-            vg_assert(reply.syscallno == tst->syscallno);
+            vg_assert(reply.u.syscallno == tst->syscallno);
             px->state = PXS_IntReply;
             break;
@@ -712,5 +712,5 @@ static Int proxylwp(void *v)
             /* Run a syscall for our thread; results will be poked
                back into tst */
-            reply.syscallno = tst->syscallno;
+            reply.u.syscallno = tst->syscallno;
 
             vg_assert(px->state == PXS_WaitReq || 
@@ -723,5 +723,5 @@ static Int proxylwp(void *v)
                */
                px_printf("RunSyscall in SigACK: rejecting syscall %d with ERESTARTSYS\n",
-                         reply.syscallno);
+                         reply.u.syscallno);
                tst->m_eax = -VKI_ERESTARTSYS;
             } else {
@@ -1151,5 +1151,5 @@ static void sys_wait_results(Bool block,
                            tst->tid, tst->status);
          
-            vg_assert(res.syscallno == tst->syscallno);
+            vg_assert(res.u.syscallno == tst->syscallno);
             vg_assert(tst->status == VgTs_WaitSys);
 
@@ -1160,10 +1160,10 @@ static void sys_wait_results(Bool block,
             if (VG_(clo_trace_signals) || VG_(clo_trace_syscalls))
                VG_(message)(Vg_DebugMsg, "sys_wait_results: got PX_Signal for TID %d, signal %d",
-                            res.tid, res.siginfo.si_signo);
+                            res.tid, res.u.siginfo.si_signo);
 
-            vg_assert(res.siginfo.si_signo != 0);
+            vg_assert(res.u.siginfo.si_signo != 0);
             if (VG_(threads)[res.tid].proxy && 
                 !VG_(threads)[res.tid].proxy->terminating)
-               VG_(deliver_signal)(res.tid, &res.siginfo, True);
+               VG_(deliver_signal)(res.tid, &res.u.siginfo, True);
             break;

CVS commit by fitzhardinge: 

Statically allocate a page in the client address space for trampoline
code.  Currently this is just for signal returns, but there's the start
of sysinfo/vsyscalls support, as used by the TLS libraries.


  M +17 -10    stage2.c   1.3
  M +4 -1      ume.c   1.3
  M +22 -6     vg_helpers.S   1.26
  M +12 -5     vg_include.h   1.164
  M +4 -1      vg_main.c   1.133
  M +7 -11     vg_memory.c   1.49
  M +1 -23     vg_signals.c   1.54


--- valgrind/coregrind/stage2.c  #1.2:1.3
@@ -132,4 +132,6 @@ static char *copy_str(char **tab, const 
 
    higher address +-----------------+
+                  | Trampoline code |
+                  +-----------------+
                   |                 |
                   : string table    :
@@ -169,4 +171,5 @@ static Addr setup_client_stack(char **or
    unsigned stacksize;          /* total client stack size */
    addr_t cl_esp;               /* client stack base (initial esp) */
+   addr_t cl_stacktop;          /* top of stack */
 
    /* ==================== compute sizes ==================== */
@@ -216,5 +219,6 @@ static Addr setup_client_stack(char **or
       sizeof(char **) +                 /* terminal NULL */
       auxsize +                         /* auxv */
-      ROUNDUP(stringsize, sizeof(int)); /* strings (aligned) */
+      ROUNDUP(stringsize, sizeof(int)) +/* strings (aligned) */
+      VKI_BYTES_PER_PAGE;               /* page for trampoline code */
 
    /* cl_esp is the client's stack pointer */
@@ -222,4 +226,9 @@ static Addr setup_client_stack(char **or
    cl_esp = ROUNDDN(cl_esp, 16); /* make stack 16 byte aligned */
 
+   cl_stacktop = client_end;
+   cl_stacktop -= VKI_BYTES_PER_PAGE;
+
+   kp.cl_tramp_code = cl_stacktop;
+
    if (0)
       printf("stringsize=%d auxsize=%d stacksize=%d\n",
@@ -226,6 +235,7 @@ static Addr setup_client_stack(char **or
              stringsize, auxsize, stacksize);
 
+
    /* base of the string table (aligned) */
-   stringbase = strtab = (char *)(client_end - ROUNDUP(stringsize, sizeof(int)));
+   stringbase = strtab = (char *)(cl_stacktop - ROUNDUP(stringsize, sizeof(int)));
 
    kp.clstk_base = PGROUNDDN(cl_esp);
@@ -337,16 +347,13 @@ static Addr setup_client_stack(char **or
          break;
 
-#if 1
       case AT_SYSINFO:
-      case AT_SYSINFO_EHDR:
-         /* trash vsyscalls for now
+         /* Leave this unmolested for now, but we'll update it later
+            when we set up the client trapoline code page */
+         break;
                                    
-            XXX should probably replace with our own sysinfo page so
-            we can intercept sysenter syscalls too - or at least note
-            the address so that we can catch jumps here
-         */
+      case AT_SYSINFO_EHDR:
+         /* Trash this, because we don't reproduce it */
          auxv->a_type = AT_IGNORE;
          break;
-#endif
 
       default:

--- valgrind/coregrind/ume.c  #1.2:1.3
@@ -323,5 +323,5 @@ ESZ(Addr) mapelf(struct elfinfo *e, ESZ(
             fprintf(stderr, "sbrk failed while adjusting brk base: "
                     "perhaps we hit the datasize ulimit?\n");
-            break;
+            return 0;
          }
          b += delta;
@@ -483,4 +483,7 @@ static int load_ELF(char *hdr, int len, 
    info->brkbase = mapelf(e, 0, info->setbrk);          /* map the executable */
 
+   if (info->brkbase == 0)
+      return ENOMEM;
+
    if (interp != NULL) {
       /* reserve a chunk of address space for interpreter */

--- valgrind/coregrind/vg_helpers.S  #1.25:1.26
@@ -43,7 +43,11 @@
    position-independent.
 */
-.global VG_(signalreturn_bogusRA)
-.global VG_(signalreturn_bogusRA_length)
-VG_(signalreturn_bogusRA):
+.global VG_(trampoline_code_start)
+.global VG_(trampoline_code_length)
+.global VG_(tramp_sigreturn_offset)
+.global VG_(tramp_syscall_offset)
+        
+VG_(trampoline_code_start):
+sigreturn_start:        
         subl    $20, %esp       # allocate arg block
         movl    %esp, %edx      # %edx == &_zzq_args[0]
@@ -64,7 +68,19 @@
         ud2
 
-VG_(signalreturn_bogusRA_length):
-        .long . - VG_(signalreturn_bogusRA)
-
+        # We can point our sysinfo stuff here
+        .align 16
+syscall_start:  
+        int     $0x80
+        ret
+tramp_code_end:
+                        
+.data
+VG_(trampoline_code_length):
+        .long tramp_code_end - VG_(trampoline_code_start)
+VG_(tramp_sigreturn_offset):
+        .long sigreturn_start - VG_(trampoline_code_start)
+VG_(tramp_syscall_offset):
+        .long syscall_start - VG_(trampoline_code_start)
+.text
 
         

--- valgrind/coregrind/vg_include.h  #1.163:1.164
@@ -1342,4 +1342,8 @@ typedef struct {
    Addr client_end;             /* end of client address space          */
    Addr client_mapbase;         /* base address of !MAP_FIXED mappings  */
+   Addr clstk_base;             /* lowest address of client stack       */
+   Addr clstk_end;              /* highest address of client stack      */
+   Addr cl_tramp_code;          /* syscall+signal trampoline code       */
+
    Addr shadow_base;            /* start of skin's shadow memory        */
    Addr shadow_end;             /* end of skin's shadow memory          */
@@ -1347,6 +1352,4 @@ typedef struct {
    Addr vg_mmap_end;            /* end of Valgrind's mmap area          */
    Addr vg_end;                 /* end of Valgrind's memory             */
-   Addr clstk_base;             /* lowest address of client stack       */
-   Addr clstk_end;              /* highest address of client stack      */
 } KickstartParams;
 
@@ -1377,4 +1380,6 @@ extern Addr VG_(client_mapbase); /* base
 extern Addr VG_(clstk_base);    /* client stack range */
 extern Addr VG_(clstk_end);
+extern Addr VG_(client_trampoline_code);
+
 extern Addr VG_(brk_base);      /* start of brk */
 extern Addr VG_(brk_limit);     /* current brk */
@@ -1743,7 +1748,9 @@ extern void VG_(helper_DAA);
 extern void VG_(helper_undefined_instruction);
 
-/* NOT A FUNCTION; this is a bogus RETURN ADDRESS. */
-extern Char VG_(signalreturn_bogusRA);
-extern Int  VG_(signalreturn_bogusRA_length);   /* length */
+/* Information about trampoline code (for signal return and syscalls) */
+extern const Char VG_(trampoline_code_start);
+extern const Int  VG_(trampoline_code_length);
+extern const Int  VG_(tramp_sigreturn_offset);
+extern const Int  VG_(tramp_syscall_offset);
 
 /* ---------------------------------------------------------------------

--- valgrind/coregrind/vg_main.c  #1.132:1.133
@@ -125,4 +125,5 @@ Addr VG_(client_base);	/* client address
 Addr VG_(client_end);
 Addr VG_(client_mapbase);
+Addr VG_(client_trampoline_code);
 Addr VG_(clstk_base);
 Addr VG_(clstk_end);
@@ -778,4 +779,5 @@ static void process_cmd_line_options ( c
       case VKI_AT_SYSINFO:
          VG_(sysinfo_page_exists) = True;
+         auxp[1] = (Int)(VG_(client_trampoline_code) + VG_(tramp_syscall_offset));
          VG_(sysinfo_page_addr) = auxp[1];
          break;
@@ -1393,4 +1395,5 @@ void VG_(main) ( const KickstartParams *
    VG_(clstk_base)        = kp->clstk_base;
    VG_(clstk_end)         = kp->clstk_end;
+   vg_assert(VG_(clstk_end) == VG_(client_end));
 
    VG_(shadow_base)       = kp->shadow_base;
@@ -1402,5 +1405,5 @@ void VG_(main) ( const KickstartParams *
    VG_(libdir)            = kp->libdir;
 
-   vg_assert(VG_(clstk_end) == VG_(client_end));
+   VG_(client_trampoline_code) = kp->cl_tramp_code;
 
    if (0) {

--- valgrind/coregrind/vg_memory.c  #1.48:1.49
@@ -469,5 +469,5 @@ void VG_(mprotect_range)(Addr a, UInt le
    /* Everything must be page-aligned */
    vg_assert((a & (VKI_BYTES_PER_PAGE-1)) == 0);
-   vg_assert((len & (VKI_BYTES_PER_PAGE-1)) == 0);
+   len = PGROUNDUP(len);
 
    VG_(split_segment)(a);
@@ -662,14 +662,10 @@ void VG_(init_memory) ( void )
    VG_(parse_procselfmaps) ( build_segment_map_callback );      /* everything */
 
-   /* kludge: some newer kernels place a "sysinfo" page up high, with
-      vsyscalls in it, and possibly some other stuff in the future. */
-   if (VG_(sysinfo_page_exists)) {
-      // 2003-Sep-25, njn: Jeremy thinks the sysinfo page probably doesn't
-      // have any symbols that need to be loaded.  So just treat it like
-      // a non-executable page.
-      //VG_(new_exeseg_mmap)( VG_(sysinfo_page_addr), 4096 );
-      VG_TRACK( new_mem_startup, VG_(sysinfo_page_addr), 4096, 
-                True, True, True );
-     }
+   /* initialize our trampoline page (which is also sysinfo stuff) */
+   VG_(memcpy)((void *)VG_(client_trampoline_code), 
+               &VG_(trampoline_code_start),
+               VG_(trampoline_code_length));
+   VG_(mprotect)((void *)VG_(client_trampoline_code), VG_(trampoline_code_length), 
+                 VKI_PROT_READ|VKI_PROT_EXEC);
 }
 

--- valgrind/coregrind/vg_signals.c  #1.53:1.54
@@ -951,6 +951,4 @@ static void synth_ucontext(ThreadId tid,
 }
 
-static Addr signalreturn_stub_addr = 0;
-
 /* Set up a stack frame (VgSigContext) for the client's signal
    handler.  This includes the signal number and a bogus return
@@ -1010,28 +1008,8 @@ void vg_push_signal_frame ( ThreadId tid
               == ((Char*)(esp_top_of_frame)) );
 
-   /* if the sigreturn stub isn't in the client address space yet,
-      allocate space for it and copy it into place. */
-   if (signalreturn_stub_addr == 0) {
-      UInt len = PGROUNDUP(VG_(signalreturn_bogusRA_length));
-
-      signalreturn_stub_addr = VG_(client_alloc)(0, len,
-                                                 VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
-                                                 0);
-      VG_(memcpy)((void *)signalreturn_stub_addr, &VG_(signalreturn_bogusRA), 
-                  VG_(signalreturn_bogusRA_length));
-      VG_(mprotect)((void *)signalreturn_stub_addr, len, VKI_PROT_READ|VKI_PROT_EXEC);
-      VG_TRACK(new_mem_mmap, signalreturn_stub_addr, VG_(signalreturn_bogusRA_length),
-               True, False, True);
-
-      if (VG_(clo_trace_signals))
-         VG_(message)(Vg_DebugMsg, "Put sigreturn stub at %p-%p in client address space",
-                      signalreturn_stub_addr, 
-                      signalreturn_stub_addr + VG_(signalreturn_bogusRA_length));
-   }
-
    /* retaddr, sigNo, psigInfo, puContext fields are to be written */
    VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", 
                             (Addr)frame, offsetof(VgSigFrame, handlerArgs) );
-   frame->retaddr    = (UInt)signalreturn_stub_addr;
+   frame->retaddr    = (UInt)VG_(client_trampoline_code)+VG_(tramp_sigreturn_offset);
    frame->sigNo      = sigNo;
    frame->sigNo_private = sigNo;

CVS commit by jseward: 

(David Lee, <david.lee@...>)
This patch fixes a semaphore leak within valgrind. If your application
dynamically allocates/releases semaphores, you will very quickly run out.
Also, as a nice side effect, it implements sem_destroy properly.

(me)
Protect sem_getvalue with a lock/unlock of the semaphore's mutex,
like the other routines do.


  M +54 -2     vg_libpthread.c   1.142


--- valgrind/coregrind/vg_libpthread.c  #1.141:1.142
@@ -2254,4 +2254,5 @@ typedef
       pthread_cond_t se_cv;
       int count;
+      int waiters;
    }
    vg_sem_t;
@@ -2288,4 +2289,27 @@ static vg_sem_t* se_remap ( sem_t* orig 
 }
 
+static void se_unmap( sem_t* orig )
+{
+   int res, i;
+   res = __pthread_mutex_lock(&se_remap_mx);
+   my_assert(res == 0);
+
+   for (i = 0; i < se_remap_used; i++) {
+      if (se_remap_orig[i] == orig)
+         break;
+   }
+   if (i == se_remap_used) {
+      res = pthread_mutex_unlock(&se_remap_mx);
+      my_assert(res == 0);
+      barf("se_unmap: unmapping invalid semaphore");
+   } else {
+      se_remap_orig[i] = se_remap_orig[--se_remap_used];
+      se_remap_orig[se_remap_used] = 0;
+      memset(&se_remap_new[se_remap_used], 0,
+             sizeof(se_remap_new[se_remap_used]));
+   }
+   res = pthread_mutex_unlock(&se_remap_mx);
+   my_assert(res == 0);
+}
 
 int sem_init(sem_t *sem, int pshared, unsigned int value)
@@ -2318,5 +2342,7 @@ int sem_wait ( sem_t* sem ) 
    my_assert(res == 0);
    while (vg_sem->count == 0) {
+      ++vg_sem->waiters;
       res = pthread_cond_wait(&vg_sem->se_cv, &vg_sem->se_mx);
+      --vg_sem->waiters;
       my_assert(res == 0);
    }
@@ -2371,8 +2397,13 @@ int sem_trywait ( sem_t* sem ) 
 int sem_getvalue(sem_t* sem, int * sval)
 {
+   int res;
    vg_sem_t* vg_sem; 
-   ensure_valgrind("sem_trywait");
+   ensure_valgrind("sem_getvalue");
    vg_sem = se_remap(sem);
+   res = __pthread_mutex_lock(&vg_sem->se_mx);
+   my_assert(res == 0);
    *sval = vg_sem->count;
+   res = __pthread_mutex_unlock(&vg_sem->se_mx);
+   my_assert(res == 0);
    return 0;
 }
@@ -2381,6 +2412,25 @@ int sem_getvalue(sem_t* sem, int * sval)
 int sem_destroy(sem_t * sem)
 {
-   kludged("sem_destroy", "(it always succeeds, even if semaphore waited on)");
    /* if someone waiting on this semaphore, errno = EBUSY, return -1 */
+   vg_sem_t* vg_sem;
+   int res;
+   ensure_valgrind("sem_destroy");
+   vg_sem = se_remap(sem);
+   res = __pthread_mutex_lock(&vg_sem->se_mx);
+   my_assert(res == 0);
+   if (vg_sem->waiters > 0)
+   {
+      *(__errno_location()) = EBUSY;
+      res = __pthread_mutex_unlock(&vg_sem->se_mx);
+      my_assert(res == 0);
+      return -1;
+   }
+   res = pthread_cond_destroy(&vg_sem->se_cv);
+   my_assert(res == 0);
+   res = __pthread_mutex_unlock(&vg_sem->se_mx);
+   my_assert(res == 0);
+   res = pthread_mutex_destroy(&vg_sem->se_mx);
+   my_assert(res == 0);
+   se_unmap(sem);
    return 0;
 }
@@ -2396,5 +2446,7 @@ int sem_timedwait(sem_t* sem, const stru
    my_assert(res == 0); 
    while ( vg_sem->count == 0 && res != ETIMEDOUT ) { 
+      ++vg_sem->waiters;
       res = pthread_cond_timedwait(&vg_sem->se_cv, &vg_sem->se_mx, abstime); 
+      --vg_sem->waiters;
    } 
    if ( vg_sem->count > 0 ) {

CVS commit by mueller: 

movntpd/movntps support (patch by Tom Hughes)
CCMAIL: 69782-done@...


  M +21 -0     vg_to_ucode.c   1.118


--- valgrind/coregrind/vg_to_ucode.c  #1.117:1.118
@@ -4373,4 +4373,25 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
+   /* MOVNTPS -- 16-byte store with temporal hint (which we
+      ignore). */
+   if (insn[0] == 0x0F
+       && insn[1] == 0x2B) {
+      eip = dis_SSE2_load_store_or_mov 
+               (cb, sorb, eip+2, 16, True /* is_store */, "movntps",
+                    insn[0], insn[1] );
+      goto decode_success;
+   }
+
+   /* MOVNTPD -- 16-byte store with temporal hint (which we
+      ignore). */
+   if (sz == 2
+       && insn[0] == 0x0F
+       && insn[1] == 0x2B) {
+      eip = dis_SSE3_load_store_or_mov 
+               (cb, sorb, eip+2, 16, True /* is_store */, "movntpd",
+                    0x66, insn[0], insn[1] );
+      goto decode_success;
+   }
+
    /* MOVD -- 4-byte move between xmmregs and (ireg or memory). */
    if (sz == 2

CVS commit by mueller: 

add support for mincore syscall, patch by Tom Hughes
CCMAIL: 69783-done@...


  M +15 -0     vg_syscalls.c   1.73


--- valgrind/coregrind/vg_syscalls.c  #1.72:1.73
@@ -3635,4 +3635,18 @@ POST(munmap)
 }
 
+PRE(mincore)
+{
+   /* int mincore(void *start, size_t length, unsigned char *vec); */
+   MAYBE_PRINTF("mincore ( %p, %d, %p )\n", arg1,arg2,arg3);
+   SYSCALL_TRACK(pre_mem_write, tid, "mincore(vec)",
+                 arg3, (arg2 + 4096 - 1) / 4096);
+}
+
+POST(mincore)
+{
+   if (!VG_(is_kerror)(res))
+      VG_TRACK( post_mem_write, arg3, (arg2 + 4096 - 1) / 4096 );  
+}
+
 PRE(nanosleep)
 {
@@ -5021,4 +5035,5 @@ static const struct sys_info sys_info[] 
    SYSBA(mprotect,              False),
    SYSBA(munmap,                False),
+   SYSBA(mincore,               False),
    SYSBA(nanosleep,             True),
    SYSB_(_newselect,            True),

CVS commit by nethercote: 

Adding "use strict" and "use warnings", for safety.  Required some extra
variable declarations.


  M +6 -0      gen_toolint.pl   1.3


--- valgrind/coregrind/gen_toolint.pl  #1.2:1.3
@@ -24,4 +24,6 @@
 #  The GNU General Public License is contained in the file COPYING.
 
+use strict;
+use warnings;
 
 my $output = shift @ARGV;
@@ -30,4 +32,7 @@
 my $include;
 my $passcomment = 1;
+my $pre;
+my $post;
+my $generate;
 
 my $struct = "VG_(tool_interface)";
@@ -211,4 +216,5 @@
 my $buf;
 my $lines;
+my $prefix;
 
 while(<STDIN>) {

CVS commit by jseward: 

Handle 'B' (volatile) and 'k' (const) qualifiers in stabs.  (Tom
Hughes / Manish Singh).  Fixes #71791.


  M +7 -0      vg_stabs.c   1.4


--- valgrind/coregrind/vg_stabs.c  #1.3:1.4
@@ -651,4 +651,11 @@ static SymType *stabtype_parser(SegInfo 
    }
 
+   case 'k':                    /* const */
+   case 'B': {                  /* volatile */
+      /* 'k' TYPE */
+      type = stabtype_parser(si, NULL, &p);
+      break;
+   }
+
    case 'x': {                  /* reference to undefined type */
       /* 'x' ('s' | 'u' | 'e') NAME ':' */

CVS commit by fitzhardinge: 

Fix do_exec's permission checking.


  M +19 -10    ume.c   1.6


--- valgrind/coregrind/ume.c  #1.5:1.6
@@ -647,16 +647,25 @@ static int do_exec_inner(const char *exe
       }
 
-      if (uid == st.st_uid && !(st.st_mode & S_IXUSR))
-         return EACCES;
-
-      if (gid == st.st_gid && !(st.st_mode & S_IXGRP))
+      if (uid == st.st_uid) {
+         if (!(st.st_mode & S_IXUSR))
          return EACCES;
+      } else {
+         int grpmatch = 0;
 
+         if (gid == st.st_gid)
+            grpmatch = 1;
+         else 
       for(i = 0; i < ngrp; i++)
-         if (groups[i] == st.st_gid && !(st.st_mode & S_IXGRP))
-            return EACCES;
+               if (groups[i] == st.st_gid) {
+                  grpmatch = 1;
+                  break;
+               }
 
-      if (!(st.st_mode & S_IXOTH))
+         if (grpmatch) {
+            if (!(st.st_mode & S_IXGRP))
          return EACCES;
+         } else if (!(st.st_mode & S_IXOTH))
+            return EACCES;
+      }
    }

CVS commit by fitzhardinge: 

Fix problem with trace-children=yes when using a tool which replaces
malloc.  The problem was that LD_PRELOAD was being left set with
our replacement .so files, which meant they were being applied to
stage1/stage2.  This caused malloc to fail and a subsequent SIGSEGV.
This change unconditionally removes all of Valgrind's special environment
before each execve, since it will be replaced as needed by the child
Valgrind.


  M +7 -3      vg_syscalls.c   1.75


--- valgrind/coregrind/vg_syscalls.c  #1.74:1.75
@@ -1768,7 +1768,9 @@ PRE(execve)
    VG_(nuke_all_threads_except)( VG_INVALID_THREADID );
 
-   if (!VG_(clo_trace_children)) {
+   {
       /* Make the LD_LIBRARY_PATH/LD_PRELOAD disappear so that the
-         child doesn't get our libpthread and other stuff */
+         child doesn't get our libpthread and other stuff.  This is
+         done unconditionally, since if we are tracing the child,
+         stage1/2 will set up the appropriate client environment. */
       Int i;
       Char** envp = (Char**)arg3;
@@ -1801,5 +1803,7 @@ PRE(execve)
          /* XXX if variable becomes empty, remove it completely? */
       }
-   } else {
+   }
+
+   if (VG_(clo_trace_children)) {
       /* If we're tracing the children, then we need to start it
          with our starter+arguments.

CVS commit by fitzhardinge: 

Move logfile fd into safe range.


  M +1 -1      vg_main.c   1.136


--- valgrind/coregrind/vg_main.c  #1.135:1.136
@@ -1069,5 +1069,5 @@ static void process_cmd_line_options ( c
                            VKI_S_IRUSR|VKI_S_IWUSR);
             if (eventually_logfile_fd >= 0) {
-               VG_(clo_logfile_fd) = eventually_logfile_fd;
+               VG_(clo_logfile_fd) = VG_(safe_fd)(eventually_logfile_fd);
                break;
             } else {

CVS commit by fitzhardinge: 

Make --gdb-attach=yes work properly; rather than trying to attach gdb
to itself, Valgrind forks a child, and uses ptrace to manipulate its
state into what the client state would be at that point, and attaches
gdb to that.  In addition to giving gdb clean state to inspect, it
also stops mistakes in gdb (eg, continuing) from killing your target.
It also makes gdb strictly read-only; any state changes made from within
gdb will not be reflected in the running client.  Patch from Tom Hughes.


  M +2 -15     vg_errcontext.c   1.49
  M +2 -10     vg_include.h   1.167
  M +87 -21    vg_main.c   1.137
  M +1 -2      vg_signals.c   1.56
  M +0 -82     vg_startup.S   1.22


--- valgrind/coregrind/vg_errcontext.c  #1.48:1.49
@@ -254,19 +254,6 @@ void do_actions_on_error(Error* err, Boo
        VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) 
    {
-      Addr m_eip, m_esp, m_ebp; 
-      
-      if (VG_(is_running_thread)( err->tid )) {
-         m_eip = VG_(baseBlock)[VGOFF_(m_eip)];
-         m_esp = VG_(baseBlock)[VGOFF_(m_esp)];
-         m_ebp = VG_(baseBlock)[VGOFF_(m_ebp)];
-      } else {
-         ThreadState* tst = & VG_(threads)[ err->tid ];
-         m_eip = tst->m_eip;
-         m_esp = tst->m_esp;
-         m_ebp = tst->m_ebp;
-      }
-      VG_(printf)("starting gdb with eip=%p esp=%p ebp=%p\n",
-                  m_eip, m_esp, m_ebp);
-      VG_(swizzle_esp_then_start_GDB)( m_eip, m_esp, m_ebp );
+      VG_(printf)("starting gdb\n");
+      VG_(start_GDB)( err->tid );
    }
    /* Or maybe we want to generate the error's suppression? */

--- valgrind/coregrind/vg_include.h  #1.166:1.167
@@ -1451,9 +1451,6 @@ extern Addr VG_(sysinfo_page_addr);
 extern void VG_(mash_colon_env)(Char *varp, const Char *pattern);
 
-/* Something of a function looking for a home ... start up GDB.  This
-   is called from VG_(swizzle_esp_then_start_GDB) and so runs on the
-   *client's* stack.  This is necessary to give GDB the illusion that
-   the client program really was running on the real cpu. */
-extern void VG_(start_GDB_whilst_on_client_stack) ( void );
+/* Something of a function looking for a home ... start up GDB. */
+extern void VG_(start_GDB) ( Int tid );
 
 /* VG_(bbs_done) in include/vg_skin.h */
@@ -1683,9 +1680,4 @@ extern Int VG_(clone) ( Int (*fn)(void *
 extern void VG_(switch_to_real_CPU) ( void );
 
-extern void VG_(swizzle_esp_then_start_GDB) ( Addr m_eip_at_error,
-                                              Addr m_esp_at_error,
-                                              Addr m_ebp_at_error );
-
-
 /* ---------------------------------------------------------------------
    Exports of vg_dispatch.S

--- valgrind/coregrind/vg_main.c  #1.136:1.137
@@ -32,4 +32,11 @@
 #include "vg_include.h"
 
+#include <stdlib.h>
+#include <sys/ptrace.h>
+#include <sys/signal.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
 /* ---------------------------------------------------------------------
    Compute offsets into baseBlock.  See comments in vg_include.h.
@@ -1746,16 +1753,70 @@ void VG_(mash_colon_env)(Char *varp, con
 }
 
-/* RUNS ON THE CLIENT'S STACK, but on the real CPU.  Start GDB and get
-   it to attach to this process.  Called if the user requests this
-   service after an error has been shown, so she can poke around and
-   look at parameters, memory, etc.  You can't meaningfully get GDB to
-   continue the program, though; to continue, quit GDB.  */
-void VG_(start_GDB_whilst_on_client_stack) ( void )
+/* Start GDB and get it to attach to this process.  Called if the user
+   requests this service after an error has been shown, so she can
+   poke around and look at parameters, memory, etc.  You can't
+   meaningfully get GDB to continue the program, though; to continue,
+   quit GDB.  */
+void VG_(start_GDB) ( Int tid )
 {
+   Int pid;
+
+   if ((pid = fork()) == 0)
+   {
+      ptrace(PTRACE_TRACEME, 0, NULL, NULL);
+      VG_(kkill)(VG_(getpid)(), VKI_SIGSTOP);
+   }
+   else if (pid > 0) 
+   {
+      struct user_regs_struct regs;
+      Int status;
    Int   res;
-   UChar buf[100];
+
+      if (VG_(is_running_thread)( tid )) {
+         regs.xcs = VG_(baseBlock)[VGOFF_(m_cs)];
+         regs.xss = VG_(baseBlock)[VGOFF_(m_ss)];
+         regs.xds = VG_(baseBlock)[VGOFF_(m_ds)];
+         regs.xes = VG_(baseBlock)[VGOFF_(m_es)];
+         regs.xfs = VG_(baseBlock)[VGOFF_(m_fs)];
+         regs.xgs = VG_(baseBlock)[VGOFF_(m_gs)];
+         regs.eax = VG_(baseBlock)[VGOFF_(m_eax)];
+         regs.ebx = VG_(baseBlock)[VGOFF_(m_ebx)];
+         regs.ecx = VG_(baseBlock)[VGOFF_(m_ecx)];
+         regs.edx = VG_(baseBlock)[VGOFF_(m_edx)];
+         regs.esi = VG_(baseBlock)[VGOFF_(m_esi)];
+         regs.edi = VG_(baseBlock)[VGOFF_(m_edi)];
+         regs.ebp = VG_(baseBlock)[VGOFF_(m_ebp)];
+         regs.esp = VG_(baseBlock)[VGOFF_(m_esp)];
+         regs.eflags = VG_(baseBlock)[VGOFF_(m_eflags)];
+         regs.eip = VG_(baseBlock)[VGOFF_(m_eip)];
+      } else {
+         ThreadState* tst = & VG_(threads)[ tid ];
+         
+         regs.xcs = tst->m_cs;
+         regs.xss = tst->m_ss;
+         regs.xds = tst->m_ds;
+         regs.xes = tst->m_es;
+         regs.xfs = tst->m_fs;
+         regs.xgs = tst->m_gs;
+         regs.eax = tst->m_eax;
+         regs.ebx = tst->m_ebx;
+         regs.ecx = tst->m_ecx;
+         regs.edx = tst->m_edx;
+         regs.esi = tst->m_esi;
+         regs.edi = tst->m_edi;
+         regs.ebp = tst->m_ebp;
+         regs.esp = tst->m_esp;
+         regs.eflags = tst->m_eflags;
+         regs.eip = tst->m_eip;
+      }
+
+      if ((res = VG_(waitpid)(pid, &status, 0)) == pid &&
+          WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP &&
+          ptrace(PTRACE_SETREGS, pid, NULL, &regs) == 0 &&
+          ptrace(PTRACE_DETACH, pid, NULL, SIGSTOP) == 0) {
+         UChar buf[VG_(strlen)(VG_(clo_GDB_path)) + 100];
 
    VG_(sprintf)(buf, "%s -nw /proc/%d/fd/%d %d",
-                VG_(clo_GDB_path), VG_(getpid)(), VG_(clexecfd), VG_(getpid)());
+                      VG_(clo_GDB_path), VG_(main_pid), VG_(clexecfd), pid);
    VG_(message)(Vg_UserMsg, "starting GDB with cmd: %s", buf);
    res = VG_(system)(buf);
@@ -1768,4 +1829,9 @@ void VG_(start_GDB_whilst_on_client_stac
       VG_(message)(Vg_UserMsg, "");
    }
+      }
+
+      VG_(kkill)(pid, VKI_SIGKILL);
+      VG_(waitpid)(pid, &status, 0);
+   }
 }
 

--- valgrind/coregrind/vg_signals.c  #1.55:1.56
@@ -1393,6 +1393,5 @@ static void vg_default_action(const vki_
 
       if (VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) {
-         ThreadState* tst = & VG_(threads)[ tid ];      
-         VG_(swizzle_esp_then_start_GDB)( tst->m_eip, tst->m_esp, tst->m_ebp );
+         VG_(start_GDB)( tid );
       }
 

--- valgrind/coregrind/vg_startup.S  #1.21:1.22
@@ -81,86 +81,4 @@
 
 
-/*------------------------------------------------------------*/
-/*--- A function to temporarily copy %ESP/%EBP into        ---*/
-/*--- %esp/%ebp and then start up GDB.                     ---*/
-/*------------------------------------------------------------*/
-
-/*
-extern void VG_(swizzle_esp_then_start_GDB) ( Addr m_eip_at_error,
-                                              Addr m_esp_at_error,
-                                              Addr m_ebp_at_error );
-*/
-
-/*--- This is clearly not re-entrant! ---*/
-.data
-vg_ebp_saved_over_GDB_start:
-        .long   0
-vg_esp_saved_over_GDB_start:
-        .long   0
-.text
-        
-.type VG_(swizzle_esp_then_start_GDB),@function
-.global VG_(swizzle_esp_then_start_GDB) 
-VG_(swizzle_esp_then_start_GDB):
-#ifdef HAVE_GAS_CFI
-        .cfi_startproc
-#endif
-        pushal
-
-        # remember the simulators current stack/frame pointers
-        movl    %ebp, vg_ebp_saved_over_GDB_start
-        movl    %esp, vg_esp_saved_over_GDB_start
-
-        # get args into regs
-        movl    44(%esp), %eax          # client %EBP
-        movl    40(%esp), %ebx          # client %ESP
-        movl    36(%esp), %ecx          # client %EIP
-
-        # Now that we dont need to refer to simulators stack any more,
-        # put %ESP into %esp
-        movl    %ebx, %esp
-
-        ### %esp now refers to clients stack
-        ### mess with the clients stack to make it look as if it
-        ### called this procedure, since otherwise it will look to gdb
-        ### as if the top (currently executing) stack frame of the
-        ### client is missing.
-        
-        # push %EIP.  This is a faked-up return address.
-        pushl   %ecx
-
-        # push %EBP.  This is a faked %ebp-chain pointer.
-        pushl   %eax
-#ifdef HAVE_GAS_CFI
-        .cfi_adjust_cfa_offset 0x4
-#endif
-
-        movl    %esp, %ebp
-#ifdef HAVE_GAS_CFI
-        .cfi_def_cfa_register ebp
-#endif
-        
-        call    VG_(start_GDB_whilst_on_client_stack)
-
-        # restore the simulators stack/frame pointer
-        movl    vg_ebp_saved_over_GDB_start, %ebp
-        movl    vg_esp_saved_over_GDB_start, %esp
-#ifdef HAVE_GAS_CFI
-        .cfi_adjust_cfa_offset -0x4
-#endif
-        
-        popal
-        ret
-#ifdef HAVE_GAS_CFI
-        .cfi_endproc
-#endif
-
-# gcc puts this construction at the end of every function.  I think it
-# allows the linker to figure out the size of the function.  So we do
-# the same, in the vague hope that it might help GDBs navigation.
-.Lend_of_swizzle:
-        .size   VG_(swizzle_esp_then_start_GDB), .Lend_of_swizzle-VG_(swizzle_esp_then_start_GDB)
-
-
 ##--------------------------------------------------------------------##
 ##--- end                                             vg_startup.S ---##

CVS commit by fitzhardinge: 

Fix for bug 72006 by Tom Hughes: report proper error returns for mmap()


  M +24 -13    vg_syscalls.c   1.76


--- valgrind/coregrind/vg_syscalls.c  #1.75:1.76
@@ -3556,4 +3556,5 @@ PRE(mmap2)
 POST(mmap2)
 {
+   if (!VG_(is_kerror)(res)) {
    if (!valid_client_addr(res, arg2, tid, "mmap2")) {
       VG_(munmap)((void *)res, arg2);
@@ -3561,4 +3562,5 @@ POST(mmap2)
    } else
       mmap_segment( (Addr)res, arg2, arg3, arg4, arg5, arg6 * (ULong)VKI_BYTES_PER_PAGE );
+   }
 }
 
@@ -3597,9 +3599,17 @@ PRE(mmap)
 
    if (res != -VKI_ENOMEM) {
-      res = (Int)VG_(mmap)((void *)a1, a2, a3, a4 | VKI_MAP_CLIENT, a5, a6);
+      UInt new_arg_block[6];
       
-      if (res == -1)
-         res = -VKI_ENOMEM;
-      else if (!valid_client_addr(res, a2, tid, "mmap")) {
+      new_arg_block[0] = a1;
+      new_arg_block[1] = a2;
+      new_arg_block[2] = a3;
+      new_arg_block[3] = a4;
+      new_arg_block[4] = a5;
+      new_arg_block[5] = a6;
+      
+      res = VG_(do_syscall)(__NR_mmap, new_arg_block);
+
+      if (!VG_(is_kerror)(res)) {
+         if (!valid_client_addr(res, a2, tid, "mmap")) {
          VG_(munmap)((void *)res, a2);
          res = -VKI_ENOMEM;
@@ -3607,4 +3617,5 @@ PRE(mmap)
          mmap_segment( (Addr)res, a2, a3, a4, a5, a6 );
    }
+   }
 }

CVS commit by mueller: 

yet another SSE insn (rsqrtss)


  M +9 -0      vg_to_ucode.c   1.121


--- valgrind/coregrind/vg_to_ucode.c  #1.120:1.121
@@ -4514,4 +4514,13 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
+   /* RSQRTSS: square root reciprocal of scalar float. */
+   if (insn[0] == 0xF3 && insn[1] == 0x0F && insn[2] == 0x52) {
+      vg_assert(sz == 4);
+      eip = dis_SSE3_reg_or_mem ( cb, sorb, eip+3, 4,
+                                      "sqrtss",
+                                      insn[0], insn[1], insn[2] );
+      goto decode_success;
+   }
+
    /* MOVLPS -- 8-byte load/store.  How is this different from MOVLPS
       ? */

CVS commit by nethercote: 

From Tom Hughes: patch to report port numbers correctly


  M +1 -1      vg_syscalls.c   1.79


--- valgrind/coregrind/vg_syscalls.c  #1.78:1.79
@@ -541,5 +541,5 @@ Char *inet2name(struct sockaddr_in *sa, 
                       addr & 0xFF, (addr>>8) & 0xFF,
                       (addr>>16) & 0xFF, (addr>>24) & 0xFF,
-                      sa->sin_port);
+                      ntohs(sa->sin_port));
       }
    }

CVS commit by nethercote: 

Patch to add support for the alternate MOVQ encoding, from Tom Hughes.


  M +8 -1      vg_to_ucode.c   1.123


--- valgrind/coregrind/vg_to_ucode.c  #1.122:1.123
@@ -6823,5 +6823,12 @@ static Addr disInstr ( UCodeBlock* cb, A
          modrm = getUChar(eip);
          if (epartIsReg(modrm)) {
-            goto decode_failure;
+            eip++;
+            uInstr1(cb, MMX2, 0, 
+                        Lit16, 
+                        (((UShort)(opc)) << 8) | ((UShort)modrm) );
+            if (dis)
+               VG_(printf)("movq %s, %s\n", 
+                           nameMMXReg(gregOfRM(modrm)),
+                           nameMMXReg(eregOfRM(modrm)));
          } else {
             Int tmpa;

CVS commit by nethercote: 

Forgot to remove this.


  R            stage2.c   1.7

CVS commit by fitzhardinge: 

Virtualize CPUID.  Rather than just using the host CPU's CPUID,
we now completely virtualize it.  The feature flags returned are the
intersection of the set the CPU supports, and the set of flags Valgrind
supports.  This turns out to be a small number of features, like FPU,
TSC, MMX, SSE, SSE2, FXSR.  All mention of things which are only useful
to kernel-mode code are also suppressed.  This CPUID doesn't support
any extended feature flags, or extended CPUID operations.  It returns a
vendor string of "ValgrindVCPU".

If the host CPU doesn't support CPUID, then we make sure we treat it as
an illegal instruction (I'm not sure if we handle the eflags bit toggle
test right).  This is because the CPUID helper doesn't actually use the
cpuid instruction in all cases, so it may succeed where the host CPU
wouldn't (other instructions which depend on feature flags will end up
generating those instructions, so they'll endup generating a SIGILL if
client code uses them on a CPU which doesn't support them).


  M +47 -0     vg_constants.h   1.16
  M +38 -14    vg_helpers.S   1.29
  M +0 -33     vg_include.h   1.173
  M +6 -1      vg_to_ucode.c   1.126


--- valgrind/coregrind/vg_constants.h  #1.15:1.16
@@ -95,4 +95,51 @@
 #define VG_USERREQ__SIGNAL_RETURNS          0x4001
 
+/* CPU features */
+#define VG_X86_FEAT_FPU         (0*32 + 0)
+#define VG_X86_FEAT_VME         (0*32 + 1)
+#define VG_X86_FEAT_DE          (0*32 + 2)
+#define VG_X86_FEAT_PSE         (0*32 + 3)
+#define VG_X86_FEAT_TSC         (0*32 + 4)
+#define VG_X86_FEAT_MSR         (0*32 + 5)
+#define VG_X86_FEAT_PAE         (0*32 + 6)
+#define VG_X86_FEAT_MCE         (0*32 + 7)
+#define VG_X86_FEAT_CX8         (0*32 + 8)
+#define VG_X86_FEAT_APIC        (0*32 + 9)
+#define VG_X86_FEAT_SEP         (0*32 + 11)
+#define VG_X86_FEAT_MTRR        (0*32 + 12)
+#define VG_X86_FEAT_PGE         (0*32 + 13)
+#define VG_X86_FEAT_MCA         (0*32 + 14)
+#define VG_X86_FEAT_CMOV        (0*32 + 15)
+#define VG_X86_FEAT_PAT         (0*32 + 16)
+#define VG_X86_FEAT_PSE36       (0*32 + 17)
+#define VG_X86_FEAT_CLFSH       (0*32 + 19)
+#define VG_X86_FEAT_DS          (0*32 + 21)
+#define VG_X86_FEAT_ACPI        (0*32 + 22)
+#define VG_X86_FEAT_MMX         (0*32 + 23)
+#define VG_X86_FEAT_FXSR        (0*32 + 24)
+#define VG_X86_FEAT_SSE         (0*32 + 25)
+#define VG_X86_FEAT_SSE2        (0*32 + 26)
+#define VG_X86_FEAT_SS          (0*32 + 27)
+#define VG_X86_FEAT_HT          (0*32 + 28)
+#define VG_X86_FEAT_TM          (0*32 + 29)
+#define VG_X86_FEAT_PBE         (0*32 + 31)
+
+#define VG_X86_FEAT_EST         (1*32 + 7)
+#define VG_X86_FEAT_TM2         (1*32 + 8)
+#define VG_X86_FEAT_CNXTID      (1*32 + 10)
+
+/* Used internally to mark whether CPUID is even implemented */
+#define VG_X86_FEAT_CPUID       (2*32 + 0)
+
+/* The set of features we're willing to support for the client */
+#define VG_SUPPORTED_FEATURES                   \
+        ((1 << VG_X86_FEAT_FPU)  |              \
+         (1 << VG_X86_FEAT_TSC)  |              \
+         (1 << VG_X86_FEAT_CMOV) |              \
+         (1 << VG_X86_FEAT_MMX)  |              \
+         (1 << VG_X86_FEAT_FXSR) |              \
+         (1 << VG_X86_FEAT_SSE)  |              \
+         (1 << VG_X86_FEAT_SSE2))
+ 
 /* Various environment variables we pay attention to */
 

--- valgrind/coregrind/vg_helpers.S  #1.28:1.29
@@ -194,5 +194,6 @@
    issue a "real" cpuid instruction and then mask out
    the bits of the features we do not support currently (3dnow mostly).
-
+   We also claim to not support most CPUID operations.
+        
    Dirk Mueller <mueller@...>
 
@@ -214,17 +215,37 @@
         movl    32(%esp), %eax
 
-        cmpl    $0x80000001, %eax
-        je      cpuid_no3dnow
-
-        cpuid
-        jmp     cpuid__99
-
-cpuid_no3dnow:
-        cpuid
+        /* eax==0 - max valid request+processor vendor */
+        cmpl    $0, %eax
+        jne     1f
+
+        movl    $1, %eax        /* only support request 1 */
+        movl    valgrind_brand+0, %ebx
+        movl    valgrind_brand+4, %edx
+        movl    valgrind_brand+8, %ecx
+        jmp     99f
+
+        /* eax==1 - CPU features and model ID */
+1:      cmpl    $1, %eax
+        jne     2f
+
+        cpuid   /* get host CPU's capabilities */
+
+        movl    $0111, %eax
+        movl    $0, %ebx                        /* clear APIC id, CLFLUSH size, Brand ID */
+        movl    $0, %ecx                        /* clear extended feature bits */
+        andl    $VG_SUPPORTED_FEATURES, %edx    /* mask off feature bits we don't support */
+        jmp     99f
+
+        /* eax=0x80000000 - extended cpuid functions */
+2:      cmpl    $0x80000000, %eax
+        jne     99f
+
+        /* leave eax==0x80000000 - we don't support any other extended operations */
+        movl    valgrind_brand+0, %ebx  /* AMD load the brand string again - */
+        movl    valgrind_brand+4, %edx  /* Intel leaves them "reserved" */
+        movl    valgrind_brand+8, %ecx
         
-        andl    $0x3fffffff, %edx
-
-cpuid__99:
-        movl    %edx, 20(%esp)
+        
+99:     movl    %edx, 20(%esp)
         movl    %ecx, 24(%esp)
         movl    %ebx, 28(%esp)
@@ -236,5 +257,8 @@
         popl    %eax
         ret
-
+.data
+valgrind_brand:
+        .ascii "ValgrindVCPU"
+.text
 
 /* Fetch the FPU status register.

--- valgrind/coregrind/vg_include.h  #1.172:1.173
@@ -1137,37 +1137,4 @@ extern Bool   VG_(is_chained_jumpsite)  
    ------------------------------------------------------------------ */
 
-#define VG_X86_FEAT_FPU         (0*32 + 0)
-#define VG_X86_FEAT_VME         (0*32 + 1)
-#define VG_X86_FEAT_DE          (0*32 + 2)
-#define VG_X86_FEAT_PSE         (0*32 + 3)
-#define VG_X86_FEAT_TSC         (0*32 + 4)
-#define VG_X86_FEAT_MSR         (0*32 + 5)
-#define VG_X86_FEAT_PAE         (0*32 + 6)
-#define VG_X86_FEAT_MCE         (0*32 + 7)
-#define VG_X86_FEAT_CX8         (0*32 + 8)
-#define VG_X86_FEAT_APIC        (0*32 + 9)
-#define VG_X86_FEAT_SEP         (0*32 + 11)
-#define VG_X86_FEAT_MTRR        (0*32 + 12)
-#define VG_X86_FEAT_PGE         (0*32 + 13)
-#define VG_X86_FEAT_MCA         (0*32 + 14)
-#define VG_X86_FEAT_CMOV        (0*32 + 15)
-#define VG_X86_FEAT_PAT         (0*32 + 16)
-#define VG_X86_FEAT_PSE36       (0*32 + 17)
-#define VG_X86_FEAT_CLFSH       (0*32 + 19)
-#define VG_X86_FEAT_DS          (0*32 + 21)
-#define VG_X86_FEAT_ACPI        (0*32 + 22)
-#define VG_X86_FEAT_MMX         (0*32 + 23)
-#define VG_X86_FEAT_FXSR        (0*32 + 24)
-#define VG_X86_FEAT_SSE         (0*32 + 25)
-#define VG_X86_FEAT_SSE2        (0*32 + 26)
-#define VG_X86_FEAT_SS          (0*32 + 27)
-#define VG_X86_FEAT_HT          (0*32 + 28)
-#define VG_X86_FEAT_TM          (0*32 + 29)
-#define VG_X86_FEAT_PBE         (0*32 + 31)
-
-#define VG_X86_FEAT_EST         (1*32 + 7)
-#define VG_X86_FEAT_TM2         (1*32 + 8)
-#define VG_X86_FEAT_CNXTID      (1*32 + 10)
-
 Bool VG_(cpu_has_feature)(UInt feat);
 

--- valgrind/coregrind/vg_to_ucode.c  #1.125:1.126
@@ -46,5 +46,5 @@
 /*------------------------------------------------------------*/
 
-#define VG_N_FEATURE_WORDS      2
+#define VG_N_FEATURE_WORDS      3
 
 static Int cpuid_level = -2;    /* -2 -> not initialized */
@@ -109,4 +109,6 @@ static void get_cpu_features(void)
    }
 
+   cpu_features[2] |= (1 << (VG_X86_FEAT_CPUID%32));
+
    cpuid_level = cpuid_eax(0);
 
@@ -6504,4 +6506,7 @@ static Addr disInstr ( UCodeBlock* cb, A
 
       case 0xA2: /* CPUID */
+         if (!VG_(cpu_has_feature)(VG_X86_FEAT_CPUID))
+            goto decode_failure;
+
          t1 = newTemp(cb);
          t2 = newTemp(cb);

On Sunday 25 January 2004 03:38, Jeremy Fitzhardinge wrote:
> to kernel-mode code are also suppressed.  This CPUID doesn't support
> any extended feature flags, or extended CPUID operations.  It returns a
> vendor string of "ValgrindVCPU".

Euhm, I'm curious: why that?

It seems most sensible to me to actually emulate the host we're running on as 
close as possible, instead of purposefully breaking the emulation by doing 
stuff like returning a vendor string of "ValgrindVCPU". 

I'm pretty sure that developers do want to figure out why an application 
doesn't work when it is not run under valgrind. when it is run under 
valgrind, the same codepaths should be taken. 

Its hard to imagine what you were trying to fix here since though.

On Sat, 2004-01-24 at 19:00, Dirk Mueller wrote:
> Euhm, I'm curious: why that?
> 
> It seems most sensible to me to actually emulate the host we're running on as 
> close as possible, instead of purposefully breaking the emulation by doing 
> stuff like returning a vendor string of "ValgrindVCPU". 
> 
> I'm pretty sure that developers do want to figure out why an application 
> doesn't work when it is not run under valgrind. when it is run under 
> valgrind, the same codepaths should be taken. 
> 
> Its hard to imagine what you were trying to fix here since though. 

Well, exactly that.  We're so far from being like the underlying CPU,
there's no point in pretending it is actually the underlying CPU.  It
still emulates all the important parts of the CPUID instruction, and any
program which correctly uses CPUID will be fine.  Programs which don't
correctly use the CPUID instruction should be given the opportunity to
fail so they can be fixed.

Also, it means you could use CPUID to implement RUNNING_ON_VALGRIND,
which may be useful (for example, if you want to special-case something,
without actually having a source dependency on valgrind/*.h).

	J

CVS commit by fitzhardinge: 

Don't use TSC for internal timing purposes.  This is for two reasons:
 - old CPUs (and their modern embedded clones) don't implement the TSC
 - new machines with power management, the TSC changes rate, and so is
   useless as a timebase
Valgrind doesn't use read_millisecond_timer very much these days, so
the expense of doing a gettimeofday syscall shouldn't be a huge issue.
Naturally, rdtsc is still available for client purposes (if the host CPU
supports it).


  M +0 -4      vg_include.h   1.174
  M +0 -14     vg_main.c   1.141
  M +11 -113   vg_mylibc.c   1.66


--- valgrind/coregrind/vg_include.h  #1.173:1.174
@@ -1059,8 +1059,4 @@ extern void* VG_(brk) ( void* end_data_s
 extern Char* VG_(arena_strdup) ( ArenaId aid, const Char* s);
 
-/* Skins shouldn't need these...(?) */
-extern void VG_(start_rdtsc_calibration) ( void );
-extern void VG_(end_rdtsc_calibration) ( void );
-
 extern Int VG_(fcntl) ( Int fd, Int cmd, Int arg );
 extern Int VG_(select)( Int n, 

--- valgrind/coregrind/vg_main.c  #1.140:1.141
@@ -2886,10 +2886,4 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // Start calibration of our RDTSC-based clock
-   //   p: n/a
-   //--------------------------------------------------------------
-   VG_(start_rdtsc_calibration)();
-
-   //--------------------------------------------------------------
    // Reserve Valgrind's kickstart, heap and stack
    //   p: XXX ???
@@ -2945,12 +2939,4 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // End calibrating our RDTSC-based clock, having waited a while.
-   //   p: VG_(start_rdtsc_calibration)()  [obviously]
-   //--------------------------------------------------------------
-   // Nb: Don't have to wait very long;  it does pretty well even if
-   // start_rdtsc_calibration() is immediately before this.
-   VG_(end_rdtsc_calibration)();
-
-   //--------------------------------------------------------------
    // Initialise translation table and translation cache
    //   p: read_procselfmaps  [so the anonymous mmaps for the TT/TC

--- valgrind/coregrind/vg_mylibc.c  #1.65:1.66
@@ -1527,124 +1527,23 @@ Int VG_(system) ( Char* cmd )
 
 /* ---------------------------------------------------------------------
-   Support for a millisecond-granularity counter using RDTSC.
+   Support for a millisecond-granularity timer.
    ------------------------------------------------------------------ */
 
-static __inline__ ULong do_rdtsc_insn ( void )
-{
-   ULong x;
-   __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
-   return x;
-}
-
-/* 0 = pre-calibration, 1 = calibration, 2 = running */
-static Int   rdtsc_calibration_state     = 0;
-static ULong rdtsc_ticks_per_millisecond = 0; /* invalid value */
-
-static struct vki_timeval rdtsc_cal_start_timeval;
-static struct vki_timeval rdtsc_cal_end_timeval;
-
-static ULong              rdtsc_cal_start_raw;
-static ULong              rdtsc_cal_end_raw;
-
 UInt VG_(read_millisecond_timer) ( void )
 {
-   ULong rdtsc_now;
-   // If called before rdtsc setup completed (eg. from SK_(pre_clo_init)())
-   // just return 0.
-   if (rdtsc_calibration_state < 2) return 0;
-   rdtsc_now = do_rdtsc_insn();
-   vg_assert(rdtsc_now > rdtsc_cal_end_raw);
-   rdtsc_now -= rdtsc_cal_end_raw;
-   rdtsc_now /= rdtsc_ticks_per_millisecond;
-   return (UInt)rdtsc_now;
-}
-
-
-void VG_(start_rdtsc_calibration) ( void )
-{
+   ULong base;
+   struct vki_timeval tv_now;
+   ULong now;
    Int res;
-   vg_assert(rdtsc_calibration_state == 0);
-   rdtsc_calibration_state = 1;
-   rdtsc_cal_start_raw = do_rdtsc_insn();
-   res = VG_(do_syscall)(__NR_gettimeofday, (UInt)&rdtsc_cal_start_timeval, 
-                         (UInt)NULL);
-   vg_assert(!VG_(is_kerror)(res));
-}
-
-void VG_(end_rdtsc_calibration) ( void )
-{
-   Int   res, loops;
-   ULong cpu_clock_MHZ;
-   ULong cal_clock_ticks;
-   ULong cal_wallclock_microseconds;
-   ULong wallclock_start_microseconds;
-   ULong wallclock_end_microseconds;
-   struct vki_timespec req;
-   struct vki_timespec rem;
-   
-   vg_assert(rdtsc_calibration_state == 1);
-   rdtsc_calibration_state = 2;
-
-   /* Try and delay for 20 milliseconds, so that we can at least have
-      some minimum level of accuracy. */
-   req.tv_sec = 0;
-   req.tv_nsec = 20 * 1000 * 1000;
-   loops = 0;
-   while (True) {
-      res = VG_(nanosleep)(&req, &rem);
-      vg_assert(res == 0 /*ok*/ || res == 1 /*interrupted*/);
-      if (res == 0)
-         break;
-      if (rem.tv_sec == 0 && rem.tv_nsec == 0) 
-         break;
-      req = rem;
-      loops++;
-      if (loops > 100) 
-         VG_(core_panic)("calibration nanosleep loop failed?!");
-   }
 
-   /* Now read both timers, and do the Math. */
-   rdtsc_cal_end_raw = do_rdtsc_insn();
-   res = VG_(do_syscall)(__NR_gettimeofday, (UInt)&rdtsc_cal_end_timeval, 
+   res = VG_(do_syscall)(__NR_gettimeofday, (UInt)&tv_now, 
                          (UInt)NULL);
 
-   vg_assert(rdtsc_cal_end_raw > rdtsc_cal_start_raw);
-   cal_clock_ticks = rdtsc_cal_end_raw - rdtsc_cal_start_raw;
-
-   wallclock_start_microseconds
-      = (1000000ULL * (ULong)(rdtsc_cal_start_timeval.tv_sec)) 
-         + (ULong)(rdtsc_cal_start_timeval.tv_usec);
-   wallclock_end_microseconds
-      = (1000000ULL * (ULong)(rdtsc_cal_end_timeval.tv_sec)) 
-         + (ULong)(rdtsc_cal_end_timeval.tv_usec);
-   vg_assert(wallclock_end_microseconds > wallclock_start_microseconds);
-   cal_wallclock_microseconds 
-      = wallclock_end_microseconds - wallclock_start_microseconds;
-
-   /* Since we just nanoslept for 20 ms ... */
-   vg_assert(cal_wallclock_microseconds >= 20000);
+   now = tv_now.tv_sec * 1000000ULL + tv_now.tv_usec;
 
-   /* Now we know (roughly) that cal_clock_ticks on RDTSC take
-      cal_wallclock_microseconds elapsed time.  Calculate the RDTSC
-      ticks-per-millisecond value. */
-   if (0)
-      VG_(printf)("%lld ticks in %lld microseconds\n", 
-                  cal_clock_ticks,  cal_wallclock_microseconds );
+   if (base == 0)
+      base = now;
 
-   rdtsc_ticks_per_millisecond   
-      = cal_clock_ticks / (cal_wallclock_microseconds / 1000ULL);
-   cpu_clock_MHZ
-      = (1000ULL * rdtsc_ticks_per_millisecond) / 1000000ULL;
-   if (VG_(clo_verbosity) >= 1)
-      VG_(message)(Vg_UserMsg, "Estimated CPU clock rate is %d MHz",
-                               (UInt)cpu_clock_MHZ);
-   if (cpu_clock_MHZ < 50 || cpu_clock_MHZ > 10000)
-      VG_(core_panic)("end_rdtsc_calibration: "
-                 "estimated CPU MHz outside range 50 .. 10000");
-   /* Paranoia about division by zero later. */
-   vg_assert(rdtsc_ticks_per_millisecond != 0);
-   if (0)
-      VG_(printf)("ticks per millisecond %llu\n", 
-                  rdtsc_ticks_per_millisecond);
+   return (now - base) / 1000;
 }

CVS commit by fitzhardinge: 

Oops, make base static.


  M +1 -1      vg_mylibc.c   1.67


--- valgrind/coregrind/vg_mylibc.c  #1.66:1.67
@@ -1532,5 +1532,5 @@ Int VG_(system) ( Char* cmd )
 UInt VG_(read_millisecond_timer) ( void )
 {
-   ULong base;
+   static ULong base = 0;
    struct vki_timeval tv_now;
    ULong now;

In message <20040125023830.2415C2A6E@...>
          Jeremy Fitzhardinge <jeremy@...> wrote:

> +/* The set of features we're willing to support for the client */
> +#define VG_SUPPORTED_FEATURES                   \
> +        ((1 << VG_X86_FEAT_FPU)  |              \
> +         (1 << VG_X86_FEAT_TSC)  |              \
> +         (1 << VG_X86_FEAT_CMOV) |              \
> +         (1 << VG_X86_FEAT_MMX)  |              \
> +         (1 << VG_X86_FEAT_FXSR) |              \
> +         (1 << VG_X86_FEAT_SSE)  |              \
> +         (1 << VG_X86_FEAT_SSE2))
> +

The CX8 bit should be set as well, as valgrind supports cmpxchg8b.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

In message <20040125023830.2415C2A6E@...>
          Jeremy Fitzhardinge <jeremy@...> wrote:

> Virtualize CPUID.  Rather than just using the host CPU's CPUID,
> we now completely virtualize it.  The feature flags returned are the
> intersection of the set the CPU supports, and the set of flags Valgrind
> supports.  This turns out to be a small number of features, like FPU,
> TSC, MMX, SSE, SSE2, FXSR.  All mention of things which are only useful
> to kernel-mode code are also suppressed.  This CPUID doesn't support
> any extended feature flags, or extended CPUID operations.  It returns a
> vendor string of "ValgrindVCPU".

We should really handle extended flags and set the MMXEXT bit as we
do support all the MMXEXT instructions on Athlons.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Sunday 25 January 2004 04:07, Jeremy Fitzhardinge wrote:

> Well, exactly that.  We're so far from being like the underlying CPU,
> there's no point in pretending it is actually the underlying CPU. 

Well, I disagree. Besides timing, we're pretty much like the underlying CPU. I 
think its important that the application, no matter if I wrote it or not, and 
if I have the sources or not,runs just the very same code it would run 
without valgrind as well. Otherwise trying to debug failures becomes pretty 
much mood. 

> still emulates all the important parts of the CPUID instruction, and any
> program which correctly uses CPUID will be fine.  Programs which don't
> correctly use the CPUID instruction should be given the opportunity to
> fail so they can be fixed.

What do you gain by breaking code which you don't have the sources of (like 
for example the nvidia dri stuff) ?

> Also, it means you could use CPUID to implement RUNNING_ON_VALGRIND,
> which may be useful (for example, if you want to special-case something,
> without actually having a source dependency on valgrind/*.h).

Thats not a reason IMHO. RUNNING_ON_VALGRIND is a 5 line #define, which you 
can just copy&paste into your sources instead of including something from 
valgrind/*h. 

I'm not sure how the others feel, but given that there was absolutely NO 
discussion about this patch I'm surprised that it was just committed.

On Sun, 25 Jan 2004, Dirk Mueller wrote:

> > Well, exactly that.  We're so far from being like the underlying CPU,
> > there's no point in pretending it is actually the underlying CPU.
>
> Well, I disagree. Besides timing, we're pretty much like the underlying CPU. I
> think its important that the application, no matter if I wrote it or not, and
> if I have the sources or not,runs just the very same code it would run
> without valgrind as well. Otherwise trying to debug failures becomes pretty
> much mood.

"ValgrindVCPU" seems ok to me, for two reasons:

1. Theoretical:  The difference between Valgrind's VCPU and the underlying
one are greater than just timing.  For example, my Athlon supports 3dNow!
instructions, Valgrind doesn't.

2. Practical: It's hard to imagine anyone actually using the vendor string
ID in a real program;  or certainly not in a way that changes any code
paths taken.

> What do you gain by breaking code which you don't have the sources of (like
> for example the nvidia dri stuff) ?

I don't understand -- what code is being broken?

N

On Sunday 25 January 2004 13:17, Dirk Mueller wrote:
> On Sunday 25 January 2004 04:07, Jeremy Fitzhardinge wrote:
> > Well, exactly that.  We're so far from being like the underlying CPU,
> > there's no point in pretending it is actually the underlying CPU.
>
> Well, I disagree. Besides timing, we're pretty much like the underlying
> CPU. I think its important that the application, no matter if I wrote it or
> not, and if I have the sources or not,runs just the very same code it would
> run without valgrind as well. Otherwise trying to debug failures becomes
> pretty much mood.

I think a case can be made for both points of view.  However, it
seems to me that Jeremy's approach is reasonable enough -- in fact
I quite like the sound of it.  If we get a lot of people complaining,
we can always back it out and/or modify it.

> What do you gain by breaking code which you don't have the sources of (like
> for example the nvidia dri stuff) ?

Be specific -- what problem(s) is this change giving you?
Obviously we want V to work for as many people as possible, and
for that we need specifics.

J

CVS commit by nethercote: 

Anti-globalisation


  M +2 -2      vg_errcontext.c   1.51
  M +0 -2      vg_include.h   1.175


--- valgrind/coregrind/vg_errcontext.c  #1.50:1.51
@@ -192,5 +192,5 @@ void construct_error ( Error* err, Threa
 }
 
-void VG_(gen_suppression)(Error* err)
+void gen_suppression(Error* err)
 {
    Int         i;
@@ -260,5 +260,5 @@ void do_actions_on_error(Error* err, Boo
    if (VG_(is_action_requested)( "Print suppression",
                                  & VG_(clo_gen_suppressions) )) {
-      VG_(gen_suppression)(err);
+      gen_suppression(err);
    }
 }

--- valgrind/coregrind/vg_include.h  #1.174:1.175
@@ -1282,6 +1282,4 @@ extern void VG_(show_all_errors)      ( 
 extern Bool VG_(is_action_requested) ( Char* action, Bool* clo );
 
-extern void VG_(gen_suppression) ( Error* err );
-
 extern UInt VG_(n_errs_found);

On Sunday 25 January 2004 20:30, Nicholas Nethercote wrote:

> Anti-globalisation
> -void VG_(gen_suppression)(Error* err)
> +void gen_suppression(Error* err)

static?

CVS commit by nethercote: 

staticalise


  M +1 -1      vg_errcontext.c   1.52


--- valgrind/coregrind/vg_errcontext.c  #1.51:1.52
@@ -192,5 +192,5 @@ void construct_error ( Error* err, Threa
 }
 
-void gen_suppression(Error* err)
+static void gen_suppression(Error* err)
 {
    Int         i;

On Sunday 25 January 2004 18:46, Julian Seward wrote:

> I think a case can be made for both points of view.  However, it
> seems to me that Jeremy's approach is reasonable enough -- in fact
> I quite like the sound of it.

I complain less about the Vendorname change (though I find it pretty 
pointless, it just introduces an emulation breakage without any good reason 
for it as far as I can see), but about the "we only tell the user about those 
flags we know about". There are so many cpu's out there, and so far the only 
problem we had was that we don't support 3dnow!. I think it is wrong trying 
to artificially limit the "features" we advertise from those of the host we 
run on. Tom already found two features that were disabled with this patch 
which we support just fine - there might be more. 

> If we get a lot of people complaining, 
> we can always back it out and/or modify it.

How many people do you think will be able to track back that whatever weird 
behaviour they see when not running under valgrind, and is gone when running 
under valgrind, to exactly this change? So how do we expect to get a lot of 
complains?

Personally, I find it rather frustrating during debugging that whatever I'm 
trying to look at is "healed" by running under valgrind. This is just another 
change that purposefully breaks the emulation for (apparently) no good 
reason. There are a few that are nasty, and are remaining: like syscalls 
being terrible fast compared to the "normal" case, and the resulting "timing" 
based races. Adding another one on top doesn't make things better. 

> > What do you gain by breaking code which you don't have the sources of
> > (like for example the nvidia dri stuff) ?
> Be specific -- what problem(s) is this change giving you?

I haven't tested yet. But to ask another question: which problems does this 
change fix? Be specific, please. 

Just give me one concrete bug that can't be fixed without that patch, and I'll 
shut up.  

Dirk "if it ain't broken, don't fix it"

On Sun, 2004-01-25 at 02:12, Tom Hughes wrote:
> We should really handle extended flags and set the MMXEXT bit as we
> do support all the MMXEXT instructions on Athlons.

Oh, I hadn't realized we were supporting some of the AMD extensions. 
Well, I guess we need to leave the vendor name unmolested.

	J

On Sun, 2004-01-25 at 08:06, Nicholas Nethercote wrote:
> "ValgrindVCPU" seems ok to me, for two reasons:
> 
> 1. Theoretical:  The difference between Valgrind's VCPU and the underlying
> one are greater than just timing.  For example, my Athlon supports 3dNow!
> instructions, Valgrind doesn't.
> 
> 2. Practical: It's hard to imagine anyone actually using the vendor string
> ID in a real program;  or certainly not in a way that changes any code
> paths taken.

Well, that's not quite true.  The vendorname is what you need to look at
to see what vendor-specific extensions are available (requests
>0x80000000).  One of the reasons for changing the vendor name is that
it gives us scope to add our own vendor extensions.

Unfortunately, if we're implementing vendor-specific extensions like
AMD's MMXext, then we can't play this game.  We need to pass through the
vendor string so that clients can know what parts of the CPUID request
space they can use.

I still think its a good idea to suppress all the extensions which we
either don't know about, or aren't relevant to user-mode programs.

Also, things like the cache/TLB details are (naturally) very
implementation specific, so the vendor ID will play a role there.  We'll
care about that when we get to self-virtualizing.

	J

On Sun, 2004-01-25 at 13:27, Dirk Mueller wrote:
> On Sunday 25 January 2004 18:46, Julian Seward wrote:
> 
> > I think a case can be made for both points of view.  However, it
> > seems to me that Jeremy's approach is reasonable enough -- in fact
> > I quite like the sound of it.
> 
> I complain less about the Vendorname change (though I find it pretty 
> pointless, it just introduces an emulation breakage without any good reason 
> for it as far as I can see), but about the "we only tell the user about those 
> flags we know about". There are so many cpu's out there, and so far the only 
> problem we had was that we don't support 3dnow!. I think it is wrong trying 
> to artificially limit the "features" we advertise from those of the host we 
> run on. Tom already found two features that were disabled with this patch 
> which we support just fine - there might be more. 

Those are just typos.  The real issue is that should we claim to support
instruction set features which we don't actually support.  If we claim
to support SSE3 just because the underlying CPU supports it, how does
that help anyone?

All the other feature flags are things which just don't matter to
user-mode programs.  They don't represent any kind of instruction set
extension; they're related to other things like page-table format, power
management, etc.  We could pass them through, but there's no strong
reason to do so.

> Personally, I find it rather frustrating during debugging that whatever I'm 
> trying to look at is "healed" by running under valgrind. This is just another 
> change that purposefully breaks the emulation for (apparently) no good 
> reason. There are a few that are nasty, and are remaining: like syscalls 
> being terrible fast compared to the "normal" case, and the resulting "timing" 
> based races.

Hm?  What's this?

> I haven't tested yet. But to ask another question: which problems does this 
> change fix? Be specific, please. 
> 
> Just give me one concrete bug that can't be fixed without that patch, and I'll 
> shut up.  

The specific thing I wanted to address here was not reporting CPU
capabilities which Valgrind doesn't implement.  Since there's a new wave
of CPUs being released with new feature bits (most importantly Intel's
Prescott, but also AMD's Athlon64), we're going to see new feature flags
appearing, and they need to be handled correctly.

The ValgrindVCPU thing was more a spur of the moment thing, and I'll
think I'll back it out, since it obscures real information.

	J

On Sunday 25 January 2004 22:59, Jeremy Fitzhardinge wrote:

> Those are just typos.  The real issue is that should we claim to support
> instruction set features which we don't actually support.  

No of course not, but thats not what your patch was about, was it?. For 
example, up to the best of my knowledge we unmasked the 3dnow! feature for 
example before already. So no application correctly using cpuid was ever 
going to run into 3dnow! instructions. 

> If we claim 
> to support SSE3 just because the underlying CPU supports it, how does
> that help anyone?

It doesn't. But do you want to "blacklist" features which we for sure not 
support, or do you want to "whitelist" features which we support?

since its hard to say which kind of features some obscure CPU might have, I 
don't think whitelisting makes sense. We know the handful of features we 
don't support, so blacklist them. Leave the rest alone. Don't disturb the 
emulation when there is no urgent need to do so. 

Coincidentally, this was exactly what the old code was doing, and I'd have 
liked to see some discussion first before we radically change such a 
decision, especially when there was apparently no concrete bug fix pending. 

> The specific thing I wanted to address here was not reporting CPU
> capabilities which Valgrind doesn't implement.  Since there's a new wave
> of CPUs being released with new feature bits (most importantly Intel's
> Prescott, but also AMD's Athlon64), we're going to see new feature flags
> appearing, and they need to be handled correctly.

Sure, when they cause a known problem, which we can't fix otherwise right now, 
we disable them. I for one would like to know about those problems first for 
deciding if its better to disable the feature in the cpuid, or instead trying 
to implement the feature in the valgrind emulation. 

When you're disabling the feature in the first place, you'll never get told 
about if that feature is working or not, or what you have to look at to get 
it working. 


Dirk

In message <1075066893.31555.4.camel@...>
          Jeremy Fitzhardinge <jeremy@...> wrote:

> On Sun, 2004-01-25 at 02:12, Tom Hughes wrote:
> > We should really handle extended flags and set the MMXEXT bit as we
> > do support all the MMXEXT instructions on Athlons.
> 
> Oh, I hadn't realized we were supporting some of the AMD extensions.
> Well, I guess we need to leave the vendor name unmolested.

Well it's only MMXEXT at the moment, which is actually a subset of
the original SSE extensions, but earlier Athlons had MMXEXT but not
full SSE support.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Sun, 2004-01-25 at 14:53, Dirk Mueller wrote:
> No of course not, but thats not what your patch was about, was it?. For 
> example, up to the best of my knowledge we unmasked the 3dnow! feature for 
> example before already. So no application correctly using cpuid was ever 
> going to run into 3dnow! instructions. 

The old code was incorrect, because it just masked out a bit without
checking the vendor ID.  That bit is only defined for AMD CPUs.

> > If we claim 
> > to support SSE3 just because the underlying CPU supports it, how does
> > that help anyone?
> 
> It doesn't. But do you want to "blacklist" features which we for sure not 
> support, or do you want to "whitelist" features which we support?
> 
> since its hard to say which kind of features some obscure CPU might have, I 
> don't think whitelisting makes sense. We know the handful of features we 
> don't support, so blacklist them. Leave the rest alone. Don't disturb the 
> emulation when there is no urgent need to do so. 

There are two kinds of features: those which indicate a CPU instruction
set extension, and those which indicate some other non-ISA change.  In
the first case, we know exactly which instruction-set extensions we
support, so those are the only ones which we should expose to the
client.  For the latter, they're only relevent to kernels, and not
user-mode code, since they don't functionally change the CPU's
characteristics for user-mode - or if they do, then we don't emulate
that change, and so should suppress the bit.

Since most of CPUID is defined in a vendor-specific way, we don't really
know what it's telling the client without explicitly parsing all the
results.  I'm very uneasy about CPUID returning partially mangled
undefined results; we should only return stuff which we *know* to be
true, or at worst irrelevant.

> Coincidentally, this was exactly what the old code was doing, and I'd have 
> liked to see some discussion first before we radically change such a 
> decision, especially when there was apparently no concrete bug fix pending. 

The old code was fragile and broken, because it always assumed
0x80000001 was returning AMD feature flags.  We may as well replace it
with something which does the job properly, in a moderately extensible
way.  Every interpretation and manipulation of the output of CPUID must
be done in the context of a (vendor ID, operation code) tuple.

> > The specific thing I wanted to address here was not reporting CPU
> > capabilities which Valgrind doesn't implement.  Since there's a new wave
> > of CPUs being released with new feature bits (most importantly Intel's
> > Prescott, but also AMD's Athlon64), we're going to see new feature flags
> > appearing, and they need to be handled correctly.
> 
> Sure, when they cause a known problem, which we can't fix otherwise right now, 
> we disable them. I for one would like to know about those problems first for 
> deciding if its better to disable the feature in the cpuid, or instead trying 
> to implement the feature in the valgrind emulation. 

Well, if we can get away from adding yet another instruction set
extension, we should do so where-ever possible.  If it's enough to say
we don't support it, then that's the correct fix.  It's the correct fix
for extensions we do know about but don't care about (3dnow), and its
the correct fix for any future extension (SSE3, etc).  If we see a
significant number of programs requiring, say, SSE3, then we can add the
emulation, but in the meantime the correct thing to do is say we don't
support it.

> When you're disabling the feature in the first place, you'll never get told 
> about if that feature is working or not, or what you have to look at to get 
> it working. 

Disabling it is always the right first implementation.

	J

On Monday 26 January 2004 01:16, Jeremy Fitzhardinge wrote:

> The old code was incorrect, because it just masked out a bit without
> checking the vendor ID.  That bit is only defined for AMD CPUs.

Exactly thats why the code was correct. The application that we're emulating 
has to check before calling cpuid(0x80000001) if it is in fact a AMD CPU. If 
they don't, well, they get undefined behaviour anyway. 

Besides that, the behaviour is defined: those cpus which don't support the 
extension return 0x00 in all registers. masking out a bit there doesn't hurt 
at all. 

Looking at the kernel sources, I don't see any other CPU implementing this 
cpuid feature extension. according to sandpile.org no vendor is documented to 
support it in a different way either, and in addition, this bit has no 
overloaded meaning for other vendors besides AMD.  

I agree though that there are bits which indicate different things depending 
on the vendor, but this is not the case here. But you're right, the old cpuid 
check could have been more careful to only mask out when the cpu was in fact 
a AMD one. easy fix though, no need to change the design. 

> There are two kinds of features: those which indicate a CPU instruction
> set extension, and those which indicate some other non-ISA change.  In
> the first case, we know exactly which instruction-set extensions we
> support, so those are the only ones which we should expose to the
> client.

Correct. IMHO, we should only expose those which exist at all on the original 
host cpu. So basically we have to blacklist a few extensions which we don't 
support. 

> For the latter, they're only relevent to kernels, and not 
> user-mode code, since they don't functionally change the CPU's
> characteristics for user-mode - or if they do, then we don't emulate
> that change, and so should suppress the bit.

euhm? when does invoking the cpuid instruction change the CPU behavior? Got an 
example for that?

I think its fine for an application to be able to query CPU characteristics, 
like cache sizes etc even when running under valgrind. 

IMHO as long as the characteristics doesn't affect valgrind emulation in any 
way: don't hide the information. 

> results.  I'm very uneasy about CPUID returning partially mangled
> undefined results; we should only return stuff which we *know* to be
> true, or at worst irrelevant.

I think it should return all the information the "real" CPU would do too, 
except for those bits what we *know* to be *false* on our CPU. 

> The old code was fragile and broken, because it always assumed
> 0x80000001 was returning AMD feature flags.

Ok, on which CPU does it return something else?

I'm fine with disabling the manipulation of 0x80000001 when the host CPU is 
not an AMD one (of course). Just a matter of either another cpuid 
instruction, or querying a global variable which we fill during 
initialization. 

> emulation, but in the meantime the correct thing to do is say we don't
> support it.

Thats why we disabled the 3dnow! capabilities. We didn't disable the SSE ones 
for that reason because a lot of code uses significantly different codepaths 
nowadays when the CPU supports SSE. And if those codepaths trigger a bug in 
your application, you do want to be able to find this bug using valgrind. If 
running under valgrind makes your application avoid those code paths that 
trigger the bug, then valgrind is pointless. And we don't want that, do 
we? :-)

On Sun, 2004-01-25 at 16:57, Dirk Mueller wrote:
> On Monday 26 January 2004 01:16, Jeremy Fitzhardinge wrote:
> 
> > The old code was incorrect, because it just masked out a bit without
> > checking the vendor ID.  That bit is only defined for AMD CPUs.
> 
> Exactly thats why the code was correct. The application that we're emulating 
> has to check before calling cpuid(0x80000001) if it is in fact a AMD CPU. If 
> they don't, well, they get undefined behaviour anyway. 

No, because other vendors can use 0x80000001 for other purposes.  Intel
has this reserved, for example.  Just clearing the bit means you could
be clearing some other feature flag for another vendor.

> Besides that, the behaviour is defined: those cpus which don't support the 
> extension return 0x00 in all registers. masking out a bit there doesn't hurt 
> at all. 

Yes it does, because other vendors can (and do) have their own
definitions for those operations.

> Correct. IMHO, we should only expose those which exist at all on the original 
> host cpu. So basically we have to blacklist a few extensions which we don't 
> support. 

But that makes no sense.  At any point, one of the currently reserved
bits could come into use, and a piece of software will try to use
instructions which are associated with that bit - requiring an upgrade
to Valgrind to make any progress at all.  If we clear all the unknown
bits, then the program will either behave as it would on an older CPU,
or crash anyway because it uses the new instructions without checking
(as it would on any other CPU which doesn't implement that extension).

After all, Valgrind's intent is not to emulate your actual host CPU, but
the common useful subset of ia32 implementation - which your host CPU
happens to be one of.

> > For the latter, they're only relevent to kernels, and not 
> > user-mode code, since they don't functionally change the CPU's
> > characteristics for user-mode - or if they do, then we don't emulate
> > that change, and so should suppress the bit.
> 
> euhm? when does invoking the cpuid instruction change the CPU behavior? Got an 
> example for that?

It doesn't, but it does indicate CPU behavioural changes.  The only ones
which user-mode programs care about are instruction-set extensions.

> I think its fine for an application to be able to query CPU characteristics, 
> like cache sizes etc even when running under valgrind. 

Yes, I agree.  But that isn't part of the feature bitmasks.

> IMHO as long as the characteristics doesn't affect valgrind emulation in any 
> way: don't hide the information. 

Instruction set changes do affect the emulation.  All the others are a
big "don't care".  It's trivial to copy them through.

> > results.  I'm very uneasy about CPUID returning partially mangled
> > undefined results; we should only return stuff which we *know* to be
> > true, or at worst irrelevant.
> 
> I think it should return all the information the "real" CPU would do too, 
> except for those bits what we *know* to be *false* on our CPU. 

Well, we don't know anything about the reserved bits, since they could
come to mean anything at all in future.  So we have to assume that they
will indicate something we can't handle when they become defined.

> > The old code was fragile and broken, because it always assumed
> > 0x80000001 was returning AMD feature flags.
> 
> Ok, on which CPU does it return something else?

Intel reserve that output, so it could mean anything else.

> Thats why we disabled the 3dnow! capabilities. We didn't disable the SSE ones 
> for that reason because a lot of code uses significantly different codepaths 
> nowadays when the CPU supports SSE. And if those codepaths trigger a bug in 
> your application, you do want to be able to find this bug using valgrind. If 
> running under valgrind makes your application avoid those code paths that 
> trigger the bug, then valgrind is pointless. And we don't want that, do 
> we? :-)

Yes, enough people use SSE that it is worthwhile supporting it. 
Practically nobody uses 3dnow, so nobody made the effort.  For any
future extensions, we'll assume that they're useless until enough people
make a fuss about them to want them implemented.  One program which
happens to use them isn't enough.

	J

CVS commit by nethercote: 

Fix comment


  M +2 -2      vg_scheduler.c   1.140


--- valgrind/coregrind/vg_scheduler.c  #1.139:1.140
@@ -2964,6 +2964,6 @@ void do_client_request ( ThreadId tid )
          the replacement versions.  For those that don't, we want to call
          VG_(cli_malloc)() et al.  We do this by calling SK_(malloc)(), which
-         malloc-replacing tools must replace, but have its default definition
-         call */
+         malloc-replacing tools must replace, but have the default definition
+         of SK_(malloc)() call VG_(cli_malloc)().  */
 
       /* Note: for MALLOC and FREE, must set the appropriate "lock"... see

CVS commit by nethercote: 

Remove some small unnecessary, out-of-date bits


  M +0 -15     vg_default.c   1.21


--- valgrind/coregrind/vg_default.c  #1.20:1.21
@@ -32,8 +32,4 @@
 
 
-/* These functions aren't intended to be run.  Replacement functions used by
- * the chosen tool are substituted by compiling the tool into a .so and
- * LD_PRELOADing it.  Nasty :) */
-
 #include "vg_include.h"
 
@@ -67,15 +63,4 @@ void malloc_panic ( const Char* fn )
 }
 
-#define MALLOC(proto)                     \
-__attribute__((weak))                     \
-proto                                     \
-{                                         \
-   malloc_panic(__PRETTY_FUNCTION__);     \
-}
-
-/* ---------------------------------------------------------------------
-   Default functions
-   ------------------------------------------------------------------ */
-
 /*------------------------------------------------------------*/
 /*--- Replacing malloc et al                               ---*/

CVS commit by nethercote: 

Patch from Tom Hughes:

    Patch to allow debuggers other than GDB to be used

    The patch replaces --gdb-attach and --gdb-path with --db-attach and
    --db-command which are more general. The --db-command switch takes a
    command string that can contain one or more instances of %p and %f markers.
    The %p marker is replaced with the PID of the process to attach to and the
    %f marker with the filename of the executable being attached to.

    The default command is "gdb -nw %f %p" which gaves the same result as
    currently. 


  M +10 -10    vg_errcontext.c   1.53
  M +9 -6      vg_include.h   1.176
  M +60 -25    vg_main.c   1.142
  M +2 -2      vg_signals.c   1.59
  M +21 -16    docs/coregrind_core.html   1.24


--- valgrind/coregrind/vg_errcontext.c  #1.52:1.53
@@ -112,5 +112,5 @@ static void pp_Error ( Error* err, Bool 
 }
 
-/* Figure out if we want to attach for GDB for this error, possibly
+/* Figure out if we want to perform a given action for this error, possibly
    by asking the user. */
 Bool VG_(is_action_requested) ( Char* action, Bool* clo )
@@ -248,12 +248,12 @@ static void gen_suppression(Error* err)
 
 static 
-void do_actions_on_error(Error* err, Bool allow_GDB_attach)
+void do_actions_on_error(Error* err, Bool allow_db_attach)
 {
-   /* Perhaps we want a GDB attach at this point? */
-   if (allow_GDB_attach &&
-       VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) 
+   /* Perhaps we want a debugger attach at this point? */
+   if (allow_db_attach &&
+       VG_(is_action_requested)( "Attach to debugger", & VG_(clo_db_attach) )) 
    {
-      VG_(printf)("starting gdb\n");
-      VG_(start_GDB)( err->tid );
+      VG_(printf)("starting debugger\n");
+      VG_(start_debugger)( err->tid );
    }
    /* Or maybe we want to generate the error's suppression? */
@@ -413,5 +413,5 @@ void VG_(maybe_record_error) ( ThreadId 
       is_first_shown_context = False;
       vg_n_errs_shown++;
-      do_actions_on_error(p, /*allow_GDB_attach*/True);
+      do_actions_on_error(p, /*allow_db_attach*/True);
    } else {
       vg_n_errs_suppressed++;
@@ -429,5 +429,5 @@ void VG_(maybe_record_error) ( ThreadId 
 Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, Char* s,
                          void* extra, ExeContext* where, Bool print_error,
-                         Bool allow_GDB_attach, Bool count_error )
+                         Bool allow_db_attach, Bool count_error )
 {
    Error  err;
@@ -454,5 +454,5 @@ Bool VG_(unique_error) ( ThreadId tid, E
          is_first_shown_context = False;
       }
-      do_actions_on_error(&err, allow_GDB_attach);
+      do_actions_on_error(&err, allow_db_attach);
 
       return False;

--- valgrind/coregrind/vg_include.h  #1.175:1.176
@@ -164,4 +164,7 @@
 #define VG_CLO_MAX_SFILES 10
 
+/* Default debugger command. */
+#define VG_CLO_DEFAULT_DBCOMMAND GDB_PATH " -nw %f %p"
+
 /* Describes where logging output is to be sent. */
 typedef
@@ -183,8 +186,8 @@ extern Int VG_(max_fd);
 /* Should we stop collecting errors if too many appear?  default: YES */
 extern Bool  VG_(clo_error_limit);
-/* Enquire about whether to attach to GDB at errors?   default: NO */
-extern Bool  VG_(clo_GDB_attach);
-/* The path to GDB?  default: whatever ./configure found */
-extern Char* VG_(clo_GDB_path);
+/* Enquire about whether to attach to a debugger at errors?   default: NO */
+extern Bool  VG_(clo_db_attach);
+/* The debugger command?  default: whatever gdb ./configure found */
+extern Char* VG_(clo_db_command);
 /* Enquire about generating a suppression for each error?   default: NO */
 extern Bool  VG_(clo_gen_suppressions);
@@ -1411,6 +1414,6 @@ extern Bool VG_(sysinfo_page_exists);
 extern Addr VG_(sysinfo_page_addr);
 
-/* Something of a function looking for a home ... start up GDB. */
-extern void VG_(start_GDB) ( Int tid );
+/* Something of a function looking for a home ... start up debugger. */
+extern void VG_(start_debugger) ( Int tid );
 
 /* VG_(bbs_done) in include/vg_skin.h */

--- valgrind/coregrind/vg_main.c  #1.141:1.142
@@ -293,10 +293,10 @@ static void show_counts ( void )
 /*====================================================================*/
 
-/* Start GDB and get it to attach to this process.  Called if the user
-   requests this service after an error has been shown, so she can
+/* Start debugger and get it to attach to this process.  Called if the
+   user requests this service after an error has been shown, so she can
    poke around and look at parameters, memory, etc.  You can't
-   meaningfully get GDB to continue the program, though; to continue,
-   quit GDB.  */
-void VG_(start_GDB) ( Int tid )
+   meaningfully get the debugger to continue the program, though; to
+   continue, quit the debugger.  */
+void VG_(start_debugger) ( Int tid )
 {
    Int pid;
@@ -353,14 +353,49 @@ void VG_(start_GDB) ( Int tid )
           ptrace(PTRACE_SETREGS, pid, NULL, &regs) == 0 &&
           ptrace(PTRACE_DETACH, pid, NULL, SIGSTOP) == 0) {
-         UChar buf[VG_(strlen)(VG_(clo_GDB_path)) + 100];
+         Char pidbuf[15];
+         Char file[30];
+         Char buf[100];
+         Char *bufptr;
+         Char *cmdptr;
 
-         VG_(sprintf)(buf, "%s -nw /proc/%d/fd/%d %d",
-                      VG_(clo_GDB_path), VG_(main_pid), VG_(clexecfd), pid);
-         VG_(message)(Vg_UserMsg, "starting GDB with cmd: %s", buf);
+         VG_(sprintf)(pidbuf, "%d", pid);
+         VG_(sprintf)(file, "/proc/%d/fd/%d", pid, VG_(clexecfd));
+ 
+         bufptr = buf;
+         cmdptr = VG_(clo_db_command);
+         
+         while (*cmdptr) {
+            switch (*cmdptr) {
+               case '%':
+                  switch (*++cmdptr) {
+                     case 'f':
+                        VG_(memcpy)(bufptr, file, VG_(strlen)(file));
+                        bufptr += VG_(strlen)(file);
+                        cmdptr++;
+                        break;
+                  case 'p':
+                     VG_(memcpy)(bufptr, pidbuf, VG_(strlen)(pidbuf));
+                     bufptr += VG_(strlen)(pidbuf);
+                     cmdptr++;
+                     break;
+                  default:
+                     *bufptr++ = *cmdptr++;
+                     break;
+                  }
+                  break;
+               default:
+                  *bufptr++ = *cmdptr++;
+                  break;
+            }
+         }
+         
+         *bufptr++ = '\0';
+  
+         VG_(message)(Vg_UserMsg, "starting debugger with cmd: %s", buf);
          res = VG_(system)(buf);
          if (res == 0) {      
             VG_(message)(Vg_UserMsg, "");
             VG_(message)(Vg_UserMsg, 
-                         "GDB has detached.  Valgrind regains control.  We continue.");
+                         "Debugger has detached.  Valgrind regains control.  We continue.");
          } else {
             VG_(message)(Vg_UserMsg, "Apparently failed!");
@@ -1364,6 +1399,6 @@ static void load_client(char* cl_argv[],
 /* Define, and set defaults. */
 Bool   VG_(clo_error_limit)    = True;
-Bool   VG_(clo_GDB_attach)     = False;
-Char*  VG_(clo_GDB_path)       = GDB_PATH;
+Bool   VG_(clo_db_attach)      = False;
+Char*  VG_(clo_db_command)     = VG_CLO_DEFAULT_DBCOMMAND;
 Bool   VG_(clo_gen_suppressions) = False;
 Int    VG_(sanity_level)       = 1;
@@ -1473,7 +1508,7 @@ void usage ( void )
 "    --gen-suppressions=no|yes print suppressions for errors detected [no]\n"
 
-"    --gdb-attach=no|yes       start GDB when errors detected? [no]\n"
-"    --gdb-path=/path/to/gdb   path to the GDB to use [/usr/bin/gdb]\n"
-"    --input-fd=<number>       file descriptor for (gdb) input [0=stdin]\n"
+"    --db-attach=no|yes        start debugger when errors detected? [no]\n"
+"    --db-command=<command>    command to start debugger [gdb -nw %%f %%p]\n"
+"    --input-fd=<number>       file descriptor for input [0=stdin]\n"
 "\n";
 
@@ -1656,11 +1691,11 @@ static void process_cmd_line_options 
          VG_(clo_error_limit) = False;
 
-      else if (VG_CLO_STREQ(arg, "--gdb-attach=yes"))
-         VG_(clo_GDB_attach) = True;
-      else if (VG_CLO_STREQ(arg, "--gdb-attach=no"))
-         VG_(clo_GDB_attach) = False;
+      else if (VG_CLO_STREQ(arg, "--db-attach=yes"))
+         VG_(clo_db_attach) = True;
+      else if (VG_CLO_STREQ(arg, "--db-attach=no"))
+         VG_(clo_db_attach) = False;
 
-      else if (VG_CLO_STREQN(11,arg, "--gdb-path="))
-         VG_(clo_GDB_path) = &arg[11];
+      else if (VG_CLO_STREQN(13,arg, "--db-command="))
+         VG_(clo_db_command) = &arg[13];
 
       else if (VG_CLO_STREQ(arg, "--gen-suppressions=yes"))
@@ -1849,11 +1884,11 @@ static void process_cmd_line_options 
       VG_(clo_verbosity) = 0;
 
-   if (VG_(clo_GDB_attach) && VG_(clo_trace_children)) {
+   if (VG_(clo_db_attach) && VG_(clo_trace_children)) {
       VG_(message)(Vg_UserMsg, "");
       VG_(message)(Vg_UserMsg, 
-         "--gdb-attach=yes conflicts with --trace-children=yes");
+         "--db-attach=yes conflicts with --trace-children=yes");
       VG_(message)(Vg_UserMsg, 
          "Please choose one or the other, but not both.");
-      VG_(bad_option)("--gdb-attach=yes and --trace-children=yes");
+      VG_(bad_option)("--db-attach=yes and --trace-children=yes");
    }
 

--- valgrind/coregrind/vg_signals.c  #1.58:1.59
@@ -1392,6 +1392,6 @@ static void vg_default_action(const vki_
       }
 
-      if (VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) {
-         VG_(start_GDB)( tid );
+      if (VG_(is_action_requested)( "Attach to debugger", & VG_(clo_db_attach) )) {
+         VG_(start_debugger)( tid );
       }
 

--- valgrind/coregrind/docs/coregrind_core.html  #1.23:1.24
@@ -617,5 +617,5 @@
       <code>---- Print suppression ? --- [Return/N/n/Y/y/C/c] ----</code>
       <p>
-      The prompt's behaviour is the same as for the <code>--gdb-attach</code>
+      The prompt's behaviour is the same as for the <code>--db-attach</code>
       option.
       <p>
@@ -647,26 +647,26 @@
       <br><p>
 
-  <li><code>--gdb-attach=no</code> [default]<br>
-      <code>--gdb-attach=yes</code>
+  <li><code>--db-attach=no</code> [default]<br>
+      <code>--db-attach=yes</code>
       <p>When enabled, Valgrind will pause after every error shown,
       and print the line
       <br>
-      <code>---- Attach to GDB ? --- [Return/N/n/Y/y/C/c] ----</code>
+      <code>---- Attach to debugger ? --- [Return/N/n/Y/y/C/c] ----</code>
       <p>
       Pressing <code>Ret</code>, or <code>N</code> <code>Ret</code>
       or <code>n</code> <code>Ret</code>, causes Valgrind not to
-      start GDB for this error.
+      start a debugger for this error.
       <p>
       <code>Y</code> <code>Ret</code>
       or <code>y</code> <code>Ret</code> causes Valgrind to
-      start GDB, for the program at this point.  When you have
-      finished with GDB, quit from it, and the program will continue.
-      Trying to continue from inside GDB doesn't work.
+      start a debugger, for the program at this point.  When you have
+      finished with the debugger, quit from it, and the program will continue.
+      Trying to continue from inside the debugger doesn't work.
       <p>
       <code>C</code> <code>Ret</code>
       or <code>c</code> <code>Ret</code> causes Valgrind not to
-      start GDB, and not to ask again.
+      start a debugger, and not to ask again.
       <p>
-      <code>--gdb-attach=yes</code> conflicts with
+      <code>--db-attach=yes</code> conflicts with
       <code>--trace-children=yes</code>.  You can't use them together.
       Valgrind refuses to start up in this situation.  1 May 2002:
@@ -679,14 +679,19 @@
       </li><br><p>
 
-  <li><code>--gdb-path=/path/to/gdb</code>
-      <p>This specifies how Valgrind will invoke GDB.  By default, it
-      will use whatever GDB is detected at build time, 
+  <li><code>--db-command=&lt;command&gt;</code> [default: gdb -nw %f %p]<br>
+      <p>This specifies how Valgrind will invoke the debugger.  By
+      default it will use whatever GDB is detected at build time, 
       which is usually <code>/usr/bin/gdb</code>.  Using this command,
-      you can specify some alternative path to the GDB you want to
-      use.
+      you can specify some alternative command to invoke the debugger
+      you want to use.
+      <p>
+      The command string given can include one or instances of the
+      %p and %f expansions. Each instance of %p expands to the PID of
+      the process to be debugged and each instance of %f expands to
+      the path to the executable for the process to be debugged.
       </li><br><p>
 
   <li><code>--input-fd=&lt;number&gt;</code> [default=0, stdin]<br>
-      <p>When using <code>--gdb-attach=yes</code> and 
+      <p>When using <code>--db-attach=yes</code> and 
          <code>--gen-suppressions=yes</code>, Valgrind will stop
       so as to read keyboard input from you, when each error occurs.

CVS commit by nethercote: 

Patch from Tom Hughes:

    Patch to provide a proper environment to the debugger

    Although this patch isn't strictly needed to allow alternative debuggers to
    be used, it is needed if you want to use an X based debugger such as ups
    (and presumably ddd) as VG_(system) has until now passed an empty
    enviroment when starting the debugger but that causes DISPLAY to be lost.

    This patch causes VG_(system) to pass a copy of the client environment
    instead, with the necessary mashing done to clean up the LD_xxx variables. 


  M +5 -0      vg_include.h   1.177
  M +62 -2     vg_mylibc.c   1.68
  M +8 -8      vg_syscalls.c   1.82


--- valgrind/coregrind/vg_include.h  #1.176:1.177
@@ -1088,4 +1088,5 @@ extern Int VG_(connect_via_socket)( UCha
 
 /* Environment manipulations */
+extern Char **VG_(env_clone) ( Char **oldenv );
 extern Char* VG_(env_getenv) ( Char **env, Char* varname );
 extern Char **VG_(env_setenv) ( Char ***envp, const Char* varname, const Char *val );
@@ -1414,4 +1415,8 @@ extern Bool VG_(sysinfo_page_exists);
 extern Addr VG_(sysinfo_page_addr);
 
+/* Walk through a colon separated list variable, removing entries
+   which match pattern. */
+extern void VG_(mash_colon_env)(Char *varp, const Char *pattern);
+
 /* Something of a function looking for a home ... start up debugger. */
 extern void VG_(start_debugger) ( Int tid );

--- valgrind/coregrind/vg_mylibc.c  #1.67:1.68
@@ -1344,4 +1344,30 @@ Bool VG_(getcwd_alloc) ( Char** out )
    ------------------------------------------------------------------ */
 
+/* clone the environment */
+Char **VG_(env_clone) ( Char **oldenv )
+{
+   Char **oldenvp;
+   Char **newenvp;
+   Char **newenv;
+   Int  envlen;
+
+   for (oldenvp = oldenv; oldenvp && *oldenvp; oldenvp++);
+
+   envlen = oldenvp - oldenv + 1;
+   
+   newenv = VG_(arena_malloc)(VG_AR_CORE, envlen * sizeof(Char **));
+
+   oldenvp = oldenv;
+   newenvp = newenv;
+   
+   while (oldenvp && *oldenvp) {
+      *newenvp++ = *oldenvp++;
+   }
+   
+   *newenvp = *oldenvp;
+
+   return newenv;
+}
+
 void  VG_(env_unsetenv) ( Char **env, const Char *varname )
 {
@@ -1497,5 +1523,4 @@ Int VG_(system) ( Char* cmd )
 {
    Int pid, res;
-   void* environ[1] = { NULL };
    if (cmd == NULL)
       return 1;
@@ -1505,5 +1530,38 @@ Int VG_(system) ( Char* cmd )
    if (pid == 0) {
       /* child */
+      static Char** envp = NULL;
       Char* argv[4];
+
+      if (envp == NULL) {
+         Int i;
+         Char* ld_preload_str = NULL;
+         Char* ld_library_path_str = NULL;
+         Char* buf;
+
+         envp = VG_(env_clone)(VG_(client_envp));
+         
+         for (i = 0; envp[i] != NULL; i++) {
+            if (VG_(strncmp)(envp[i], "LD_PRELOAD=", 11) == 0)
+               ld_preload_str = &envp[i][11];
+            if (VG_(strncmp)(envp[i], "LD_LIBRARY_PATH=", 16) == 0)
+               ld_library_path_str = &envp[i][16];
+         }
+
+         buf = VG_(arena_malloc)(VG_AR_CORE, VG_(strlen)(VG_(libdir)) + 20);
+
+         VG_(sprintf)(buf, "%s*/vg_inject.so", VG_(libdir));
+         VG_(mash_colon_env)(ld_preload_str, buf);
+
+         VG_(sprintf)(buf, "%s*/vgpreload_*.so", VG_(libdir));
+         VG_(mash_colon_env)(ld_preload_str, buf);
+
+         VG_(sprintf)(buf, "%s*", VG_(libdir));
+         VG_(mash_colon_env)(ld_library_path_str, buf);
+
+         VG_(env_unsetenv)(envp, VALGRINDCLO);
+
+         VG_(arena_free)(VG_AR_CORE, buf);
+      }
+
       argv[0] = "/bin/sh";
       argv[1] = "-c";
@@ -1510,6 +1568,8 @@ Int VG_(system) ( Char* cmd )
       argv[2] = cmd;
       argv[3] = 0;
+
       (void)VG_(do_syscall)(__NR_execve, 
-                            (UInt)"/bin/sh", (UInt)argv, (UInt)&environ);
+                            (UInt)"/bin/sh", (UInt)argv, (UInt)envp);
+
       /* If we're still alive here, execve failed. */
       return -1;

--- valgrind/coregrind/vg_syscalls.c  #1.81:1.82
@@ -164,5 +164,5 @@ static Bool valid_client_addr(Addr start
    delimited by ':' are considered to be '.' in a path.
 */
-static void mash_colon_env(Char *varp, const Char *remove_pattern)
+void VG_(mash_colon_env)(Char *varp, const Char *remove_pattern)
 {
    Char *const start = varp;
@@ -1870,11 +1870,11 @@ PRE(execve)
 
          VG_(sprintf)(buf, "%s*/vg_inject.so", VG_(libdir));
-         mash_colon_env(ld_preload_str, buf);
+         VG_(mash_colon_env)(ld_preload_str, buf);
 
          VG_(sprintf)(buf, "%s*/vgpreload_*.so", VG_(libdir));
-         mash_colon_env(ld_preload_str, buf);
+         VG_(mash_colon_env)(ld_preload_str, buf);
 
          VG_(sprintf)(buf, "%s*", VG_(libdir));
-         mash_colon_env(ld_library_path_str, buf);
+         VG_(mash_colon_env)(ld_library_path_str, buf);
 
          VG_(env_unsetenv)(envp, VALGRINDCLO);

CVS commit by nethercote: 


Made code more concise.  In particular:

  - introduced DIS() and DIP() macros to shorten debug printing

  - introduce jmp_lit(), jcc_lit(), jmp_treg() for common UCode sequences

  - replace many unnecessary dis?dis_buf:NULL tests with dis_buf, by
    changing the tests in disAMode()

Overall, reduced code size by about 230 lines.


  M +505 -744  vg_to_ucode.c   1.127


--- valgrind/coregrind/vg_to_ucode.c  #1.126:1.127
@@ -34,9 +34,14 @@
 
 /*------------------------------------------------------------*/
-/*--- Renamings of frequently-used global functions.       ---*/
+/*--- Debugging output                                     ---*/
 /*------------------------------------------------------------*/
 
-#define dis       VG_(print_codegen)
+#define DIP(format, args...)  \
+   if (VG_(print_codegen))        \
+      VG_(printf)(format, ## args)
 
+#define DIS(buf, format, args...)  \
+   if (VG_(print_codegen))        \
+      VG_(sprintf)(buf, format, ## args)
 
 /*------------------------------------------------------------*/
@@ -389,4 +393,32 @@ void VG_(set_cond_field) ( UCodeBlock* c
 }
 
+/*------------------------------------------------------------*/
+/*--- JMP helpers                                          ---*/
+/*------------------------------------------------------------*/
+
+static __inline__
+void jmp_lit( UCodeBlock* cb, Addr d32 )
+{
+   uInstr1 (cb, JMP,   0, Literal, 0);
+   uLiteral(cb, d32);
+   uCond   (cb, CondAlways);
+}
+
+static __inline__
+void jmp_treg( UCodeBlock* cb, Int t )
+{
+   uInstr1 (cb, JMP,   0, TempReg, t);
+   uCond   (cb, CondAlways);
+}
+
+static __inline__
+void jcc_lit( UCodeBlock* cb, Addr d32, Condcode cond )
+{
+   uInstr1  (cb, JMP, 0, Literal, 0);
+   uLiteral (cb, d32);
+   uCond    (cb, cond);
+   uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
+}
+
 
 /*------------------------------------------------------------*/
@@ -443,6 +475,6 @@ void handleSegOverride ( UCodeBlock* cb,
    returned, as a pair (length << 24) | temp.  Note that this fn should
    not be called if the R/M part of the address denotes a register
-   instead of memory.  If buf is non-NULL, text of the addressing mode
-   is placed therein. */
+   instead of memory.  If VG_(print_codegen) is true, text of the addressing
+   mode is placed therein. */
 
 static 
@@ -469,6 +501,5 @@ UInt disAMode ( UCodeBlock* cb, UChar so
            uInstr2(cb, GET, 4, ArchReg, rm,  TempReg, tmp);
            handleSegOverride(cb, sorb, tmp);
-           if (buf) VG_(sprintf)(buf,"%s(%s)", sorbTxt(sorb), 
-                                               nameIReg(4,rm));
+           DIS(buf, "%s(%s)", sorbTxt(sorb), nameIReg(4,rm));
            return (1<<24 | tmp);
          }
@@ -484,8 +515,7 @@ UInt disAMode ( UCodeBlock* cb, UChar so
            uInstr2(cb, GET,  4, ArchReg, rm,  TempReg, tmq);
            uInstr2(cb, LEA1, 4, TempReg, tmq, TempReg, tmp);
-           LAST_UINSTR(cb).lit32 = d;
+           uLiteral(cb, d);
            handleSegOverride(cb, sorb, tmp);
-           if (buf) VG_(sprintf)(buf,"%s%d(%s)", sorbTxt(sorb), 
-                                                 d, nameIReg(4,rm));
+           DIS(buf, "%s%d(%s)", sorbTxt(sorb), d, nameIReg(4,rm));
            return (2<<24 | tmp);
          }
@@ -501,8 +531,7 @@ UInt disAMode ( UCodeBlock* cb, UChar so
            uInstr2(cb, GET,  4, ArchReg, rm,  TempReg, tmq);
            uInstr2(cb, LEA1, 4, TempReg, tmq, TempReg, tmp);
-           LAST_UINSTR(cb).lit32 = d;
+           uLiteral(cb, d);
            handleSegOverride(cb, sorb, tmp);
-           if (buf) VG_(sprintf)(buf,"%s0x%x(%s)", sorbTxt(sorb), 
-                                                   d, nameIReg(4,rm));
+           DIS(buf, "%s0x%x(%s)", sorbTxt(sorb), d, nameIReg(4,rm));
            return (5<<24 | tmp);
          }
@@ -521,5 +550,5 @@ UInt disAMode ( UCodeBlock* cb, UChar so
            uLiteral(cb, d);
            handleSegOverride(cb, sorb, tmp);
-           if (buf) VG_(sprintf)(buf,"%s(0x%x)", sorbTxt(sorb), d);
+           DIS(buf, "%s(0x%x)", sorbTxt(sorb), d);
            return (5<<24 | tmp);
          }
@@ -557,10 +586,9 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr3(cb, LEA2, 4, TempReg, base_tmp, TempReg, index_tmp, 
                                  TempReg, tmp);
-            LAST_UINSTR(cb).lit32   = 0;
+            uLiteral(cb, 0);
             LAST_UINSTR(cb).extra4b = 1 << scale;
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s(%s,%s,%d)", sorbTxt(sorb), 
-                                  nameIReg(4,base_r),
-                                  nameIReg(4,index_r),1<<scale);
+            DIS(buf, "%s(%s,%s,%d)", sorbTxt(sorb), 
+                      nameIReg(4,base_r), nameIReg(4,index_r), 1<<scale);
             return (2<<24 | tmp);
          }
@@ -574,9 +602,9 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr3(cb, LEA2, 4, TempReg, tmp,      TempReg, index_tmp, 
                                  TempReg, tmp);
-            LAST_UINSTR(cb).lit32   = d;
+            uLiteral(cb, d);
             LAST_UINSTR(cb).extra4b = 1 << scale;
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s0x%x(,%s,%d)", sorbTxt(sorb), d, 
-                                  nameIReg(4,index_r),1<<scale);
+            DIS(buf, "%s0x%x(,%s,%d)", sorbTxt(sorb), d, 
+                      nameIReg(4,index_r), 1<<scale);
             return (6<<24 | tmp);
          }
@@ -585,6 +613,5 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr2(cb, GET, 4, ArchReg, base_r, TempReg, tmp);
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s(%s,,)", 
-                                      sorbTxt(sorb), nameIReg(4,base_r));
+            DIS(buf, "%s(%s,,)", sorbTxt(sorb), nameIReg(4,base_r));
             return (2<<24 | tmp);
          }
@@ -595,5 +622,5 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uLiteral(cb, d);
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s0x%x()", sorbTxt(sorb), d);
+            DIS(buf, "%s0x%x()", sorbTxt(sorb), d);
             return (6<<24 | tmp);
          }
@@ -622,8 +649,7 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr2(cb, GET,  4, ArchReg, base_r,  TempReg, tmq);
             uInstr2(cb, LEA1, 4, TempReg, tmq, TempReg, tmp);
-            LAST_UINSTR(cb).lit32 = d;
+            uLiteral(cb, d);
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s%d(%s,,)", sorbTxt(sorb), 
-                                  d, nameIReg(4,base_r));
+            DIS(buf, "%s%d(%s,,)", sorbTxt(sorb), d, nameIReg(4,base_r));
             return (3<<24 | tmp);
          } else {
@@ -634,10 +660,9 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr3(cb, LEA2, 4, TempReg, base_tmp, TempReg, index_tmp, 
                                  TempReg, tmp);
-            LAST_UINSTR(cb).lit32   = d;
+            uLiteral(cb, d);
             LAST_UINSTR(cb).extra4b = 1 << scale;
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s%d(%s,%s,%d)", 
-                                  sorbTxt(sorb), d, nameIReg(4,base_r), 
-                                  nameIReg(4,index_r), 1<<scale);
+            DIS(buf, "%s%d(%s,%s,%d)", sorbTxt(sorb), d, 
+                     nameIReg(4,base_r), nameIReg(4,index_r), 1<<scale);
             return (3<<24 | tmp);
          }
@@ -665,8 +690,7 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr2(cb, GET,  4, ArchReg, base_r,  TempReg, tmq);
             uInstr2(cb, LEA1, 4, TempReg, tmq, TempReg, tmp);
-            LAST_UINSTR(cb).lit32 = d;
+            uLiteral(cb, d);
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s%d(%s,,)", 
-                                  sorbTxt(sorb), d, nameIReg(4,base_r));
+            DIS(buf, "%s%d(%s,,)", sorbTxt(sorb), d, nameIReg(4,base_r));
             return (6<<24 | tmp);
          } else {
@@ -677,10 +701,9 @@ UInt disAMode ( UCodeBlock* cb, UChar so
             uInstr3(cb, LEA2, 4, TempReg, base_tmp, TempReg, index_tmp, 
                                  TempReg, tmp);
-            LAST_UINSTR(cb).lit32   = d;
+            uLiteral(cb, d);
             LAST_UINSTR(cb).extra4b = 1 << scale;
             handleSegOverride(cb, sorb, tmp);
-            if (buf) VG_(sprintf)(buf,"%s%d(%s,%s,%d)", 
-                                  sorbTxt(sorb), d, nameIReg(4,base_r), 
-                                  nameIReg(4,index_r), 1<<scale);
+            DIS(buf, "%s%d(%s,%s,%d)", sorbTxt(sorb), d, 
+                      nameIReg(4,base_r), nameIReg(4,index_r), 1<<scale);
             return (6<<24 | tmp);
          }
@@ -783,6 +806,5 @@ void codegen_XOR_reg_with_itself ( UCode
                                    Int ge_reg, Int tmp )
 {
-   if (dis) 
-      VG_(printf)("xor%c %s, %s\n", nameISize(size),
+   DIP("xor%c %s, %s\n", nameISize(size),
                   nameIReg(size,ge_reg), nameIReg(size,ge_reg) );
    uInstr2(cb, MOV, size, Literal, 0, TempReg, tmp);
@@ -857,5 +879,5 @@ Addr dis_op2_E_G ( UCodeBlock* cb,
       if (keep)
          uInstr2(cb, PUT, size, TempReg, tmp, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("%s%c %s,%s\n", t_x86opc, nameISize(size), 
+      DIP("%s%c %s,%s\n", t_x86opc, nameISize(size), 
                            nameIReg(size,eregOfRM(rm)),
                            nameIReg(size,gregOfRM(rm)));
@@ -868,5 +890,5 @@ Addr dis_op2_E_G ( UCodeBlock* cb,
            ? True : False;
    if (reversible) {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf);
       Int  tmpa = LOW24(pair);
       uInstr2(cb, LOAD, size, TempReg, tmpa, TempReg, tmpa);
@@ -883,9 +905,9 @@ Addr dis_op2_E_G ( UCodeBlock* cb,
       if (keep)
          uInstr2(cb, PUT,  size, TempReg, tmpa, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("%s%c %s,%s\n", t_x86opc, nameISize(size), 
+      DIP("%s%c %s,%s\n", t_x86opc, nameISize(size), 
                            dis_buf,nameIReg(size,gregOfRM(rm)));
       return HI8(pair)+eip0;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf);
       Int  tmpa = LOW24(pair);
       Int  tmp2 = newTemp(cb);
@@ -896,5 +918,5 @@ Addr dis_op2_E_G ( UCodeBlock* cb,
       if (keep)
          uInstr2(cb, PUT,  size, TempReg, tmp2, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("%s%c %s,%s\n", t_x86opc, nameISize(size), 
+      DIP("%s%c %s,%s\n", t_x86opc, nameISize(size), 
                            dis_buf,nameIReg(size,gregOfRM(rm)));
       return HI8(pair)+eip0;
@@ -960,5 +982,5 @@ Addr dis_op2_G_E ( UCodeBlock* cb, 
       if (keep)
          uInstr2(cb, PUT, size, TempReg, tmp, ArchReg, eregOfRM(rm));
-      if (dis) VG_(printf)("%s%c %s,%s\n", t_x86opc, nameISize(size), 
+      DIP("%s%c %s,%s\n", t_x86opc, nameISize(size), 
                            nameIReg(size,gregOfRM(rm)),
                            nameIReg(size,eregOfRM(rm)));
@@ -968,5 +990,5 @@ Addr dis_op2_G_E ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf);
       Int  tmpa = LOW24(pair);
       Int  tmpv = newTemp(cb);
@@ -985,5 +1007,5 @@ Addr dis_op2_G_E ( UCodeBlock* cb, 
          uInstr2(cb, STORE, size, TempReg, tmpv, TempReg, tmpa);
       }
-      if (dis) VG_(printf)("%s%c %s,%s\n", t_x86opc, nameISize(size), 
+      DIP("%s%c %s,%s\n", t_x86opc, nameISize(size), 
                            nameIReg(size,gregOfRM(rm)), dis_buf);
       return HI8(pair)+eip0;
@@ -1021,5 +1043,5 @@ Addr dis_mov_E_G ( UCodeBlock* cb, 
       uInstr2(cb, GET, size, ArchReg, eregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, PUT, size, TempReg, tmpv, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("mov%c %s,%s\n", nameISize(size), 
+      DIP("mov%c %s,%s\n", nameISize(size), 
                            nameIReg(size,eregOfRM(rm)),
                            nameIReg(size,gregOfRM(rm)));
@@ -1029,10 +1051,10 @@ Addr dis_mov_E_G ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf);
       Int  tmpa = LOW24(pair);
       Int  tmpb = newTemp(cb);
       uInstr2(cb, LOAD, size, TempReg, tmpa, TempReg, tmpb);
       uInstr2(cb, PUT,  size, TempReg, tmpb, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("mov%c %s,%s\n", nameISize(size), 
+      DIP("mov%c %s,%s\n", nameISize(size), 
                            dis_buf,nameIReg(size,gregOfRM(rm)));
       return HI8(pair)+eip0;
@@ -1070,5 +1092,5 @@ Addr dis_mov_G_E ( UCodeBlock* cb, 
       uInstr2(cb, GET, size, ArchReg, gregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, PUT, size, TempReg, tmpv, ArchReg, eregOfRM(rm));
-      if (dis) VG_(printf)("mov%c %s,%s\n", nameISize(size), 
+      DIP("mov%c %s,%s\n", nameISize(size), 
                            nameIReg(size,gregOfRM(rm)),
                            nameIReg(size,eregOfRM(rm)));
@@ -1078,10 +1100,10 @@ Addr dis_mov_G_E ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf);
       Int  tmpa = LOW24(pair);
       Int  tmpv = newTemp(cb);
       uInstr2(cb, GET,   size, ArchReg, gregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, STORE, size, TempReg, tmpv, TempReg, tmpa);
-      if (dis) VG_(printf)("mov%c %s,%s\n", nameISize(size), 
+      DIP("mov%c %s,%s\n", nameISize(size), 
                            nameIReg(size,gregOfRM(rm)), dis_buf);
       return HI8(pair)+eip0;
@@ -1115,5 +1137,5 @@ Addr dis_op_imm_A ( UCodeBlock* cb, 
    if (keep)
       uInstr2(cb, PUT, size, TempReg, tmp, ArchReg, R_EAX);
-   if (dis) VG_(printf)("%s%c $0x%x, %s\n", t_x86opc, nameISize(size), 
+   DIP("%s%c $0x%x, %s\n", t_x86opc, nameISize(size), 
                         lit, nameIReg(size,R_EAX));
    return eip+size;
@@ -1136,6 +1158,5 @@ Addr dis_movx_E_G ( UCodeBlock* cb, 
       LAST_UINSTR(cb).signed_widen = sign_extend;
       uInstr2(cb, PUT, szd, TempReg, tmpv, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("mov%c%c%c %s,%s\n", 
-                           sign_extend ? 's' : 'z',
+      DIP("mov%c%c%c %s,%s\n", sign_extend ? 's' : 'z',
                            nameISize(szs), nameISize(szd),
                            nameIReg(szs,eregOfRM(rm)),
@@ -1146,5 +1167,5 @@ Addr dis_movx_E_G ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf);
       Int  tmpa = LOW24(pair);
       uInstr2(cb, LOAD, szs, TempReg, tmpa, TempReg, tmpa);
@@ -1153,9 +1174,7 @@ Addr dis_movx_E_G ( UCodeBlock* cb, 
       LAST_UINSTR(cb).signed_widen = sign_extend;
       uInstr2(cb, PUT, szd, TempReg, tmpa, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("mov%c%c%c %s,%s\n", 
-                           sign_extend ? 's' : 'z',
+      DIP("mov%c%c%c %s,%s\n", sign_extend ? 's' : 'z',
                            nameISize(szs), nameISize(szd),
-                           dis_buf,
-                           nameIReg(szd,gregOfRM(rm)));
+                               dis_buf, nameIReg(szd,gregOfRM(rm)));
       return HI8(pair)+eip;
    }
@@ -1251,10 +1270,8 @@ Addr dis_Grp1 ( UCodeBlock* cb, 
          uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, eregOfRM(modrm));
       eip += (am_sz + d_sz);
-      if (dis)
-         VG_(printf)("%s%c $0x%x, %s\n",
-                     nameGrp1(gregOfRM(modrm)), nameISize(sz), d32, 
+      DIP("%s%c $0x%x, %s\n", nameGrp1(gregOfRM(modrm)), nameISize(sz), d32, 
                      nameIReg(sz,eregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+      pair = disAMode ( cb, sorb, eip, dis_buf);
       t1   = LOW24(pair);
       t2   = newTemp(cb);
@@ -1283,8 +1300,6 @@ Addr dis_Grp1 ( UCodeBlock* cb, 
          uInstr2(cb, STORE, sz, TempReg, t2, TempReg, t1);
       }
-      if (dis)
-         VG_(printf)("%s%c $0x%x, %s\n",
-                     nameGrp1(gregOfRM(modrm)), nameISize(sz), d32, 
-                     dis_buf);
+      DIP("%s%c $0x%x, %s\n", nameGrp1(gregOfRM(modrm)), nameISize(sz),
+                              d32, dis_buf);
    }
    return eip;
@@ -1338,5 +1353,5 @@ Addr dis_Grp2 ( UCodeBlock* cb, 
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, eregOfRM(modrm));
       eip += (am_sz + d_sz);
-      if (dis) {
+      if (VG_(print_codegen)) {
          if (orig_src_tag == Literal)
             VG_(printf)("%s%c $0x%x, %s\n",
@@ -1350,5 +1365,5 @@ Addr dis_Grp2 ( UCodeBlock* cb, 
       }
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+      pair = disAMode ( cb, sorb, eip, dis_buf);
       t1   = LOW24(pair);
       t2   = newTemp(cb);
@@ -1371,5 +1386,5 @@ Addr dis_Grp2 ( UCodeBlock* cb, 
       setFlagsFromUOpcode(cb, uopc);
       uInstr2(cb, STORE, sz, TempReg, t2, TempReg, t1);
-      if (dis) {
+      if (VG_(print_codegen)) {
          if (orig_src_tag == Literal)
             VG_(printf)("%s%c $0x%x, %s\n",
@@ -1424,5 +1439,5 @@ Addr dis_Grp8_BT ( UCodeBlock* cb, 
    Int   t1, t2, t_fetched, t_mask;
    UInt  pair;
-   UChar dis_buf[50];
+   Char  dis_buf[50];
    UInt  v_mask;
 
@@ -1473,11 +1488,8 @@ Addr dis_Grp8_BT ( UCodeBlock* cb, 
 
       eip += (am_sz + 1);
-      if (dis)
-         VG_(printf)("%s%c $0x%x, %s\n",
-                     nameGrp8(gregOfRM(modrm)), nameISize(sz),
-                     src_val,
-                     nameIReg(sz,eregOfRM(modrm)));
+      DIP("%s%c $0x%x, %s\n", nameGrp8(gregOfRM(modrm)), nameISize(sz),
+                              src_val, nameIReg(sz,eregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+      pair = disAMode ( cb, sorb, eip, dis_buf);
       t1   = LOW24(pair);
       t2   = newTemp(cb);
@@ -1493,8 +1505,6 @@ Addr dis_Grp8_BT ( UCodeBlock* cb, 
          uInstr2(cb, STORE, sz, TempReg, t2, TempReg, t1);
       }
-      if (dis)
-            VG_(printf)("%s%c $0x%x, %s\n",
-                        nameGrp8(gregOfRM(modrm)), nameISize(sz), src_val, 
-                        dis_buf);
+      DIP("%s%c $0x%x, %s\n", nameGrp8(gregOfRM(modrm)), nameISize(sz),
+                              src_val, dis_buf);
    }
    return eip;
@@ -1540,5 +1550,5 @@ static void codegen_mul_A_D_Reg ( UCodeB
    }
    uInstr0(cb, CALLM_E, 0);
-   if (dis) VG_(printf)("%s%c %s\n", signed_multiply ? "imul" : "mul",
+   DIP("%s%c %s\n", signed_multiply ? "imul" : "mul",
                         nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
 
@@ -1579,5 +1589,5 @@ static void codegen_mul_A_D_Temp ( UCode
    }
    uInstr0(cb, CALLM_E, 0);
-   if (dis) VG_(printf)("%s%c %s\n", signed_multiply ? "imul" : "mul",
+   DIP("%s%c %s\n", signed_multiply ? "imul" : "mul",
                         nameISize(sz), dis_buf);
 }
@@ -1607,6 +1617,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             uInstr2(cb, AND, sz, TempReg, tao, TempReg, t1);
             setFlagsFromUOpcode(cb, AND);
-            if (dis)
-               VG_(printf)("test%c $0x%x, %s\n",
+            DIP("test%c $0x%x, %s\n",
                    nameISize(sz), d32, nameIReg(sz, eregOfRM(modrm)));
             break;
@@ -1618,7 +1627,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             setFlagsFromUOpcode(cb, NOT);
             uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, eregOfRM(modrm));
-            if (dis)
-               VG_(printf)("not%c %s\n",
-                   nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
+            DIP("not%c %s\n", nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
             break;
          case 3: /* NEG */
@@ -1628,7 +1635,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             setFlagsFromUOpcode(cb, NEG);
             uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, eregOfRM(modrm));
-            if (dis)
-               VG_(printf)("neg%c %s\n",
-                   nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
+            DIP("neg%c %s\n", nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
             break;
          case 4: /* MUL */
@@ -1644,7 +1649,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             uInstr2(cb, GET, sz, ArchReg, eregOfRM(modrm), TempReg, t1);
             codegen_div ( cb, sz, t1, False );
-            if (dis)
-               VG_(printf)("div%c %s\n", nameISize(sz), 
-                           nameIReg(sz, eregOfRM(modrm)));
+            DIP("div%c %s\n", nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
             break;
          case 7: /* IDIV */
@@ -1652,7 +1655,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             uInstr2(cb, GET, sz, ArchReg, eregOfRM(modrm), TempReg, t1);
             codegen_div ( cb, sz, t1, True );
-            if (dis)
-               VG_(printf)("idiv%c %s\n", nameISize(sz), 
-                           nameIReg(sz, eregOfRM(modrm)));
+            DIP("idiv%c %s\n", nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
             break;
          default: 
@@ -1662,5 +1663,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
       }
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       t2   = LOW24(pair);
       t1   = newTemp(cb);
@@ -1675,7 +1676,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             uInstr2(cb, AND, sz, TempReg, tao, TempReg, t1);
             setFlagsFromUOpcode(cb, AND);
-            if (dis)
-               VG_(printf)("test%c $0x%x, %s\n", 
-                           nameISize(sz), d32, dis_buf);
+            DIP("test%c $0x%x, %s\n", nameISize(sz), d32, dis_buf);
             break;
          }
@@ -1684,6 +1683,5 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             setFlagsFromUOpcode(cb, NOT);
             uInstr2(cb, STORE, sz, TempReg, t1, TempReg, t2);
-            if (dis)
-               VG_(printf)("not%c %s\n", nameISize(sz), dis_buf);
+            DIP("not%c %s\n", nameISize(sz), dis_buf);
             break;
          case 3: /* NEG */
@@ -1691,23 +1689,20 @@ Addr dis_Grp3 ( UCodeBlock* cb, 
             setFlagsFromUOpcode(cb, NEG);
             uInstr2(cb, STORE, sz, TempReg, t1, TempReg, t2);
-            if (dis)
-               VG_(printf)("neg%c %s\n", nameISize(sz), dis_buf);
+            DIP("neg%c %s\n", nameISize(sz), dis_buf);
             break;
          case 4: /* MUL */
             codegen_mul_A_D_Temp ( cb, sz, t1, False, 
-                                   dis?dis_buf:NULL );
+                                   dis_buf );
             break;
          case 5: /* IMUL */
-            codegen_mul_A_D_Temp ( cb, sz, t1, True, dis?dis_buf:NULL );
+            codegen_mul_A_D_Temp ( cb, sz, t1, True, dis_buf );
             break;
          case 6: /* DIV */
             codegen_div ( cb, sz, t1, False );
-            if (dis)
-               VG_(printf)("div%c %s\n", nameISize(sz), dis_buf);
+            DIP("div%c %s\n", nameISize(sz), dis_buf);
             break;
          case 7: /* IDIV */
             codegen_div ( cb, sz, t1, True );
-            if (dis)
-               VG_(printf)("idiv%c %s\n", nameISize(sz), dis_buf);
+            DIP("idiv%c %s\n", nameISize(sz), dis_buf);
             break;
          default: 
@@ -1754,9 +1749,8 @@ Addr dis_Grp4 ( UCodeBlock* cb, 
       }
       eip++;
-      if (dis)
-         VG_(printf)("%sb %s\n", nameGrp4(gregOfRM(modrm)),
+      DIP("%sb %s\n", nameGrp4(gregOfRM(modrm)),
                      nameIReg(1, eregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       t2   = LOW24(pair);
       t1   = newTemp(cb);
@@ -1779,6 +1773,5 @@ Addr dis_Grp4 ( UCodeBlock* cb, 
       }
       eip += HI8(pair);
-      if (dis)
-         VG_(printf)("%sb %s\n", nameGrp4(gregOfRM(modrm)), dis_buf);
+      DIP("%sb %s\n", nameGrp4(gregOfRM(modrm)), dis_buf);
    }
    return eip;
@@ -1822,12 +1815,10 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
             uLiteral(cb, eip+1);
             uInstr2(cb, STORE, 4, TempReg, t4,    TempReg, t3);
-            uInstr1(cb, JMP,   0, TempReg, t1);
-            uCond(cb, CondAlways);
+            jmp_treg(cb, t1);
             LAST_UINSTR(cb).jmpkind = JmpCall;
             *isEnd = True;
             break;
          case 4: /* jmp Ev */
-            uInstr1(cb, JMP, 0, TempReg, t1);
-            uCond(cb, CondAlways);
+            jmp_treg(cb, t1);
             *isEnd = True;
             break;
@@ -1838,9 +1829,8 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
       }
       eip++;
-      if (dis)
-         VG_(printf)("%s%c %s\n", nameGrp5(gregOfRM(modrm)),
+      DIP("%s%c %s\n", nameGrp5(gregOfRM(modrm)),
                      nameISize(sz), nameIReg(sz, eregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       t2   = LOW24(pair);
       t1   = newTemp(cb);
@@ -1866,12 +1856,10 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
                  uLiteral(cb, eip+HI8(pair));
             uInstr2(cb, STORE, 4, TempReg, t4,    TempReg, t3);
-            uInstr1(cb, JMP,   0, TempReg, t1);
-            uCond(cb, CondAlways);
+            jmp_treg(cb, t1);
             LAST_UINSTR(cb).jmpkind = JmpCall;
             *isEnd = True;
             break;
          case 4: /* JMP Ev */
-            uInstr1(cb, JMP, 0, TempReg, t1);
-            uCond(cb, CondAlways);
+            jmp_treg(cb, t1);
             *isEnd = True;
             break;
@@ -1890,6 +1878,5 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
       }
       eip += HI8(pair);
-      if (dis)
-         VG_(printf)("%s%c %s\n", nameGrp5(gregOfRM(modrm)),
+      DIP("%s%c %s\n", nameGrp5(gregOfRM(modrm)),
                      nameISize(sz), dis_buf);
    }
@@ -1897,12 +1884,4 @@ Addr dis_Grp5 ( UCodeBlock* cb, 
 }
 
-static __inline__
-void dis_JMP_d32( UCodeBlock* cb, Addr d32 )
-{
-   uInstr1(cb, JMP,   0, Literal, 0);
-   uLiteral(cb, d32);
-   uCond(cb, CondAlways);
-}
-
 /*------------------------------------------------------------*/
 /*--- Disassembling string ops (including REP prefixes)    ---*/
@@ -1938,5 +1917,5 @@ void dis_string_op( UCodeBlock* cb, void
    dis_string_op_increment(cb, sz, t_inc);
    dis_OP( cb, sz, t_inc );
-   if (dis) VG_(printf)("%s%c\n", name, nameISize(sz));
+   DIP("%s%c\n", name, nameISize(sz));
 }
 
@@ -2055,14 +2034,10 @@ void dis_REP_op ( UCodeBlock* cb, Int co
 
    if (cond == CondAlways) {
-      dis_JMP_d32  (cb, eip);
+      jmp_lit(cb, eip);
    } else {
-      uInstr1      (cb, JMP,   0, Literal, 0);
-      uLiteral     (cb, eip);
-      uCond        (cb, cond);
-      uFlagsRWU    (cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
-
-      dis_JMP_d32  (cb, eip_next);
+      jcc_lit(cb, eip, cond);
+      jmp_lit(cb, eip_next);
    }
-   if (dis) VG_(printf)("%s%c\n", name, nameISize(sz));
+   DIP("%s%c\n", name, nameISize(sz));
 }
 
@@ -2092,6 +2067,5 @@ Addr dis_mul_E_G ( UCodeBlock* cb, 
       setFlagsFromUOpcode(cb, MUL);
       uInstr2(cb, PUT,  size, TempReg, tg, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("%smul%c %s, %s\n",
-                           signed_multiply ? "i" : "",
+      DIP("%smul%c %s, %s\n", signed_multiply ? "i" : "",
                            nameISize(size), 
                            nameIReg(size,eregOfRM(rm)),
@@ -2101,5 +2075,5 @@ Addr dis_mul_E_G ( UCodeBlock* cb, 
       UInt pair;
       vg_assert(signed_multiply);
-      pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      pair = disAMode ( cb, sorb, eip0, dis_buf );
       ta = LOW24(pair);
       uInstr2(cb, LOAD,  size, TempReg, ta, TempReg, te);
@@ -2109,8 +2083,7 @@ Addr dis_mul_E_G ( UCodeBlock* cb, 
       uInstr2(cb, PUT,  size, TempReg, tg,    ArchReg, gregOfRM(rm));
 
-      if (dis) VG_(printf)("%smul%c %s, %s\n",
-                           signed_multiply ? "i" : "",
+      DIP("%smul%c %s, %s\n", signed_multiply ? "i" : "",
                            nameISize(size), 
-                           dis_buf,nameIReg(size,gregOfRM(rm)));
+                              dis_buf, nameIReg(size,gregOfRM(rm)));
       return HI8(pair)+eip0;
    }
@@ -2127,5 +2100,5 @@ Addr dis_imul_I_E_G ( UCodeBlock* cb, 
 {
    Int ta, te, tl, d32;
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar rm = getUChar(eip);
    ta = INVALID_TEMPREG;
@@ -2137,5 +2110,5 @@ Addr dis_imul_I_E_G ( UCodeBlock* cb, 
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       ta = LOW24(pair);
       uInstr2(cb, LOAD,  size, TempReg, ta, TempReg, te);
@@ -2152,13 +2125,7 @@ Addr dis_imul_I_E_G ( UCodeBlock* cb, 
    uInstr2(cb, PUT,   size, TempReg, te,   ArchReg, gregOfRM(rm));
 
-   if (dis) {
-      if (epartIsReg(rm)) {
-         VG_(printf)("imul %d, %s, %s\n", d32, nameIReg(size,eregOfRM(rm)),
-                                          nameIReg(size,gregOfRM(rm)));
-      } else {
-         VG_(printf)("imul %d, %s, %s\n", d32, dis_buf,
-                                          nameIReg(size,gregOfRM(rm)));
-      }
-   }
+   DIP("imul %d, %s, %s\n", d32, 
+       ( epartIsReg(rm) ? nameIReg(size,eregOfRM(rm)) : dis_buf ),
+       nameIReg(size,gregOfRM(rm)) );
 
    return eip;
@@ -2180,5 +2147,5 @@ Addr dis_fpu_mem ( UCodeBlock* cb, 
    vg_assert(second_byte < 0xC0);
    second_byte &= 0x38;
-   pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+   pair = disAMode ( cb, sorb, eip, dis_buf );
    ta   = LOW24(pair);
    eip  += HI8(pair);
@@ -2187,14 +2154,10 @@ Addr dis_fpu_mem ( UCodeBlock* cb, 
                (((UShort)first_byte) << 8) | ((UShort)second_byte),
                TempReg, ta);
-   if (dis) {
-      if (is_write)
-         VG_(printf)("fpu_w_%d 0x%x:0x%x, %s\n",
-                     size, (UInt)first_byte, 
-                           (UInt)second_byte, dis_buf );
-      else
-         VG_(printf)("fpu_r_%d %s, 0x%x:0x%x\n",
-                     size, dis_buf,
-                     (UInt)first_byte, 
-                     (UInt)second_byte );
+   if (is_write) {
+      DIP("fpu_w_%d 0x%x:0x%x, %s\n",
+          size, (UInt)first_byte, (UInt)second_byte, dis_buf );
+   } else {
+      DIP("fpu_r_%d %s, 0x%x:0x%x\n",
+          size, dis_buf, (UInt)first_byte, (UInt)second_byte );
    }
    return eip;
@@ -2265,6 +2228,5 @@ Addr dis_fpu_no_mem ( UCodeBlock* cb, Ad
    }
 
-   if (dis) VG_(printf)("fpu 0x%x:0x%x%s%s\n",
-                        (UInt)first_byte, (UInt)second_byte,
+   DIP("fpu 0x%x:0x%x%s%s\n", (UInt)first_byte, (UInt)second_byte,
                         uses_ZCP ? " -rZCP" : "",
                         sets_ZCP ? " -wZCP" : "" );
@@ -2296,5 +2258,5 @@ Addr dis_fpu ( UCodeBlock* cb, 
       uInstr2(cb, PUT,   2,  TempReg, t1, ArchReg, R_EAX);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) VG_(printf)("fstsw %%ax\n");
+      DIP("fstsw %%ax\n");
       eip++;
       return eip;
@@ -2498,11 +2460,9 @@ Addr dis_SHLRD_Gv_Ev ( UCodeBlock* cb,
       uInstr1(cb, POP,   sz, TempReg, t);
       uInstr2(cb, PUT,   sz, TempReg, t, ArchReg, eregOfRM(modrm));
-      if (dis)
-         VG_(printf)("sh%cd%c %%cl, %s, %s\n",
-                     ( left_shift ? 'l' : 'r' ),
-                     nameISize(sz), nameIReg(sz, gregOfRM(modrm)), 
-                     nameIReg(sz, eregOfRM(modrm)));
+      DIP("sh%cd%c %%cl, %s, %s\n",
+          ( left_shift ? 'l' : 'r' ), nameISize(sz), 
+          nameIReg(sz, gregOfRM(modrm)), nameIReg(sz, eregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       ta   = LOW24(pair);
       eip  += HI8(pair);
@@ -2513,9 +2473,6 @@ Addr dis_SHLRD_Gv_Ev ( UCodeBlock* cb,
       uInstr1(cb, POP,   sz, TempReg, t);
       uInstr2(cb, STORE, sz, TempReg, t,      TempReg, ta);
-      if (dis)
-         VG_(printf)("sh%cd%c %%cl, %s, %s\n",
-                     ( left_shift ? 'l' : 'r' ),
-                     nameISize(sz), nameIReg(sz, gregOfRM(modrm)), 
-                     dis_buf);
+      DIP("sh%cd%c %%cl, %s, %s\n", ( left_shift ? 'l' : 'r' ),
+          nameISize(sz), nameIReg(sz, gregOfRM(modrm)), dis_buf);
    }
   
@@ -2551,5 +2508,5 @@ Addr dis_bt_G_E ( UCodeBlock* cb, 
 {
    UInt  pair;
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm;
 
@@ -2592,5 +2549,5 @@ Addr dis_bt_G_E ( UCodeBlock* cb, 
       uInstr2(cb, AND, 4, TempReg, lit, TempReg, t_bitno);
    } else {
-      pair   = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair   = disAMode ( cb, sorb, eip, dis_buf );
       t_addr = LOW24(pair);
       eip   += HI8(pair);
@@ -2668,17 +2625,7 @@ Addr dis_bt_G_E ( UCodeBlock* cb, 
    }
 
-   if (epartIsReg(modrm)) {
-      if (dis)
-         VG_(printf)("bt%s%c %s, %s\n",
-                     nameBtOp(op),
-                     nameISize(sz), nameIReg(sz, gregOfRM(modrm)), 
-                     nameIReg(sz, eregOfRM(modrm)));
-   } else {
-      if (dis)
-         VG_(printf)("bt%s%c %s, %s\n",
-                     nameBtOp(op),
-                     nameISize(sz), nameIReg(sz, gregOfRM(modrm)), 
-                     dis_buf);
-   }
+   DIP("bt%s%c %s, %s\n",
+       nameBtOp(op), nameISize(sz), nameIReg(sz, gregOfRM(modrm)), 
+       ( epartIsReg(modrm) ? nameIReg(sz, eregOfRM(modrm)) : dis_buf ) );
  
    return eip;
@@ -2696,6 +2642,7 @@ Addr dis_bs_E_G ( UCodeBlock* cb, 
    Int   t, t1, ta, helper;
    UInt  pair;
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm;
+   Bool  isReg;
 
    vg_assert(sz == 2 || sz == 4);
@@ -2711,23 +2658,18 @@ Addr dis_bs_E_G ( UCodeBlock* cb, 
    uInstr1(cb, PUSH, sz, TempReg, t1);
 
-   if (epartIsReg(modrm)) {
+   isReg = epartIsReg(modrm);
+   if (isReg) {
       eip++;
       uInstr2(cb, GET, sz, ArchReg, eregOfRM(modrm), TempReg, t);
-      if (dis)
-         VG_(printf)("bs%c%c %s, %s\n",
-                     fwds ? 'f' : 'r',
-                     nameISize(sz), nameIReg(sz, eregOfRM(modrm)), 
-                     nameIReg(sz, gregOfRM(modrm)));
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       ta   = LOW24(pair);
       eip  += HI8(pair);
       uInstr2(cb, LOAD, sz, TempReg, ta, TempReg, t);
-      if (dis)
-         VG_(printf)("bs%c%c %s, %s\n",
-                     fwds ? 'f' : 'r',
-                     nameISize(sz), dis_buf,
-                     nameIReg(sz, gregOfRM(modrm)));
    }
+   DIP("bs%c%c %s, %s\n",
+       fwds ? 'f' : 'r', nameISize(sz), 
+       ( isReg ? nameIReg(sz, eregOfRM(modrm)) : dis_buf ), 
+       nameIReg(sz, gregOfRM(modrm)));
 
    uInstr1(cb, PUSH,  sz,  TempReg, t);
@@ -2754,7 +2696,6 @@ void codegen_xchg_eAX_Reg ( UCodeBlock* 
    uInstr2(cb, PUT, sz, TempReg, t2,    ArchReg, R_EAX);
    uInstr2(cb, PUT, sz, TempReg, t1,    ArchReg, reg);
-   if (dis)
-      VG_(printf)("xchg%c %s, %s\n", nameISize(sz),
-                  nameIReg(sz, R_EAX), nameIReg(sz, reg));
+   DIP("xchg%c %s, %s\n", 
+       nameISize(sz), nameIReg(sz, R_EAX), nameIReg(sz, reg));
 }
 
@@ -2830,14 +2771,13 @@ Addr dis_cmpxchg_G_E ( UCodeBlock* cb, 
      uInstr2(cb, GET, size, ArchReg, eregOfRM(rm), TempReg, dest);
      eip0++;
-     if (dis) VG_(printf)("cmpxchg%c %s,%s\n", 
-                          nameISize(size),
+     DIP("cmpxchg%c %s,%s\n", nameISize(size),
                           nameIReg(size,gregOfRM(rm)),
                           nameIReg(size,eregOfRM(rm)) );
    } else {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf );
       ta        = LOW24(pair);
       uInstr2(cb, LOAD, size, TempReg, ta, TempReg, dest);
       eip0 += HI8(pair);
-      if (dis) VG_(printf)("cmpxchg%c %s,%s\n",  nameISize(size), 
+      DIP("cmpxchg%c %s,%s\n", nameISize(size), 
                            nameIReg(size,gregOfRM(rm)), dis_buf);
    }
@@ -2889,5 +2829,5 @@ Addr dis_cmpxchg8b ( UCodeBlock* cb, 
    vg_assert(!epartIsReg(rm));
 
-   pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL );
+   pair = disAMode ( cb, sorb, eip0, dis_buf );
    tal = LOW24(pair);
    tah = newTemp(cb);
@@ -2896,5 +2836,5 @@ Addr dis_cmpxchg8b ( UCodeBlock* cb, 
    uLiteral(cb, 4);
    eip0 += HI8(pair);
-   if (dis) VG_(printf)("cmpxchg8b %s\n", dis_buf);
+   DIP("cmpxchg8b %s\n", dis_buf);
    
    uInstr0(cb, CALLM_S, 0);
@@ -2972,6 +2912,5 @@ Addr dis_cmov_E_G ( UCodeBlock* cb, 
       uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
       uInstr2(cb, PUT, size, TempReg, tmpd, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("cmov%c%s %s,%s\n", 
-                           nameISize(size), 
+      DIP("cmov%c%s %s,%s\n", nameISize(size), 
                            VG_(name_UCondcode)(cond),
                            nameIReg(size,eregOfRM(rm)),
@@ -2982,5 +2921,5 @@ Addr dis_cmov_E_G ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf );
       Int  tmpa = LOW24(pair);
       uInstr2(cb, LOAD, size, TempReg, tmpa, TempReg, tmps);
@@ -2990,6 +2929,5 @@ Addr dis_cmov_E_G ( UCodeBlock* cb, 
       uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
       uInstr2(cb, PUT, size, TempReg, tmpd, ArchReg, gregOfRM(rm));
-      if (dis) VG_(printf)("cmov%c%s %s,%s\n", 
-                           nameISize(size), 
+      DIP("cmov%c%s %s,%s\n", nameISize(size), 
                            VG_(name_UCondcode)(cond),
                            dis_buf,
@@ -3019,11 +2957,9 @@ Addr dis_xadd_G_E ( UCodeBlock* cb, 
       uInstr2(cb, PUT, sz, TempReg, tmpt, ArchReg, eregOfRM(rm));
       uInstr2(cb, PUT, sz, TempReg, tmpd, ArchReg, gregOfRM(rm));
-      if (dis)
-         VG_(printf)("xadd%c %s, %s\n", nameISize(sz), 
-                     nameIReg(sz,gregOfRM(rm)), 
-                     nameIReg(sz,eregOfRM(rm)));
+      DIP("xadd%c %s, %s\n", 
+          nameISize(sz), nameIReg(sz,gregOfRM(rm)), nameIReg(sz,eregOfRM(rm)));
       return 1+eip0;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf );
       Int  tmpa  = LOW24(pair);
       uInstr2(cb, LOAD, sz, TempReg, tmpa,          TempReg, tmpd);
@@ -3033,8 +2969,6 @@ Addr dis_xadd_G_E ( UCodeBlock* cb, 
       uInstr2(cb, STORE, sz, TempReg, tmpt, TempReg, tmpa);
       uInstr2(cb, PUT, sz, TempReg, tmpd, ArchReg, gregOfRM(rm));
-      if (dis)
-         VG_(printf)("xadd%c %s, %s\n", nameISize(sz), 
-                     nameIReg(sz,gregOfRM(rm)), 
-                     dis_buf);
+      DIP("xadd%c %s, %s\n", 
+          nameISize(sz), nameIReg(sz,gregOfRM(rm)), dis_buf);
       return HI8(pair)+eip0;
    }
@@ -3070,7 +3004,5 @@ Addr dis_mov_Ew_Sw ( UCodeBlock* cb, 
       uInstr2(cb, GET,    2, ArchReg, eregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, PUTSEG, 2, TempReg, tmpv, ArchRegS, gregOfRM(rm));
-      if (dis) VG_(printf)("movw %s,%s\n",
-                           nameIReg(2,eregOfRM(rm)),
-                           nameSReg(gregOfRM(rm)));
+      DIP("movw %s,%s\n", nameIReg(2,eregOfRM(rm)), nameSReg(gregOfRM(rm)));
       return 1+eip0;
    }
@@ -3078,11 +3010,10 @@ Addr dis_mov_Ew_Sw ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf );
       Int  tmpa = LOW24(pair);
       Int  tmpb = newTemp(cb);
       uInstr2(cb, LOAD,   2, TempReg, tmpa, TempReg, tmpb);
       uInstr2(cb, PUTSEG, 2, TempReg, tmpb, ArchRegS, gregOfRM(rm));
-      if (dis) VG_(printf)("movw %s,%s\n",
-                           dis_buf,nameSReg(gregOfRM(rm)));
+      DIP("movw %s,%s\n", dis_buf,nameSReg(gregOfRM(rm)));
       return HI8(pair)+eip0;
    }
@@ -3118,7 +3049,5 @@ Addr dis_mov_Sw_Ew ( UCodeBlock* cb, 
       uInstr2(cb, GETSEG, 2, ArchRegS, gregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, PUT,    2, TempReg, tmpv, ArchReg, eregOfRM(rm));
-      if (dis) VG_(printf)("movw %s,%s\n",
-                           nameSReg(gregOfRM(rm)),
-                           nameIReg(2,eregOfRM(rm)));
+      DIP("movw %s,%s\n", nameSReg(gregOfRM(rm)), nameIReg(2,eregOfRM(rm)));
       return 1+eip0;
    }
@@ -3126,11 +3055,10 @@ Addr dis_mov_Sw_Ew ( UCodeBlock* cb, 
    /* E refers to memory */    
    {
-      UInt pair = disAMode ( cb, sorb, eip0, dis?dis_buf:NULL);
+      UInt pair = disAMode ( cb, sorb, eip0, dis_buf );
       Int  tmpa = LOW24(pair);
       Int  tmpv = newTemp(cb);
       uInstr2(cb, GETSEG, 2, ArchRegS, gregOfRM(rm), TempReg, tmpv);
       uInstr2(cb, STORE,  2, TempReg, tmpv, TempReg, tmpa);
-      if (dis) VG_(printf)("mov %s,%s\n",
-                           nameSReg(gregOfRM(rm)), dis_buf);
+      DIP("mov %s,%s\n", nameSReg(gregOfRM(rm)), dis_buf);
       return HI8(pair)+eip0;
    }
@@ -3153,20 +3081,15 @@ Addr dis_MMXop_regmem_to_reg ( UCodeBloc
                                Bool show_granularity )
 {
-   UChar dis_buf[50];
-   UChar modrm;
-   modrm = getUChar(eip);
-   if (epartIsReg(modrm)) {
+    Char dis_buf[50];
+   UChar modrm = getUChar(eip);
+   Bool  isReg = epartIsReg(modrm);
+
+   if (isReg) {
       eip++;
       uInstr1(cb, MMX2, 0, 
                   Lit16, 
                   (((UShort)(opc)) << 8) | ((UShort)modrm) );
-      if (dis)
-         VG_(printf)("%s%s %s, %s\n", 
-                     name,
-                     show_granularity ? nameMMXGran(opc & 3) : (Char*)"",
-                     nameMMXReg(eregOfRM(modrm)),
-                     nameMMXReg(gregOfRM(modrm)));
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3175,11 +3098,11 @@ Addr dis_MMXop_regmem_to_reg ( UCodeBloc
                   (((UShort)(opc)) << 8) | ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s%s %s, %s\n", 
-                     name,
-                     show_granularity ? nameMMXGran(opc & 3) : (Char*)"",
-                     dis_buf,
-                     nameMMXReg(gregOfRM(modrm)));
    }
+
+   DIP("%s%s %s, %s\n", 
+       name, show_granularity ? nameMMXGran(opc & 3) : (Char*)"",
+       ( isReg ? nameMMXReg(eregOfRM(modrm)) : dis_buf ),
+       nameMMXReg(gregOfRM(modrm)) );
+
    return eip;
 }
@@ -3204,18 +3127,16 @@ Addr dis_SSE3_reg_or_mem ( UCodeBlock* c
                            UChar opc3 )
 {
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm = getUChar(eip);
-   if (epartIsReg(modrm)) {
+   Bool  isReg = epartIsReg(modrm);
+
+   if (isReg) {
       /* Completely internal SSE insn. */
       uInstr2(cb, SSE4, 0,  /* ignore sz for internal ops */
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (((UShort)opc3) << 8) | (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3224,10 +3145,11 @@ Addr dis_SSE3_reg_or_mem ( UCodeBlock* c
                   Lit16, (((UShort)(opc3)) << 8) | ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)));
    }
+
+   DIP("%s %s, %s\n", 
+       name, 
+       ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ),
+       nameXMMReg(gregOfRM(modrm)) );
+
    return eip;
 }
@@ -3250,18 +3172,16 @@ Addr dis_SSE2_reg_or_mem ( UCodeBlock* c
                            UChar opc2 )
 {
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm = getUChar(eip);
-   if (epartIsReg(modrm)) {
+   Bool  isReg = epartIsReg(modrm);
+
+   if (isReg) {
       /* Completely internal SSE insn. */
       uInstr2(cb, SSE3, 0,  /* ignore sz for internal ops */
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3270,10 +3190,10 @@ Addr dis_SSE2_reg_or_mem ( UCodeBlock* c
                   Lit16, (UShort)modrm,
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)));
    }
+   DIP("%s %s, %s\n", 
+       name, 
+       ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ), 
+       nameXMMReg(gregOfRM(modrm)) );
+
    return eip;
 }
@@ -3296,8 +3216,10 @@ Addr dis_SSE2_reg_or_mem_Imm8 ( UCodeBlo
                                 UChar opc2 )
 {
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm = getUChar(eip);
    UChar imm8;
-   if (epartIsReg(modrm)) {
+   Bool  isReg = epartIsReg(modrm);
+
+   if (isReg) {
       /* Completely internal SSE insn. */
       eip++;
@@ -3306,11 +3228,7 @@ Addr dis_SSE2_reg_or_mem_Imm8 ( UCodeBlo
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (((UShort)modrm) << 8) | (UShort)imm8 );
-      if (dis)
-         VG_(printf)("%s %s, %s, $%d\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3321,10 +3239,8 @@ Addr dis_SSE2_reg_or_mem_Imm8 ( UCodeBlo
                   Lit16, (((UShort)(modrm)) << 8) | ((UShort)imm8),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s, $%d\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
    }
+   DIP("%s %s, %s, $%d\n", 
+       name, ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ), 
+       nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
    return eip;
 }
@@ -3348,8 +3264,10 @@ Addr dis_SSE3_reg_or_mem_Imm8 ( UCodeBlo
                                 UChar opc3 )
 {
-   UChar dis_buf[50];
+    Char dis_buf[50];
    UChar modrm = getUChar(eip);
    UChar imm8;
-   if (epartIsReg(modrm)) {
+   Bool  isReg = epartIsReg(modrm);
+
+   if (isReg) {
       /* Completely internal SSE insn. */
       eip++;
@@ -3359,11 +3277,7 @@ Addr dis_SSE3_reg_or_mem_Imm8 ( UCodeBlo
                   Lit16, (((UShort)opc3) << 8) | (UShort)modrm,
                   Lit16, (UShort)imm8 );
-      if (dis)
-         VG_(printf)("%s %s, %s, $%d\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3375,10 +3289,8 @@ Addr dis_SSE3_reg_or_mem_Imm8 ( UCodeBlo
                   TempReg, tmpa);
       uLiteral(cb, imm8);
-      if (dis)
-         VG_(printf)("%s %s, %s, $%d\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
    }
+   DIP("%s %s, %s, $%d\n", 
+       name, ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ), 
+       nameXMMReg(gregOfRM(modrm)), (Int)imm8 );
    return eip;
 }
@@ -3400,10 +3312,11 @@ Addr dis_SSE3_load_store_or_mov ( UCodeB
                                   UChar insn2 )
 {
-   UChar dis_buf[50];
-   UChar modrm; 
+    Char dis_buf[50];
+   UChar modrm = getUChar(eip);
+   Bool  isReg = epartIsReg(modrm);
    UInt  pair;
    Int   t1;
-   modrm = getUChar(eip);
-   if (epartIsReg(modrm)) {
+
+   if (isReg) {
       /* Completely internal; we can issue SSE4. */
       eip++;
@@ -3411,14 +3324,6 @@ Addr dis_SSE3_load_store_or_mov ( UCodeB
                   Lit16, (((UShort)insn0) << 8) | (UShort)insn1,
                   Lit16, (((UShort)insn2) << 8) | (UShort)modrm );
-      if (dis && is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     nameXMMReg(gregOfRM(modrm)),
-                     nameXMMReg(eregOfRM(modrm)) );
-      if (dis && !is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                      nameXMMReg(eregOfRM(modrm)), 
-                      nameXMMReg(gregOfRM(modrm)) );
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       t1   = LOW24(pair);
       eip += HI8(pair);
@@ -3427,10 +3332,16 @@ Addr dis_SSE3_load_store_or_mov ( UCodeB
                   Lit16, (((UShort)insn2) << 8) | (UShort)modrm,
                   TempReg, t1 );
-      if (dis && is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     nameXMMReg(gregOfRM(modrm)), dis_buf );
-      if (dis && !is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     dis_buf, nameXMMReg(gregOfRM(modrm)) );
+   }
+
+   if (is_store) {
+      DIP("%s %s, %s\n", 
+          name,
+          nameXMMReg(gregOfRM(modrm)),
+          ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ) );
+   } else {
+      DIP("%s %s, %s\n", 
+          name,
+          ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ),
+          nameXMMReg(gregOfRM(modrm)) );
    }
    return eip;
@@ -3451,10 +3362,11 @@ Addr dis_SSE2_load_store_or_mov ( UCodeB
                                   UChar insn1 )
 {
-   UChar dis_buf[50];
-   UChar modrm; 
+    Char dis_buf[50];
+   UChar modrm = getUChar(eip);
+   Bool  isReg = epartIsReg(modrm);
    UInt  pair;
    Int   t1;
-   modrm = getUChar(eip);
-   if (epartIsReg(modrm)) {
+
+   if (isReg) {
       /* Completely internal; we can issue SSE3. */
       eip++;
@@ -3462,14 +3374,6 @@ Addr dis_SSE2_load_store_or_mov ( UCodeB
                   Lit16, (((UShort)insn0) << 8) | (UShort)insn1,
                   Lit16, (UShort)modrm );
-      if (dis && is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     nameXMMReg(gregOfRM(modrm)),
-                     nameXMMReg(eregOfRM(modrm)) );
-      if (dis && !is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                      nameXMMReg(eregOfRM(modrm)), 
-                      nameXMMReg(gregOfRM(modrm)) );
    } else {
-      pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip, dis_buf );
       t1   = LOW24(pair);
       eip += HI8(pair);
@@ -3478,10 +3382,16 @@ Addr dis_SSE2_load_store_or_mov ( UCodeB
                   Lit16, (UShort)modrm,
                   TempReg, t1 );
-      if (dis && is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     nameXMMReg(gregOfRM(modrm)), dis_buf );
-      if (dis && !is_store)
-         VG_(printf)("%s %s, %s\n", name,
-                     dis_buf, nameXMMReg(gregOfRM(modrm)) );
+   }
+
+   if (is_store) {
+      DIP("%s %s, %s\n",
+          name,
+          nameXMMReg(gregOfRM(modrm)),
+          ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ) );
+   } else {
+      DIP("%s %s, %s\n",
+          name,
+          ( isReg ? nameXMMReg(eregOfRM(modrm)) : dis_buf ),
+          nameXMMReg(gregOfRM(modrm)) );
    }
    return eip;
@@ -3512,11 +3422,9 @@ Addr dis_SSE2_to_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameMMXReg(gregOfRM(modrm)) );
+      DIP("%s %s, %s\n",
+          name, nameXMMReg(eregOfRM(modrm)), nameMMXReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3525,9 +3433,5 @@ Addr dis_SSE2_to_MMX ( UCodeBlock *cb,
                   Lit16, ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameMMXReg(gregOfRM(modrm)));
+      DIP("%s %s, %s\n", name, dis_buf, nameMMXReg(gregOfRM(modrm)));
    }
    return eip;
@@ -3558,11 +3462,9 @@ Addr dis_SSE2_from_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameMMXReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)) );
+      DIP("%s %s, %s\n",
+          name, nameMMXReg(eregOfRM(modrm)), nameXMMReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3571,9 +3473,5 @@ Addr dis_SSE2_from_MMX ( UCodeBlock *cb,
                   Lit16, ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)));
+      DIP("%s %s, %s\n", name, dis_buf, nameXMMReg(gregOfRM(modrm)));
    }
    return eip;
@@ -3605,11 +3503,9 @@ Addr dis_SSE3_to_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (((UShort)opc3) << 8) | (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameXMMReg(eregOfRM(modrm)), 
-                     nameMMXReg(gregOfRM(modrm)) );
+      DIP("%s %s, %s\n",
+          name, nameXMMReg(eregOfRM(modrm)), nameMMXReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3618,9 +3514,5 @@ Addr dis_SSE3_to_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)(opc3)) << 8) | ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameMMXReg(gregOfRM(modrm)));
+      DIP("%s %s, %s\n", name, dis_buf, nameMMXReg(gregOfRM(modrm)));
    }
    return eip;
@@ -3652,11 +3544,9 @@ Addr dis_SSE3_from_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)opc1) << 8) | (UShort)opc2,
                   Lit16, (((UShort)opc3) << 8) | (UShort)modrm );
-      if (dis)
-         VG_(printf)("%s %s, %s\n", name, 
-                     nameMMXReg(eregOfRM(modrm)), 
-                     nameXMMReg(gregOfRM(modrm)) );
+      DIP("%s %s, %s\n",
+          name, nameMMXReg(eregOfRM(modrm)), nameXMMReg(gregOfRM(modrm)) );
       eip++;
    } else {
-      UInt pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+      UInt pair = disAMode ( cb, sorb, eip, dis_buf );
       Int  tmpa = LOW24(pair);
       eip += HI8(pair);
@@ -3665,9 +3555,5 @@ Addr dis_SSE3_from_MMX ( UCodeBlock *cb,
                   Lit16, (((UShort)(opc3)) << 8) | ((UShort)modrm),
                   TempReg, tmpa);
-      if (dis)
-         VG_(printf)("%s %s, %s\n", 
-                     name,
-                     dis_buf,
-                     nameXMMReg(gregOfRM(modrm)));
+      DIP("%s %s, %s\n", name, dis_buf, nameXMMReg(gregOfRM(modrm)));
    }
    return eip;
@@ -3686,6 +3572,5 @@ void dis_push_segreg ( UCodeBlock* cb, U
     uInstr2(cb, PUT,    4, TempReg,  t2,    ArchReg, R_ESP);
     uInstr2(cb, STORE,  2, TempReg,  t1,    TempReg, t2);
-    if (dis)
-       VG_(printf)("push %s\n", VG_(name_of_seg_reg)(sreg));
+    DIP("push %s\n", VG_(name_of_seg_reg)(sreg));
 }
 
@@ -3701,6 +3586,5 @@ void dis_pop_segreg ( UCodeBlock* cb, UI
    uInstr2(cb, PUT,    4, TempReg, t2,       ArchReg,  R_ESP);
    uInstr2(cb, PUTSEG, 2, TempReg, t1,       ArchRegS, sreg);
-   if (dis) 
-      VG_(printf)("pop %s\n", VG_(name_of_seg_reg)(sreg));
+   DIP("pop %s\n", VG_(name_of_seg_reg)(sreg));
 }
 
@@ -3711,5 +3595,5 @@ void dis_pop_segreg ( UCodeBlock* cb, UI
 /* Disassemble a single instruction into ucode, returning the updated
    eip, and setting *isEnd to True if this is the last insn in a basic
-   block.  Also do debug printing if (dis). */
+   block.  Also do debug printing if necessary. */
 
 static Addr disInstr ( UCodeBlock* cb, Addr eip, Bool* isEnd )
@@ -3739,5 +3623,5 @@ static Addr disInstr ( UCodeBlock* cb, A
    t1 = t2 = t3 = t4 = INVALID_TEMPREG;
 
-   if (dis) VG_(printf)("\t0x%x:  ", eip);
+   DIP("\t0x%x:  ", eip);
 
    /* Spot the client-request magic sequence. */
@@ -3760,11 +3644,8 @@ static Addr disInstr ( UCodeBlock* cb, A
          ) {
          eip += 18;
-         uInstr1(cb, JMP,  0, Literal, 0);
-         uLiteral(cb, eip);
-         uCond(cb, CondAlways);
+         jmp_lit(cb, eip);
          LAST_UINSTR(cb).jmpkind = JmpClientReq;
          *isEnd = True;
-         if (dis) 
-            VG_(printf)("%%edx = client_request ( %%eax )\n");
+         DIP("%%edx = client_request ( %%eax )\n");
          return eip;
       }
@@ -3829,5 +3710,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       Bool store = gregOfRM(insn[2]) == 0;
       vg_assert(sz == 4);
-      pair = disAMode ( cb, sorb, eip+2, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip+2, dis_buf );
       t1   = LOW24(pair);
       eip += 2+HI8(pair);
@@ -3836,6 +3717,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                   Lit16, (UShort)insn[2],
                   TempReg, t1 );
-      if (dis)
-         VG_(printf)("fx%s %s\n", store ? "save" : "rstor", dis_buf );
+      DIP("fx%s %s\n", store ? "save" : "rstor", dis_buf );
       goto decode_success;
    }
@@ -3847,5 +3727,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       Bool store = gregOfRM(insn[2]) == 3;
       vg_assert(sz == 4);
-      pair = disAMode ( cb, sorb, eip+2, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip+2, dis_buf );
       t1   = LOW24(pair);
       eip += 2+HI8(pair);
@@ -3854,6 +3734,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                   Lit16, (UShort)insn[2],
                   TempReg, t1 );
-      if (dis)
-         VG_(printf)("%smxcsr %s\n", store ? "st" : "ld", dis_buf );
+      DIP("%smxcsr %s\n", store ? "st" : "ld", dis_buf );
       goto decode_success;
    }
@@ -3869,6 +3748,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                   Lit16, (((UShort)0x0F) << 8) | (UShort)0xAE,
                   Lit16, (UShort)insn[2] );
-      if (dis)
-         VG_(printf)("sfence\n");
+      DIP("sfence\n");
       goto decode_success;
    }
@@ -3880,5 +3758,5 @@ static Addr disInstr ( UCodeBlock* cb, A
    {
       vg_assert(sz == 4);
-      pair = disAMode ( cb, sorb, eip+2, dis?dis_buf:NULL );
+      pair = disAMode ( cb, sorb, eip+2, dis_buf );
       t1   = LOW24(pair);
       eip += 2+HI8(pair);
@@ -3887,6 +3765,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                   Lit16, (UShort)insn[2],
                   TempReg, t1 );
-      if (dis)
-         VG_(printf)("clflush %s\n", dis_buf);
+      DIP("clflush %s\n", dis_buf);
       goto decode_success;
    }
@@ -3953,8 +3830,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-         if (dis)
-            VG_(printf)("cvt{t}s{s,d}2si %s, %s\n", 
-                        nameXMMReg(eregOfRM(modrm)),
-                        nameIReg(4,gregOfRM(modrm)) );
+         DIP("cvt{t}s{s,d}2si %s, %s\n", 
+             nameXMMReg(eregOfRM(modrm)), nameIReg(4,gregOfRM(modrm)) );
       } else {
          /* So, we're reading memory and writing an ireg.  This calls
@@ -3967,5 +3842,5 @@ static Addr disInstr ( UCodeBlock* cb, A
             usual. */
          t1 = newTemp(cb); /* t1 holds value on its way to ireg */
-         pair = disAMode ( cb, sorb, eip+3, dis?dis_buf:NULL );
+         pair = disAMode ( cb, sorb, eip+3, dis_buf );
          t2   = LOW24(pair); /* t2 holds addr */
          eip += 3+HI8(pair);
@@ -3978,8 +3853,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                       | ((UInt)modrm) );
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-         if (dis)
-            VG_(printf)("cvt{t}s{s,d}2si %s, %s\n", 
-                        dis_buf,
-                        nameIReg(4,gregOfRM(modrm)) );
+         DIP("cvt{t}s{s,d}2si %s, %s\n", 
+             dis_buf, nameIReg(4,gregOfRM(modrm)) );
       }
       goto decode_success;
@@ -4004,10 +3877,8 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          eip += 4;
-         if (dis)
-            VG_(printf)("cvtsi2s%s %s, %s\n", s_or_d,
-                        nameIReg(4,eregOfRM(modrm)), 
-                        nameXMMReg(gregOfRM(modrm)));
+         DIP("cvtsi2s%s %s, %s\n", s_or_d,
+             nameIReg(4,eregOfRM(modrm)), nameXMMReg(gregOfRM(modrm)));
       } else {
-         pair = disAMode ( cb, sorb, eip+3, dis?dis_buf:NULL );
+         pair = disAMode ( cb, sorb, eip+3, dis_buf );
          t2   = LOW24(pair);
          eip += 3+HI8(pair);
@@ -4016,8 +3887,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      Lit16, (((UShort)insn[2]) << 8) | (UShort)modrm,
                      TempReg, t2 );
-         if (dis)
-            VG_(printf)("cvtsi2s%s %s, %s\n", s_or_d,
-                        dis_buf,
-                        nameXMMReg(gregOfRM(modrm)));
+         DIP("cvtsi2s%s %s, %s\n",
+             s_or_d, dis_buf, nameXMMReg(gregOfRM(modrm)));
       }
       goto decode_success;
@@ -4878,8 +4747,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, eregOfRM(modrm));
-         if (dis)
-            VG_(printf)("movd %s, %s\n", 
-                        nameXMMReg(gregOfRM(modrm)),
-                        nameIReg(4,eregOfRM(modrm)));
+         DIP("movd %s, %s\n", 
+             nameXMMReg(gregOfRM(modrm)), nameIReg(4,eregOfRM(modrm)));
          eip += 3;
       } else
@@ -4891,8 +4758,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      Lit16, (((UShort)insn[1]) << 8) | (UShort)modrm,
                      TempReg, t1 );
-         if (dis)
-            VG_(printf)("movd %s, %s\n", 
-                        nameIReg(4,eregOfRM(modrm)),
-                        nameXMMReg(gregOfRM(modrm)));
+         DIP("movd %s, %s\n", 
+             nameIReg(4,eregOfRM(modrm)), nameXMMReg(gregOfRM(modrm)));
          eip += 3;
       } else {
@@ -4916,6 +4781,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, insn[3]);
       uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-      if (dis)
-         VG_(printf)("pextrw %s, %d, %s\n",
+      DIP("pextrw %s, %d, %s\n",
                      nameXMMReg(eregOfRM(modrm)), (Int)insn[3], 
                                 nameIReg(4, gregOfRM(modrm)));
@@ -4936,8 +4800,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          uLiteral(cb, insn[3]);
-         if (dis)
-            VG_(printf)("pinsrw %s, %d, %s\n",
-                        nameIReg(2, eregOfRM(modrm)),
-                        (Int)insn[3], 
+         DIP("pinsrw %s, %d, %s\n",
+             nameIReg(2, eregOfRM(modrm)), (Int)insn[3],
                         nameXMMReg(gregOfRM(modrm)));
          eip += 4;
@@ -5008,9 +4870,6 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
       }
-      if (dis)
-         VG_(printf)("movmskp%c %s, %s\n",
-                      sz == 4 ? 's' : 'd',
-                      nameXMMReg(eregOfRM(modrm)),
-                      nameIReg(4,gregOfRM(modrm)));
+      DIP("movmskp%c %s, %s\n", sz == 4 ? 's' : 'd',
+          nameXMMReg(eregOfRM(modrm)), nameIReg(4,gregOfRM(modrm)));
       eip += 3;
       goto decode_success;
@@ -5096,8 +4955,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                   TempReg, t1 );
       uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-      if (dis)
-         VG_(printf)("pmovmskb %s, %s\n", 
-                      nameXMMReg(eregOfRM(modrm)),
-                      nameIReg(4,gregOfRM(modrm)));
+      DIP("pmovmskb %s, %s\n", 
+          nameXMMReg(eregOfRM(modrm)), nameIReg(4,gregOfRM(modrm)));
       eip += 3;
       goto decode_success;
@@ -5161,13 +5018,11 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, 4+d32);
       uInstr2(cb, PUT,  4, TempReg, t1,    ArchReg, R_ESP);
-      uInstr1(cb, JMP,  0, TempReg, t2);
-      uCond(cb, CondAlways);
+      jmp_treg(cb, t2);
       LAST_UINSTR(cb).jmpkind = JmpRet;
 
       *isEnd = True;
-      if (dis) {
-         if (d32 == 0) VG_(printf)("ret\n"); 
-                  else VG_(printf)("ret %d\n", d32);
-      }
+      if (d32 == 0) { DIP("ret\n"); }
+      else          { DIP("ret %d\n", d32); }
+
       break;
       
@@ -5190,6 +5045,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT, 4, TempReg, t1,  ArchReg, archReg);
          eip++; /* Step over the POP */
-         if (dis) 
-            VG_(printf)("call 0x%x ; popl %s\n",d32,nameIReg(4,archReg));
+         DIP("call 0x%x ; popl %s\n",d32,nameIReg(4,archReg));
       } else {
          /* The normal sequence for a call. */
@@ -5203,10 +5057,8 @@ static Addr disInstr ( UCodeBlock* cb, A
          uLiteral(cb, eip);
          uInstr2(cb, STORE, 4, TempReg, t2,    TempReg, t1);
-         uInstr1(cb, JMP,   0, Literal, 0);
-         uLiteral(cb, d32);
-         uCond(cb, CondAlways);
+         jmp_lit(cb, d32);
          LAST_UINSTR(cb).jmpkind = JmpCall;
          *isEnd = True;
-         if (dis) VG_(printf)("call 0x%x\n",d32);
+         DIP("call 0x%x\n",d32);
       }
       break;
@@ -5232,5 +5084,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT,    4, TempReg, t2,    ArchReg, R_ESP);
       }
-      if (dis) VG_(printf)("enter 0x%x, 0x%x", d32, abyte);
+      DIP("enter 0x%x, 0x%x", d32, abyte);
       break;
 
@@ -5246,5 +5098,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, 4);
       uInstr2(cb, PUT,  4, TempReg, t1, ArchReg, R_ESP);
-      if (dis) VG_(printf)("leave");
+      DIP("leave");
       break;
 
@@ -5267,5 +5119,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr0(cb, CALLM_E, 0);
       uInstr2(cb, PUT, 1, TempReg, t1, ArchReg, R_AL);
-      if (dis) VG_(printf)(opc == 0x27 ? "daa\n" : "das\n");
+      DIP(opc == 0x27 ? "daa\n" : "das\n");
       break;
 
@@ -5280,5 +5132,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          LAST_UINSTR(cb).signed_widen = True;
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, R_EAX);
-         if (dis) VG_(printf)("cwd\n");
+         DIP("cwd\n");
       } else {
          vg_assert(sz == 2);
@@ -5288,5 +5140,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          LAST_UINSTR(cb).signed_widen = True;
          uInstr2(cb, PUT, 2, TempReg, t1, ArchReg, R_EAX);
-         if (dis) VG_(printf)("cbw\n");
+         DIP("cbw\n");
       }
       break;
@@ -5298,5 +5150,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, sz == 2 ? 15  : 31);
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, R_EDX);
-      if (dis) VG_(printf)(sz == 2 ? "cwdq\n" : "cdqq\n");
+      DIP(sz == 2 ? "cwdq\n" : "cdqq\n");
       break;
 
@@ -5305,15 +5157,15 @@ static Addr disInstr ( UCodeBlock* cb, A
    case 0x9E: /* SAHF */
       codegen_SAHF ( cb );
-      if (dis) VG_(printf)("sahf\n");
+      DIP("sahf\n");
       break;
 
    case 0x9F: /* LAHF */
       codegen_LAHF ( cb );
-      if (dis) VG_(printf)("lahf\n");
+      DIP("lahf\n");
       break;
 
    case 0x9B: /* FWAIT */
       /* ignore? */
-      if (dis) VG_(printf)("fwait\n");
+      DIP("fwait\n");
       break;
 
@@ -5346,6 +5198,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg,
                              (UInt)(opc - 0x40));
-      if (dis)
-         VG_(printf)("inc%c %s\n", nameISize(sz), nameIReg(sz,opc-0x40));
+      DIP("inc%c %s\n", nameISize(sz), nameIReg(sz,opc-0x40));
       break;
 
@@ -5365,6 +5216,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg,
                              (UInt)(opc - 0x48));
-      if (dis)
-         VG_(printf)("dec%c %s\n", nameISize(sz), nameIReg(sz,opc-0x48));
+      DIP("dec%c %s\n", nameISize(sz), nameIReg(sz,opc-0x48));
       break;
 
@@ -5377,10 +5227,8 @@ static Addr disInstr ( UCodeBlock* cb, A
          at this point.  So we declare an end-of-block here, which
          forces any TempRegs caching ArchRegs to be flushed. */
-      uInstr1(cb, JMP,  0, Literal, 0);
-      uLiteral(cb, eip);
-      uCond(cb, CondAlways);
+      jmp_lit(cb, eip);
       LAST_UINSTR(cb).jmpkind = JmpSyscall;
       *isEnd = True;
-      if (dis) VG_(printf)("int $0x80\n");
+      DIP("int $0x80\n");
       break;
 
@@ -5389,20 +5237,14 @@ static Addr disInstr ( UCodeBlock* cb, A
    case 0xEB: /* Jb (jump, byte offset) */
       d32 = (eip+1) + getSDisp8(eip); eip++;
-      uInstr1(cb, JMP, 0, Literal, 0);
-      uLiteral(cb, d32);
-      uCond(cb, CondAlways);
+      jmp_lit(cb, d32);
       *isEnd = True;
-      if (dis)
-         VG_(printf)("jmp-8 0x%x\n", d32);
+      DIP("jmp-8 0x%x\n", d32);
       break;
 
    case 0xE9: /* Jv (jump, 16/32 offset) */
       d32 = (eip+sz) + getSDisp(sz,eip); eip += sz;
-      uInstr1(cb, JMP, 0, Literal, 0);
-      uLiteral(cb, d32);
-      uCond(cb, CondAlways);
+      jmp_lit(cb, d32);
       *isEnd = True;
-      if (dis)
-        VG_(printf)("jmp 0x%x\n", d32);
+      DIP("jmp 0x%x\n", d32);
       break;
 
@@ -5424,8 +5266,5 @@ static Addr disInstr ( UCodeBlock* cb, A
    case 0x7F: /* JGb/JNLEb (jump greater) */
       d32 = (eip+1) + getSDisp8(eip); eip++;
-      uInstr1(cb, JMP, 0, Literal, 0);
-      uLiteral(cb, d32);
-      uCond(cb, (Condcode)(opc - 0x70));
-      uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
+      jcc_lit(cb, d32, (Condcode)(opc - 0x70));
       /* It's actually acceptable not to end this basic block at a
          control transfer, reducing the number of jumps through
@@ -5433,12 +5272,9 @@ static Addr disInstr ( UCodeBlock* cb, A
          following this jump twice.  This does give faster code, but
          on the whole I don't think the effort is worth it. */
-      uInstr1(cb, JMP, 0, Literal, 0);
-      uLiteral(cb, eip);
-      uCond(cb, CondAlways);
+      jmp_lit(cb, eip);
       *isEnd = True;
       /* The above 3 lines would be removed if the bb was not to end
          here. */
-      if (dis)
-         VG_(printf)("j%s-8 0x%x\n", VG_(name_UCondcode)(opc - 0x70), d32);
+      DIP("j%s-8 0x%x\n", VG_(name_UCondcode)(opc - 0x70), d32);
       break;
 
@@ -5451,6 +5287,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, JIFZ, 4,  TempReg, t1,    Literal, 0);
       uLiteral(cb, d32);
-      if (dis)
-         VG_(printf)("j%sz 0x%x\n", nameIReg(sz, R_ECX), d32);
+      DIP("j%sz 0x%x\n", nameIReg(sz, R_ECX), d32);
       break;
 
@@ -5470,15 +5305,9 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, eip);
       if (opc == 0xE0 || opc == 0xE1) {   /* LOOPE/LOOPNE */
-         uInstr1(cb, JMP,  0, Literal, 0);
-         uLiteral(cb, eip);
-         uCond(cb, (opc == 0xE1 ? CondNZ : CondZ));
-         uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
+         jcc_lit(cb, eip, (opc == 0xE1 ? CondNZ : CondZ));
       }
-      uInstr1(cb, JMP,  0, Literal, 0);
-      uLiteral(cb, d32);
-      uCond(cb, CondAlways);
+      jmp_lit(cb, d32);
       *isEnd = True;
-      if (dis)
-         VG_(printf)("loop 0x%x\n", d32);
+      DIP("loop 0x%x\n", d32);
       break;
 
@@ -5517,10 +5346,9 @@ static Addr disInstr ( UCodeBlock* cb, A
          has no effect on the address calculation.  Therefore we pass
          zero instead of sorb here. */
-      pair = disAMode ( cb, /*sorb*/ 0, eip, dis?dis_buf:NULL );
+      pair = disAMode ( cb, /*sorb*/ 0, eip, dis_buf );
       eip  += HI8(pair);
       t1   = LOW24(pair);
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, gregOfRM(modrm));
-      if (dis)
-         VG_(printf)("lea%c %s, %s\n", nameISize(sz), dis_buf, 
+      DIP("lea%c %s, %s\n", nameISize(sz), dis_buf, 
                                        nameIReg(sz,gregOfRM(modrm)));
       break;
@@ -5545,6 +5373,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, LOAD, sz, TempReg, t2,  TempReg, t1);
       uInstr2(cb, PUT,  sz, TempReg, t1,  ArchReg, R_EAX);
-      if (dis) VG_(printf)("mov%c %s0x%x, %s\n", nameISize(sz), 
-                           sorbTxt(sorb),
+      DIP("mov%c %s0x%x, %s\n", nameISize(sz), sorbTxt(sorb),
                            d32, nameIReg(sz,R_EAX));
       break;
@@ -5561,6 +5388,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       handleSegOverride(cb, sorb, t2);
       uInstr2(cb, STORE, sz, TempReg, t1,    TempReg, t2);
-      if (dis) VG_(printf)("mov%c %s, %s0x%x\n", nameISize(sz), 
-                           nameIReg(sz,R_EAX),
+      DIP("mov%c %s, %s0x%x\n", nameISize(sz), nameIReg(sz,R_EAX),
                            sorbTxt(sorb), d32);
       break;
@@ -5579,6 +5405,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, d32);
       uInstr2(cb, PUT, 1, TempReg, t1, ArchReg, opc-0xB0);
-      if (dis) VG_(printf)("movb $0x%x,%s\n", d32,
-                           nameIReg(1,opc-0xB0));
+      DIP("movb $0x%x,%s\n", d32, nameIReg(1,opc-0xB0));
       break;
 
@@ -5596,6 +5421,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, d32);
       uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, opc-0xB8);
-      if (dis) VG_(printf)("mov%c $0x%x,%s\n", nameISize(sz), d32,
-                           nameIReg(sz,opc-0xB8));
+      DIP("mov%c $0x%x,%s\n", nameISize(sz), d32, nameIReg(sz,opc-0xB8));
       break;
 
@@ -5615,8 +5439,8 @@ static Addr disInstr ( UCodeBlock* cb, A
          uLiteral(cb, d32);
          uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, eregOfRM(modrm));
-         if (dis) VG_(printf)("mov%c $0x%x, %s\n", nameISize(sz), d32, 
+         DIP("mov%c $0x%x, %s\n", nameISize(sz), d32, 
                               nameIReg(sz,eregOfRM(modrm)));
       } else {
-         pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+         pair = disAMode ( cb, sorb, eip, dis_buf );
          eip += HI8(pair);
          d32 = getUDisp(sz,eip); eip += sz;
@@ -5626,5 +5450,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uLiteral(cb, d32);
          uInstr2(cb, STORE, sz, TempReg, t1, TempReg, t2);
-         if (dis) VG_(printf)("mov%c $0x%x, %s\n", nameISize(sz), d32, dis_buf);
+         DIP("mov%c $0x%x, %s\n", nameISize(sz), d32, dis_buf);
       }
       break;
@@ -5829,6 +5653,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT,    4, TempReg, t2,       ArchReg, R_ESP);
       uInstr2(cb, PUT,   sz, TempReg, t1,       ArchReg, opc-0x58);
-      if (dis) 
-         VG_(printf)("pop%c %s\n", nameISize(sz), nameIReg(sz,opc-0x58));
+      DIP("pop%c %s\n", nameISize(sz), nameIReg(sz,opc-0x58));
       break;
 
@@ -5844,6 +5667,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       /* PUTF writes all the flags we are interested in */
       uFlagsRWU(cb, FlagsEmpty, FlagsALL, FlagsEmpty);
-      if (dis) 
-         VG_(printf)("popf%c\n", nameISize(sz));
+      DIP("popf%c\n", nameISize(sz));
       break;
 
@@ -5884,6 +5706,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, sz * 8);             /* One 'sz' per register */
       uInstr2(cb, PUT,    4, TempReg, t3, ArchReg, R_ESP);
-      if (dis)
-         VG_(printf)("popa%c\n", nameISize(sz));
+      DIP("popa%c\n", nameISize(sz));
       break;
     }
@@ -5916,5 +5737,5 @@ static Addr disInstr ( UCodeBlock* cb, A
 
        /* resolve MODR/M */
-       pair1 = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);              
+       pair1 = disAMode ( cb, sorb, eip, dis_buf );              
        
        tmpa = LOW24(pair1);
@@ -5923,6 +5744,5 @@ static Addr disInstr ( UCodeBlock* cb, A
        uInstr2(cb, STORE, 4, TempReg, t3, TempReg, tmpa);
 
-       if (dis) 
-          VG_(printf)("popl %s\n", dis_buf);
+       DIP("popl %s\n", dis_buf);
 
        eip += HI8(pair1);
@@ -5958,6 +5778,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT,    4, TempReg, t2,       ArchReg, R_ESP);
       uInstr2(cb, STORE, sz, TempReg, t1,       TempReg, t2);
-      if (dis) 
-         VG_(printf)("push%c %s\n", nameISize(sz), nameIReg(sz,opc-0x50));
+      DIP("push%c %s\n", nameISize(sz), nameIReg(sz,opc-0x50));
       break;
 
@@ -5977,6 +5796,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uLiteral(cb, d32);
       uInstr2(cb, STORE, sz, TempReg, t2,    TempReg, t1);
-      if (dis) 
-         VG_(printf)("push%c $0x%x\n", nameISize(sz), d32);
+      DIP("push%c $0x%x\n", nameISize(sz), d32);
       break;
 
@@ -5993,6 +5811,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT,    4, TempReg, t2,       ArchReg, R_ESP);
       uInstr2(cb, STORE, sz, TempReg, t1,       TempReg, t2);
-      if (dis) 
-         VG_(printf)("pushf%c\n", nameISize(sz));
+      DIP("pushf%c\n", nameISize(sz));
       break;
 
@@ -6036,6 +5853,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, STORE, sz, TempReg,  t1, TempReg, t2);
       }
-      if (dis)
-         VG_(printf)("pusha%c\n", nameISize(sz));
+      DIP("pusha%c\n", nameISize(sz));
       break;
    }
@@ -6083,5 +5899,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uFlagsRWU(cb, FlagsEmpty, FlagD, FlagsEmpty);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) VG_(printf)("cld\n");
+      DIP("cld\n");
       break;
 
@@ -6091,5 +5907,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uFlagsRWU(cb, FlagsEmpty, FlagD, FlagsEmpty);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) VG_(printf)("std\n");
+      DIP("std\n");
       break;
 
@@ -6099,5 +5915,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uFlagsRWU(cb, FlagsEmpty, FlagC, FlagsOSZAP);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) VG_(printf)("clc\n");
+      DIP("clc\n");
       break;
 
@@ -6107,5 +5923,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uFlagsRWU(cb, FlagsEmpty, FlagC, FlagsOSZCP);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) VG_(printf)("stc\n");
+      DIP("stc\n");
       break;
 
@@ -6161,8 +5977,7 @@ static Addr disInstr ( UCodeBlock* cb, A
       else
       if (abyte == 0x90) { /* REP NOP (PAUSE) */
-         if (dis) VG_(printf)("rep nop (P4 pause)\n");
-         uInstr1(cb, JMP,  0, Literal, 0);
-         uLiteral(cb, eip);
-         uCond(cb, CondAlways);
+         /* a hint to the P4 re spin-wait loop */
+         DIP("rep nop (P4 pause)\n");
+         jmp_lit(cb, eip);
          LAST_UINSTR(cb).jmpkind = JmpYield;
          *isEnd = True;
@@ -6188,10 +6003,9 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT, sz, TempReg, t2, ArchReg, eregOfRM(modrm));
          eip++;
-         if (dis)
-            VG_(printf)("xchg%c %s, %s\n", nameISize(sz), 
-                        nameIReg(sz,gregOfRM(modrm)), 
+         DIP("xchg%c %s, %s\n", 
+             nameISize(sz), nameIReg(sz,gregOfRM(modrm)), 
                         nameIReg(sz,eregOfRM(modrm)));
       } else {
-         pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL);
+         pair = disAMode ( cb, sorb, eip, dis_buf );
          t3   = LOW24(pair);
          uInstr2(cb, LOAD, sz, TempReg, t3, TempReg, t1);
@@ -6200,13 +6014,11 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT, sz, TempReg, t1, ArchReg, gregOfRM(modrm));
          eip += HI8(pair);
-         if (dis)
-            VG_(printf)("xchg%c %s, %s\n", nameISize(sz), 
-                        nameIReg(sz,gregOfRM(modrm)), 
-                        dis_buf);
+         DIP("xchg%c %s, %s\n", nameISize(sz), 
+                                nameIReg(sz,gregOfRM(modrm)), dis_buf);
       }
       break;
 
    case 0x90: /* XCHG eAX,eAX */
-      if (dis) VG_(printf)("nop\n");
+      DIP("nop\n");
       break;
    case 0x91: /* XCHG eAX,eCX */
@@ -6235,6 +6047,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr2(cb, PUT, 1, TempReg, t2, ArchReg, R_AL); /* put byte into AL */
 
-      if (dis)
-         VG_(printf)("xlat%c [ebx]\n", nameISize(sz));
+      DIP("xlat%c [ebx]\n", nameISize(sz));
       break;
 
@@ -6270,9 +6081,8 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr0(cb, CALLM_E, 0);
       uInstr2(cb, PUT,   4, TempReg, t2, ArchReg, R_EAX);
-      if (dis) {
-         if ( opc == 0xE4 || opc == 0xE5 )
-            VG_(printf)("in 0x%x, %%eax/%%ax/%%al\n", getUChar(eip-1) );
-         else
-            VG_(printf)("in (%%dx), %%eax/%%ax/%%al\n");
+      if ( opc == 0xE4 || opc == 0xE5 ) {
+         DIP("in 0x%x, %%eax/%%ax/%%al\n", getUChar(eip-1) );
+      } else {
+         DIP("in (%%dx), %%eax/%%ax/%%al\n");
       }
       break;
@@ -6305,9 +6115,8 @@ static Addr disInstr ( UCodeBlock* cb, A
       uInstr1(cb, CLEAR,  0, Lit16,  12);
       uInstr0(cb, CALLM_E, 0);
-      if (dis) {
-         if ( opc == 0xE4 || opc == 0xE5 )
-            VG_(printf)("out %%eax/%%ax/%%al, 0x%x\n", getUChar(eip-1) );
-         else
-            VG_(printf)("out %%eax/%%ax/%%al, (%%dx)\n");
+      if ( opc == 0xE4 || opc == 0xE5 ) {
+         DIP("out %%eax/%%ax/%%al, 0x%x\n", getUChar(eip-1) );
+      } else {
+         DIP("out %%eax/%%ax/%%al, (%%dx)\n");
       }
       break;
@@ -6452,5 +6261,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr1(cb, BSWAP, 4, TempReg, t1);
          uInstr2(cb, PUT,   4, TempReg, t1, ArchReg, opc-0xC8);
-         if (dis) VG_(printf)("bswapl %s\n", nameIReg(4, opc-0xC8));
+         DIP("bswapl %s\n", nameIReg(4, opc-0xC8));
          break;
 
@@ -6546,5 +6355,5 @@ static Addr disInstr ( UCodeBlock* cb, A
 
          uInstr0(cb, CALLM_E, 0);
-         if (dis) VG_(printf)("cpuid\n");
+         DIP("cpuid\n");
          break;
 
@@ -6573,12 +6382,9 @@ static Addr disInstr ( UCodeBlock* cb, A
          t1 = newTemp(cb);
          uInstr2(cb, GET, 4, ArchReg, gregOfRM(modrm), TempReg, t1);
-         pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+         pair = disAMode ( cb, sorb, eip, dis_buf );
          t2 = LOW24(pair);
          eip += HI8(pair);
          uInstr2(cb, STORE, 4, TempReg, t1, TempReg, t2);
-         if (dis)
-           VG_(printf)("movnti %s,%s\n",
-                       nameIReg(4,gregOfRM(modrm)),
-                       dis_buf);
+         DIP("movnti %s,%s\n", nameIReg(4,gregOfRM(modrm)), dis_buf);
          break;
 
@@ -6607,15 +6413,8 @@ static Addr disInstr ( UCodeBlock* cb, A
       case 0x8F: /* JGb/JNLEb (jump greater) */
          d32 = (eip+4) + getUDisp32(eip); eip += 4;
-         uInstr1(cb, JMP, 0, Literal, 0);
-         uLiteral(cb, d32);
-         uCond(cb, (Condcode)(opc - 0x80));
-         uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
-         uInstr1(cb, JMP, 0, Literal, 0);
-         uLiteral(cb, eip);
-         uCond(cb, CondAlways);
+         jcc_lit(cb, d32, (Condcode)(opc - 0x80));
+         jmp_lit(cb, eip);
          *isEnd = True;
-         if (dis)
-            VG_(printf)("j%s-32 0x%x\n", 
-                        VG_(name_UCondcode)(opc - 0x80), d32);
+         DIP("j%s-32 0x%x\n", VG_(name_UCondcode)(opc - 0x80), d32);
          break;
 
@@ -6640,5 +6439,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uInstr2(cb, PUT,   4, TempReg, t3, ArchReg, R_EAX);
          uInstr0(cb, CALLM_E, 0);
-         if (dis) VG_(printf)("rdtsc\n");
+         DIP("rdtsc\n");
          break;
 
@@ -6668,9 +6467,8 @@ static Addr disInstr ( UCodeBlock* cb, A
             uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
             uInstr2(cb, PUT, 1, TempReg, t1, ArchReg, eregOfRM(modrm));
-            if (dis) VG_(printf)("set%s %s\n", 
-                                 VG_(name_UCondcode)(opc-0x90), 
+            DIP("set%s %s\n", VG_(name_UCondcode)(opc-0x90), 
                                  nameIReg(1,eregOfRM(modrm)));
          } else {
-            pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+            pair = disAMode ( cb, sorb, eip, dis_buf );
             t2 = LOW24(pair);
             eip += HI8(pair);
@@ -6679,7 +6477,5 @@ static Addr disInstr ( UCodeBlock* cb, A
             uFlagsRWU(cb, FlagsOSZACP, FlagsEmpty, FlagsEmpty);
             uInstr2(cb, STORE, 1, TempReg, t1, TempReg, t2);
-            if (dis) VG_(printf)("set%s %s\n", 
-                                 VG_(name_UCondcode)(opc-0x90), 
-                                 dis_buf);
+            DIP("set%s %s\n", VG_(name_UCondcode)(opc-0x90), dis_buf);
          }
          break;
@@ -6733,7 +6529,7 @@ static Addr disInstr ( UCodeBlock* cb, A
          }
          eip += lengthAMode(eip);
-         if (dis) {
+         if (VG_(print_codegen)) {
             UChar* hintstr;
-            if(opc == 0x0D) {
+            if (opc == 0x0D) {
                switch (gregOfRM(modrm)) {
                   case 0: hintstr = ""; break;
@@ -6755,8 +6551,7 @@ static Addr disInstr ( UCodeBlock* cb, A
          break;
 
-      case 0x71: case 0x72: case 0x73: 
+      case 0x71: case 0x72: case 0x73: {
          /* (sz==4): PSLL/PSRA/PSRL mmxreg by imm8 */
          /* (sz==2): PSLL/PSRA/PSRL xmmreg by imm8 */
-         {
          UChar byte1, byte2, byte3, subopc, mmreg;
          vg_assert(sz == 4 || sz == 2);
@@ -6784,13 +6579,10 @@ static Addr disInstr ( UCodeBlock* cb, A
                         Lit16, (((UShort)byte1) << 8) | ((UShort)byte2),
                         Lit16, ((UShort)byte3) );
-            if (dis)
-               VG_(printf)("ps%s%s $%d, %s\n",
-                           (subopc == 2 ? "rl" 
+            DIP("ps%s%s $%d, %s\n",
+                ( subopc == 2 ? "rl" 
                             : subopc == 6 ? "ll" 
                             : subopc == 4 ? "ra"
                             : "??"),
-                           nameMMXGran(opc & 3),
-                           (Int)byte3,
-                           nameMMXReg(mmreg) );
+                nameMMXGran(opc & 3), (Int)byte3, nameMMXReg(mmreg) );
          } else {
             /* Whereas we have to include it for SSE. */
@@ -6799,7 +6591,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                         Lit16, (((UShort)byte1) << 8) | ((UShort)byte2),
                         Lit16, ((UShort)byte3) );
-            if (dis)
-               VG_(printf)("ps%s%s $%d, %s\n",
-                           (subopc == 2 ? "rl" 
+            DIP("ps%s%s $%d, %s\n",
+                ( subopc == 2 ? "rl" 
                             : subopc == 6 ? "ll" 
                             : subopc == 4 ? "ra"
@@ -6807,16 +6598,13 @@ static Addr disInstr ( UCodeBlock* cb, A
                             : subopc == 7 ? "(PSLLDQ)"
                             : "??"),
-                           nameMMXGran(opc & 3),
-                           (Int)byte3,
-                           nameXMMReg(mmreg) );
-         }
+                nameMMXGran(opc & 3), (Int)byte3, nameXMMReg(mmreg) );
          }
          break;
+      }
 
       case 0x77: /* EMMS */
          vg_assert(sz == 4);
          uInstr1(cb, MMX1, 0, Lit16, ((UShort)(opc)) );
-         if (dis)
-            VG_(printf)("emms\n");
+         DIP("emms\n");
          break;
 
@@ -6832,11 +6620,9 @@ static Addr disInstr ( UCodeBlock* cb, A
                         TempReg, t1 );
             uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, eregOfRM(modrm));
-            if (dis)
-               VG_(printf)("movd %s, %s\n", 
-                           nameMMXReg(gregOfRM(modrm)),
-                           nameIReg(4,eregOfRM(modrm)));
+            DIP("movd %s, %s\n", 
+                nameMMXReg(gregOfRM(modrm)), nameIReg(4,eregOfRM(modrm)));
          } else {
             Int tmpa;
-            pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+            pair = disAMode ( cb, sorb, eip, dis_buf );
             tmpa = LOW24(pair);
             eip += HI8(pair);
@@ -6845,8 +6631,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                         (((UShort)(opc)) << 8) | ((UShort)modrm),
                         TempReg, tmpa);
-            if (dis)
-               VG_(printf)("movd %s, %s\n", 
-                           nameMMXReg(gregOfRM(modrm)),
-                           dis_buf);
+            DIP("movd %s, %s\n", nameMMXReg(gregOfRM(modrm)), dis_buf);
          }
          break;
@@ -6863,11 +6646,9 @@ static Addr disInstr ( UCodeBlock* cb, A
                         (((UShort)(opc)) << 8) | ((UShort)modrm),
                         TempReg, t1 );
-            if (dis)
-               VG_(printf)("movd %s, %s\n", 
-                           nameIReg(4,eregOfRM(modrm)),
-                           nameMMXReg(gregOfRM(modrm)));
+            DIP("movd %s, %s\n", 
+                nameIReg(4,eregOfRM(modrm)), nameMMXReg(gregOfRM(modrm)));
          } else {
             Int tmpa;
-            pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+            pair = disAMode ( cb, sorb, eip, dis_buf );
             tmpa = LOW24(pair);
             eip += HI8(pair);
@@ -6876,8 +6657,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                         (((UShort)(opc)) << 8) | ((UShort)modrm),
                         TempReg, tmpa);
-            if (dis)
-               VG_(printf)("movd %s, %s\n", 
-                           dis_buf,
-                           nameMMXReg(gregOfRM(modrm)));
+            DIP("movd %s, %s\n", dis_buf, nameMMXReg(gregOfRM(modrm)));
          }
          break;
@@ -6891,11 +6669,9 @@ static Addr disInstr ( UCodeBlock* cb, A
                         Lit16, 
                         (((UShort)(opc)) << 8) | ((UShort)modrm) );
-            if (dis)
-               VG_(printf)("movq %s, %s\n", 
-                           nameMMXReg(eregOfRM(modrm)),
-                           nameMMXReg(gregOfRM(modrm)));
+            DIP("movq %s, %s\n", 
+                nameMMXReg(eregOfRM(modrm)), nameMMXReg(gregOfRM(modrm)));
          } else {
             Int tmpa;
-            pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+            pair = disAMode ( cb, sorb, eip, dis_buf );
             tmpa = LOW24(pair);
             eip += HI8(pair);
@@ -6904,8 +6680,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                         (((UShort)(opc)) << 8) | ((UShort)modrm),
                         TempReg, tmpa);
-            if (dis)
-               VG_(printf)("movq %s, %s\n", 
-                           dis_buf,
-                           nameMMXReg(gregOfRM(modrm)));
+            DIP("movq %s, %s\n", 
+                dis_buf, nameMMXReg(gregOfRM(modrm)));
          }
          break;
@@ -6920,11 +6694,9 @@ static Addr disInstr ( UCodeBlock* cb, A
                         Lit16, 
                         (((UShort)(opc)) << 8) | ((UShort)modrm) );
-            if (dis)
-               VG_(printf)("movq %s, %s\n", 
-                           nameMMXReg(gregOfRM(modrm)),
-                           nameMMXReg(eregOfRM(modrm)));
+            DIP("movq %s, %s\n", 
+                nameMMXReg(gregOfRM(modrm)), nameMMXReg(eregOfRM(modrm)));
          } else {
             Int tmpa;
-            pair = disAMode ( cb, sorb, eip, dis?dis_buf:NULL );
+            pair = disAMode ( cb, sorb, eip, dis_buf );
             tmpa = LOW24(pair);
             eip += HI8(pair);
@@ -6933,8 +6705,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                         (((UShort)(opc)) << 8) | ((UShort)modrm),
                         TempReg, tmpa);
-            if (dis)
-               VG_(printf)("mov(nt)q %s, %s\n", 
-                           nameMMXReg(gregOfRM(modrm)),
-                           dis_buf);
+            DIP("mov(nt)q %s, %s\n", 
+                nameMMXReg(gregOfRM(modrm)), dis_buf);
          }
          break;
@@ -7137,8 +6907,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-         if (dis)
-            VG_(printf)("pmovmskb %s, %s\n", 
-                        nameMMXReg(eregOfRM(modrm)),
-                        nameIReg(4,gregOfRM(modrm)));
+         DIP("pmovmskb %s, %s\n", 
+             nameMMXReg(eregOfRM(modrm)), nameIReg(4,gregOfRM(modrm)));
          eip++;         
          break;
@@ -7157,6 +6925,5 @@ static Addr disInstr ( UCodeBlock* cb, A
          uLiteral(cb, abyte);
          uInstr2(cb, PUT, 4, TempReg, t1, ArchReg, gregOfRM(modrm));
-         if (dis)
-            VG_(printf)("pextrw %s, %d, %s\n",
+         DIP("pextrw %s, %d, %s\n",
                         nameMMXReg(eregOfRM(modrm)), (Int)abyte, 
                         nameIReg(4, gregOfRM(modrm)));
@@ -7176,9 +6943,6 @@ static Addr disInstr ( UCodeBlock* cb, A
                      TempReg, t1 );
          uLiteral(cb, abyte);
-         if (dis)
-            VG_(printf)("pinsrw %s, %d, %s\n",
-                        nameIReg(2, eregOfRM(modrm)),
-                        (Int)abyte, 
-                        nameMMXReg(gregOfRM(modrm)));
+         DIP("pinsrw %s, %d, %s\n", nameIReg(2, eregOfRM(modrm)),
+                        (Int)abyte, nameMMXReg(gregOfRM(modrm)));
          break;
 
@@ -7224,7 +6988,5 @@ static Addr disInstr ( UCodeBlock* cb, A
    /* just because everything else insists the last instruction of
       a BB is a jmp */
-   uInstr1(cb, JMP,     0, Literal, 0);
-   uCond(cb, CondAlways);
-   uLiteral(cb, eip);
+   jmp_lit(cb, eip);
    *isEnd = True;
    break;
@@ -7235,9 +6997,8 @@ static Addr disInstr ( UCodeBlock* cb, A
   decode_success:
    /* All decode successes end up here. */
-   if (dis)
-      VG_(printf)("\n");
+   DIP("\n");
    for (; first_uinstr < cb->used; first_uinstr++) {
       Bool sane = VG_(saneUInstr)(True, True, &cb->instrs[first_uinstr]);
-      if (dis) 
+      if (VG_(print_codegen)) 
          VG_(pp_UInstr)(first_uinstr, &cb->instrs[first_uinstr]);
       else if (!sane)
@@ -7260,5 +7021,5 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
    Int delta = 0;
 
-   if (dis) VG_(printf)("Original x86 code to UCode:\n\n");
+   DIP("Original x86 code to UCode:\n\n");
 
    /* After every x86 instruction do an INCEIP, except for the final one
@@ -7276,11 +7037,10 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
        * which occurs if the x86 instr was a nop */
       if (cb->used == 0 || LAST_UINSTR(cb).opcode != JMP) {
-         uInstr1(cb, JMP, 0, Literal, 0);
-         uLiteral(cb, eip);
-         uCond(cb, CondAlways);
+         jmp_lit(cb, eip);
          /* Print added JMP */
-         if (dis) VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
+         if (VG_(print_codegen)) 
+            VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
       }
-      if (dis) VG_(printf)("\n");
+      DIP("\n");
       delta = eip - eip0;
 
@@ -7298,9 +7058,8 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
                             "Warning: splitting giant basic block into pieces at %p %(y",
                             eip, eip);
-            uInstr1(cb, JMP, 0, Literal, 0);
-            uLiteral(cb, eip);
-            uCond(cb, CondAlways);
+            jmp_lit(cb, eip);
             /* Print added JMP */
-            if (dis) VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
+            if (VG_(print_codegen))
+               VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
             isEnd = True;
 
@@ -7308,7 +7067,8 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
             uInstr1(cb, INCEIP, 0, Lit16, delta);
             /* Print added INCEIP */
-            if (dis) VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
+            if (VG_(print_codegen)) 
+               VG_(pp_UInstr)(cb->used-1, &cb->instrs[cb->used-1]);
          }
-         if (dis) VG_(printf)("\n");
+         DIP("\n");
       }
    }
@@ -7326,5 +7086,6 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
 }
 
-#undef dis
+#undef DIP
+#undef DIS
 
 /*--------------------------------------------------------------------*/

CVS commit by nethercote: 

"VG_AR_SKIN" --> "VG_AR_TOOL"


  M +2 -2      vg_include.h   1.178
  M +6 -6      vg_malloc2.c   1.19
  M +1 -1      vg_mylibc.c   1.69
  M +2 -2      vg_skiplist.c   1.3


--- valgrind/coregrind/vg_include.h  #1.177:1.178
@@ -359,5 +359,5 @@ void VG_(sanity_check_needs)(void);
 
       CORE      for the core's general use.
-      SKIN      for the skin to use (and the only one it uses).
+      TOOL      for the tool to use (and the only one it uses).
       SYMTAB    for Valgrind's symbol table storage.
       JITTER    for small storage during translation.
@@ -376,5 +376,5 @@ typedef Int ArenaId;
 
 #define VG_AR_CORE         0
-#define VG_AR_SKIN         1
+#define VG_AR_TOOL         1
 #define VG_AR_SYMTAB       2
 #define VG_AR_JITTER       3

--- valgrind/coregrind/vg_malloc2.c  #1.18:1.19
@@ -262,5 +262,5 @@ void ensure_mm_init ( void )
    arena_init ( &vg_arena[VG_AR_CORE],      "core",     1, True, 262144, False );
 
-   arena_init ( &vg_arena[VG_AR_SKIN],      "tool",     1, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_TOOL],      "tool",     1, True, 262144, False );
 
    arena_init ( &vg_arena[VG_AR_SYMTAB],    "symtab",   1, True, 262144, False );
@@ -1363,25 +1363,25 @@ void* VG_(arena_realloc) ( ArenaId aid, 
 void* VG_(malloc) ( Int nbytes )
 {
-   return VG_(arena_malloc) ( VG_AR_SKIN, nbytes );
+   return VG_(arena_malloc) ( VG_AR_TOOL, nbytes );
 }
 
 void  VG_(free) ( void* ptr )
 {
-   VG_(arena_free) ( VG_AR_SKIN, ptr );
+   VG_(arena_free) ( VG_AR_TOOL, ptr );
 }
 
 void* VG_(calloc) ( Int nmemb, Int nbytes )
 {
-   return VG_(arena_calloc) ( VG_AR_SKIN, /*alignment*/4, nmemb, nbytes );
+   return VG_(arena_calloc) ( VG_AR_TOOL, /*alignment*/4, nmemb, nbytes );
 }
 
 void* VG_(realloc) ( void* ptr, Int size )
 {
-   return VG_(arena_realloc) ( VG_AR_SKIN, ptr, /*alignment*/4, size );
+   return VG_(arena_realloc) ( VG_AR_TOOL, ptr, /*alignment*/4, size );
 }
 
 void* VG_(malloc_aligned) ( Int req_alignB, Int req_pszB )
 {
-   return VG_(arena_malloc_aligned) ( VG_AR_SKIN, req_alignB, req_pszB );
+   return VG_(arena_malloc_aligned) ( VG_AR_TOOL, req_alignB, req_pszB );
 }
 

--- valgrind/coregrind/vg_mylibc.c  #1.68:1.69
@@ -1038,5 +1038,5 @@ __inline__ Char* VG_(arena_strdup) ( Are
 Char* VG_(strdup) ( const Char* s )
 {
-   return VG_(arena_strdup) ( VG_AR_SKIN, s ); 
+   return VG_(arena_strdup) ( VG_AR_TOOL, s ); 
 }
 

--- valgrind/coregrind/vg_skiplist.c  #1.2:1.3
@@ -144,5 +144,5 @@ void *VG_(SkipNode_Alloc)(const SkipList
 
    if (l->arena == -1)
-      *(Short *)&l->arena = VG_AR_SKIN;
+      *(Short *)&l->arena = VG_AR_TOOL;
 
    ret = VG_(arena_malloc)(l->arena, size);
@@ -289,5 +289,5 @@ void VG_(SkipList_Insert)(SkipList *l, v
 
       if (l->arena == -1)
-         *(Short *)&l->arena = VG_AR_SKIN;
+         *(Short *)&l->arena = VG_AR_TOOL;
       
       l->head = VG_(arena_malloc)(l->arena, size);

On Monday 26 January 2004 10:40, Jeremy Fitzhardinge wrote:

> > emulating has to check before calling cpuid(0x80000001) if it is in fact
> > a AMD CPU. If they don't, well, they get undefined behaviour anyway.
> No, because other vendors can use 0x80000001 for other purposes.  Intel
> has this reserved, for example. 

intel cleans all bits. 

> Just clearing the bit means you could 
> be clearing some other feature flag for another vendor.

Yes, as I said, one could check first if its an athlon cpu. However, thats not 
what your patch did.

> > Correct. IMHO, we should only expose those which exist at all on the
> > original host cpu. So basically we have to blacklist a few extensions
> > which we don't support.
> But that makes no sense.  At any point, one of the currently reserved
> bits could come into use, and a piece of software will try to use
> instructions which are associated with that bit - requiring an upgrade
> to Valgrind to make any progress at all.

Its not as if valgrind would be a package that requires more than 5 minutes to 
download, configure, compile and install. 

When you use such a ultra new CPU you're going to get a lot more trouble with 
your kernel, your libc and your other runtime environment anyway. 

> After all, Valgrind's intent is not to emulate your actual host CPU, but
> the common useful subset of ia32 implementation - which your host CPU
> happens to be one of.

Is this true? I wonder why we keep adding new instructions then. we could just 
claim to not support cpuid and only implement 386 instructions, not any of 
the "fancy" stuff newer processors do. 

Look, there were good reasons for implementing SSE: for example because of DRI 
drivers that use SSE without checking for it (NVIDIA being a good example). 
There was no way to suppress SSE support, and it was often requested since 
almost every second computer uses those NVIDIA drivers nowadays. 

> > euhm? when does invoking the cpuid instruction change the CPU behavior?
> > Got an example for that?
> It doesn't, but it does indicate CPU behavioural changes.  The only ones
> which user-mode programs care about are instruction-set extensions.

Oh, how do you know what all possible user-mode programs care about? Is there 
some secret source of CPUID wisdom I don't know about yet?

For the single reason that the old code did not expose any problem in any 
existing application that we know of I ask you to consider changing the code 
back to a blacklisting behavior. If you don't want to fix the cpuid masking 
to be athlon specific,then thats fine, I can do that. 

> Yes, I agree.  But that isn't part of the feature bitmasks.

Really? I wonder why I can read about such processor specific information then 
in the documentation  of cpuid on sandpile.org.

> Instruction set changes do affect the emulation.  All the others are a
> big "don't care".  It's trivial to copy them through.

Great. Then why did you break the "copy through" bit ? Thats the point I'm 
complaining about the whole time !


Dirk

CVS commit by fitzhardinge: 

Rearrange CPUID again.  Moved most of the helper logic into C, since
the assember was getting fiddly.  It now masks out only the undefined
or unimplemented parts of the feature set bits, so it now passes through
all the non-ISA-related feature bits to clients.

It also leaves the vendor ID string unmolested, so that clients can
extract vendor-specific information like extended brand strings and
cache/TLB configuration info.

It does, however, implement some Valgrind-specific requests at 0xd8000000,
though at present the only functionality is the ValgrindVCPU signature.


  M +61 -44    vg_constants.h   1.17
  M +23 -56    vg_helpers.S   1.30
  M +179 -4    vg_to_ucode.c   1.128


--- valgrind/coregrind/vg_constants.h  #1.16:1.17
@@ -95,50 +95,67 @@
 #define VG_USERREQ__SIGNAL_RETURNS          0x4001
 
-/* CPU features */
-#define VG_X86_FEAT_FPU         (0*32 + 0)
-#define VG_X86_FEAT_VME         (0*32 + 1)
-#define VG_X86_FEAT_DE          (0*32 + 2)
-#define VG_X86_FEAT_PSE         (0*32 + 3)
-#define VG_X86_FEAT_TSC         (0*32 + 4)
-#define VG_X86_FEAT_MSR         (0*32 + 5)
-#define VG_X86_FEAT_PAE         (0*32 + 6)
-#define VG_X86_FEAT_MCE         (0*32 + 7)
-#define VG_X86_FEAT_CX8         (0*32 + 8)
-#define VG_X86_FEAT_APIC        (0*32 + 9)
-#define VG_X86_FEAT_SEP         (0*32 + 11)
-#define VG_X86_FEAT_MTRR        (0*32 + 12)
-#define VG_X86_FEAT_PGE         (0*32 + 13)
-#define VG_X86_FEAT_MCA         (0*32 + 14)
-#define VG_X86_FEAT_CMOV        (0*32 + 15)
-#define VG_X86_FEAT_PAT         (0*32 + 16)
-#define VG_X86_FEAT_PSE36       (0*32 + 17)
-#define VG_X86_FEAT_CLFSH       (0*32 + 19)
-#define VG_X86_FEAT_DS          (0*32 + 21)
-#define VG_X86_FEAT_ACPI        (0*32 + 22)
-#define VG_X86_FEAT_MMX         (0*32 + 23)
-#define VG_X86_FEAT_FXSR        (0*32 + 24)
-#define VG_X86_FEAT_SSE         (0*32 + 25)
-#define VG_X86_FEAT_SSE2        (0*32 + 26)
-#define VG_X86_FEAT_SS          (0*32 + 27)
-#define VG_X86_FEAT_HT          (0*32 + 28)
-#define VG_X86_FEAT_TM          (0*32 + 29)
-#define VG_X86_FEAT_PBE         (0*32 + 31)
+/* 
+   0 - standard feature flags
+   1 - Intel extended flags
+   2 - Valgrind internal flags
+   3 - AMD-specific flags
+ */
+#define VG_N_FEATURE_WORDS      4
 
-#define VG_X86_FEAT_EST         (1*32 + 7)
-#define VG_X86_FEAT_TM2         (1*32 + 8)
-#define VG_X86_FEAT_CNXTID      (1*32 + 10)
+#define VG_X86_FEAT             0
+#define VG_EXT_FEAT             1
+#define VG_INT_FEAT             2
+#define VG_AMD_FEAT             3
+
+/* CPU features (generic) */
+#define VG_X86_FEAT_FPU         (VG_X86_FEAT*32 + 0)
+#define VG_X86_FEAT_VME         (VG_X86_FEAT*32 + 1)
+#define VG_X86_FEAT_DE          (VG_X86_FEAT*32 + 2)
+#define VG_X86_FEAT_PSE         (VG_X86_FEAT*32 + 3)
+#define VG_X86_FEAT_TSC         (VG_X86_FEAT*32 + 4)
+#define VG_X86_FEAT_MSR         (VG_X86_FEAT*32 + 5)
+#define VG_X86_FEAT_PAE         (VG_X86_FEAT*32 + 6)
+#define VG_X86_FEAT_MCE         (VG_X86_FEAT*32 + 7)
+#define VG_X86_FEAT_CX8         (VG_X86_FEAT*32 + 8)
+#define VG_X86_FEAT_APIC        (VG_X86_FEAT*32 + 9)
+#define VG_X86_FEAT_SEP         (VG_X86_FEAT*32 + 11)
+#define VG_X86_FEAT_MTRR        (VG_X86_FEAT*32 + 12)
+#define VG_X86_FEAT_PGE         (VG_X86_FEAT*32 + 13)
+#define VG_X86_FEAT_MCA         (VG_X86_FEAT*32 + 14)
+#define VG_X86_FEAT_CMOV        (VG_X86_FEAT*32 + 15)
+#define VG_X86_FEAT_PAT         (VG_X86_FEAT*32 + 16)
+#define VG_X86_FEAT_PSE36       (VG_X86_FEAT*32 + 17)
+#define VG_X86_FEAT_CLFSH       (VG_X86_FEAT*32 + 19)
+#define VG_X86_FEAT_DS          (VG_X86_FEAT*32 + 21)
+#define VG_X86_FEAT_ACPI        (VG_X86_FEAT*32 + 22)
+#define VG_X86_FEAT_MMX         (VG_X86_FEAT*32 + 23)
+#define VG_X86_FEAT_FXSR        (VG_X86_FEAT*32 + 24)
+#define VG_X86_FEAT_SSE         (VG_X86_FEAT*32 + 25)
+#define VG_X86_FEAT_SSE2        (VG_X86_FEAT*32 + 26)
+#define VG_X86_FEAT_SS          (VG_X86_FEAT*32 + 27)
+#define VG_X86_FEAT_HT          (VG_X86_FEAT*32 + 28)
+#define VG_X86_FEAT_TM          (VG_X86_FEAT*32 + 29)
+#define VG_X86_FEAT_IA64        (VG_X86_FEAT*32 + 30)
+#define VG_X86_FEAT_PBE         (VG_X86_FEAT*32 + 31)
+
+/* Intel extended feature word */
+#define VG_X86_FEAT_SSE3        (VG_EXT_FEAT*32 + 0)
+#define VG_X86_FEAT_MON         (VG_EXT_FEAT*32 + 3)
+#define VG_X86_FEAT_DSCPL       (VG_EXT_FEAT*32 + 4)
+#define VG_X86_FEAT_EST         (VG_EXT_FEAT*32 + 7)
+#define VG_X86_FEAT_TM2         (VG_EXT_FEAT*32 + 8)
+#define VG_X86_FEAT_CNXTID      (VG_EXT_FEAT*32 + 10)
 
 /* Used internally to mark whether CPUID is even implemented */
-#define VG_X86_FEAT_CPUID       (2*32 + 0)
+#define VG_X86_FEAT_CPUID       (VG_INT_FEAT*32 + 0)
 
-/* The set of features we're willing to support for the client */
-#define VG_SUPPORTED_FEATURES                   \
-        ((1 << VG_X86_FEAT_FPU)  |              \
-         (1 << VG_X86_FEAT_TSC)  |              \
-         (1 << VG_X86_FEAT_CMOV) |              \
-         (1 << VG_X86_FEAT_MMX)  |              \
-         (1 << VG_X86_FEAT_FXSR) |              \
-         (1 << VG_X86_FEAT_SSE)  |              \
-         (1 << VG_X86_FEAT_SSE2))
+/* AMD special features */
+#define VG_AMD_FEAT_SYSCALL     (VG_AMD_FEAT*32 + 11)
+#define VG_AMD_FEAT_NXP         (VG_AMD_FEAT*32 + 20)
+#define VG_AMD_FEAT_MMXEXT      (VG_AMD_FEAT*32 + 22)
+#define VG_AMD_FEAT_FFXSR       (VG_AMD_FEAT*32 + 25)
+#define VG_AMD_FEAT_LONGMODE    (VG_AMD_FEAT*32 + 29)
+#define VG_AMD_FEAT_3DNOWEXT    (VG_AMD_FEAT*32 + 30)
+#define VG_AMD_FEAT_3DNOW       (VG_AMD_FEAT*32 + 31)
  
 /* Various environment variables we pay attention to */

--- valgrind/coregrind/vg_helpers.S  #1.29:1.30
@@ -191,74 +191,41 @@
         RA   <- %esp
 
-   For simulating the cpuid instruction, we will
-   issue a "real" cpuid instruction and then mask out
-   the bits of the features we do not support currently (3dnow mostly).
-   We also claim to not support most CPUID operations.
-        
-   Dirk Mueller <mueller@...>
-
-   http://www.sandpile.org/ia32/cpuid.htm
-
-   references: 
-
-   pre-MMX pentium:
-
-   <werner> cpuid words (0): 0x1 0x756e6547 0x6c65746e 0x49656e69
-   <werner> cpuid words (1): 0x52b 0x0 0x0 0x1bf
+   We save registers and package up the args so we can call a C helper
+   for all this.
 */
 .global VG_(helper_CPUID)
 VG_(helper_CPUID):
+        pushl   %ebp
+        movl    %esp,%ebp
         pushl   %eax
         pushl   %ebx
         pushl   %ecx
         pushl   %edx
-        movl    32(%esp), %eax
+        pushl   %esi
+        pushl   %edi
+        pushf
+        
+        lea     2*4(%ebp),%eax  /* &edx */
+        pushl   %eax
+        addl    $4,%eax         /* &ecx */
+        pushl   %eax
+        addl    $4,%eax         /* &ebx */
+        pushl   %eax
+        addl    $4,%eax         /* &eax */
+        pushl   %eax
+        pushl   (%eax)          /* eax */
 
-        /* eax==0 - max valid request+processor vendor */
-        cmpl    $0, %eax
-        jne     1f
-
-        movl    $1, %eax        /* only support request 1 */
-        movl    valgrind_brand+0, %ebx
-        movl    valgrind_brand+4, %edx
-        movl    valgrind_brand+8, %ecx
-        jmp     99f
-
-        /* eax==1 - CPU features and model ID */
-1:      cmpl    $1, %eax
-        jne     2f
-
-        cpuid   /* get host CPU's capabilities */
-
-        movl    $0111, %eax
-        movl    $0, %ebx                        /* clear APIC id, CLFLUSH size, Brand ID */
-        movl    $0, %ecx                        /* clear extended feature bits */
-        andl    $VG_SUPPORTED_FEATURES, %edx    /* mask off feature bits we don't support */
-        jmp     99f
-
-        /* eax=0x80000000 - extended cpuid functions */
-2:      cmpl    $0x80000000, %eax
-        jne     99f
-
-        /* leave eax==0x80000000 - we don't support any other extended operations */
-        movl    valgrind_brand+0, %ebx  /* AMD load the brand string again - */
-        movl    valgrind_brand+4, %edx  /* Intel leaves them "reserved" */
-        movl    valgrind_brand+8, %ecx
-        
-        
-99:     movl    %edx, 20(%esp)
-        movl    %ecx, 24(%esp)
-        movl    %ebx, 28(%esp)
-        movl    %eax, 32(%esp)
+        call    VG_(helperc_CPUID)
+        addl    $20,%esp
 
+        popf
+        popl    %edi
+        popl    %esi
         popl    %edx
         popl    %ecx
         popl    %ebx
         popl    %eax
+        popl    %ebp
         ret
-.data
-valgrind_brand:
-        .ascii "ValgrindVCPU"
-.text
 
 /* Fetch the FPU status register.

--- valgrind/coregrind/vg_to_ucode.c  #1.127:1.128
@@ -51,5 +51,17 @@
 /*------------------------------------------------------------*/
 
-#define VG_N_FEATURE_WORDS      3
+#define VG_CPU_VENDOR_GENERIC   0
+#define VG_CPU_VENDOR_INTEL     1
+#define VG_CPU_VENDOR_AMD       2
+
+static Int cpu_vendor = VG_CPU_VENDOR_GENERIC;
+
+static const struct cpu_vendor {
+        const Char *vendorstr;
+        Int         vendorid;
+} cpu_vendors[] = {
+        { "GenuineIntel", VG_CPU_VENDOR_INTEL },
+        { "AuthenticAMD", VG_CPU_VENDOR_AMD },
+};
 
 static Int cpuid_level = -2;    /* -2 -> not initialized */
@@ -109,4 +121,7 @@ static inline void cpuid(UInt eax, 
 static void get_cpu_features(void)
 {
+   Char vendorstr[13];
+   Int i;
+
    if (!has_cpuid()) {
       cpuid_level = -1;
@@ -114,10 +129,27 @@ static void get_cpu_features(void)
    }
 
-   cpu_features[2] |= (1 << (VG_X86_FEAT_CPUID%32));
+   cpu_features[VG_INT_FEAT] |= (1 << (VG_X86_FEAT_CPUID%32));
 
-   cpuid_level = cpuid_eax(0);
+   cpuid(0, &cpuid_level, (UInt *)&vendorstr[0], (UInt *)&vendorstr[8], (UInt *)&vendorstr[4]);
+   vendorstr[12] = '\0';
+
+   for(i = 0; i < sizeof(cpu_vendors)/sizeof(*cpu_vendors); i++)
+      if (VG_(memcmp)(vendorstr, cpu_vendors[i].vendorstr, 12) == 0) {
+         cpu_vendor = cpu_vendors[i].vendorid;
+         break;
+      }
 
    if (cpuid_level >= 1)
-      cpuid(1, NULL, NULL, &cpu_features[1], &cpu_features[0]);
+      cpuid(1, NULL, NULL, &cpu_features[VG_EXT_FEAT], &cpu_features[VG_X86_FEAT]);
+
+   switch(cpu_vendor) {
+   case VG_CPU_VENDOR_AMD:
+      /* get AMD-specific flags */
+      cpuid(0x80000001, NULL, NULL, NULL, &cpu_features[VG_AMD_FEAT]);
+      break;
+
+   default:
+      break;
+   }
 }
 
@@ -135,4 +167,147 @@ Bool VG_(cpu_has_feature)(UInt feature)
 }
 
+/* The set of features we're willing to support for the client
+   
+   This includes supported instruction set extensions, plus any
+   extensions which don't have any user-mode visible effect (but the
+   client may find interesting).
+ */
+#define VG_X86_SUPPORTED_FEATURES               \
+         ((1 << VG_X86_FEAT_FPU)        |       \
+          (1 << VG_X86_FEAT_VME)        |       \
+          (1 << VG_X86_FEAT_DE)         |       \
+          (1 << VG_X86_FEAT_PSE)        |       \
+          (1 << VG_X86_FEAT_TSC)        |       \
+          (0 << VG_X86_FEAT_MSR)        |       \
+          (1 << VG_X86_FEAT_PAE)        |       \
+          (1 << VG_X86_FEAT_MCE)        |       \
+          (1 << VG_X86_FEAT_CX8)        |       \
+          (1 << VG_X86_FEAT_APIC)       |       \
+          (0 << VG_X86_FEAT_SEP)        |       \
+          (1 << VG_X86_FEAT_MTRR)       |       \
+          (1 << VG_X86_FEAT_PGE)        |       \
+          (1 << VG_X86_FEAT_MCA)        |       \
+          (1 << VG_X86_FEAT_CMOV)       |       \
+          (1 << VG_X86_FEAT_PAT)        |       \
+          (1 << VG_X86_FEAT_PSE36)      |       \
+          (0 << VG_X86_FEAT_CLFSH)      |       \
+          (1 << VG_X86_FEAT_DS)         |       \
+          (1 << VG_X86_FEAT_ACPI)       |       \
+          (1 << VG_X86_FEAT_MMX)        |       \
+          (1 << VG_X86_FEAT_FXSR)       |       \
+          (1 << VG_X86_FEAT_SSE)        |       \
+          (1 << VG_X86_FEAT_SSE2)       |       \
+          (1 << VG_X86_FEAT_SS)         |       \
+          (1 << VG_X86_FEAT_HT)         |       \
+          (1 << VG_X86_FEAT_TM)         |       \
+          (0 << VG_X86_FEAT_IA64)       |       \
+          (1 << VG_X86_FEAT_PBE))
+
+#define VG_AMD_SUPPORTED_FEATURES                                       \
+        ((0 << (VG_AMD_FEAT_SYSCALL % 32))      |                       \
+         (0 << (VG_AMD_FEAT_NXP % 32))          |                       \
+         (1 << (VG_AMD_FEAT_MMXEXT % 32))       |                       \
+         (0 << (VG_AMD_FEAT_FFXSR % 32))        |                       \
+         (0 << (VG_AMD_FEAT_LONGMODE % 32))     |                       \
+         (0 << (VG_AMD_FEAT_3DNOWEXT % 32))     |                       \
+         (0 << (VG_AMD_FEAT_3DNOW % 32))        |                       \
+         /* Common bits between standard features and AMD features */   \
+         (1 << VG_X86_FEAT_FPU)         |                               \
+         (1 << VG_X86_FEAT_VME)         |                               \
+         (1 << VG_X86_FEAT_DE)          |                               \
+         (1 << VG_X86_FEAT_PSE)         |                               \
+         (1 << VG_X86_FEAT_TSC)         |                               \
+         (0 << VG_X86_FEAT_MSR)         |                               \
+         (1 << VG_X86_FEAT_PAE)         |                               \
+         (1 << VG_X86_FEAT_MCE)         |                               \
+         (1 << VG_X86_FEAT_CX8)         |                               \
+         (1 << VG_X86_FEAT_APIC)        |                               \
+         (1 << VG_X86_FEAT_MTRR)        |                               \
+         (1 << VG_X86_FEAT_PGE)         |                               \
+         (1 << VG_X86_FEAT_MCA)         |                               \
+         (1 << VG_X86_FEAT_CMOV)        |                               \
+         (1 << VG_X86_FEAT_PAT)         |                               \
+         (1 << VG_X86_FEAT_PSE36)       |                               \
+         (1 << VG_X86_FEAT_MMX)         |                               \
+         (1 << VG_X86_FEAT_FXSR))
+
+
+/*      
+   For simulating the cpuid instruction, we will
+   issue a "real" cpuid instruction and then mask out
+   the bits of the features we do not support currently (3dnow mostly).
+   We also claim to not support most CPUID operations.
+        
+   Dirk Mueller <mueller@...>
+
+   http://www.sandpile.org/ia32/cpuid.htm
+
+   references: 
+
+   pre-MMX pentium:
+
+   <werner> cpuid words (0): 0x1 0x756e6547 0x6c65746e 0x49656e69
+   <werner> cpuid words (1): 0x52b 0x0 0x0 0x1bf
+
+   Updated to be more extensible about future vendor extensions and
+   vendor-specific parts of CPUID.
+*/
+void VG_(helperc_CPUID)(UInt op, UInt *eax_ret, UInt *ebx_ret, UInt *ecx_ret, UInt *edx_ret)
+{
+   UInt eax, ebx, ecx, edx;
+
+   if (cpuid_level == -2)
+      get_cpu_features();       /* for cpu_vendor */
+
+   cpuid(op, &eax, &ebx, &ecx, &edx);
+
+   /* Common mangling */
+   switch(op) {
+   case 1:
+      edx &= VG_X86_SUPPORTED_FEATURES;
+      break;
+
+   case 0xd8000000: {
+      /* Implement some private information at 0xd8000000 */
+      static const Char valgrind_vendor[] = "ValgrindVCPU";
+
+      eax = 0xd8000000;         /* max request */
+      ebx = *(UInt *)&valgrind_vendor[0];
+      ecx = *(UInt *)&valgrind_vendor[8];
+      edx = *(UInt *)&valgrind_vendor[4];
+   }
+      break;
+   }
+
+   /* Vendor-specific mangling of the results */
+   switch(cpu_vendor) {
+   case VG_CPU_VENDOR_INTEL:
+      switch(op) {
+      case 1:
+         ecx = 0;               /* mask out all extended features for now */
+         break;
+
+      case 0x80000001:
+         ebx = ecx = edx = 0;
+         break;
+      }
+      break;
+
+   case VG_CPU_VENDOR_AMD:
+      switch(op) {
+      case 0x80000001:
+         edx &= VG_AMD_SUPPORTED_FEATURES;
+         break;
+      }
+      break;
+   }
+
+   *eax_ret = eax;
+   *ebx_ret = ebx;
+   *ecx_ret = ecx;
+   *edx_ret = edx;
+}
+
+
 /*------------------------------------------------------------*/
 /*--- Here so it can be inlined everywhere.                ---*/

On Mon, 26 Jan 2004, Dirk Mueller wrote:

> Oh, how do you know what all possible user-mode programs care about? Is there
> some secret source of CPUID wisdom I don't know about yet?

Isn't this exciting!  Still, I've lost track of all the arguing back and
forth, and how Jeremy's latest commit affects things.  Can someone
explain, briefly, dispassionately, exactly what is happening?

Thanks.

N

On Mon, 2004-01-26 at 10:28, Dirk Mueller wrote:
> Its not as if valgrind would be a package that requires more than 5 minutes to 
> download, configure, compile and install. 
> 
> When you use such a ultra new CPU you're going to get a lot more trouble with 
> your kernel, your libc and your other runtime environment anyway. 

I doubt it.  The Athlon64 still looks like an 8086 to programs which
want it to.  If you don't tell the client code that the CPU implements
gee-whiz feature X, then the client code is unlikely to want to use it
(unless the client code isn't really portable x86 code, but specific to
some particular CPU/implementation).

> > After all, Valgrind's intent is not to emulate your actual host CPU, but
> > the common useful subset of ia32 implementation - which your host CPU
> > happens to be one of.
> 
> Is this true? I wonder why we keep adding new instructions then. we could just 
> claim to not support cpuid and only implement 386 instructions, not any of 
> the "fancy" stuff newer processors do. 

Well, until MMX support was added, Valgrind's CPUID unconditionally
returned a P54C (pre-MMX Pentium) set of results, without any reference
to the host CPU.  Most things were happy with that - the exception was
the NVIDIA drivers, which simply required SSE until a couple of versions
ago.

> Look, there were good reasons for implementing SSE: for example because of DRI 
> drivers that use SSE without checking for it (NVIDIA being a good example). 
> There was no way to suppress SSE support, and it was often requested since 
> almost every second computer uses those NVIDIA drivers nowadays. 

I agree.  But only because SSE is very useful to real programs. 
Certainly nobody implemented it for fun (well, maybe they did).

> Oh, how do you know what all possible user-mode programs care about? Is there 
> some secret source of CPUID wisdom I don't know about yet?

Well, there's the various Intel documents on how one should and should
not use the various functions in CPUID.  And there's looking at the
actual feature bits, and seeing what they mean.  For all but the
user-mode instruction extensions, there's nothing there which is
concretely relevant to a user-mode program.  Sure, a program could
inspect the bits, but unless it's just for its own interest (like
x86info), then there's no functional relevance.  One could imagine a
program doing something special if it sees HT, I guess, but it isn't
going to change dramatically (especially since Valgrind itself has more
affect on program execution than HT/non-HT).

> For the single reason that the old code did not expose any problem in any 
> existing application that we know of I ask you to consider changing the code 
> back to a blacklisting behavior. If you don't want to fix the cpuid masking 
> to be athlon specific,then thats fine, I can do that. 
> 
> > Yes, I agree.  But that isn't part of the feature bitmasks.
> 
> Really? I wonder why I can read about such processor specific information then 
> in the documentation  of cpuid on sandpile.org.

The cache/TLB configuration is returned by CPUID request 2; we're
talking about the feature bits returned in %edx and %ecx by request 1
(and request 0x80000001 on AMD CPUs).

> > Instruction set changes do affect the emulation.  All the others are a
> > big "don't care".  It's trivial to copy them through.
> 
> Great. Then why did you break the "copy through" bit ? Thats the point I'm 
> complaining about the whole time !

OK, done - it's just typing.

	J

CVS commit by nethercote: 

No longer showing debugging options for --help;  only for the newly added
--help-debug.


  M +24 -18    vg_main.c   1.143
  M +4 -0      docs/coregrind_core.html   1.25


--- valgrind/coregrind/vg_main.c  #1.142:1.143
@@ -1353,5 +1353,5 @@ static void load_tool( const char *tooln
 
 static void load_client(char* cl_argv[], const char* exec,    
-                 /*inout*/Bool* need_help,
+                 /*inout*/Int* need_help,
                  /*out*/struct exeinfo* info, /*out*/Addr* client_eip)
 {
@@ -1362,5 +1362,5 @@ static void load_client(char* cl_argv[],
           ( NULL == (exec = find_executable(cl_argv[0])) ) )
       {
-         *need_help = True;
+         *need_help = 1;
       }
    }
@@ -1470,5 +1470,5 @@ static void config_error ( Char* msg )
 }
 
-void usage ( void )
+void usage ( Bool debug_help )
 {
    Char* usage1 = 
@@ -1478,4 +1478,5 @@ void usage ( void )
 "    --tool=<name>             Use the Valgrind tool named <name>\n"
 "    --help                    show this message\n"
+"    --help-debug              show this message, plus debugging options\n"
 "    --version                 show version\n"
 "    -q --quiet                run silently; only print error msgs\n"
@@ -1558,4 +1559,5 @@ void usage ( void )
          VG_(printf)("    (none)\n");
    }
+   if (debug_help) {
    VG_(printf)(usage2);
 
@@ -1568,4 +1570,5 @@ void usage ( void )
          VG_(printf)("    (none)\n");
    }
+   }
    VG_(printf)(usage3, VG_BUGS_TO);
 
@@ -1577,5 +1580,5 @@ void usage ( void )
 
 static void pre_process_cmd_line_options
-      ( Bool* need_help, const char** tool, const char** exec )
+      ( Int* need_help, const char** tool, const char** exec )
 {
    UInt i;
@@ -1589,5 +1592,8 @@ static void pre_process_cmd_line_options
 
       } else if (strcmp(VG_(vg_argv)[i], "--help") == 0) {
-         *need_help = True;
+         *need_help = 1;
+
+      } else if (strcmp(VG_(vg_argv)[i], "--help-debug") == 0) {
+         *need_help = 2;
 
       } else if (strncmp(VG_(vg_argv)[i], "--tool=", 7) == 0 ||
@@ -1604,5 +1610,5 @@ static void pre_process_cmd_line_options
       if (!need_help)
          list_tools();
-      usage();
+      usage(/*help-debug?*/False);
    }
 }
@@ -1610,5 +1616,5 @@ static void pre_process_cmd_line_options
 static void process_cmd_line_options 
       ( UInt* client_auxv, Addr esp_at_startup, 
-        const char* toolname, Bool need_help )
+        const char* toolname, Int need_help )
 {
    Int  i, eventually_logfile_fd;
@@ -1639,5 +1645,5 @@ static void process_cmd_line_options 
 
    if (need_help)
-      usage();
+      usage(/*--help-debug?*/need_help == 2);
 
    /* We know the initial ESP is pointing at argc/argv */
@@ -1877,5 +1883,5 @@ static void process_cmd_line_options 
       else if ( ! VG_(needs).command_line_options
              || ! SK_(process_cmd_line_option)(arg) ) {
-         usage();
+         usage(/*--help-debug?*/need_help == 2);
       }
    }
@@ -2689,5 +2695,5 @@ int main(int argc, char **argv)
    char *preload;          /* tool-specific LD_PRELOAD .so */
    char **env;
-   Bool need_help = False;
+   Int need_help = 0;      // 0 = no, 1 = --help, 2 = --help-debug
    struct exeinfo info;
    ToolInfo *toolinfo = NULL;

--- valgrind/coregrind/docs/coregrind_core.html  #1.24:1.25
@@ -496,4 +496,8 @@
       selected tool. </li><br><p>
 
+  <li><code>--help-debug</code><br>
+      <p>Same as <code>--help</code>, but also lists debugging options which
+      usually are only of use to developers.</li><br><p>
+
   <li><code>--version</code><br> <p>Show the version number of the
       Valgrind core.  Tools can have their own version numbers.  There

CVS commit by nethercote: 

Fix broken "make dist". 

Doesn't fix "make distcheck", however, because this happens:

  /usr/bin/ld: cannot open linker script file ../../coregrind/x86/stage2.lds:
  No such file or directory

For some reason I can't work out, that file is built when you make in a CVS
tree, or manually from a "make dist" tarball, but not when you "make
distcheck".


  M +1 -1      Makefile.am   1.66
  M +0 -1      x86/Makefile.am   1.5


--- valgrind/coregrind/Makefile.am  #1.65:1.66
@@ -1,4 +1,4 @@
 
-SUBDIRS = x86 demangle . docs
+SUBDIRS = x86 demangle arch . docs
 
 add_includes = -I$(srcdir)/demangle -I$(top_srcdir)/include -I$(srcdir)/x86

--- valgrind/coregrind/x86/Makefile.am  #1.4:1.5
@@ -3,5 +3,4 @@
 
 EXTRA_DIST =            \
-        Make.inc        \
         ume_archdefs.c  \
         ume_archdefs.h  \

CVS commit by fitzhardinge: 

Fix for bug 73326.  It seems that gcc 3.2.2 is generating negatively-sized
scopes and out of order line number information in the stabs debug info.
I wonder if this is the stabs writer rotting now that dwarf is the
default...


  M +2 -2      vg_symtab2.c   1.75


--- valgrind/coregrind/vg_symtab2.c  #1.74:1.75
@@ -302,6 +302,6 @@ void VG_(addScopeInfo) ( SegInfo* si,
    ScopeRange range;
 
-   /* Ignore zero-sized scopes */
-   if (this == next) {
+   /* Ignore zero-sized or negative scopes */
+   if (size <= 0) {
       if (debug)
          VG_(printf)("ignoring zero-sized range, scope %p at %p\n", scope, this);

On Thu, 2004-02-05 at 22:58, Jeremy Fitzhardinge wrote:
> CVS commit by fitzhardinge: 
> 
> Fix for bug 73326.  It seems that gcc 3.2.2 is generating negatively-sized
> scopes and out of order line number information in the stabs debug info.
> I wonder if this is the stabs writer rotting now that dwarf is the
> default...

I've seen both of these with old FreeBSD toolchains, typically with
gcc-2.95.3 and binutils-2.11.2. I've attempted to fix the out-of-order
line info problems but not yet entirely successfully.

On Fri, 6 Feb 2004, Doug Rabson wrote:

> > Fix for bug 73326.  It seems that gcc 3.2.2 is generating negatively-sized
> > scopes and out of order line number information in the stabs debug info.
> > I wonder if this is the stabs writer rotting now that dwarf is the
> > default...
>
> I've seen both of these with old FreeBSD toolchains, typically with
> gcc-2.95.3 and binutils-2.11.2. I've attempted to fix the out-of-order
> line info problems but not yet entirely successfully.

I saw out-of-order line number entries, ages ago, when I first hacked on
the stabs reader;  I think I even added the code that allowed them to be
handled.  This was over 18 months ago;  maybe it disappeared in the
subsequent code edits.

N

On Friday 06 February 2004 10:39, Nicholas Nethercote wrote:
> On Fri, 6 Feb 2004, Doug Rabson wrote:
> > > Fix for bug 73326.  It seems that gcc 3.2.2 is generating
> > > negatively-sized scopes and out of order line number information in the
> > > stabs debug info. I wonder if this is the stabs writer rotting now that
> > > dwarf is the default...
> >
> > I've seen both of these with old FreeBSD toolchains, typically with
> > gcc-2.95.3 and binutils-2.11.2. I've attempted to fix the out-of-order
> > line info problems but not yet entirely successfully.
>
> I saw out-of-order line number entries, ages ago, when I first hacked on
> the stabs reader;  I think I even added the code that allowed them to be
> handled.  This was over 18 months ago;  maybe it disappeared in the
> subsequent code edits.

Just curious... What's wrong with out-of-order line numbers?
If a compiler does optimization, line numbers can be shuffled according to 
instruction address order.
Sometimes, with the Intel compiler, I get these out-of-order warnings for line 
numbers, too (with DWARF).

Josef

On Fri, 2004-02-06 at 10:51, Josef Weidendorfer wrote:
> On Friday 06 February 2004 10:39, Nicholas Nethercote wrote:
> > On Fri, 6 Feb 2004, Doug Rabson wrote:
> > > > Fix for bug 73326.  It seems that gcc 3.2.2 is generating
> > > > negatively-sized scopes and out of order line number information in the
> > > > stabs debug info. I wonder if this is the stabs writer rotting now that
> > > > dwarf is the default...
> > >
> > > I've seen both of these with old FreeBSD toolchains, typically with
> > > gcc-2.95.3 and binutils-2.11.2. I've attempted to fix the out-of-order
> > > line info problems but not yet entirely successfully.
> >
> > I saw out-of-order line number entries, ages ago, when I first hacked on
> > the stabs reader;  I think I even added the code that allowed them to be
> > handled.  This was over 18 months ago;  maybe it disappeared in the
> > subsequent code edits.
> 
> Just curious... What's wrong with out-of-order line numbers?
> If a compiler does optimization, line numbers can be shuffled according to 
> instruction address order.
> Sometimes, with the Intel compiler, I get these out-of-order warnings for line 
> numbers, too (with DWARF).

It isn't the line numbers that get out of order, its the address ranges
of the line info blocks that the stabs reader parses.

CVS commit by nethercote: 

fix code typo


  M +1 -1      vg_syscalls.c   1.85


--- valgrind/coregrind/vg_syscalls.c  #1.84:1.85
@@ -4132,5 +4132,5 @@ PRE(select)
       if (a3 != (Addr)NULL)
          SYSCALL_TRACK( pre_mem_read, tid, "select(writefds)", a3, 
-                        arg1/8 /* __FD_SETSIZE/8 */ );
+                        a1/8 /* __FD_SETSIZE/8 */ );
       if (a4 != (Addr)NULL)
          SYSCALL_TRACK( pre_mem_read, tid, "select(exceptfds)", a4,

CVS commit by nethercote: 

Add a pair of missing {pre,post}_mem_write events.


  M +5 -0      vg_ldt.c   1.13


--- valgrind/coregrind/vg_ldt.c  #1.12:1.13
@@ -430,5 +430,10 @@ Int VG_(sys_set_thread_area) ( ThreadId 
    translate_to_hw_format(info, VG_(threads)[tid].tls + idx, 0);
 
+   VG_TRACK( pre_mem_write, Vg_CoreSysCall, tid,
+             "set_thread_area(info->entry)",
+             (Addr) & info->entry_number, sizeof(unsigned int) );
    info->entry_number = idx + VKI_GDT_TLS_MIN;
+   VG_TRACK( post_mem_write,
+             (Addr) & info->entry_number, sizeof(unsigned int) );
 
    return 0;

CVS commit by nethercote: 

Patch from Tom Hughes:

  Patch to ignore REP prefixes on single byte RET instructions.

(REP RET is apparently faster than RET on AMD K7/K8)


  M +27 -17    vg_to_ucode.c   1.130


--- valgrind/coregrind/vg_to_ucode.c  #1.129:1.130
@@ -3770,4 +3770,17 @@ void dis_pop_segreg ( UCodeBlock* cb, UI
 }
 
+static
+void dis_ret ( UCodeBlock* cb, UInt d32 )
+{
+   Int t1 = newTemp(cb), t2 = newTemp(cb);
+   uInstr2(cb, GET,  4, ArchReg, R_ESP, TempReg, t1);
+   uInstr2(cb, LOAD, 4, TempReg, t1,    TempReg, t2);
+   uInstr2(cb, ADD,  4, Literal, 0,     TempReg, t1);
+   uLiteral(cb, 4+d32);
+   uInstr2(cb, PUT,  4, TempReg, t1,    ArchReg, R_ESP);
+   jmp_treg(cb, t2);
+   LAST_UINSTR(cb).jmpkind = JmpRet;
+}
+
 /*------------------------------------------------------------*/
 /*--- Disassembling entire basic blocks                    ---*/
@@ -5188,22 +5201,12 @@ static Addr disInstr ( UCodeBlock* cb, A
    case 0xC2: /* RET imm16 */
       d32 = getUDisp16(eip); eip += 2;
-      goto do_Ret;
+      dis_ret(cb, d32);
+      *isEnd = True;
+      DIP("ret %d\n", d32);
+      break;
    case 0xC3: /* RET */
-      d32 = 0;
-      goto do_Ret;
-   do_Ret:
-      t1 = newTemp(cb); t2 = newTemp(cb);
-      uInstr2(cb, GET,  4, ArchReg, R_ESP, TempReg, t1);
-      uInstr2(cb, LOAD, 4, TempReg, t1,    TempReg, t2);
-      uInstr2(cb, ADD,  4, Literal, 0,     TempReg, t1);
-      uLiteral(cb, 4+d32);
-      uInstr2(cb, PUT,  4, TempReg, t1,    ArchReg, R_ESP);
-      jmp_treg(cb, t2);
-      LAST_UINSTR(cb).jmpkind = JmpRet;
-
+      dis_ret(cb, 0);
       *isEnd = True;
-      if (d32 == 0) { DIP("ret\n"); }
-      else          { DIP("ret %d\n", d32); }
-
+      DIP("ret\n");
       break;
       
@@ -6218,4 +6221,11 @@ static Addr disInstr ( UCodeBlock* cb, A
          *isEnd = True;
       } 
+      else
+      if (abyte == 0xC3) { /* REP RET */
+         /* AMD K7/K8-specific optimisation; faster than vanilla RET */
+         dis_ret(cb, 0);
+         *isEnd = True;
+         DIP("rep ret\n");
+      }
       else {
          goto decode_failure;

CVS commit by nethercote: 

Three CDROM ioctls, from Rocky Bernstein.


  M +12 -0     vg_syscalls.c   1.88


--- valgrind/coregrind/vg_syscalls.c  #1.87:1.88
@@ -3160,4 +3160,12 @@ PRE(ioctl)
 
       /* CD ROM stuff (??)  */
+   case CDROM_GET_MCN:
+      SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROM_GET_MCN)", arg3,
+                    sizeof(struct cdrom_mcn) );
+      break;
+   case CDROM_SEND_PACKET:
+      SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROM_SEND_PACKET)", arg3,
+                    sizeof(struct cdrom_generic_command));
+      break;
    case CDROMSUBCHNL:
       SYSCALL_TRACK( pre_mem_read,tid, 
@@ -3169,4 +3177,8 @@ PRE(ioctl)
                      sizeof(struct cdrom_subchnl));
       break;
+   case CDROMREADMODE2:
+      SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROMREADMODE2)", arg3,
+                     CD_FRAMESIZE_RAW0 );
+      break;
    case CDROMREADTOCHDR:
       SYSCALL_TRACK( pre_mem_write,tid,

CVS commit by fitzhardinge: 

This fixes bug 75614.  It seems that a symbol can be named
"foo<bar::blat>"; normally stabs names are terminated by ':', but we
also need to keep track of <> pairs so we can ignore nested colons.


  M +19 -2     vg_stabs.c   1.6


--- valgrind/coregrind/vg_stabs.c  #1.5:1.6
@@ -776,7 +776,24 @@ static SymType *stabtype_parser(SegInfo 
          UInt off, sz;
          SymType *fieldty;
+         Int templ=0;
+
+         /* Skip past field name, which ends with ':' or '::' - but
+            '::' can appear within a template-mangled name, so keep
+            track of '<' and '>'. */
+         end = p;
+         while(*end) {
+             Char ch = *end++;
+
+             if (ch == '<')
+                 templ++;
+             else if (ch == '>')
+                 templ--;
+             else if (templ == 0 && ch == ':') {
+                 end--;
+                 break;
+             }
+         }
+         /* XXX check for *end != ':' */
 
-         end = SKIPPAST(p, ':', "struct/union field NAME");
-         end--;                 /* want to point to (first) ':' */
          if (end[1] == ':') {
             /* c++ method names end in :: */

CVS commit by fitzhardinge: 

Fix shmdt by using the right argument for the shared segment address.


  M +3 -3      vg_syscalls.c   1.91


--- valgrind/coregrind/vg_syscalls.c  #1.90:1.91
@@ -2649,5 +2649,5 @@ PRE(ipc)
    }
    case 22: /* IPCOP_shmdt */
-      if (!valid_client_addr(arg1, 1, tid, "shmdt"))
+      if (!valid_client_addr(arg5, 1, tid, "shmdt"))
          res = -VKI_EINVAL;
       break;
@@ -2788,7 +2788,7 @@ POST(ipc)
    case 22: /* IPCOP_shmdt */
    {
-      Segment *s = VG_(find_segment)(arg1);
+      Segment *s = VG_(find_segment)(arg5);
 
-      if (s != NULL && (s->flags & SF_SHM) && VG_(seg_contains)(s, arg1, 1)) {
+      if (s != NULL && (s->flags & SF_SHM) && VG_(seg_contains)(s, arg5, 1)) {
          VG_TRACK( die_mem_munmap, s->addr, s->len );
          VG_(unmap_range)(s->addr, s->len);

CVS commit by nethercote: 

Some newer systems have a new version of pthreadtypes.h that comes from glibc
2.3.3, which is binary-compatible, but not source compatible with the old one,
which came from LinuxThreads.  We were using the types defined in the old one,
which caused compilation errors on systems using the new one.

This commit introduces our own versions of these types.  Our versions are laid
out identically to the LinuxThreads ones, but the field names are different.
We convert all pthread types to our versions before using them, so we don't
rely on the pthreadtypes.h types any more.  Hopefully this will fix the
problem;  I have three reports that it does.  Let's see...


  M +37 -1     vg_include.h   1.183
  M +221 -77   vg_libpthread.c   1.145
  M +80 -108   vg_scheduler.c   1.142


--- valgrind/coregrind/vg_include.h  #1.182:1.183
@@ -645,4 +645,39 @@ extern Addr VG_(do_useseg) ( UInt seg_se
 
 /* ---------------------------------------------------------------------
+   Exports of vg_libpthread.c
+   ------------------------------------------------------------------ */
+
+/* Replacements for pthread types, shared between vg_libpthread.c and
+   vg_scheduler.c.  See comment in vg_libpthread.c above the other
+   vg_pthread_*_t types for a description of how these are used. */
+
+struct _vg_pthread_fastlock
+{
+   long int __vg_status;   /* "Free" or "taken" or head of waiting list */
+   int __vg_spinlock;      /* Used by compare_and_swap emulation. Also,
+                           adaptive SMP lock stores spin count here. */
+};
+
+typedef struct
+{
+   int __vg_m_reserved;               /* Reserved for future use */
+   int __vg_m_count;                  /* Depth of recursive locking */
+   /*_pthread_descr*/ void* __vg_m_owner;       /* Owner thread (if recursive or errcheck) */
+   int __vg_m_kind;                   /* Mutex kind: fast, recursive or errcheck */
+   struct _vg_pthread_fastlock __vg_m_lock; /* Underlying fast lock */
+}  vg_pthread_mutex_t;
+
+typedef struct
+{
+  struct _vg_pthread_fastlock __vg_c_lock; /* Protect against concurrent access */
+  /*_pthread_descr*/ void* __vg_c_waiting;        /* Threads waiting on this condition */
+  // Padding ensures the size is 48 bytes
+  char __vg_padding[48 - sizeof(struct _vg_pthread_fastlock)
+         - sizeof(void*) - sizeof(long long)];
+  long long __vg_align;
+} vg_pthread_cond_t;
+
+
+/* ---------------------------------------------------------------------
    Exports of vg_scheduler.c
    ------------------------------------------------------------------ */
@@ -703,5 +738,5 @@ typedef
       the condition variable indicated by the .associated_cv field.
       In all other cases, should be NULL. */
-   void* /*pthread_mutex_t* */ associated_mx;
+   vg_pthread_mutex_t* associated_mx;
 
    /* When .status == WaitCV, points to the condition variable I am

--- valgrind/coregrind/vg_libpthread.c  #1.144:1.145
@@ -83,4 +83,86 @@
 
 /* ---------------------------------------------------------------------
+   Our own definition of types that vary between LinuxThreads and NPTL.
+   ------------------------------------------------------------------ */
+
+/* Moving from LinuxThreads to NPTL, several crucial types (eg.
+   pthread_mutex_t, pthread_mutexattr_t, etc) in pthreadtypes.h were changed
+   in binary-compatible, but source-incompatible, ways.  We can similarly
+   use any layout we want, so long as it's binary-compatible.  However, we
+   can no longer use the LinuxThreads types, because they won't work on NPTL
+   systems.  Thus, we have to introduce a layer of indirection, and define
+   our own versions of these types (vg_pthread_mutex_t, etc).  NPTL does
+   pretty much the same thing, and it keeps many of its internal types
+   secret.
+
+   We can layout our types however we want, as long as we put the small
+   number of fields in the right place for binary compatibility (eg.
+   mutex->kind).  To make life easy, our versions have the exact same layout
+   as the LinuxThreads ones;  only the type names and field names are
+   different (they differ only by include "vg" at the start).
+
+   In our implementation of the pthread operations (pthread_mutex_lock(),
+   pthread_mutexattr_settype(), etc) we always cast the standard pthread
+   types to our own types, (eg. pthread_mutex_t --> vg_pthread_mutex_t),
+   before working with them.
+    
+   Note that we have various mutexes (and condvars) in this file that have the
+   type pthread_mutex_t (and pthread_cond_t).  That is fine, because they
+   are always only handled by calling the standard pthread functions (eg.
+   pthread_mutex_lock()) on them.  Phew.
+
+   WARNING: as a result of all this, we should *never* access these standard
+   pthread types as is;  they *must* be converted to the vg_pthread_foo_t
+   equivalent.   It would be nice if this was enforced...  (but compilation
+   on NPTL-only systems should fail if this rule isn't followed...?)
+*/
+
+#include <sched.h>   // for 'struct __sched_param'
+
+typedef struct __vg_pthread_attr_s
+{
+   int __vg_detachstate;
+   int __vg_schedpolicy;
+   struct __sched_param __vg_schedparam;
+   int __vg_inheritsched;
+   int __vg_scope;
+   size_t __vg_guardsize;
+   int __vg_stackaddr_set;
+   void *__vg_stackaddr;
+   size_t __vg_stacksize;
+} vg_pthread_attr_t;
+
+typedef struct
+{
+   int __vg_mutexkind;
+} vg_pthread_mutexattr_t;
+
+typedef struct _vg_pthread_rwlock_t
+{
+   struct _vg_pthread_fastlock __vg_rw_lock; /* Lock to guarantee mutual exclusion */
+   int __vg_rw_readers;                   /* Number of readers */
+   /*_pthread_descr*/ void* __vg_rw_writer;         /* Identity of writer, or NULL if none */
+   /*_pthread_descr*/ void* __vg_rw_read_waiting;   /* Threads waiting for reading */
+   /*_pthread_descr*/ void* __vg_rw_write_waiting;  /* Threads waiting for writing */
+   int __vg_rw_kind;                      /* Reader/Writer preference selection */
+   int __vg_rw_pshared;                   /* Shared between processes or not */
+} vg_pthread_rwlock_t;
+
+typedef struct
+{
+   int __vg_lockkind;
+   int __vg_pshared;
+} vg_pthread_rwlockattr_t;
+
+/* Converting pthread types to vg_pthread types.  We always check that the
+   passed-in type is as big as ours, for safety.  We also zero the pointer
+   to the original struct, to ensure we don't accidentally use it again. */
+
+#define CONVERT(foo, x, vg_x) \
+   my_assert(sizeof(*x) >= sizeof(vg_pthread_##foo##_t)); \
+   vg_x = (vg_pthread_##foo##_t*)x; \
+   x = 0;  // ensure we don't accidentally use x again!
+
+/* ---------------------------------------------------------------------
    Forwardses.
    ------------------------------------------------------------------ */
@@ -302,13 +384,20 @@ pthread_t pthread_self(void)
 int pthread_attr_init(pthread_attr_t *attr)
 {
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   
    /* Just initialise the fields which we might look at. */
-   attr->__detachstate = PTHREAD_CREATE_JOINABLE;
+   vg_attr->__vg_detachstate = PTHREAD_CREATE_JOINABLE;
    /* Linuxthreads sets this field to the value __getpagesize(), so I
       guess the following is OK. */
-   attr->__guardsize = VKI_BYTES_PER_PAGE;   return 0;
+   vg_attr->__vg_guardsize = VKI_BYTES_PER_PAGE;
+   return 0;
 }
 
 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
 {
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+
    if (detachstate != PTHREAD_CREATE_JOINABLE 
        && detachstate != PTHREAD_CREATE_DETACHED) {
@@ -317,5 +406,5 @@ int pthread_attr_setdetachstate(pthread_
       return EINVAL;
    }
-   attr->__detachstate = detachstate;
+   vg_attr->__vg_detachstate = detachstate;
    return 0;
 }
@@ -323,5 +412,8 @@ int pthread_attr_setdetachstate(pthread_
 int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
 {
-   *detachstate = attr->__detachstate;
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+
+   *detachstate = vg_attr->__vg_detachstate;
    return 0;
 }
@@ -413,17 +506,20 @@ int pthread_getattr_np (pthread_t thread
    int    detached;
    size_t limit;
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+
    ensure_valgrind("pthread_getattr_np");
    kludged("pthread_getattr_np", NULL);
    limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 
                                  - 1000; /* paranoia */
-   attr->__detachstate = PTHREAD_CREATE_JOINABLE;
-   attr->__schedpolicy = SCHED_OTHER;
-   attr->__schedparam.sched_priority = 0;
-   attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
-   attr->__scope = PTHREAD_SCOPE_SYSTEM;
-   attr->__guardsize = VKI_BYTES_PER_PAGE;
-   attr->__stackaddr = NULL;
-   attr->__stackaddr_set = 0;
-   attr->__stacksize = limit;
+   vg_attr->__vg_detachstate = PTHREAD_CREATE_JOINABLE;
+   vg_attr->__vg_schedpolicy = SCHED_OTHER;
+   vg_attr->__vg_schedparam.sched_priority = 0;
+   vg_attr->__vg_inheritsched = PTHREAD_EXPLICIT_SCHED;
+   vg_attr->__vg_scope = PTHREAD_SCOPE_SYSTEM;
+   vg_attr->__vg_guardsize = VKI_BYTES_PER_PAGE;
+   vg_attr->__vg_stackaddr = NULL;
+   vg_attr->__vg_stackaddr_set = 0;
+   vg_attr->__vg_stacksize = limit;
    VALGRIND_MAGIC_SEQUENCE(detached, (-1) /* default */,
                            VG_USERREQ__SET_OR_GET_DETACH, 
@@ -431,5 +527,5 @@ int pthread_getattr_np (pthread_t thread
    my_assert(detached == 0 || detached == 1);
    if (detached)
-      attr->__detachstate = PTHREAD_CREATE_DETACHED;
+      vg_attr->__vg_detachstate = PTHREAD_CREATE_DETACHED;
    return 0;
 }
@@ -464,7 +560,9 @@ int pthread_attr_getstacksize ( const pt
 int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
 {
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
   if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)
     return EINVAL;
-  attr->__schedpolicy = policy;
+   vg_attr->__vg_schedpolicy = policy;
   return 0;
 }
@@ -472,5 +570,7 @@ int pthread_attr_setschedpolicy(pthread_
 int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 {
-  *policy = attr->__schedpolicy;
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   *policy = vg_attr->__vg_schedpolicy;
   return 0;
 }
@@ -499,5 +599,7 @@ WEAK 
 int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
 {
-   *guardsize = attr->__guardsize;
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   *guardsize = vg_attr->__vg_guardsize;
    return 0;
 }  
@@ -786,4 +888,6 @@ pthread_create (pthread_t *__restrict __
    NewThreadInfo* info;
    int            gs;
+   vg_pthread_attr_t* __vg_attr;
+   CONVERT(attr, __attr, __vg_attr);
 
    ensure_valgrind("pthread_create");
@@ -798,6 +902,6 @@ pthread_create (pthread_t *__restrict __
    my_assert(info != NULL);
 
-   if (__attr)
-      info->attr__detachstate = __attr->__detachstate;
+   if (__vg_attr)
+      info->attr__detachstate = __vg_attr->__vg_detachstate;
    else 
       info->attr__detachstate = PTHREAD_CREATE_JOINABLE;
@@ -984,5 +1088,7 @@ void _pthread_cleanup_pop_restore (struc
 int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
 {
-   attr->__mutexkind = PTHREAD_MUTEX_ERRORCHECK_NP;
+   vg_pthread_mutexattr_t* vg_attr;
+   CONVERT(mutexattr, attr, vg_attr);
+   vg_attr->__vg_mutexkind = PTHREAD_MUTEX_ERRORCHECK_NP;
    return 0;
 }
@@ -990,4 +1096,7 @@ int __pthread_mutexattr_init(pthread_mut
 int __pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
 {
+   vg_pthread_mutexattr_t* vg_attr;
+   CONVERT(mutexattr, attr, vg_attr);
+
    switch (type) {
 #     ifndef GLIBC_2_1    
@@ -1000,5 +1109,5 @@ int __pthread_mutexattr_settype(pthread_
       case PTHREAD_MUTEX_RECURSIVE_NP:
       case PTHREAD_MUTEX_ERRORCHECK_NP:
-         attr->__mutexkind = type;
+         vg_attr->__vg_mutexkind = type;
          return 0;
       default:
@@ -1034,9 +1143,14 @@ int __pthread_mutex_init(pthread_mutex_t
                          const  pthread_mutexattr_t *mutexattr)
 {
-   mutex->__m_count = 0;
-   mutex->__m_owner = (_pthread_descr)VG_INVALID_THREADID;
-   mutex->__m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;
-   if (mutexattr)
-      mutex->__m_kind = mutexattr->__mutexkind;
+   vg_pthread_mutex_t* vg_mutex;
+   vg_pthread_mutexattr_t* vg_mutexattr;
+   CONVERT(mutex, mutex, vg_mutex); 
+   CONVERT(mutexattr, mutexattr, vg_mutexattr);
+   
+   vg_mutex->__vg_m_count = 0;
+   vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)VG_INVALID_THREADID;
+   vg_mutex->__vg_m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;
+   if (vg_mutexattr)
+      vg_mutex->__vg_m_kind = vg_mutexattr->__vg_mutexkind;
    return 0;
 }
@@ -1046,9 +1160,11 @@ int __pthread_mutex_lock(pthread_mutex_t
 {
    int res;
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
 
    if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_LOCK,
-                              mutex, 0, 0, 0);
+                              vg_mutex, 0, 0, 0);
       return res;
    } else {
@@ -1056,7 +1172,7 @@ int __pthread_mutex_lock(pthread_mutex_t
       if (0)
          kludged("prehistoric lock", NULL);
-      mutex->__m_owner = (_pthread_descr)1;
-      mutex->__m_count = 1;
-      mutex->__m_kind |= VG_PTHREAD_PREHISTORY;
+      vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)1;
+      vg_mutex->__vg_m_count = 1;
+      vg_mutex->__vg_m_kind |= VG_PTHREAD_PREHISTORY;
       return 0; /* success */
    }
@@ -1067,9 +1183,11 @@ int __pthread_mutex_trylock(pthread_mute
 {
    int res;
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
 
    if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_TRYLOCK,
-                              mutex, 0, 0, 0);
+                              vg_mutex, 0, 0, 0);
       return res;
    } else {
@@ -1077,7 +1195,7 @@ int __pthread_mutex_trylock(pthread_mute
       if (0)
          kludged("prehistoric trylock", NULL);
-      mutex->__m_owner = (_pthread_descr)1;
-      mutex->__m_count = 1;
-      mutex->__m_kind |= VG_PTHREAD_PREHISTORY;
+      vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)1;
+      vg_mutex->__vg_m_count = 1;
+      vg_mutex->__vg_m_kind |= VG_PTHREAD_PREHISTORY;
       return 0; /* success */
    }
@@ -1088,9 +1206,11 @@ int __pthread_mutex_unlock(pthread_mutex
 {
    int res;
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
 
    if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_UNLOCK,
-                              mutex, 0, 0, 0);
+                              vg_mutex, 0, 0, 0);
       return res;
    } else {
@@ -1098,7 +1218,7 @@ int __pthread_mutex_unlock(pthread_mutex
       if (0)
          kludged("prehistoric unlock", NULL);
-      mutex->__m_owner = 0;
-      mutex->__m_count = 0;
-      mutex->__m_kind &= ~VG_PTHREAD_PREHISTORY;
+      vg_mutex->__vg_m_owner = 0;
+      vg_mutex->__vg_m_count = 0;
+      vg_mutex->__vg_m_kind &= ~VG_PTHREAD_PREHISTORY;
       return 0; /* success */
    }
@@ -1108,18 +1228,20 @@ int __pthread_mutex_unlock(pthread_mutex
 int __pthread_mutex_destroy(pthread_mutex_t *mutex)
 {
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
+
    /* Valgrind doesn't hold any resources on behalf of the mutex, so no
       need to involve it. */
-   if (mutex->__m_count > 0) {
+   if (vg_mutex->__vg_m_count > 0) {
       /* Oh, the horror.  glibc's internal use of pthreads "knows"
          that destroying a lock does an implicit unlock.  Make it
          explicit. */
-      __pthread_mutex_unlock(mutex);
-      pthread_error("pthread_mutex_destroy: "
-                    "mutex is still in use");
+      __pthread_mutex_unlock( (pthread_mutex_t*)vg_mutex );
+      pthread_error("pthread_mutex_destroy: mutex is still in use");
       return EBUSY;
    }
-   mutex->__m_count = 0;
-   mutex->__m_owner = (_pthread_descr)VG_INVALID_THREADID;
-   mutex->__m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;
+   vg_mutex->__vg_m_count = 0;
+   vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)VG_INVALID_THREADID;
+   vg_mutex->__vg_m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;
    return 0;
 }
@@ -1145,5 +1267,7 @@ int pthread_cond_init( pthread_cond_t *c
                        const pthread_condattr_t *cond_attr)
 {
-   cond->__c_waiting = (_pthread_descr)VG_INVALID_THREADID;
+   vg_pthread_cond_t* vg_cond;
+   CONVERT(cond, cond, vg_cond);
+   vg_cond->__vg_c_waiting = (/*_pthread_descr*/void*)VG_INVALID_THREADID;
    return 0;
 }
@@ -1193,8 +1317,11 @@ int pthread_cond_wait(pthread_cond_t *co
 {
    int res;
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
+
    ensure_valgrind("pthread_cond_wait");
    VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                            VG_USERREQ__PTHREAD_COND_WAIT,
-                           cond, mutex, 0, 0);
+                           cond, vg_mutex, 0, 0);
    return res;
 }
@@ -1209,4 +1336,6 @@ int pthread_cond_timedwait ( pthread_con
    unsigned long long int ull_ms_now_after_1970;
    unsigned long long int ull_ms_end_after_1970;
+   vg_pthread_mutex_t* vg_mutex;
+   CONVERT(mutex, mutex, vg_mutex);
 
    ensure_valgrind("pthread_cond_timedwait");
@@ -1230,5 +1359,5 @@ int pthread_cond_timedwait ( pthread_con
    VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                            VG_USERREQ__PTHREAD_COND_TIMEDWAIT,
-                           cond, mutex, ms_end, 0);
+                           cond, vg_mutex, ms_end, 0);
    return res;
 }
@@ -2658,7 +2787,7 @@ void init_vg_rwlock ( vg_rwlock_t* vg_rw
    address of our version.  Further, if the LinuxThreads version
    appears to have been statically initialised, do the same to the one
-   we allocate here.  The pthread_rwlock_t.__rw_readers field is set
-   to zero by PTHREAD_RWLOCK_INITIALIZER, so we take zero as meaning
-   uninitialised and non-zero meaning initialised. 
+   we allocate here.  The vg_pthread_rwlock_t.__vg_rw_readers field is set
+   to zero by PTHREAD_RWLOCK_INITIALIZER (as are several other fields), so
+   we take zero as meaning uninitialised and non-zero meaning initialised. 
 */
 static vg_rwlock_t* rw_remap ( pthread_rwlock_t* orig )
@@ -2666,4 +2795,6 @@ static vg_rwlock_t* rw_remap ( pthread_r
    int          res, i;
    vg_rwlock_t* vg_rwl;
+   vg_pthread_rwlock_t* vg_orig;
+   
    res = __pthread_mutex_lock(&rw_remap_mx);
    my_assert(res == 0);
@@ -2689,8 +2820,9 @@ static vg_rwlock_t* rw_remap ( pthread_r
 
    /* Initialise the shadow, if required. */
-   if (orig->__rw_readers == 0) {
-      orig->__rw_readers = 1;
+   CONVERT(rwlock, orig, vg_orig);
+   if (vg_orig->__vg_rw_readers == 0) {
+      vg_orig->__vg_rw_readers = 1;
       init_vg_rwlock(vg_rwl);
-      if (orig->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP)
+      if (vg_orig->__vg_rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP)
          vg_rwl->prefer_w = 0;
    }
@@ -2704,12 +2836,17 @@ int pthread_rwlock_init ( pthread_rwlock
 {
    vg_rwlock_t* rwl;
+   vg_pthread_rwlock_t* vg_orig;
+   vg_pthread_rwlockattr_t* vg_attr;
+   CONVERT(rwlock, orig, vg_orig);
+   CONVERT(rwlockattr, attr, vg_attr);
+
    if (0) printf ("pthread_rwlock_init\n");
    /* Force the remapper to initialise the shadow. */
-   orig->__rw_readers = 0;
+   vg_orig->__vg_rw_readers = 0;
    /* Install the lock preference; the remapper needs to know it. */
-   orig->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
-   if (attr)
-      orig->__rw_kind = attr->__lockkind;
-   rwl = rw_remap ( orig );
+   vg_orig->__vg_rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
+   if (vg_attr)
+      vg_orig->__vg_rw_kind = vg_attr->__vg_lockkind;
+   rwl = rw_remap ( (pthread_rwlock_t*)vg_orig );
    return 0;
 }
@@ -2960,7 +3100,8 @@ int
 pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
 {
-  attr->__lockkind = 0;
-  attr->__pshared = PTHREAD_PROCESS_PRIVATE;
-
+   vg_pthread_rwlockattr_t* vg_attr;
+   CONVERT(rwlockattr, attr, vg_attr);
+   vg_attr->__vg_lockkind = 0;
+   vg_attr->__vg_pshared = PTHREAD_PROCESS_PRIVATE;
   return 0;
 }
@@ -2977,4 +3118,7 @@ int
 pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
 {
+   vg_pthread_rwlockattr_t* vg_attr;
+   CONVERT(rwlockattr, attr, vg_attr);
+
   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
     return EINVAL;
@@ -2984,5 +3128,5 @@ pthread_rwlockattr_setpshared (pthread_r
     return ENOSYS;
 
-  attr->__pshared = pshared;
+   vg_attr->__vg_pshared = pshared;
 
   return 0;

--- valgrind/coregrind/vg_scheduler.c  #1.141:1.142
@@ -1932,37 +1932,24 @@ void do__apply_in_new_thread ( ThreadId 
    -------------------------------------------------------- */
 
-/* pthread_mutex_t is a struct with at 5 words:
-      typedef struct
-      {
-        int __m_reserved;         -- Reserved for future use
-        int __m_count;            -- Depth of recursive locking
-        _pthread_descr __m_owner; -- Owner thread (if recursive or errcheck)
-        int __m_kind;      -- Mutex kind: fast, recursive or errcheck
-        struct _pthread_fastlock __m_lock;  -- Underlying fast lock
-      } pthread_mutex_t;
+/* vg_pthread_mutex_t is defined in vg_include.h.
 
-   #define PTHREAD_MUTEX_INITIALIZER \
-     {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, __LOCK_INITIALIZER}
-   # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
-     {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __LOCK_INITIALIZER}
-   # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \
-     {0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, __LOCK_INITIALIZER}
-   # define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \
-     {0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __LOCK_INITIALIZER}
+   The initializers zero everything, except possibly the fourth word,
+   which in vg_pthread_mutex_t is the __vg_m_kind field.  It gets set to one
+   of PTHREAD_MUTEX_{TIMED,RECURSIVE,ERRORCHECK,ADAPTIVE}_NP
 
    How we use it:
 
-   __m_kind  never changes and indicates whether or not it is recursive.
+   __vg_m_kind  never changes and indicates whether or not it is recursive.
 
-   __m_count indicates the lock count; if 0, the mutex is not owned by 
+   __vg_m_count indicates the lock count; if 0, the mutex is not owned by 
              anybody.  
 
-   __m_owner has a ThreadId value stuffed into it.  We carefully arrange 
+   __vg_m_owner has a ThreadId value stuffed into it.  We carefully arrange 
              that ThreadId == 0 is invalid (VG_INVALID_THREADID), so that
              statically initialised mutexes correctly appear 
              to belong to nobody.
 
-   In summary, a not-in-use mutex is distinguised by having __m_owner
-   == 0 (VG_INVALID_THREADID) and __m_count == 0 too.  If one of those
+   In summary, a not-in-use mutex is distinguised by having __vg_m_owner
+   == 0 (VG_INVALID_THREADID) and __vg_m_count == 0 too.  If one of those
    conditions holds, the other should too.
 
@@ -1978,5 +1965,5 @@ void do__apply_in_new_thread ( ThreadId 
 /* Helper fns ... */
 static
-void release_one_thread_waiting_on_mutex ( pthread_mutex_t* mutex, 
+void release_one_thread_waiting_on_mutex ( vg_pthread_mutex_t* mutex, 
                                            Char* caller )
 {
@@ -1994,11 +1981,11 @@ void release_one_thread_waiting_on_mutex
    }
 
-   VG_TRACK( post_mutex_unlock, (ThreadId)mutex->__m_owner, mutex );
+   VG_TRACK( post_mutex_unlock, (ThreadId)mutex->__vg_m_owner, mutex );
 
    vg_assert(i <= VG_N_THREADS);
    if (i == VG_N_THREADS) {
       /* Nobody else is waiting on it. */
-      mutex->__m_count = 0;
-      mutex->__m_owner = VG_INVALID_THREADID;
+      mutex->__vg_m_count = 0;
+      mutex->__vg_m_owner = VG_INVALID_THREADID;
    } else {
       /* Notionally transfer the hold to thread i, whose
@@ -2006,5 +1993,5 @@ void release_one_thread_waiting_on_mutex
       /* The .count is already == 1. */
       vg_assert(VG_(threads)[i].associated_mx == mutex);
-      mutex->__m_owner = (_pthread_descr)i;
+      mutex->__vg_m_owner = (/*_pthread_descr*/void*)i;
       VG_(threads)[i].status        = VgTs_Runnable;
       VG_(threads)[i].associated_mx = NULL;
@@ -2025,5 +2012,5 @@ static
 void do_pthread_mutex_lock( ThreadId tid, 
                             Bool is_trylock, 
-                            pthread_mutex_t* mutex )
+                            vg_pthread_mutex_t* mutex )
 {
    Char  msg_buf[100];
@@ -2050,5 +2037,5 @@ void do_pthread_mutex_lock( ThreadId tid
 
    /* More paranoia ... */
-   switch (mutex->__m_kind) {
+   switch (mutex->__vg_m_kind) {
 #     ifndef GLIBC_2_1
       case PTHREAD_MUTEX_TIMED_NP:
@@ -2060,5 +2047,5 @@ void do_pthread_mutex_lock( ThreadId tid
       case PTHREAD_MUTEX_RECURSIVE_NP:
       case PTHREAD_MUTEX_ERRORCHECK_NP:
-         if (mutex->__m_count >= 0) break;
+         if (mutex->__vg_m_count >= 0) break;
          /* else fall thru */
       default:
@@ -2069,6 +2056,6 @@ void do_pthread_mutex_lock( ThreadId tid
    }
 
-   if (mutex->__m_count > 0) {
-      if (!VG_(is_valid_tid)((ThreadId)mutex->__m_owner)) {
+   if (mutex->__vg_m_count > 0) {
+      if (!VG_(is_valid_tid)((ThreadId)mutex->__vg_m_owner)) {
          VG_(record_pthread_error)( tid, 
             "pthread_mutex_lock/trylock: mutex has invalid owner");
@@ -2078,13 +2065,13 @@ void do_pthread_mutex_lock( ThreadId tid
 
       /* Someone has it already. */
-      if ((ThreadId)mutex->__m_owner == tid) {
+      if ((ThreadId)mutex->__vg_m_owner == tid) {
          /* It's locked -- by me! */
-         if (mutex->__m_kind == PTHREAD_MUTEX_RECURSIVE_NP) {
+         if (mutex->__vg_m_kind == PTHREAD_MUTEX_RECURSIVE_NP) {
             /* return 0 (success). */
-            mutex->__m_count++;
+            mutex->__vg_m_count++;
             SET_PTHREQ_RETVAL(tid, 0);
             if (0)
                VG_(printf)("!!!!!! tid %d, mx %p -> locked %d\n", 
-                           tid, mutex, mutex->__m_count);
+                           tid, mutex, mutex->__vg_m_count);
             return;
          } else {
@@ -2098,5 +2085,5 @@ void do_pthread_mutex_lock( ThreadId tid
          /* Someone else has it; we have to wait.  Mark ourselves
             thusly. */
-         /* GUARD: __m_count > 0 && __m_owner is valid */
+         /* GUARD: __vg_m_count > 0 && __vg_m_owner is valid */
          if (is_trylock) {
             /* caller is polling; so return immediately. */
@@ -2119,11 +2106,11 @@ void do_pthread_mutex_lock( ThreadId tid
    } else {
       /* Nobody owns it.  Sanity check ... */
-      vg_assert(mutex->__m_owner == VG_INVALID_THREADID);
+      vg_assert(mutex->__vg_m_owner == VG_INVALID_THREADID);
 
       VG_TRACK ( pre_mutex_lock, tid, mutex );
 
       /* We get it! [for the first time]. */
-      mutex->__m_count = 1;
-      mutex->__m_owner = (_pthread_descr)tid;
+      mutex->__vg_m_count = 1;
+      mutex->__vg_m_owner = (/*_pthread_descr*/void*)tid;
 
       /* return 0 (success). */
@@ -2137,5 +2124,5 @@ void do_pthread_mutex_lock( ThreadId tid
 static
 void do_pthread_mutex_unlock ( ThreadId tid,
-                               pthread_mutex_t* mutex )
+                               vg_pthread_mutex_t* mutex )
 {
    Char msg_buf[100];
@@ -2159,12 +2146,12 @@ void do_pthread_mutex_unlock ( ThreadId 
    /* If this was locked before the dawn of time, pretend it was
       locked now so that it balances with unlocks */
-   if (mutex->__m_kind & VG_PTHREAD_PREHISTORY) {
-      mutex->__m_kind &= ~VG_PTHREAD_PREHISTORY;
-      VG_TRACK( pre_mutex_lock, (ThreadId)mutex->__m_owner, mutex );
-      VG_TRACK( post_mutex_lock, (ThreadId)mutex->__m_owner, mutex );
+   if (mutex->__vg_m_kind & VG_PTHREAD_PREHISTORY) {
+      mutex->__vg_m_kind &= ~VG_PTHREAD_PREHISTORY;
+      VG_TRACK( pre_mutex_lock, (ThreadId)mutex->__vg_m_owner, mutex );
+      VG_TRACK( post_mutex_lock, (ThreadId)mutex->__vg_m_owner, mutex );
    }
 
    /* More paranoia ... */
-   switch (mutex->__m_kind) {
+   switch (mutex->__vg_m_kind) {
 #     ifndef GLIBC_2_1    
       case PTHREAD_MUTEX_TIMED_NP:
@@ -2176,5 +2163,5 @@ void do_pthread_mutex_unlock ( ThreadId 
       case PTHREAD_MUTEX_RECURSIVE_NP:
       case PTHREAD_MUTEX_ERRORCHECK_NP:
-         if (mutex->__m_count >= 0) break;
+         if (mutex->__vg_m_count >= 0) break;
          /* else fall thru */
       default:
@@ -2186,5 +2173,5 @@ void do_pthread_mutex_unlock ( ThreadId 
 
    /* Barf if we don't currently hold the mutex. */
-   if (mutex->__m_count == 0) {
+   if (mutex->__vg_m_count == 0) {
       /* nobody holds it */
       VG_(record_pthread_error)( tid, 
@@ -2194,5 +2181,5 @@ void do_pthread_mutex_unlock ( ThreadId 
    }
 
-   if ((ThreadId)mutex->__m_owner != tid) {
+   if ((ThreadId)mutex->__vg_m_owner != tid) {
       /* we don't hold it */
       VG_(record_pthread_error)( tid, 
@@ -2204,7 +2191,7 @@ void do_pthread_mutex_unlock ( ThreadId 
    /* If it's a multiply-locked recursive mutex, just decrement the
       lock count and return. */
-   if (mutex->__m_count > 1) {
-      vg_assert(mutex->__m_kind == PTHREAD_MUTEX_RECURSIVE_NP);
-      mutex->__m_count --;
+   if (mutex->__vg_m_count > 1) {
+      vg_assert(mutex->__vg_m_kind == PTHREAD_MUTEX_RECURSIVE_NP);
+      mutex->__vg_m_count --;
       SET_PTHREQ_RETVAL(tid, 0); /* success */
       return;
@@ -2213,6 +2200,6 @@ void do_pthread_mutex_unlock ( ThreadId 
    /* Now we're sure it is locked exactly once, and by the thread who
       is now doing an unlock on it.  */
-   vg_assert(mutex->__m_count == 1);
-   vg_assert((ThreadId)mutex->__m_owner == tid);
+   vg_assert(mutex->__vg_m_count == 1);
+   vg_assert((ThreadId)mutex->__vg_m_owner == tid);
 
    /* Release at max one thread waiting on this mutex. */
@@ -2228,24 +2215,9 @@ void do_pthread_mutex_unlock ( ThreadId 
    -------------------------------------------------------- */
 
-/* The relevant native types are as follows:
-   (copied from /usr/include/bits/pthreadtypes.h)
-
-   -- Conditions (not abstract because of PTHREAD_COND_INITIALIZER
-   typedef struct
-   {
-     struct _pthread_fastlock __c_lock; -- Protect against concurrent access
-     _pthread_descr __c_waiting;        -- Threads waiting on this condition
-   } pthread_cond_t;
-
-   -- Attribute for conditionally variables.
-   typedef struct
-   {
-     int __dummy;
-   } pthread_condattr_t;
-
-   #define PTHREAD_COND_INITIALIZER {__LOCK_INITIALIZER, 0}
+/* The relevant type (vg_pthread_cond_t) is in vg_include.h.
 
-   We don't use any fields of pthread_cond_t for anything at all.
-   Only the identity of the CVs is important.
+   We don't use any fields of vg_pthread_cond_t for anything at all.
+   Only the identity of the CVs is important.  (Actually, we initialise
+   __vg_c_waiting in pthread_cond_init() to VG_INVALID_THREADID.)
 
    Linux pthreads supports no attributes on condition variables, so we
@@ -2257,6 +2229,6 @@ void do_pthread_cond_timedwait_TIMEOUT (
 {
    Char             msg_buf[100];
-   pthread_mutex_t* mx;
-   pthread_cond_t*  cv;
+   vg_pthread_mutex_t* mx;
+   vg_pthread_cond_t*  cv;
 
    vg_assert(VG_(is_valid_tid)(tid) 
@@ -2268,13 +2240,13 @@ void do_pthread_cond_timedwait_TIMEOUT (
    vg_assert(cv != NULL);
 
-   if (mx->__m_owner == VG_INVALID_THREADID) {
+   if (mx->__vg_m_owner == VG_INVALID_THREADID) {
       /* Currently unheld; hand it out to thread tid. */
-      vg_assert(mx->__m_count == 0);
+      vg_assert(mx->__vg_m_count == 0);
       VG_(threads)[tid].status        = VgTs_Runnable;
       SET_PTHREQ_RETVAL(tid, ETIMEDOUT);  /* pthread_cond_wait return value */
       VG_(threads)[tid].associated_cv = NULL;
       VG_(threads)[tid].associated_mx = NULL;
-      mx->__m_owner = (_pthread_descr)tid;
-      mx->__m_count = 1;
+      mx->__vg_m_owner = (/*_pthread_descr*/void*)tid;
+      mx->__vg_m_count = 1;
 
       VG_TRACK( post_mutex_lock, tid, mx );
@@ -2282,5 +2254,5 @@ void do_pthread_cond_timedwait_TIMEOUT (
       if (VG_(clo_trace_pthread_level) >= 1) {
          VG_(sprintf)(msg_buf, 
-            "pthread_cond_timedwai cv %p: TIMEOUT with mx %p", 
+            "pthread_cond_timedwait cv %p: TIMEOUT with mx %p", 
             cv, mx );
          print_pthread_event(tid, msg_buf);
@@ -2288,5 +2260,5 @@ void do_pthread_cond_timedwait_TIMEOUT (
    } else {
       /* Currently held.  Make thread tid be blocked on it. */
-      vg_assert(mx->__m_count > 0);
+      vg_assert(mx->__vg_m_count > 0);
       VG_TRACK( pre_mutex_lock, tid, mx );
 
@@ -2297,5 +2269,5 @@ void do_pthread_cond_timedwait_TIMEOUT (
       if (VG_(clo_trace_pthread_level) >= 1) {
          VG_(sprintf)(msg_buf, 
-            "pthread_cond_timedwai cv %p: TIMEOUT -> BLOCK for mx %p", 
+            "pthread_cond_timedwait cv %p: TIMEOUT -> BLOCK for mx %p", 
             cv, mx );
          print_pthread_event(tid, msg_buf);
@@ -2306,5 +2278,5 @@ void do_pthread_cond_timedwait_TIMEOUT (
 
 static
-void release_N_threads_waiting_on_cond ( pthread_cond_t* cond, 
+void release_N_threads_waiting_on_cond ( vg_pthread_cond_t* cond, 
                                          Int n_to_release, 
                                          Char* caller )
@@ -2312,5 +2284,5 @@ void release_N_threads_waiting_on_cond (
    Int              i;
    Char             msg_buf[100];
-   pthread_mutex_t* mx;
+   vg_pthread_mutex_t* mx;
 
    while (True) {
@@ -2338,12 +2310,12 @@ void release_N_threads_waiting_on_cond (
       VG_TRACK( pre_mutex_lock, i, mx );
 
-      if (mx->__m_owner == VG_INVALID_THREADID) {
+      if (mx->__vg_m_owner == VG_INVALID_THREADID) {
          /* Currently unheld; hand it out to thread i. */
-         vg_assert(mx->__m_count == 0);
+         vg_assert(mx->__vg_m_count == 0);
          VG_(threads)[i].status        = VgTs_Runnable;
          VG_(threads)[i].associated_cv = NULL;
          VG_(threads)[i].associated_mx = NULL;
-         mx->__m_owner = (_pthread_descr)i;
-         mx->__m_count = 1;
+         mx->__vg_m_owner = (/*_pthread_descr*/void*)i;
+         mx->__vg_m_count = 1;
          /* .m_edx already holds pth_cond_wait success value (0) */
 
@@ -2358,5 +2330,5 @@ void release_N_threads_waiting_on_cond (
       } else {
          /* Currently held.  Make thread i be blocked on it. */
-         vg_assert(mx->__m_count > 0);
+         vg_assert(mx->__vg_m_count > 0);
          VG_(threads)[i].status        = VgTs_WaitMX;
          VG_(threads)[i].associated_cv = NULL;
@@ -2379,6 +2351,6 @@ void release_N_threads_waiting_on_cond (
 static
 void do_pthread_cond_wait ( ThreadId tid,
-                            pthread_cond_t *cond, 
-                            pthread_mutex_t *mutex,
+                            vg_pthread_cond_t *cond, 
+                            vg_pthread_mutex_t *mutex,
                             UInt ms_end )
 {
@@ -2407,5 +2379,5 @@ void do_pthread_cond_wait ( ThreadId tid
 
    /* More paranoia ... */
-   switch (mutex->__m_kind) {
+   switch (mutex->__vg_m_kind) {
 #     ifndef GLIBC_2_1    
       case PTHREAD_MUTEX_TIMED_NP:
@@ -2417,5 +2389,5 @@ void do_pthread_cond_wait ( ThreadId tid
       case PTHREAD_MUTEX_RECURSIVE_NP:
       case PTHREAD_MUTEX_ERRORCHECK_NP:
-         if (mutex->__m_count >= 0) break;
+         if (mutex->__vg_m_count >= 0) break;
          /* else fall thru */
       default:
@@ -2427,6 +2399,6 @@ void do_pthread_cond_wait ( ThreadId tid
 
    /* Barf if we don't currently hold the mutex. */
-   if (mutex->__m_count == 0 /* nobody holds it */
-       || (ThreadId)mutex->__m_owner != tid /* we don't hold it */) {
+   if (mutex->__vg_m_count == 0 /* nobody holds it */
+       || (ThreadId)mutex->__vg_m_owner != tid /* we don't hold it */) {
          VG_(record_pthread_error)( tid, 
             "pthread_cond_wait/timedwait: mutex is unlocked "
@@ -2459,5 +2431,5 @@ static
 void do_pthread_cond_signal_or_broadcast ( ThreadId tid, 
                                            Bool broadcast,
-                                           pthread_cond_t *cond )
+                                           vg_pthread_cond_t *cond )
 {
    Char  msg_buf[100];
@@ -3011,6 +2983,6 @@ void do_client_request ( ThreadId tid )
       case VG_USERREQ__PTHREAD_COND_WAIT:
          do_pthread_cond_wait( tid, 
-                               (pthread_cond_t *)(arg[1]),
-                               (pthread_mutex_t *)(arg[2]),
+                               (vg_pthread_cond_t *)(arg[1]),
+                               (vg_pthread_mutex_t *)(arg[2]),
                                0xFFFFFFFF /* no timeout */ );
          break;
@@ -3018,6 +2990,6 @@ void do_client_request ( ThreadId tid )
       case VG_USERREQ__PTHREAD_COND_TIMEDWAIT:
          do_pthread_cond_wait( tid, 
-                               (pthread_cond_t *)(arg[1]),
-                               (pthread_mutex_t *)(arg[2]),
+                               (vg_pthread_cond_t *)(arg[1]),
+                               (vg_pthread_mutex_t *)(arg[2]),
                                arg[3] /* timeout millisecond point */ );
          break;
@@ -3027,5 +2999,5 @@ void do_client_request ( ThreadId tid )
             tid, 
             False, /* signal, not broadcast */
-            (pthread_cond_t *)(arg[1]) );
+            (vg_pthread_cond_t *)(arg[1]) );
          break;
 
@@ -3034,5 +3006,5 @@ void do_client_request ( ThreadId tid )
             tid, 
             True, /* broadcast, not signal */
-            (pthread_cond_t *)(arg[1]) );
+            (vg_pthread_cond_t *)(arg[1]) );
          break;
 
@@ -3277,6 +3249,6 @@ static
 void scheduler_sanity ( void )
 {
-   pthread_mutex_t* mx;
-   pthread_cond_t*  cv;
+   vg_pthread_mutex_t* mx;
+   vg_pthread_cond_t*  cv;
    Int              i;
    struct timeout*  top;
@@ -3317,7 +3289,7 @@ void scheduler_sanity ( void )
          vg_assert(cv == NULL);
          /* 1 */ vg_assert(mx != NULL);
-         /* 2 */ vg_assert(mx->__m_count > 0);
-         /* 3 */ vg_assert(VG_(is_valid_tid)((ThreadId)mx->__m_owner));
-         /* 4 */ vg_assert((UInt)i != (ThreadId)mx->__m_owner); 
+         /* 2 */ vg_assert(mx->__vg_m_count > 0);
+         /* 3 */ vg_assert(VG_(is_valid_tid)((ThreadId)mx->__vg_m_owner));
+         /* 4 */ vg_assert((UInt)i != (ThreadId)mx->__vg_m_owner); 
       } else 
       if (VG_(threads)[i].status == VgTs_WaitCV) {

CVS commit by nethercote: 

Adjust vg_pthread_cond_t so it works with an older glibc.


  M +8 -3      vg_include.h   1.184


--- valgrind/coregrind/vg_include.h  #1.183:1.184
@@ -672,8 +672,13 @@ typedef struct
   struct _vg_pthread_fastlock __vg_c_lock; /* Protect against concurrent access */
   /*_pthread_descr*/ void* __vg_c_waiting;        /* Threads waiting on this condition */
+
+  // Nb: the following padding removed because it was missing from an
+  // earlier glibc, so the size test in the CONVERT macro was failing.
+  // --njn
+
   // Padding ensures the size is 48 bytes
-  char __vg_padding[48 - sizeof(struct _vg_pthread_fastlock)
+  /*char __vg_padding[48 - sizeof(struct _vg_pthread_fastlock)
          - sizeof(void*) - sizeof(long long)];
-  long long __vg_align;
+  long long __vg_align;*/
 } vg_pthread_cond_t;

CVS commit by mueller: 

remove arch subdir for 2.1.1 release


  M +1 -1      Makefile.am   1.68


--- valgrind/coregrind/Makefile.am  #1.67:1.68
@@ -1,4 +1,4 @@
 
-SUBDIRS = x86 demangle arch . docs
+SUBDIRS = x86 demangle . docs
 
 add_includes = -I$(srcdir)/demangle -I$(top_srcdir)/include -I$(srcdir)/x86

CVS commit by fitzhardinge: 

Fix assertion failure when using VG_(system) near program termination.
The problem is that the use of VG_(system) causes a SIGCHLD to be sent
to the process, which ends up being delivered to one of the proxy LWPs
(which is a small problem in itself, but nothing too bad).

The proxy tells the scheduler LWP about this, and the scheduler LWP sends
a sigACK reply.

Then, while the proxy LWP is in the SigACK state, and the SigACK reply
is still queued in the message pipe, the scheduler LWP starts shutting
Valgrind down, and sends a SIGVGKILL to all proxy LWPs.  This causes
the proxy to drop from sigACK state to WaitReq state, and it reads
further commands - one of which is the SigACK message - this causes the
assertion failure.

The fix is to simply make the proxy LWP exit immediately when it gets
a SIGVGKILL, and not process any more requests.

This change also fixes a bug in VG_(system), in which the child process
returns back into Valgrind rather than exiting when exec fails.


  M +3 -3      vg_mylibc.c   1.71
  M +5 -4      vg_proxylwp.c   1.14


--- valgrind/coregrind/vg_mylibc.c  #1.70:1.71
@@ -1626,8 +1626,8 @@ Int VG_(system) ( Char* cmd )
 
       /* If we're still alive here, execve failed. */
-      return -1;
+      VG_(exit)(1);
    } else {
       /* parent */
-      res = VG_(do_syscall)(__NR_waitpid, pid, (UInt)NULL, 0);
+      res = VG_(waitpid)(pid, NULL, 0);
       if (VG_(is_kerror)(res)) {
          return -1;

--- valgrind/coregrind/vg_proxylwp.c  #1.13:1.14
@@ -520,9 +520,10 @@ static Int proxylwp(void *v)
          } else {
             /* We got VKI_SIGVGKILL, which means we just skip all the
-               below and get back to the state machine - probably to
-               exit. */
+               below and exit.  (Don't bother dealing with any pending
+               requests, because we'll probably just get confused.) */
             px->state = PXS_WaitReq;
             px->siginfo.si_signo = 0;
-            goto state_machine;
+            ret = 0;
+            goto out;
          }
 
@@ -629,5 +630,5 @@ static Int proxylwp(void *v)
       }
 
-     state_machine:
+      /* state_machine: */
       px_printf("proxylwp main: state %s\n", pxs_name(px->state));

CVS commit by fitzhardinge: 

Don't intercept mmap yet, until everything else is in place to deal
with it.


  M +2 -0      vg_glibc.c   1.2


--- valgrind/coregrind/vg_glibc.c  #1.1:1.2
@@ -34,6 +34,8 @@ void *sbrk(ptrdiff_t inc)
 int __sbrk(void *) __attribute__((alias ("sbrk")));
 
+#if 0
 void *mmap(void *addr, size_t len, int prot, int flags, int fd, __off_t offset)
 {
    return VG_(mmap)(addr, len, prot, flags, fd, offset);
 }
+#endif

On Tue, 2 Mar 2004, Jeremy Fitzhardinge wrote:

> Fix assertion failure when using VG_(system) near program termination.

Ah, great!  This fixes bugs.kde.org/show_bug.cgi?id=76004 for me.  Thanks,
Jeremy.

N

CVS commit by fitzhardinge: 

Fix bug 76780 - implement stabs type '@' for pointer to member.


  M +41 -23    vg_stabs.c   1.7


--- valgrind/coregrind/vg_stabs.c  #1.6:1.7
@@ -301,33 +301,39 @@ static StabType *getStabType(StabTypeTab
 }
 
-static Bool isdigit(Char c, Int base, Int *v)
+static Bool isdigit(Char c, Int base, Int *vp)
 {
+   Bool ret = False;
+   Int v = 0;
+
    switch(base) {
    case 10:
    case 0:
-      *v = c - '0';
-      return c >= '0' && c <= '9';
+      v = c - '0';
+      ret = (c >= '0' && c <= '9');
+      break;
 
    case 8:
-      *v = c - '0';
-      return c >= '0' && c <= '7';
+      v = c - '0';
+      ret = (c >= '0' && c <= '7');
+      break;
 
    case 16:
       if (c >= '0' && c <= '9') {
-         *v = c - '0';
-         return True;
-      }
-      if (c >= 'a' && c <= 'f') {
-         *v = c - 'a';
-         return True;
-      }
-      if (c >= 'A' && c <= 'F') {
-         *v = c - 'F';
-         return True;
+         v = c - '0';
+         ret = True;
+      } else if (c >= 'a' && c <= 'f') {
+         v = c - 'a';
+         ret = True;
+      } else if (c >= 'A' && c <= 'F') {
+         v = c - 'F';
+         ret = True;
       }
-      return False;
+      break;
    }
 
-   return False;
+   if (vp && ret)
+      *vp = v;
+
+   return ret;
 }
 
@@ -535,6 +541,9 @@ static SymType *stabtype_parser(SegInfo 
             VG_(printf)("defining type %p (%d,%d) = %s\n", symtype, file, sym, p);
 
-         /* skip type attributes */
-         while(*p == '@')
+         /* Skip type attributes
+            '@' could also be pointer-to-member, so we need to see if
+            the following character looks like a type reference or not.
+          */
+         while(*p == '@' && !(VG_(isdigit)(p[1]) || p[1] == '-' || p[1] == '(') )
             p = SKIPPAST(p+1, ';', "type attrib");
 
@@ -645,5 +654,5 @@ static SymType *stabtype_parser(SegInfo 
    case '&':                    /* reference */
    case '*': {                  /* pointer */
-      /* '*' TYPE */
+      /* ('*' | '&') TYPE */
       type = stabtype_parser(si, NULL, &p);
       type = VG_(st_mkpointer)(def, type);
@@ -653,5 +662,5 @@ static SymType *stabtype_parser(SegInfo 
    case 'k':                    /* const */
    case 'B': {                  /* volatile */
-      /* 'k' TYPE */
+      /* ('k' | 'B') TYPE */
       type = stabtype_parser(si, NULL, &p);
       break;
@@ -702,5 +711,5 @@ static SymType *stabtype_parser(SegInfo 
    case 'P':                    /* packed array */
    case 'a': {                  /* array */
-      /* a IDX-TYPE TYPE */
+      /* ( 'a' | 'P' ) IDX-TYPE TYPE */
       SymType *idxtype;
       SymType *artype;
@@ -733,5 +742,5 @@ static SymType *stabtype_parser(SegInfo 
       /* Gad.  Here we go:
 
-         's' SIZE
+         ( 's' | 'u' ) SIZE
                 ( '!' NBASE ',' ( VIRT PUB OFF ',' BASE-TYPE ){NBASE} )?
 
@@ -932,4 +941,13 @@ static SymType *stabtype_parser(SegInfo 
       break;
 
+   case '@':                    /* pointer to member */
+      /* '@' CLASS-TYPE ',' MEMBER-TYPE */
+      type = VG_(st_mkint)(def, sizeof(int), False); /* make it an int for our use */
+      
+      stabtype_parser(si, NULL, &p); /* CLASS-TYPE */
+      EXPECT(',', "member-pointer CLASS-TYPE");
+      stabtype_parser(si, NULL, &p); /* MEMBER-TYPE */
+      break;
+
    default:
       VG_(printf)(" @@ don't know what type '%c' is\n", t);

CVS commit by fitzhardinge: 

We need to specify some version.


  M +1 -1      valgrind.vs   1.4


--- valgrind/coregrind/valgrind.vs  #1.3:1.4
@@ -1,3 +1,3 @@
-{
+VALGRIND_2.1 {
         global:
                 vgPlain_*;

CVS commit by thughes: 

Fix the handling of libc thread specific data so that it doesn't rely on
being able to use malloc as the libc malloc tries to use thread specific
data and we wind up in a recursive nightmare.


  M +86 -113   vg_libpthread.c   1.146


--- valgrind/coregrind/vg_libpthread.c  #1.145:1.146
@@ -193,10 +193,9 @@ int is_kerror ( int res )
 #endif
 
-static
-void init_thread_specific_state ( void );
-
-static
-void init_libc_tsd_keys ( void );
+static void
+init_global_thread_specific_state ( void );
 
+static void
+init_thread_specific_state ( void );
 
 /* ---------------------------------------------------------------------
@@ -832,13 +831,4 @@ void thread_wrapper ( NewThreadInfo* inf
    init_thread_specific_state();
 
-#  ifdef GLIBC_2_3
-   /* Set this thread's locale to the global (default) locale.  A hack
-      in support of glibc-2.3.  This does the biz for the all new
-      threads; the root thread is done with a horrible hack in
-      init_libc_tsd_keys() below.
-   */
-   __uselocale(LC_GLOBAL_LOCALE);
-#  endif
-
    /* The root function might not return.  But if it does we simply
       move along to thread_exit_wrapper.  All other ways out for the
@@ -893,7 +883,8 @@ pthread_create (pthread_t *__restrict __
    ensure_valgrind("pthread_create");
 
-   /* make sure the tsd keys, and hence locale info, are initialised
-      before we get into complications making new threads. */
-   init_libc_tsd_keys();
+   /* make sure the tsd keys, and hence locale info, for the root
+      thread are initialised before we get into complications making
+      new threads. */
+   init_global_thread_specific_state();
 
    /* Allocate space for the arg block.  thread_wrapper will free
@@ -1870,4 +1861,14 @@ void __pthread_initialize ( void )
 #include <resolv.h>
 
+/* The allowable libc TSD keys (indices) from glibc source. */
+enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0,
+                        _LIBC_TSD_KEY_DL_ERROR,
+                        _LIBC_TSD_KEY_RPC_VARS,
+                        _LIBC_TSD_KEY_LOCALE,
+                        _LIBC_TSD_KEY_CTYPE_B,
+                        _LIBC_TSD_KEY_CTYPE_TOLOWER,
+                        _LIBC_TSD_KEY_CTYPE_TOUPPER,
+                        _LIBC_TSD_KEY_N };
+
 typedef
    struct {
@@ -1878,4 +1879,5 @@ typedef
      int                h_errno_data;
      struct __res_state res_state_data;
+     void               *libc_specifics[_LIBC_TSD_KEY_N];
    }
    ThreadSpecificState;
@@ -1883,12 +1885,66 @@ typedef
 static ThreadSpecificState thread_specific_state[VG_N_THREADS];
 
-static
-void init_thread_specific_state ( void )
+/* Auto-initialising subsystem.  global_init_done is set 
+   after initialisation.  global_init_done_mx guards it. */
+static int             global_init_done    = 0;
+static pthread_mutex_t global_init_done_mx = PTHREAD_MUTEX_INITIALIZER;
+
+static void
+init_global_thread_specific_state ( void )
+{
+   int res;
+
+   /* Don't fall into deadlock if we get called again whilst we still
+      hold the lock, via the __uselocale() call herein. */
+   if (global_init_done != 0)
+      return;
+
+   /* Take the lock. */
+   res = __pthread_mutex_lock(&global_init_done_mx);
+   if (res != 0) barf("init_global_thread_specific_state: lock");
+
+   /* Now test again, to be sure there is no mistake. */
+   if (global_init_done != 0) {
+      res = __pthread_mutex_unlock(&global_init_done_mx);
+      if (res != 0) barf("init_global_thread_specific_state: unlock(1)");
+      return;
+   }
+   
+   /* assert that we are the root thread. */
+   my_assert(pthread_self() == 1);
+
+   /* Initialise thread specific data for the root thread. */
+   init_thread_specific_state();
+
+   /* Signify init done. */
+   global_init_done = 1;
+
+   /* Unlock and return. */
+   res = __pthread_mutex_unlock(&global_init_done_mx);
+   if (res != 0) barf("init_global_thread_specific_state: unlock");
+}
+
+static void
+init_thread_specific_state ( void )
 {
   int tid = pthread_self();
+   int i;
   
+   /* Initialise the errno and resolver state pointers. */
    thread_specific_state[tid].errno_ptr = NULL;
    thread_specific_state[tid].h_errno_ptr = NULL;
    thread_specific_state[tid].res_state_ptr = NULL;
+
+   /* Initialise the per-thread libc data. */
+   for (i = 0; i < _LIBC_TSD_KEY_N; i++) {
+      thread_specific_state[tid].libc_specifics[i] = NULL;
+   }
+
+#  ifdef GLIBC_2_3
+   /* Set this thread's locale to the global (default) locale.  A hack
+      in support of glibc-2.3.
+   */
+   __uselocale(LC_GLOBAL_LOCALE);
+#  endif
 }
 
@@ -1965,94 +2021,14 @@ struct __res_state* __res_state ( void )
    ------------------------------------------------ */
 
-/* Relies on assumption that initial private data is NULL.  This
-   should be fixed somehow. */
-
-/* The allowable keys (indices) (all 3 of them). 
-   From sysdeps/pthread/bits/libc-tsd.h
-*/
-/* as per glibc anoncvs HEAD of 20021001. */
-enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0,
-                        _LIBC_TSD_KEY_DL_ERROR,
-                        _LIBC_TSD_KEY_RPC_VARS,
-                        _LIBC_TSD_KEY_LOCALE,
-                        _LIBC_TSD_KEY_CTYPE_B,
-                        _LIBC_TSD_KEY_CTYPE_TOLOWER,
-                        _LIBC_TSD_KEY_CTYPE_TOUPPER,
-                        _LIBC_TSD_KEY_N };
-
-/* Auto-initialising subsystem.  libc_specifics_inited is set 
-   after initialisation.  libc_specifics_inited_mx guards it. */
-static int             libc_specifics_inited    = 0;
-static pthread_mutex_t libc_specifics_inited_mx = PTHREAD_MUTEX_INITIALIZER;
-
-
-/* These are the keys we must initialise the first time. */
-static pthread_key_t libc_specifics_keys[_LIBC_TSD_KEY_N];
-
-
-/* Initialise the keys, if they are not already initialised. */
-static
-void init_libc_tsd_keys ( void )
-{
-   int res, i;
-   pthread_key_t k;
-
-   /* Don't fall into deadlock if we get called again whilst we still
-      hold the lock, via the __uselocale() call herein. */
-   if (libc_specifics_inited != 0)
-      return;
-
-   /* Take the lock. */
-   res = __pthread_mutex_lock(&libc_specifics_inited_mx);
-   if (res != 0) barf("init_libc_tsd_keys: lock");
-
-   /* Now test again, to be sure there is no mistake. */
-   if (libc_specifics_inited != 0) {
-      res = __pthread_mutex_unlock(&libc_specifics_inited_mx);
-      if (res != 0) barf("init_libc_tsd_keys: unlock(1)");
-      return;
-   }
-
-   /* Actually do the initialisation. */
-   /* printf("INIT libc specifics\n"); */
-   for (i = 0; i < _LIBC_TSD_KEY_N; i++) {
-      res = __pthread_key_create(&k, NULL);
-      if (res != 0) barf("init_libc_tsd_keys: create");
-      libc_specifics_keys[i] = k;
-   }
-
-   /* Signify init done. */
-   libc_specifics_inited = 1;
-
-#  ifdef GLIBC_2_3
-   /* Set the initialising thread's locale to the global (default)
-      locale.  A hack in support of glibc-2.3.  This does the biz for
-      the root thread.  For all other threads we run this in
-      thread_wrapper(), which does the real work of
-      pthread_create(). */
-   /* assert that we are the root thread.  I don't know if this is
-      really a valid assertion to make; if it breaks I'll reconsider
-      it. */
-   my_assert(pthread_self() == 1);
-   __uselocale(LC_GLOBAL_LOCALE);
-#  endif
-
-   /* Unlock and return. */
-   res = __pthread_mutex_unlock(&libc_specifics_inited_mx);
-   if (res != 0) barf("init_libc_tsd_keys: unlock");
-}
-
-
 static int
 libc_internal_tsd_set ( enum __libc_tsd_key_t key, 
                         const void * pointer )
 {
-   int res;
+   int tid = pthread_self();
    /* printf("SET SET SET key %d ptr %p\n", key, pointer); */
    if (key < _LIBC_TSD_KEY_MALLOC || key >= _LIBC_TSD_KEY_N)
       barf("libc_internal_tsd_set: invalid key");
-   init_libc_tsd_keys();
-   res = __pthread_setspecific(libc_specifics_keys[key], pointer);
-   if (res != 0) barf("libc_internal_tsd_set: setspecific failed");
+   init_global_thread_specific_state();
+   thread_specific_state[tid].libc_specifics[key] = (void *)pointer;
    return 0;
 }
@@ -2061,12 +2037,10 @@ static void *
 libc_internal_tsd_get ( enum __libc_tsd_key_t key )
 {
-   void* v;
+   int tid = pthread_self();
    /* printf("GET GET GET key %d\n", key); */
    if (key < _LIBC_TSD_KEY_MALLOC || key >= _LIBC_TSD_KEY_N)
       barf("libc_internal_tsd_get: invalid key");
-   init_libc_tsd_keys();
-   v = __pthread_getspecific(libc_specifics_keys[key]);
-   /* if (v == NULL) barf("libc_internal_tsd_set: getspecific failed"); */
-   return v;
+   init_global_thread_specific_state();
+   return thread_specific_state[tid].libc_specifics[key];
 }
 
@@ -2086,11 +2060,10 @@ static void**
 libc_internal_tsd_address ( enum __libc_tsd_key_t key )
 {
-   void** v;
+   int tid = pthread_self();
    /* printf("ADDR ADDR ADDR key %d\n", key); */
    if (key < _LIBC_TSD_KEY_MALLOC || key >= _LIBC_TSD_KEY_N)
       barf("libc_internal_tsd_address: invalid key");
-   init_libc_tsd_keys();
-   v = __pthread_getspecific_addr(libc_specifics_keys[key]);
-   return v;
+   init_global_thread_specific_state();
+   return &thread_specific_state[tid].libc_specifics[key];
 }

CVS commit by thughes: 

Remove function which is no longer used following the changes to
the handling of libc thread specific data.


  M +0 -16     vg_libpthread.c   1.147


--- valgrind/coregrind/vg_libpthread.c  #1.146:1.147
@@ -1675,20 +1675,4 @@ void * __pthread_getspecific(pthread_key
 
 
-#ifdef GLIBC_2_3
-static
-void ** __pthread_getspecific_addr(pthread_key_t key)
-{
-   void** specifics_ptr;
-   ensure_valgrind("pthread_getspecific_addr");
-
-   if (!key_is_valid(key))
-      return NULL;
-
-   specifics_ptr = get_or_allocate_specifics_ptr(pthread_self());
-   return &(specifics_ptr[key]);
-}
-#endif
-
-
 /* ---------------------------------------------------
    ONCEry

CVS commit by fitzhardinge: 

Cope with strange templated symbol names containing quoted ':'.


  M +30 -40    vg_stabs.c   1.8


--- valgrind/coregrind/vg_stabs.c  #1.7:1.8
@@ -403,10 +403,31 @@ static UInt atou(Char **pp, Int base)
 }
 
-/* Skip to end of name (':'); "::" in the name indicate nesting, and
-   are included within the name */
-static Char *nested_name(Char *p) {
-   while(*p && (p[0] != ':' || p[1] == ':')) {
-      if (*p == ':')
+/* Skip a ':'-delimited name which may have ::, 'char' or other things in
+   <> brackets */
+static Char *templ_name(Char *p)
+{
+   Int brac = 0;
+
+   for(;;) {
+      if (*p == '<')
+         brac++;
+      if (*p == '>')
+         brac--;
+      /* skip quoted character (note, it could be anything, even a
+         literal \0)
+
+         XXX This is a complete botch; we can't do anything sane here,
+         like support \-quoting, because gcc doesn't seem to generate
+         it, and even if it did, we wouldn't know what "'\'" means -
+         the begining of '\'' or a char in itself ('\\')?
+       */
+      if (brac && p[0] == '\'' && p[2] == '\'')
+         p += 3;
+      if (*p == ':') {
+         if (brac && p[1] == ':')
          p++;
+         else
+            break;
+      }
       p++;
    }
@@ -669,22 +690,8 @@ static SymType *stabtype_parser(SegInfo 
    case 'x': {                  /* reference to undefined type */
       /* 'x' ('s' | 'u' | 'e') NAME ':' */
-      Int brac = 0;             /* < > brackets in type */
       Char kind = *p++;         /* get kind */
       Char *name = p;
 
-      /* name is delimited by : except for :: within <> */
-      for(;;) {
-         if (*p == '<')
-            brac++;
-         if (*p == '>')
-            brac--;
-         if (*p == ':') {
-            if (brac && p[1] == ':')
-               p += 1;
-            else
-               break;
-         }
-         p++;
-      }
+      p = templ_name(name);
       EXPECT(':', "struct/union/enum ref");
 
@@ -785,23 +792,6 @@ static SymType *stabtype_parser(SegInfo 
          UInt off, sz;
          SymType *fieldty;
-         Int templ=0;
-
-         /* Skip past field name, which ends with ':' or '::' - but
-            '::' can appear within a template-mangled name, so keep
-            track of '<' and '>'. */
-         end = p;
-         while(*end) {
-             Char ch = *end++;
 
-             if (ch == '<')
-                 templ++;
-             else if (ch == '>')
-                 templ--;
-             else if (templ == 0 && ch == ':') {
-                 end--;
-                 break;
-             }
-         }
-         /* XXX check for *end != ':' */
+         end = templ_name(p);
 
          if (end[1] == ':') {
@@ -981,5 +971,5 @@ static Bool initSym(SegInfo *si, Sym *sy
                   si, si->stab_typetab, sym, kind, name, name, val);
 
-   ty = nested_name(name);
+   ty = templ_name(name);
 
    len = ty - name;

CVS commit by fitzhardinge: 

Raise RLIMIT_AS to max allowable, so that we can create the large mappings
we need to.  If the hard limit is set to low, then things will fail as
large mmaps fail.


  M +8 -0      stage1.c   1.8


--- valgrind/coregrind/stage1.c  #1.7:1.8
@@ -39,4 +39,5 @@
 #include <fcntl.h>
 #include <errno.h>
+#include <sys/resource.h>
 
 #include "vg_include.h"
@@ -197,4 +198,5 @@ static void hoops(void)
 int main(int argc, char **argv)
 {
+   struct rlimit rlim;
    const char *cp = getenv(VALGRINDLIB);
 
@@ -206,4 +208,10 @@ int main(int argc, char **argv)
    our_argc = argc;
 
+   /* Set the address space limit as high as it will go, since we make
+      a lot of very large mappings. */
+   getrlimit(RLIMIT_AS, &rlim);
+   rlim.rlim_cur = rlim.rlim_max;
+   setrlimit(RLIMIT_AS, &rlim);
+
    /* move onto another stack so we can play with the main one */
    ume_go((addr_t)hoops, (addr_t)stack + sizeof(stack));

CVS commit by fitzhardinge: 

Oops, passing wrong thing to st_mkarray


  M +1 -1      vg_stabs.c   1.10


--- valgrind/coregrind/vg_stabs.c  #1.9:1.10
@@ -722,5 +722,5 @@ static SymType *stabtype_parser(SegInfo 
       typeinfo = stabtype_parser(si, NULL, &p);
 
-      type = VG_(st_mkarray)(si, typeinfo, VG_(st_mkint)(NULL, 1, True));
+      type = VG_(st_mkarray)(def, typeinfo, VG_(st_mkint)(NULL, 1, True));
       break;
    }

CVS commit by jseward: 

Partially unbreak 'make distcheck'.


  M +1 -1      Makefile.am   1.69


--- valgrind/coregrind/Makefile.am  #1.68:1.69
@@ -1,4 +1,4 @@
 
-SUBDIRS = x86 demangle . docs
+SUBDIRS = arch x86 demangle . docs
 
 add_includes = -I$(srcdir)/demangle -I$(top_srcdir)/include -I$(srcdir)/x86

On Friday 12 March 2004 02:22, Julian Seward wrote:

> Partially unbreak 'make distcheck'.

sigh, this breaks the build, as the arch subdir is in a half finished state.

CVS commit by fitzhardinge: 

Close bug 71906.  Set default malloc alignment to 8 rather than 4.


  M +1 -1      vg_malloc2.c   1.20


--- valgrind/coregrind/vg_malloc2.c  #1.19:1.20
@@ -48,5 +48,5 @@ Bool VG_(clo_trace_malloc)   = False;
 /* Minimum alignment in functions that don't specify alignment explicitly.
    default: 0, i.e. use default of the machine (== 4) */
-Int  VG_(clo_alignment) = 4;
+Int  VG_(clo_alignment) = 8;

CVS commit by mueller: 

fix up the other places as well


  M +2 -2      vg_malloc2.c   1.21
  M +12 -0     arch/x86-linux/Makefile.am   1.2
  M +1 -1      docs/coregrind_core.html   1.27


--- valgrind/coregrind/vg_malloc2.c  #1.20:1.21
@@ -47,5 +47,5 @@ Bool VG_(clo_trace_malloc)   = False;
 
 /* Minimum alignment in functions that don't specify alignment explicitly.
-   default: 0, i.e. use default of the machine (== 4) */
+   default: 0, i.e. use default of the machine (== 8) */
 Int  VG_(clo_alignment) = 8;
 
@@ -87,5 +87,5 @@ void VG_(replacement_malloc_print_usage)
    VG_(printf)(
 "    --sloppy-malloc=no|yes    round malloc sizes to next word? [no]\n"
-"    --alignment=<number>      set minimum alignment of allocations [4]\n"
+"    --alignment=<number>      set minimum alignment of allocations [8]\n"
    );
 }

--- valgrind/coregrind/arch/x86-linux/Makefile.am  #1.1:1.2
@@ -1,2 +1,14 @@
 
+valdir = $(libdir)/valgrind
+val_PROGRAMS = libpthread.so
 
+libpthread_so_SOURCES = \
+       vg_libpthread.c \
+       vg_libpthread_unimp.c \
+       vg_syscall.S
+libpthread_so_DEPENDENCIES = $(srcdir)/vg_libpthread.vs
+libpthread_so_LDFLAGS = -Werror -fno-omit-frame-pointer -UVG_LIBDIR \
+       -shared -fpic \
+       -Wl,-version-script $(srcdir)/vg_libpthread.vs \
+       -Wl,-z,nodelete \
+       -Wl,--soname=libpthread.so.0

--- valgrind/coregrind/docs/coregrind_core.html  #1.26:1.27
@@ -711,5 +711,5 @@
 and Addrcheck), the following options apply.
 <ul>
-  <li><code>--alignment=&lt;number&gt;</code> [default: 4]<br> <p>By
+  <li><code>--alignment=&lt;number&gt;</code> [default: 8]<br> <p>By
       default Valgrind's <code>malloc</code>, <code>realloc</code>,
       etc, return 4-byte aligned addresses.  These are suitable for

On Sat, 13 Mar 2004, Jeremy Fitzhardinge wrote:

> Close bug 71906.  Set default malloc alignment to 8 rather than 4.

Um, problem with that is that non-4-byte aligned mallocs are done with
VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)().  So now
VG_(arena_malloc)() won't be used at all unless one sets --alignment=4.

This doesn't seem like the right thing to do.  Julian, you wrote the
allocator, do you have an opinion about this?

N

On Sat, 2004-03-13 at 03:30, Nicholas Nethercote wrote:
> Um, problem with that is that non-4-byte aligned mallocs are done with
> VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)().  So now
> VG_(arena_malloc)() won't be used at all unless one sets --alignment=4.

Returning unaligned pointers is worse.

	J

On Saturday 13 March 2004 11:30, Nicholas Nethercote wrote:
> On Sat, 13 Mar 2004, Jeremy Fitzhardinge wrote:
> > Close bug 71906.  Set default malloc alignment to 8 rather than 4.
>
> Um, problem with that is that non-4-byte aligned mallocs are done with
> VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)().  So now
> VG_(arena_malloc)() won't be used at all unless one sets --alignment=4.
>
> This doesn't seem like the right thing to do.  Julian, you wrote the
> allocator, do you have an opinion about this?

(historical note:) The Right Solution is to modify vg_malloc2.c so all
payload pointers come out 8-aligned.  I realised I had made a mistake 
to set the baseline alignment at 4 rather than 8 soon after this allocator
went into service, but it was already a complete rewrite of a previous
one and I couldn't be bothered to rewrite it yet again.

See "block layout" at vg_malloc2.c:145.  If the block layout is
changed to the following, and the number of red zone words is 
forced to be even, then presumably the payloads will all be 8-aligned.

     this block total sizeW   (1 word)
     freelist previous ptr    (1 word)
     red zone words (depends on .rz_szW field of Arena)
     (payload words)
     red zone words (depends on .rz_szW field of Arena)
     freelist next  ptr       (1 word)
     this block total sizeW   (1 word)

Clearly the red zone sizeW % 2 == 0 is trivial to enforce.  Question
is whether or not moving the freelist next ptr after the payload is
going to break things or not.  I suspect it will be ok.  Mostly this
will involve possibly changing the family of small functions beginning
at "mk_free_bszW" through to "bszW_to_pszW" -- all the layout knowledge
is encoded in them, I think.

There might be some complication in VG_(arena_malloc_aligned).
That's the only really nasty bit.

I suspect a couple of hours figuring this out might sort it, 
partly because it's fairly well abstracted, partly because there's
a good sanity checker, and partly because there's a standalone
test driver at the bottom of the file.  And given that we are
headed inevitably to 64bit-ville, it's necessary anyway.

J

In message <200403131748.18173.jseward@...>
          Julian Seward <jseward@...> wrote:

> I suspect a couple of hours figuring this out might sort it,
> partly because it's fairly well abstracted, partly because there's
> a good sanity checker, and partly because there's a standalone
> test driver at the bottom of the file.  And given that we are
> headed inevitably to 64bit-ville, it's necessary anyway.

On that point, anybody planning to attack this should check what
alignment glibc uses on x86-64 as it have to return 16 byte aligned
pointers due to the use of SSE for floating point values. It would
be a bit silly to rework it for 8 buyte alignment and then find we
need 16 byte alignment ;-)

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Sat, 2004-03-13 at 10:19, Tom Hughes wrote:
> On that point, anybody planning to attack this should check what
> alignment glibc uses on x86-64 as it have to return 16 byte aligned
> pointers due to the use of SSE for floating point values. It would
> be a bit silly to rework it for 8 buyte alignment and then find we
> need 16 byte alignment ;-)

Yep; that might apply to x86-32 as well.

In general we should work out how to parameterise it so that it matches
the default alignment of the default allocator for the current OS/CPU
target.

	J

> On that point, anybody planning to attack this should check what
> alignment glibc uses on x86-64 as it have to return 16 byte aligned
> pointers due to the use of SSE for floating point values. It would
> be a bit silly to rework it for 8 buyte alignment and then find we
> need 16 byte alignment ;-)

On one of our Opteron boxes, I spotted this in the posix_memalign() man
page:

       GNU  libc  malloc()  always returns 8-byte aligned memory
       addresses, so these routines are only needed if you require
       larger alignment  values.

Regards,
 Robert.

--=20
Robert Walsh
Amalgamated Durables, Inc.  -  "We don't make the things you buy."
Email: rjwalsh@...

In message <1079210999.8298.1.camel@...>
          Robert Walsh <rjwalsh@...> wrote:

> > On that point, anybody planning to attack this should check what
> > alignment glibc uses on x86-64 as it have to return 16 byte aligned
> > pointers due to the use of SSE for floating point values. It would
> > be a bit silly to rework it for 8 buyte alignment and then find we
> > need 16 byte alignment ;-)
> 
> On one of our Opteron boxes, I spotted this in the posix_memalign() man
> page:
> 
>        GNU  libc  malloc()  always returns 8-byte aligned memory
>        addresses, so these routines are only needed if you require
>        larger alignment  values.

Yep. I had a look at glibc and as far as I can see it only does 8 byte
alignment, even on x86-64.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

CVS commit by jseward: 

Modify the memory manager so it "natively" supports 8-byte alignment,
basically by messing with the block layout.

* Move freelist next ptr from before payload to after it

* Ensure payload and red zones always have sizes which are
  multiples of 8-bytes.

Seems to work OK.  Values returned from the two basic allocator
functions VG_(arena_malloc) and VG_(arena_malloc_aligned) are
vg_asserted to have suitable alignment (== 8, >= 8 && == requested
alignment) respectively.


  M +69 -37    vg_malloc2.c   1.22


--- valgrind/coregrind/vg_malloc2.c  #1.21:1.22
@@ -56,5 +56,5 @@ Bool VG_(replacement_malloc_process_cmd_
       VG_(clo_alignment) = (Int)VG_(atoll)(&arg[12]);
 
-      if (VG_(clo_alignment) < 4 
+      if (VG_(clo_alignment) < 8 
           || VG_(clo_alignment) > 4096
           || VG_(log2)( VG_(clo_alignment) ) == -1 /* not a power of 2 */) {
@@ -62,5 +62,5 @@ Bool VG_(replacement_malloc_process_cmd_
          VG_(message)(Vg_UserMsg, 
             "Invalid --alignment= setting.  "
-            "Should be a power of 2, >= 4, <= 4096.");
+            "Should be a power of 2, >= 8, <= 4096.");
          VG_(bad_option)("--alignment");
       }
@@ -147,8 +147,8 @@ typedef 
      this block total sizeW   (1 word)
      freelist previous ptr    (1 word)
-     freelist next  ptr       (1 word)
      red zone words (depends on .rz_szW field of Arena)
      (payload words)
      red zone words (depends on .rz_szW field of Arena)
+     freelist next  ptr       (1 word)
      this block total sizeW  (1 word)
 
@@ -161,4 +161,8 @@ typedef 
      is not possible, because a block always has at least four words
      of overhead.  
+
+     8-byte payload alignment is ensured by requiring the number
+     of words in the red zones and the number of payload words
+     to both be even (% 2 == 0).
 */
 typedef
@@ -210,4 +214,6 @@ void arena_init ( Arena* a, Char* name, 
 {
    Int i;
+   vg_assert(rz_szW >= 0);
+   vg_assert(rz_szW % 2 == 0);
    vg_assert((min_sblockW % VKI_WORDS_PER_PAGE) == 0);
    a->name = name;
@@ -249,4 +255,5 @@ static
 void ensure_mm_init ( void )
 {
+   Int client_rz_szW;
    static Bool init_done = False;
 
@@ -260,23 +267,27 @@ void ensure_mm_init ( void )
       zone words are unchanged. */
 
-   arena_init ( &vg_arena[VG_AR_CORE],      "core",     1, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_CORE],      "core",     2, True, 262144, False );
 
-   arena_init ( &vg_arena[VG_AR_TOOL],      "tool",     1, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_TOOL],      "tool",     2, True, 262144, False );
 
-   arena_init ( &vg_arena[VG_AR_SYMTAB],    "symtab",   1, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_SYMTAB],    "symtab",   2, True, 262144, False );
 
-   arena_init ( &vg_arena[VG_AR_JITTER],    "JITter",   1, True, 8192,   False );
+   arena_init ( &vg_arena[VG_AR_JITTER],    "JITter",   2, True, 8192,   False );
 
    /* No particular reason for this figure, it's just smallish */
    sk_assert(VG_(vg_malloc_redzone_szB) < 128);
+   sk_assert(VG_(vg_malloc_redzone_szB) >= 0);
+   client_rz_szW = VG_(vg_malloc_redzone_szB)/4;
+   if (client_rz_szW % 2 == 1) client_rz_szW++;
+
    arena_init ( &vg_arena[VG_AR_CLIENT],    "client",  
-                VG_(vg_malloc_redzone_szB)/4, False, 262144, True );
+               client_rz_szW, False, 262144, True );
 
    arena_init ( &vg_arena[VG_AR_DEMANGLE],  "demangle", 4 /*paranoid*/,
                                                            True, 16384, False );
 
-   arena_init ( &vg_arena[VG_AR_EXECTXT],   "exectxt",  1, True, 16384, False );
+   arena_init ( &vg_arena[VG_AR_EXECTXT],   "exectxt",  2, True, 16384, False );
 
-   arena_init ( &vg_arena[VG_AR_ERRORS],    "errors",   1, True, 16384, False );
+   arena_init ( &vg_arena[VG_AR_ERRORS],    "errors",   2, True, 16384, False );
 
    arena_init ( &vg_arena[VG_AR_TRANSIENT], "transien", 2, True, 16384, False );
@@ -324,5 +335,6 @@ Superblock* newSuperblock ( Arena* a, In
 
    if (a->clientmem) {
-      sb = (Superblock *)VG_(client_alloc)(0, cszW * sizeof(Word), 
+      sb = (Superblock *)
+           VG_(client_alloc)(0, cszW * sizeof(Word), 
                                            VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, 0);
    } else
@@ -414,5 +426,5 @@ static __inline__
 Word* first_to_payload ( Arena* a, WordF* fw )
 {
-   return & fw[3 + a->rz_szW];
+   return & fw[2 + a->rz_szW];
 }
 
@@ -422,5 +434,5 @@ static __inline__
 Word* payload_to_first ( Arena* a, WordF* payload )
 {
-   return & payload[- 3 - a->rz_szW];
+   return & payload[- (2 + a->rz_szW)];
 }
 
@@ -444,5 +456,6 @@ void set_prev_p  ( WordF* fw, Word* prev
 static __inline__
 void set_next_p  ( WordF* fw, Word* next_p ) { 
-   fw[2] = (Word)next_p; 
+   WordL* lw = first_to_last(fw); 
+   lw[-1] = (Word)next_p; 
 }
 static __inline__
@@ -452,5 +465,6 @@ Word* get_prev_p  ( WordF* fw ) { 
 static __inline__
 Word* get_next_p  ( WordF* fw ) { 
-   return (Word*)(fw[2]);
+   WordL* lw = first_to_last(fw);
+   return (Word*)(lw[-1]);
 }
 
@@ -482,5 +496,5 @@ static __inline__
 void set_rz_lo_word ( Arena* a, WordF* fw, Int rz_wordno, Word w )
 {
-   fw[3 + rz_wordno] = w;
+   fw[2 + rz_wordno] = w;
 }
 static __inline__
@@ -488,10 +502,10 @@ void set_rz_hi_word ( Arena* a, WordF* f
 {
    WordL* lw = first_to_last(fw);
-   lw[-1-rz_wordno] = w;
+   lw[-2-rz_wordno] = w;
 }
 static __inline__
 Word get_rz_lo_word ( Arena* a, WordF* fw, Int rz_wordno )
 {
-   return fw[3 + rz_wordno];
+   return fw[2 + rz_wordno];
 }
 static __inline__
@@ -499,5 +513,5 @@ Word get_rz_hi_word ( Arena* a, WordF* f
 {
    WordL* lw = first_to_last(fw);
-   return lw[-1-rz_wordno];
+   return lw[-2-rz_wordno];
 }
 
@@ -508,10 +522,10 @@ static __inline__
 Int overhead_szW_lo ( Arena* a )
 {
-   return 3 + a->rz_szW;
+   return 2 + a->rz_szW;
 }
 static __inline__
 Int overhead_szW_hi ( Arena* a )
 {
-   return 1 + a->rz_szW;
+   return 2 + a->rz_szW;
 }
 static __inline__
@@ -949,4 +963,15 @@ Bool VG_(is_empty_arena) ( ArenaId aid )
 
 
+/* Turn a request size in bytes into a payload request size in
+   words.  This means 8-aligning the request size.
+*/
+static __inline__
+Int req_pszB_to_req_pszW ( Int req_pszB )
+{
+   return ((req_pszB + 7) / 8)   /* # of 64-bit units */
+          * 2;                   /* # of 32-bit units */
+}
+
+
 /*------------------------------------------------------------*/
 /*--- Core-visible functions.                              ---*/
@@ -959,4 +984,5 @@ void* VG_(arena_malloc) ( ArenaId aid, I
    Word*       b;
    Arena*      a;
+   void*       v;
 
    VGP_PUSHCC(VgpMalloc);
@@ -968,5 +994,5 @@ void* VG_(arena_malloc) ( ArenaId aid, I
    vg_assert(req_pszB < 0x7FFFFFF0);
 
-   req_pszW = (req_pszB + VKI_BYTES_PER_WORD - 1) / VKI_BYTES_PER_WORD;
+   req_pszW = req_pszB_to_req_pszW(req_pszB);
 
    /* Keep gcc -O happy: */
@@ -1052,5 +1078,7 @@ void* VG_(arena_malloc) ( ArenaId aid, I
 
    VGP_POPCC(VgpMalloc);
-   return first_to_payload(a, b);
+   v = first_to_payload(a, b);
+   vg_assert( (((UInt)v) & 7) == 0 );
+   return v;
 }
 
@@ -1179,4 +1207,5 @@ void* VG_(arena_malloc_aligned) ( ArenaI
    UInt   saved_bytes_on_loan;
    Arena* a;
+   void*  v;
 
    VGP_PUSHCC(VgpMalloc);
@@ -1209,9 +1238,10 @@ void* VG_(arena_malloc_aligned) ( ArenaI
       power of 2 >= word size, no need to align the alignment.  Still,
       we check. */
+   if (req_alignB == 4) req_alignB = 8;
    req_alignW = req_alignB / VKI_BYTES_PER_WORD;
    vg_assert(req_alignB == req_alignW * VKI_BYTES_PER_WORD);
 
    /* Required payload size for the aligned chunk. */
-   req_pszW = (req_pszB + VKI_BYTES_PER_WORD - 1) / VKI_BYTES_PER_WORD;
+   req_pszW = req_pszB_to_req_pszW(req_pszB);
    
    /* Payload size to request for the big block that we will split
@@ -1278,5 +1308,7 @@ void* VG_(arena_malloc_aligned) ( ArenaI
    VGP_POPCC(VgpMalloc);
 
-   return align_p;
+   v = (void*)align_p;
+   vg_assert( (((UInt)v) % req_alignB) == 0 );
+   return v;
 }
 
@@ -1296,5 +1328,5 @@ void* VG_(arena_calloc) ( ArenaId aid, I
    vg_assert(size >= 0);
 
-   if (alignB == 4)
+   if (alignB == 8)
       p = VG_(arena_malloc) ( aid, size );
    else
@@ -1339,5 +1371,5 @@ void* VG_(arena_realloc) ( ArenaId aid, 
    }
 
-   if (req_alignB == 4)
+   if (req_alignB == 8)
       p_new = VG_(arena_malloc) ( aid, req_pszB );
    else
@@ -1373,10 +1405,10 @@ void  VG_(free) ( void* ptr )
 void* VG_(calloc) ( Int nmemb, Int nbytes )
 {
-   return VG_(arena_calloc) ( VG_AR_TOOL, /*alignment*/4, nmemb, nbytes );
+   return VG_(arena_calloc) ( VG_AR_TOOL, /*alignment*/8, nmemb, nbytes );
 }
 
 void* VG_(realloc) ( void* ptr, Int size )
 {
-   return VG_(arena_realloc) ( VG_AR_TOOL, ptr, /*alignment*/4, size );
+   return VG_(arena_realloc) ( VG_AR_TOOL, ptr, /*alignment*/8, size );
 }
 
@@ -1389,6 +1421,6 @@ void* VG_(malloc_aligned) ( Int req_alig
 void* VG_(cli_malloc) ( UInt align, Int nbytes )                 
 {                                                                             
-   vg_assert(align >= 4);                                                     
-   if (4 == align)                                                            
+   vg_assert(align >= 8);
+   if (8 == align)                                                            
       return VG_(arena_malloc)         ( VG_AR_CLIENT, nbytes ); 
    else

On Saturday 13 March 2004 21:19, Tom Hughes wrote:
> In message <1079210999.8298.1.camel@...>
>
>           Robert Walsh <rjwalsh@...> wrote:
> > > On that point, anybody planning to attack this should check what
> > > alignment glibc uses on x86-64 as it have to return 16 byte
> > > aligned pointers due to the use of SSE for floating point values.
> > > It would be a bit silly to rework it for 8 buyte alignment and
> > > then find we need 16 byte alignment ;-)
> >
> > On one of our Opteron boxes, I spotted this in the posix_memalign()
> > man page:
> >
> >        GNU  libc  malloc()  always returns 8-byte aligned memory
> >        addresses, so these routines are only needed if you require
> >        larger alignment  values.
>
> Yep. I had a look at glibc and as far as I can see it only does 8
> byte alignment, even on x86-64.

I don't know about amd64 but ia64 really wants 16 byte alignment for 
malloc.

On Sunday 14 March 2004 11:50, Doug Rabson wrote:

> > Yep. I had a look at glibc and as far as I can see it only does 8
> > byte alignment, even on x86-64.
>
> I don't know about amd64 but ia64 really wants 16 byte alignment for
> malloc.

Is there anybody on the list who has Linux on ia64 and can investigate
what alignment GNU malloc returns on that platform?  That would be
helpful.

J

In message <200403141250.58208.jseward@...>
          Julian Seward <jseward@...> wrote:

> On Sunday 14 March 2004 11:50, Doug Rabson wrote:
> 
> > > Yep. I had a look at glibc and as far as I can see it only does 8
> > > byte alignment, even on x86-64.
> >
> > I don't know about amd64 but ia64 really wants 16 byte alignment for
> > malloc.
> 
> Is there anybody on the list who has Linux on ia64 and can investigate
> what alignment GNU malloc returns on that platform?  That would be
> helpful.

The actual malloc in glibc appears to be capable of any reasonable
alignment, but the default is 8 byte.

This can be altered by defining MALLOC_ALIGNMENT to the required
alignment, but a grep of the glibc sources found no sign of any
platform setting that, at least in the version I looked at, which
is the version from Fedora Core 1.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

In message <79908b8f4c.work@...>
          Tom Hughes <thh@...> wrote:

> The actual malloc in glibc appears to be capable of any reasonable
> alignment, but the default is 8 byte.

Correction - it defaults to "2 * sizeof(size_t)" which will only
be eight on a 32 bit platform - on amd64 and ia64 it will be sixteen.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

> > The actual malloc in glibc appears to be capable of any reasonable
> > alignment, but the default is 8 byte.
>=20
> Correction - it defaults to "2 * sizeof(size_t)" which will only
> be eight on a 32 bit platform - on amd64 and ia64 it will be sixteen.

Golly, you mean the man pages are wrong!?  That's unheard of!

:-)

Regards,
 Robert.

--=20
Robert Walsh
Amalgamated Durables, Inc.  -  "We don't make the things you buy."
Email: rjwalsh@...

CVS commit by fitzhardinge: 

Don't bother setting the EI_OSABI entry in the core elf header, since
the kernel doesn't, nobody uses it, and RH7.2 systems don't define it.


  M +0 -1      vg_signals.c   1.61


--- valgrind/coregrind/vg_signals.c  #1.60:1.61
@@ -1308,5 +1308,4 @@ static void fill_ehdr(Elf32_Ehdr *ehdr, 
    ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
    ehdr->e_ident[EI_VERSION] = EV_CURRENT;
-   ehdr->e_ident[EI_OSABI] = ELFOSABI_LINUX;
 
    ehdr->e_type = ET_CORE;

CVS commit by fitzhardinge: 

Be a bit clearer about core-dumping messages (don't say we are if we're not)


  M +13 -7     vg_signals.c   1.62


--- valgrind/coregrind/vg_signals.c  #1.61:1.62
@@ -1717,4 +1717,16 @@ static void vg_default_action(const vki_
 
    if (terminate) {
+      if (core) {
+         /* If they set the core-size limit to zero, don't generate a
+            core file */
+         static struct vki_rlimit zero = { 0, 0 };
+         struct vki_rlimit corelim;
+         
+         VG_(getrlimit)(VKI_RLIMIT_CORE, &corelim);
+
+         if (corelim.rlim_cur == 0)
+            core = False;
+      }
+
       if (VG_(clo_verbosity) != 0 && (core || VG_(clo_verbosity) > 1)) {
          VG_(message)(Vg_UserMsg, "");
@@ -1785,10 +1797,4 @@ static void vg_default_action(const vki_
 
       if (core) {
-         static struct vki_rlimit zero = { 0, 0 };
-         struct vki_rlimit corelim;
-
-         VG_(getrlimit)(VKI_RLIMIT_CORE, &corelim);
-
-         if (corelim.rlim_cur > 0)
             make_coredump(tid, info, corelim.rlim_cur);

CVS commit by fitzhardinge: 

Ooops.  Fix overly-hasty commit.


  M +4 -2      vg_signals.c   1.63


--- valgrind/coregrind/vg_signals.c  #1.62:1.63
@@ -1717,9 +1717,9 @@ static void vg_default_action(const vki_
 
    if (terminate) {
+      struct vki_rlimit corelim;
+
       if (core) {
          /* If they set the core-size limit to zero, don't generate a
             core file */
-         static struct vki_rlimit zero = { 0, 0 };
-         struct vki_rlimit corelim;
          
          VG_(getrlimit)(VKI_RLIMIT_CORE, &corelim);
@@ -1797,4 +1797,6 @@ static void vg_default_action(const vki_
 
       if (core) {
+         static struct vki_rlimit zero = { 0, 0 };
+
          make_coredump(tid, info, corelim.rlim_cur);

CVS commit by fitzhardinge: 

Print a backtrace for core-dumping signals, even if we're not actually
dumping core.


  M +2 -1      vg_signals.c   1.64


--- valgrind/coregrind/vg_signals.c  #1.63:1.64
@@ -1718,4 +1718,5 @@ static void vg_default_action(const vki_
    if (terminate) {
       struct vki_rlimit corelim;
+      Bool could_core = core;
 
       if (core) {
@@ -1729,5 +1730,5 @@ static void vg_default_action(const vki_
       }
 
-      if (VG_(clo_verbosity) != 0 && (core || VG_(clo_verbosity) > 1)) {
+      if (VG_(clo_verbosity) != 0 && (could_core || VG_(clo_verbosity) > 1)) {
          VG_(message)(Vg_UserMsg, "");
          VG_(message)(Vg_UserMsg, "Process terminating with default action of signal %d (%s)%s",

CVS commit by fitzhardinge: 

Make the sigaltstack per-thread state, so that two threads handling a
signal at once don't share the same stack.


  M +3 -0      vg_include.h   1.186
  M +6 -1      vg_scheduler.c   1.143
  M +25 -24    vg_signals.c   1.65


--- valgrind/coregrind/vg_scheduler.c  #1.142:1.143
@@ -3307,5 +3307,10 @@ void scheduler_sanity ( void )
          stack_used = (Addr)VG_(threads)[i].stack_highest_word 
                       - (Addr)VG_(threads)[i].m_esp;
-         if (i > 1 /* not the root thread */ 
+
+         /* This test is a bit bogus - it doesn't take into account
+            alternate signal stacks, for a start.  Also, if a thread
+            has it's stack pointer somewhere strange, killing Valgrind
+            isn't the right answer. */
+         if (0 && i > 1 /* not the root thread */ 
              && stack_used 
                 >= (VG_PTHREAD_STACK_MIN - 1000 /* paranoia */)) {

--- valgrind/coregrind/vg_signals.c  #1.64:1.65
@@ -174,7 +174,4 @@ typedef 
       SCSS_Per_Signal scss_per_sig[1+VKI_KNSIG];
 
-      /* Signal delivery stack, if any. */
-      vki_kstack_t altstack;
-
       /* Additional elements to SCSS not stored here:
          - for each thread, the thread's blocking mask
@@ -457,15 +454,19 @@ void VG_(handle_SCSS_change) ( Bool forc
 
 /* True if we are on the alternate signal stack.  */
-static Int on_sig_stack ( Addr m_esp )
+static Int on_sig_stack ( ThreadId tid, Addr m_esp )
 {
-   return (m_esp - (Addr)vg_scss.altstack.ss_sp 
-           < vg_scss.altstack.ss_size);
+   ThreadState *tst = VG_(get_ThreadState)(tid);
+
+   return (m_esp - (Addr)tst->altstack.ss_sp 
+           < tst->altstack.ss_size);
 }
 
-static Int sas_ss_flags ( Addr m_esp )
+static Int sas_ss_flags ( ThreadId tid, Addr m_esp )
 {
-   return (vg_scss.altstack.ss_size == 0 
+   ThreadState *tst = VG_(get_ThreadState)(tid);
+
+   return (tst->altstack.ss_size == 0 
               ? VKI_SS_DISABLE
-              : on_sig_stack(m_esp) ? VKI_SS_ONSTACK : 0);
+              : on_sig_stack(tid, m_esp) ? VKI_SS_ONSTACK : 0);
 }
 
@@ -489,11 +490,11 @@ void VG_(do__NR_sigaltstack) ( ThreadId 
 
    if (oss != NULL) {
-      oss->ss_sp    = vg_scss.altstack.ss_sp;
-      oss->ss_size  = vg_scss.altstack.ss_size;
-      oss->ss_flags = vg_scss.altstack.ss_flags | sas_ss_flags(m_esp);
+      oss->ss_sp    = VG_(threads)[tid].altstack.ss_sp;
+      oss->ss_size  = VG_(threads)[tid].altstack.ss_size;
+      oss->ss_flags = VG_(threads)[tid].altstack.ss_flags | sas_ss_flags(tid, m_esp);
    }
 
    if (ss != NULL) {
-      if (on_sig_stack(VG_(threads)[tid].m_esp)) {
+      if (on_sig_stack(tid, VG_(threads)[tid].m_esp)) {
          SET_SYSCALL_RETVAL(tid, -VKI_EPERM);
          return;
@@ -506,5 +507,5 @@ void VG_(do__NR_sigaltstack) ( ThreadId 
       }
       if (ss->ss_flags == VKI_SS_DISABLE) {
-         vg_scss.altstack.ss_flags = VKI_SS_DISABLE;
+         VG_(threads)[tid].altstack.ss_flags = VKI_SS_DISABLE;
       } else {
          if (ss->ss_size < VKI_MINSIGSTKSZ) {
@@ -513,7 +514,7 @@ void VG_(do__NR_sigaltstack) ( ThreadId 
          }
 
-         vg_scss.altstack.ss_sp   = ss->ss_sp;
-         vg_scss.altstack.ss_size = ss->ss_size;
-         vg_scss.altstack.ss_flags = 0;
+         VG_(threads)[tid].altstack.ss_sp   = ss->ss_sp;
+         VG_(threads)[tid].altstack.ss_size = ss->ss_size;
+         VG_(threads)[tid].altstack.ss_flags = 0;
       }
    }
@@ -922,5 +923,5 @@ static void synth_ucontext(ThreadId tid,
    uc->uc_link = 0;
    uc->uc_sigmask = *set;
-   uc->uc_stack = vg_scss.altstack;
+   uc->uc_stack = tst->altstack;
 
 #define SC(reg) sc->reg = tst->m_##reg
@@ -976,8 +977,8 @@ void vg_push_signal_frame ( ThreadId tid
              already using.  Logic from get_sigframe in
              arch/i386/kernel/signal.c. */
-          sas_ss_flags(tst->m_esp) == 0
+          sas_ss_flags(tid, tst->m_esp) == 0
       ) {
       esp_top_of_frame 
-         = (Addr)(vg_scss.altstack.ss_sp) + vg_scss.altstack.ss_size;
+         = (Addr)(tst->altstack.ss_sp) + tst->altstack.ss_size;
       if (VG_(clo_trace_signals))
          VG_(message)(Vg_DebugMsg,
@@ -986,5 +987,5 @@ void vg_push_signal_frame ( ThreadId tid
 
       /* Signal delivery to tools */
-      VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/False );
+      VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True );
       
    } else {
@@ -992,5 +993,5 @@ void vg_push_signal_frame ( ThreadId tid
 
       /* Signal delivery to tools */
-      VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True );
+      VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/False );
    }
 
@@ -2338,5 +2339,5 @@ void VG_(sigstartup_actions) ( void )
 
    /* Copy the alt stack, if any. */
-   ret = VG_(ksigaltstack)(NULL, &vg_scss.altstack);
+   ret = VG_(ksigaltstack)(NULL, &VG_(threads)[1].altstack);
    vg_assert(ret == 0);
 
@@ -2405,5 +2406,5 @@ void VG_(sigshutdown_actions) ( void )
 
    /* Restore the sig alt stack. */
-   ret = VG_(ksigaltstack)(&vg_scss.altstack, NULL);
+   ret = VG_(ksigaltstack)(&VG_(threads)[1].altstack, NULL);
    vg_assert(ret == 0);
 

--- valgrind/coregrind/vg_include.h  #1.185:1.186
@@ -845,4 +845,7 @@ typedef
    Addr stack_highest_word;
 
+   /* Alternate signal stack */
+   vki_kstack_t altstack;
+
    /* Pointer to this thread's Local (Segment) Descriptor Table.
       Starts out as NULL, indicating there is no table, and we hope to

CVS commit by fitzhardinge: 

Init the per-thread sigaltstacks properly.  New threads should always
appear without a sigaltstack.


  M +5 -0      vg_scheduler.c   1.144
  M +0 -4      vg_signals.c   1.67


--- valgrind/coregrind/vg_scheduler.c  #1.143:1.144
@@ -575,4 +575,9 @@ void mostly_clear_thread_record ( Thread
 
    VG_(threads)[tid].proxy                = NULL;
+
+   /* start with no altstack */
+   VG_(threads)[tid].altstack.ss_sp = (void *)0xdeadbeef;
+   VG_(threads)[tid].altstack.ss_size = 0;
+   VG_(threads)[tid].altstack.ss_flags = VKI_SS_DISABLE;
 }
 

--- valgrind/coregrind/vg_signals.c  #1.66:1.67
@@ -2392,8 +2392,4 @@ void VG_(sigstartup_actions) ( void )
    VG_(ksigfillset)(&vg_scss.scss_per_sig[VKI_SIGVGKILL].scss_mask);
 
-   /* Copy the alt stack, if any. */
-   ret = VG_(ksigaltstack)(NULL, &VG_(threads)[1].altstack);
-   vg_assert(ret == 0);
-
    /* Copy the process' signal mask into the root thread. */
    vg_assert(VG_(threads)[1].status == VgTs_Runnable);

CVS commit by fitzhardinge: 

When creating new threads, initially block all signals.  It's up to the
client code (in vg_libpthread.c) to set the appropriate signal mask when
its ready.  This prevents a bug where a thread gets sent a signal before
even running any of its initialization code, which can cause problems
(particularly if the signal handler directly or indirectly uses TLS).


  M +12 -3     vg_libpthread.c   1.148
  M +3 -2      vg_scheduler.c   1.145


--- valgrind/coregrind/vg_libpthread.c  #1.147:1.148
@@ -72,4 +72,5 @@
 #include <stdio.h>
 #include <errno.h>
+#include <signal.h>
 
 #include <stdlib.h>
@@ -753,4 +754,5 @@ typedef
       void*         (*root_fn) ( void* );
       void*         arg;
+      sigset_t      sigmask;
    }
    NewThreadInfo;
@@ -818,7 +820,4 @@ void thread_wrapper ( NewThreadInfo* inf
    }
 
-   /* Free up the arg block that pthread_create malloced. */
-   my_free(info);
-
    /* Minimally observe the attributes supplied. */
    if (attr__detachstate != PTHREAD_CREATE_DETACHED
@@ -831,4 +830,11 @@ void thread_wrapper ( NewThreadInfo* inf
    init_thread_specific_state();
 
+   /* Now that everything is set up, restore our signal mask (we're
+      ready to accept signals) */
+   sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
+
+   /* Free up the arg block that pthread_create malloced. */
+   my_free(info);
+
    /* The root function might not return.  But if it does we simply
       move along to thread_exit_wrapper.  All other ways out for the
@@ -923,4 +929,6 @@ pthread_create (pthread_t *__restrict __
    info->root_fn = __start_routine;
    info->arg     = __arg;
+   sigprocmask(SIG_SETMASK, NULL, &info->sigmask);
+
    VALGRIND_MAGIC_SEQUENCE(tid_child, VG_INVALID_THREADID /* default */,
                            VG_USERREQ__APPLY_IN_NEW_THREAD,

--- valgrind/coregrind/vg_scheduler.c  #1.144:1.145
@@ -1919,6 +1919,7 @@ void do__apply_in_new_thread ( ThreadId 
    }
 
-   /* We inherit our parent's signal mask. */
-   VG_(threads)[tid].sig_mask = VG_(threads)[parent_tid].sig_mask;
+   /* Start the thread with all signals blocked; it's up to the client
+      code to set the right signal mask when it's ready. */
+   VG_(ksigfillset)(&VG_(threads)[tid].sig_mask);
 
    /* Now that the signal mask is set up, create a proxy LWP for this thread */

CVS commit by thughes: 

Redirect _dl_sysinfo_int80, which is glibc's default system call
routine, to the routine in our trampoline page so that the
special sysinfo unwind hack in vg_execontext.c will kick in.


  M +7 -0      vg_symtab2.c   1.76


--- valgrind/coregrind/vg_symtab2.c  #1.75:1.76
@@ -2194,4 +2194,11 @@ void VG_(setup_code_redirect_table) ( vo
    }
 
+   /* Redirect _dl_sysinfo_int80, which is glibc's default system call
+      routine, to the routine in our trampoline page so that the
+      special sysinfo unwind hack in vg_execontext.c will kick in.
+   */
+   VG_(add_redirect_addr)("soname:ld-linux.so.2", "_dl_sysinfo_int80",
+                          VG_(client_trampoline_code)+VG_(tramp_syscall_offset));
+   
    /* Overenthusiastic use of PLT bypassing by the glibc people also
       means we need to patch the following functions to our own

CVS commit by thughes: 

Fixed decoding of x87 instructions to handle those taking 16 bit
integer arguments.


  M +24 -8     vg_to_ucode.c   1.134


--- valgrind/coregrind/vg_to_ucode.c  #1.133:1.134
@@ -2488,12 +2488,12 @@ Addr dis_fpu ( UCodeBlock* cb, 
       case 0xDA:
          switch ((second_byte >> 3) & 7) {
-            case 0: /* FIADD */
-            case 1: /* FIMUL */
-            case 2: /* FICOM */
-            case 3: /* FICOMP */
-            case 4: /* FISUB */
-            case 5: /* FISUBR */
-            case 6: /* FIDIV */
-            case 7: /* FIDIVR */
+            case 0: /* FIADD dword-integer */
+            case 1: /* FIMUL dword-integer */
+            case 2: /* FICOM dword-integer */
+            case 3: /* FICOMP dword-integer */
+            case 4: /* FISUB dword-integer */
+            case 5: /* FISUBR dword-integer */
+            case 6: /* FIDIV dword-integer */
+            case 7: /* FIDIVR dword-integer */
                return dis_fpu_mem(cb, sorb, 4, rd, eip, first_byte); 
             default: 
@@ -2553,4 +2553,20 @@ Addr dis_fpu ( UCodeBlock* cb, 
          break;
 
+      case 0xDE:
+         switch ((second_byte >> 3) & 7) {
+            case 0: /* FIADD word-integer */
+            case 1: /* FIMUL word-integer */
+            case 2: /* FICOM word-integer */
+            case 3: /* FICOMP word-integer */
+            case 4: /* FISUB word-integer */
+            case 5: /* FISUBR word-integer */
+            case 6: /* FIDIV word-integer */
+            case 7: /* FIDIVR word-integer */
+               return dis_fpu_mem(cb, sorb, 2, rd, eip, first_byte); 
+            default: 
+               goto unhandled;
+         }
+         break;
+
       case 0xDF:
          switch ((second_byte >> 3) & 7) {

CVS commit by thughes: 

Implement tcdrain in the pthread library. The fact that this function
is missing was reported in bug #70344 but the reporter then closed the
bug saying that they were using the wrong version of valgrind.

Patch from Henrik Algestam <algestam@...>.


  M +11 -0     vg_libpthread.c   1.150
  M +1 -1      vg_libpthread_unimp.c   1.44


--- valgrind/coregrind/vg_libpthread.c  #1.149:1.150
@@ -2207,4 +2207,14 @@ int __pause(void)
 
 extern
+int __libc_tcdrain(int fd);
+WEAK
+int __tcdrain(int fd)
+{
+   __my_pthread_testcancel();
+   return __libc_tcdrain(fd);
+}
+
+
+extern
 int __libc_fsync(int fd);
 WEAK
@@ -2384,4 +2394,5 @@ weak_alias (__pwrite64, pwrite64)
 weak_alias(__nanosleep, nanosleep)
 weak_alias(__pause, pause)
+weak_alias(__tcdrain, tcdrain)
 
 

--- valgrind/coregrind/vg_libpthread_unimp.c  #1.43:1.44
@@ -221,5 +221,5 @@ weak_alias(_IO_ftrylockfile, ftrylockfil
 //__attribute__((weak)) void recvmsg ( void ) { vgPlain_unimp("recvmsg"); }
 //__attribute__((weak)) void sendmsg ( void ) { vgPlain_unimp("sendmsg"); }
-__attribute__((weak)) void tcdrain ( void ) { vgPlain_unimp("tcdrain"); }
+//__attribute__((weak)) void tcdrain ( void ) { vgPlain_unimp("tcdrain"); }
 //--//__attribute__((weak)) void vfork ( void ) { vgPlain_unimp("vfork"); }

CVS commit by nethercote: 

Removed unused function.


  M +0 -17     vg_translate.c   1.73


--- valgrind/coregrind/vg_translate.c  #1.72:1.73
@@ -200,21 +200,4 @@ void VG_(copy_UInstr) ( UCodeBlock* cb, 
 }
 
-/* Copy auxiliary info from one uinstr to another. */
-static __inline__ 
-void copyAuxInfoFromTo ( UInstr* src, UInstr* dst )
-{
-   dst->cond            = src->cond;
-   dst->extra4b         = src->extra4b;
-   dst->signed_widen    = src->signed_widen;
-   dst->jmpkind         = src->jmpkind;
-   dst->flags_r         = src->flags_r;
-   dst->flags_w         = src->flags_w;
-   dst->argc            = src->argc;
-   dst->regparms_n      = src->regparms_n;
-   dst->has_ret_val     = src->has_ret_val;
-   dst->regs_live_after = src->regs_live_after;
-}
-
-
 /* Set the lit32 field of the most recent uinsn. */
 void VG_(set_lit_field) ( UCodeBlock* cb, UInt lit32 )

CVS commit by nethercote: 

Added acct() syscall.


  M +8 -0      vg_syscalls.c   1.93


--- valgrind/coregrind/vg_syscalls.c  #1.92:1.93
@@ -4969,4 +4969,11 @@ POST(futex)
 }
 
+PRE(acct)
+{
+   /* int acct(const char *filename); */
+   MAYBE_PRINTF("acct ( %p )\n", arg1);
+   SYSCALL_TRACK( pre_mem_read_asciiz, tid, "acct(filename)", arg1 );
+}
+
 #define SIGNAL_SIMULATION       1
 
@@ -5374,4 +5381,5 @@ static const struct sys_info sys_info[] 
    SYSBA(clock_gettime,         False),
    SYSBA(futex,                 True),
+   SYSB_(acct,                  False),
 
    /* new signal handling makes these normal blocking syscalls */

CVS commit by nethercote: 


Remove "pre-history" handling for mutexes -- now that Valgrind has full control
from the very beginning (thanks to FV) it's no longer necessary.


  M +0 -8      vg_include.h   1.189
  M +12 -42    vg_libpthread.c   1.151
  M +0 -8      vg_scheduler.c   1.146


--- valgrind/coregrind/vg_include.h  #1.188:1.189
@@ -1015,12 +1015,4 @@ extern Int     VG_(longjmpd_on_signal);
 
 
-/* This is or'd into a pthread mutex's __m_kind field if it is used
-   before Valgrind is up and running (prehistory).  This is used so
-   that if some early code (like the dynamic linker) takes a lock
-   before Valgrind starts and then releases it afterwards, we can work
-   out what's happening. */
-#define VG_PTHREAD_PREHISTORY           0x80000000
-
-
 /* ---------------------------------------------------------------------
    Exports of vg_signals.c

--- valgrind/coregrind/vg_libpthread.c  #1.150:1.151
@@ -1163,18 +1163,8 @@ int __pthread_mutex_lock(pthread_mutex_t
    CONVERT(mutex, mutex, vg_mutex);
    
-   if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_LOCK,
                               vg_mutex, 0, 0, 0);
       return res;
-   } else {
-      /* Play at locking */
-      if (0)
-         kludged("prehistoric lock", NULL);
-      vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)1;
-      vg_mutex->__vg_m_count = 1;
-      vg_mutex->__vg_m_kind |= VG_PTHREAD_PREHISTORY;
-      return 0; /* success */
-   }
 }
 
@@ -1186,18 +1176,8 @@ int __pthread_mutex_trylock(pthread_mute
    CONVERT(mutex, mutex, vg_mutex);
    
-   if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_TRYLOCK,
                               vg_mutex, 0, 0, 0);
       return res;
-   } else {
-      /* Play at locking */
-      if (0)
-         kludged("prehistoric trylock", NULL);
-      vg_mutex->__vg_m_owner = (/*_pthread_descr*/void*)1;
-      vg_mutex->__vg_m_count = 1;
-      vg_mutex->__vg_m_kind |= VG_PTHREAD_PREHISTORY;
-      return 0; /* success */
-   }
 }
 
@@ -1209,18 +1189,8 @@ int __pthread_mutex_unlock(pthread_mutex
    CONVERT(mutex, mutex, vg_mutex);
    
-   if (RUNNING_ON_VALGRIND) {
       VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                               VG_USERREQ__PTHREAD_MUTEX_UNLOCK,
                               vg_mutex, 0, 0, 0);
       return res;
-   } else {
-      /* Play at locking */
-      if (0)
-         kludged("prehistoric unlock", NULL);
-      vg_mutex->__vg_m_owner = 0;
-      vg_mutex->__vg_m_count = 0;
-      vg_mutex->__vg_m_kind &= ~VG_PTHREAD_PREHISTORY;
-      return 0; /* success */
-   }
 }
 

--- valgrind/coregrind/vg_scheduler.c  #1.145:1.146
@@ -2150,12 +2150,4 @@ void do_pthread_mutex_unlock ( ThreadId 
    }
 
-   /* If this was locked before the dawn of time, pretend it was
-      locked now so that it balances with unlocks */
-   if (mutex->__vg_m_kind & VG_PTHREAD_PREHISTORY) {
-      mutex->__vg_m_kind &= ~VG_PTHREAD_PREHISTORY;
-      VG_TRACK( pre_mutex_lock, (ThreadId)mutex->__vg_m_owner, mutex );
-      VG_TRACK( post_mutex_lock, (ThreadId)mutex->__vg_m_owner, mutex );
-   }
-
    /* More paranoia ... */
    switch (mutex->__vg_m_kind) {

CVS commit by fitzhardinge: 

Fix for bug 77869.  Names in stabs are terminated by ':'.  Except templated
names, which can have :: within <> quotes.  Except when it's an operator,
which can have a name like operator<, followed by ::.


  M +34 -1     vg_stabs.c   1.11


--- valgrind/coregrind/vg_stabs.c  #1.10:1.11
@@ -403,4 +403,22 @@ static UInt atou(Char **pp, Int base)
 }
 
+static Bool isoperator(Char op)
+{
+   switch(op) {
+   case 'a'...'z':
+   case 'A'...'Z':
+   case '0'...'9':
+   case '_':
+   case ':':
+   case '\'':
+   case '"':
+   case '$':
+      return False;
+      
+   default:
+      return True;
+   }
+}
+
 /* Skip a ':'-delimited name which may have ::, 'char' or other things in
    <> brackets */
@@ -409,4 +427,16 @@ static Char *templ_name(Char *p)
    Int brac = 0;
 
+   /* Special case: if the name is "operatorX", where X is not an
+      otherwise valid operator name, then just skip to the terminating
+      ':' and ignore the '<>' bracketing stuff.  That's because names
+      like "operator<" and "operator<=" can appear here, and it can be
+      terminated by ::. */
+   if (VG_(strncmp)(p, "operator", 8) == 0 && isoperator(p[8])) {
+      p += 8;
+      while(*p != ':')
+         p++;
+      return p;
+   }
+
    for(;;) {
       if (*p == '<')
@@ -424,6 +454,9 @@ static Char *templ_name(Char *p)
       if (brac && p[0] == '\'' && p[2] == '\'')
          p += 3;
+
+      /* If we're within <>, then treat :: as part of the name (a single
+         : still terminates) */
       if (*p == ':') {
-         if (brac && p[1] == ':')
+         if (brac && p[1] == ':' && p[-1] != '<')
             p++;
          else

CVS commit by fitzhardinge: 

Quiet an overly noisy message.


  M +1 -1      vg_symtab2.c   1.77


--- valgrind/coregrind/vg_symtab2.c  #1.76:1.77
@@ -214,5 +214,5 @@ void VG_(addLineInfo) ( SegInfo* si,
     * multiple instructions can map to the one line), but avoid
     * catching any other instructions bogusly. */
-   if (this > next) {
+   if (this > next && VG_(clo_verbosity) > 2) {
        VG_(message)(Vg_DebugMsg, 
                     "warning: line info addresses out of order "

CVS commit by nethercote: 

Fix assertion failure msg.


  M +1 -1      vg_from_ucode.c   1.76


--- valgrind/coregrind/vg_from_ucode.c  #1.75:1.76
@@ -3919,5 +3919,5 @@ static void emitUInstr ( UCodeBlock* cb,
                              u->opcode, u->size, u->val1, u->val2 );
                           break;
-            default: VG_(core_panic)("emitUInstr:non-shift-op");
+            default: VG_(core_panic)("emitUInstr:shift-op");
          }
          break;

CVS commit by nethercote: 


Improved pretty-printing:
 - now showing conditions for CC2VAL and CMOV
 - fixed indenting on JumpKind (-c, -r, -sys, etc)


  M +17 -9     vg_translate.c   1.74


--- valgrind/coregrind/vg_translate.c  #1.73:1.74
@@ -963,5 +963,6 @@ void pp_UInstrWorker ( Int instrNo, UIns
    VG_(printf)("\t%4d: %s", instrNo, 
                             VG_(name_UOpcode)(True, u->opcode));
-   if (u->opcode == JMP || u->opcode == CC2VAL)
+   // For JMP, the condition goes before the size
+   if (u->opcode == JMP)
       VG_(printf)("%s", VG_(name_UCondcode)(u->cond));
 
@@ -976,4 +977,19 @@ void pp_UInstrWorker ( Int instrNo, UIns
    }
 
+   // For CC2VAL and CMOV, the condition goes after the size
+   if (u->opcode == CC2VAL || u->opcode == CMOV)
+      VG_(printf)("%s", VG_(name_UCondcode)(u->cond));
+
+   // Append jmpkind
+   if (u->opcode == JMP) {
+      switch (u->jmpkind) {
+         case JmpCall:      VG_(printf)("-c"); break;
+         case JmpRet:       VG_(printf)("-r"); break;
+         case JmpSyscall:   VG_(printf)("-sys"); break;
+         case JmpClientReq: VG_(printf)("-cli"); break;
+         case JmpYield:     VG_(printf)("-yld"); break;
+         default: break;
+      }
+   }
    VG_(printf)("       \t");
 
@@ -1132,12 +1148,4 @@ void pp_UInstrWorker ( Int instrNo, UIns
 
       case JMP:
-         switch (u->jmpkind) {
-            case JmpCall:      VG_(printf)("-c"); break;
-            case JmpRet:       VG_(printf)("-r"); break;
-            case JmpSyscall:   VG_(printf)("-sys"); break;
-            case JmpClientReq: VG_(printf)("-cli"); break;
-            case JmpYield:     VG_(printf)("-yld"); break;
-            default: break;
-         }
          VG_(pp_UOperand)(u, 1, u->size, False);
          if (CondAlways == u->cond) {

CVS commit by nethercote: 

Pretty-print WIDENs properly.


  M +9 -5      vg_translate.c   1.75


--- valgrind/coregrind/vg_translate.c  #1.74:1.75
@@ -981,6 +981,7 @@ void pp_UInstrWorker ( Int instrNo, UIns
       VG_(printf)("%s", VG_(name_UCondcode)(u->cond));
 
-   // Append jmpkind
-   if (u->opcode == JMP) {
+   // Append extra bits
+   switch (u->opcode) {
+   case JMP:
       switch (u->jmpkind) {
          case JmpCall:      VG_(printf)("-c"); break;
@@ -991,4 +992,9 @@ void pp_UInstrWorker ( Int instrNo, UIns
          default: break;
       }
+      break;
+
+   case WIDEN:
+      VG_(printf)("_%c%c", VG_(toupper)(nameISize(u->extra4b)),
+                           u->signed_widen?'s':'z');
    }
    VG_(printf)("       \t");
@@ -1202,6 +1208,4 @@ void pp_UInstrWorker ( Int instrNo, UIns
 
       case WIDEN:
-         VG_(printf)("_%c%c", VG_(toupper)(nameISize(u->extra4b)),
-                              u->signed_widen?'s':'z');
          VG_(pp_UOperand)(u, 1, u->size, False);
          break;

CVS commit by nethercote: 

Increase sanity checking on .extra4b field for WIDEN, rename a sanity macro,
add some missing #undefs for some sanity macros.


  M +10 -4     vg_translate.c   1.76


--- valgrind/coregrind/vg_translate.c  #1.75:1.76
@@ -458,4 +458,5 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
 #  define COND0    (u->cond         == 0)
 #  define EXTRA4b0 (u->extra4b      == 0)
+#  define EXTRA4b12 (u->extra4b     == 1 || u->extra4b == 2)
 #  define SG_WD0   (u->signed_widen == 0)
 #  define JMPKIND0 (u->jmpkind      == 0)
@@ -466,6 +467,6 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
 
 #  define XCONDi   (         EXTRA4b0 && SG_WD0 && JMPKIND0 && CCALL0)
-#  define Xextra4b (COND0             && SG_WD0 && JMPKIND0 && CCALL0)
-#  define XWIDEN   (COND0                       && JMPKIND0 && CCALL0)
+#  define XLEA2    (COND0             && SG_WD0 && JMPKIND0 && CCALL0)
+#  define XWIDEN   (COND0 && EXTRA4b12          && JMPKIND0 && CCALL0)
 #  define XJMP     (                     SG_WD0             && CCALL0)
 #  define XCCALL   (COND0 && EXTRA4b0 && SG_WD0 && JMPKIND0          )
@@ -532,5 +533,5 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
    case FPU:    return LIT0 && SZ0  && CCf &&  Ls1 &&  N2 &&  N3 && XOTHER;
    case LEA1:   return /*any*/ SZ4  && CC0 &&  TR1 && TR2 &&  N3 && XOTHER;
-   case LEA2:   return /*any*/ SZ4  && CC0 &&  TR1 && TR2 && TR3 && Xextra4b;
+   case LEA2:   return /*any*/ SZ4  && CC0 &&  TR1 && TR2 && TR3 && XLEA2;
    case INCEIP: return LIT0 && SZ0  && CC0 &&  Ls1 &&  N2 &&  N3 && XOTHER;
    case CCALL:  return LIT1 && SZ0  && CC0 && 
@@ -592,4 +593,5 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
 #  undef SZ48
 #  undef SZ416
+#  undef SZ816
 #  undef SZsse2
 #  undef SZsse3
@@ -625,4 +627,6 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
 #  undef TRL1
 #  undef TRAL1
+#  undef TRA1
+#  undef TRA2
 #  undef N1
 #  undef N2
@@ -632,8 +636,10 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
 #  undef COND0
 #  undef EXTRA4b0
+#  undef EXTRA4b12
 #  undef SG_WD0
 #  undef JMPKIND0
 #  undef CCALL0
-#  undef Xextra4b
+#  undef XCONDi
+#  undef XLEA2
 #  undef XWIDEN
 #  undef XJMP

CVS commit by nethercote: 

Added comment clarifying RDTSC.


  M +3 -0      vg_to_ucode.c   1.135


--- valgrind/coregrind/vg_to_ucode.c  #1.134:1.135
@@ -6729,4 +6729,7 @@ static Addr disInstr ( UCodeBlock* cb, A
          t3 = newTemp(cb);
          uInstr0(cb, CALLM_S, 0);
+         // Nb: even though these args aren't used by RDTSC_helper, need
+         // them to be defined (for Memcheck).  The TempRegs pushed must
+         // also be distinct.
          uInstr2(cb, MOV,   4, Literal, 0, TempReg, t1);
          uLiteral(cb, 0);

CVS commit by rjwalsh: 

Fix bug 73655.


  A            gen_intercepts.pl   1.1
  A            vg_intercept.c.base   1.1
  A            vg_replace_malloc.c.base   1.1
  M +9 -1      Makefile.am   1.71
  M +13 -5     vg_include.h   1.190
  M +4 -17     vg_scheduler.c   1.147
  M +120 -3    vg_symtab2.c   1.78
  R            vg_intercept.c   1.28
  R            vg_replace_malloc.c   1.18


--- valgrind/coregrind/Makefile.am  #1.70:1.71
@@ -28,5 +28,5 @@
 
 BUILT_SOURCES = vg_toolint.c vg_toolint.h
-CLEANFILES = vg_toolint.c vg_toolint.h
+CLEANFILES = vg_toolint.c vg_toolint.h vg_replace_malloc.c vg_intercept.c
 
 valgrind_SOURCES = \
@@ -89,4 +89,12 @@
         -ldl
 
+vg_intercept.c: $(srcdir)/gen_intercepts.pl vg_intercept.c.base
+        rm -f $@
+        $(PERL) $(srcdir)/gen_intercepts.pl < vg_intercept.c.base > $@
+
+vg_replace_malloc.c: $(srcdir)/gen_intercepts.pl vg_replace_malloc.c.base
+        rm -f $@
+        $(PERL) $(srcdir)/gen_intercepts.pl < vg_replace_malloc.c.base > $@
+
 vg_toolint.c: $(srcdir)/gen_toolint.pl $(srcdir)/toolfuncs.def $(srcdir)/Makefile
         rm -f $@

--- valgrind/coregrind/vg_include.h  #1.189:1.190
@@ -275,4 +275,7 @@ extern Bool VG_(clo_show_below_main);
 extern Bool VG_(clo_pointercheck);
 
+/* Set up the libc freeres wrapper */
+extern void VG_(intercept_libc_freeres_wrapper)(Addr);
+
 /* ---------------------------------------------------------------------
    Debugging and profiling stuff
@@ -481,5 +484,4 @@ extern Bool  VG_(is_inside_segment_mmapd
 /* Denote the finish of VG_(__libc_freeres_wrapper). */
 #define VG_USERREQ__LIBC_FREERES_DONE       0x3029
-#define VG_USERREQ__REGISTER_LIBC_FREERES   0x302A
 
 /* Allocate RT signals */
@@ -491,8 +493,4 @@ extern Bool  VG_(is_inside_segment_mmapd
 #define VG_USERREQ__GET_MALLOCFUNCS         0x3030
 
-/* Hook for interface to vg_inject.so */
-#define VG_USERREQ__REGISTER_REDIRECT_SYM   0x3031
-#define VG_USERREQ__REGISTER_REDIRECT_ADDR  0x3032
-
 /* Cosmetic ... */
 #define VG_USERREQ__GET_PTHREAD_TRACE_LEVEL 0x3101
@@ -509,4 +507,14 @@ In vg_constants.h:
 */
 
+#define VG_INTERCEPT_PREFIX "_vgi__"
+#define VG_INTERCEPT_PREFIX_LEN 6
+#define VG_INTERCEPT(name) _vgi__##name
+#define VG_INTERCEPT_ALIAS(name) "_vgi__" #name
+
+#define VG_WRAPPER_PREFIX "_vgw__"
+#define VG_WRAPPER_PREFIX_LEN 6
+#define VG_WRAPPER(name) _vgw__##name
+#define VG_WRAPPER_ALIAS(name) "_vgw__" #name
+
 
 struct vg_mallocfunc_info {

--- valgrind/coregrind/vg_scheduler.c  #1.146:1.147
@@ -2850,4 +2850,8 @@ UInt VG_(get_exit_status_shadow) ( void 
 }
 
+void VG_(intercept_libc_freeres_wrapper)(Addr addr)
+{
+   VG_(__libc_freeres_wrapper) = addr;
+}
 
 /* ---------------------------------------------------------------------
@@ -3150,9 +3154,4 @@ void do_client_request ( ThreadId tid )
          break; }
 
-      case VG_USERREQ__REGISTER_LIBC_FREERES:
-         VG_(__libc_freeres_wrapper)    = arg[1];
-         SET_CLREQ_RETVAL( tid, 0 );     /* return value is meaningless */
-         break;
-
       case VG_USERREQ__GET_MALLOCFUNCS: {
          struct vg_mallocfunc_info *info = (struct vg_mallocfunc_info *)arg[1];
@@ -3178,16 +3177,4 @@ void do_client_request ( ThreadId tid )
       }
 
-      case VG_USERREQ__REGISTER_REDIRECT_SYM: {
-         VG_(add_redirect_sym)((const Char *)arg[1], (const Char *)arg[2],
-                               (const Char *)arg[3], (const Char *)arg[4]);
-         break;
-      }
-
-      case VG_USERREQ__REGISTER_REDIRECT_ADDR: {
-         VG_(add_redirect_addr)((const Char *)arg[1], (const Char *)arg[2],
-                                (Addr)arg[3]);
-         break;
-      }
-
       /* Requests from the client program */
 

--- valgrind/coregrind/vg_symtab2.c  #1.77:1.78
@@ -35,4 +35,6 @@
 #include <elf.h>          /* ELF defns                      */
 
+static Bool
+VG_(intercept_demangle)(const Char*, Char*, Int);
 
 /* Majorly rewritten Sun 3 Feb 02 to enable loading symbols from
@@ -442,4 +444,15 @@ static RiSym *prefersym(RiSym *a, RiSym 
    }
 
+   /* Ugh.  If we get a "free", always choose it.  This is because
+      normally, this function would choose "cfree" over free.  cfree is
+      an alias for free.  If there's any more symbols like this, we may
+      want to consider making this mechanism more generic.
+    */
+   if(VG_(strcmp)(a->name, "free") == 0)
+       return a;
+
+   if(VG_(strcmp)(b->name, "free") == 0)
+       return b;
+
    for(i = pfx = 0; i < sizeof(prefixes)/sizeof(*prefixes); i++) {
       Int pfxlen = prefixes[i].len;
@@ -472,4 +485,16 @@ void canonicaliseSymtab ( SegInfo* si )
    VG_(ssort)(si->symtab, si->symtab_used, sizeof(*si->symtab), compare_RiSym);
 
+   for (i = 0; i < si->symtab_used; i++) {
+      if(VG_(strncmp)(si->symtab[i].name, VG_INTERCEPT_PREFIX,
+                      VG_INTERCEPT_PREFIX_LEN) == 0) {
+         int len = VG_(strlen)(si->symtab[i].name);
+         char *buf = VG_(malloc)(len), *colon;
+         VG_(intercept_demangle)(si->symtab[i].name, buf, len);
+         colon = buf + VG_(strlen)(buf) - 1;
+         while(*colon != ':') colon--;
+         VG_(strncpy_safely)(si->symtab[i].name, colon+1, len);
+      }
+   }
+
   cleanup_more:
  
@@ -747,7 +772,83 @@ Bool VG_(is_object_file)(const void *buf
 }
 
+/*
+ * Demangle an intercept symbol into library:func form
+ */
+
+static Bool
+VG_(intercept_demangle)(const Char* symbol, Char* result, Int nbytes)
+{
+   int i, j = 0;
+   int len = VG_(strlen)(symbol);
+
+   for(i = VG_INTERCEPT_PREFIX_LEN; i < len; i++) {
+      if(symbol[i] == '$') {
+         i++;
+         if(symbol[i] == '$') {
+            result[j] = '$';
+         } else if((symbol[i] >= '0' && symbol[i] <= '9') ||
+                   (symbol[i] >= 'a' && symbol[i] <= 'f') ||
+                   (symbol[i] >= 'A' && symbol[i] <= 'F')) {
+            int x = symbol[i++];
+            int y = symbol[i];
+            if(x >= '0' && x <= '9') {
+               x -= '0';
+            } else if(x >= 'a' && x <= 'f') {
+               x -= 'a';
+            } else if(x >= 'A' && x <= 'F') {
+               x -= 'A';
+            }
+            if(y >= '0' && y <= '9') {
+               y -= '0';
+            } else if(y >= 'a' && y <= 'f') {
+               y = y - 'a' + 10;
+            } else if(y >= 'A' && y <= 'F') {
+               y = y - 'A' + 10;
+            } else {
+               return False;
+            }
+            result[j] = (x << 4) | y;
+         } else {
+            return False;
+         }
+      } else {
+         result[j] = symbol[i];
+      }
+      if(j >= nbytes) {
+         result[j] = '\0';
+         return True;
+      }
+      j++;
+   }
+   result[j] = '\0';
+   return True;
+}
+
+static
+void handle_intercept( SegInfo* si, Char* symbol, Elf32_Sym* sym)
+{
+   int len = VG_(strlen)(symbol) + 1 - VG_INTERCEPT_PREFIX_LEN;
+   char *lib = VG_(malloc)(len);
+   Char *func;
+
+   VG_(intercept_demangle)(symbol, lib, len);
+   func = lib + VG_(strlen)(lib)-1;
+
+   while(*func != ':') func--;
+   *func = '\0';
+
+   VG_(add_redirect_addr)(lib, func+1, si->offset + sym->st_value);
+   VG_(free)(lib);
+}
+
+static
+void handle_wrapper( SegInfo* si, Char* symbol, Elf32_Sym* sym)
+{
+   VG_(intercept_libc_freeres_wrapper)((Addr)(si->offset + sym->st_value));
+}
+
 /* Read a symbol table (normal or dynamic) */
 static
-void read_symtab( SegInfo* si, Char* tab_name,
+void read_symtab( SegInfo* si, Char* tab_name, Bool do_intercepts,
                   Elf32_Sym* o_symtab, UInt o_symtab_sz,
                   UChar*     o_strtab, UInt o_strtab_sz )
@@ -806,4 +907,20 @@ void read_symtab( SegInfo* si, Char* tab
 #     endif
 
+      /*
+       * Is this symbol a magic valgrind-intercept symbol?  If so,
+       * hand this off to the interceptinator.
+       */
+      if (do_intercepts) {
+         if (VG_(strncmp)((Char*)o_strtab+sym->st_name,
+                          VG_INTERCEPT_PREFIX,
+                          VG_INTERCEPT_PREFIX_LEN) == 0) {
+           handle_intercept(si, (Char*)o_strtab+sym->st_name, sym);
+         } else if (VG_(strncmp)((Char*)o_strtab+sym->st_name,
+                                 VG_WRAPPER_PREFIX,
+                                 VG_WRAPPER_PREFIX_LEN) == 0) {
+           handle_wrapper(si, (Char*)o_strtab+sym->st_name, sym);
+         }
+      }
+
       /* Figure out if we're interested in the symbol.
          Firstly, is it of the right flavour?  */
@@ -1144,9 +1261,9 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       }
 
-      read_symtab(si, "symbol table", 
+      read_symtab(si, "symbol table", False,
                   o_symtab, o_symtab_sz,
                   o_strtab, o_strtab_sz);
 
-      read_symtab(si, "dynamic symbol table",
+      read_symtab(si, "dynamic symbol table", True,
                   o_dynsym, o_dynsym_sz,
                   o_dynstr, o_dynstr_sz);

CVS commit by thughes: 

Initialise %cs, %ds and %ss in the virtual machine to match the values
supplied by the operating system for the code, data and stack segments.

Explicit references using these segments still won't work but they
will at least produce an assertion to indicate that they aren't
supported instead of raising a segmentation fault in the target
program because of an apparent privilege violation.


  M +12 -0     vg_main.c   1.149


--- valgrind/coregrind/vg_main.c  #1.148:1.149
@@ -2428,4 +2428,16 @@ static void init_baseBlock ( Addr client
    VGOFF_(m_gs)  = alloc_BaB_1_set(0);
 
+   /* initialise %cs, %ds and %ss to point at the operating systems
+      default code, data and stack segments */
+   asm volatile("movw %%cs, %0"
+                :
+                : "m" (VG_(baseBlock)[VGOFF_(m_cs)]));
+   asm volatile("movw %%ds, %0"
+                :
+                : "m" (VG_(baseBlock)[VGOFF_(m_ds)]));
+   asm volatile("movw %%ss, %0"
+                :
+                : "m" (VG_(baseBlock)[VGOFF_(m_ss)]));
+
    VG_(register_noncompact_helper)( (Addr) & VG_(do_useseg) );

CVS commit by thughes: 

Change the debugger attachment code to send the STOP signal to the
forked process before using ptrace() to continue it, instead of asking
ptrace to deliver it, as that doesn't seem to work on some versions
of linux.

CCMAIL: 77824-done@...


  M +2 -1      vg_main.c   1.150


--- valgrind/coregrind/vg_main.c  #1.149:1.150
@@ -351,5 +351,6 @@ void VG_(start_debugger) ( Int tid )
           WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP &&
           ptrace(PTRACE_SETREGS, pid, NULL, &regs) == 0 &&
-          ptrace(PTRACE_DETACH, pid, NULL, SIGSTOP) == 0) {
+          kill(pid, SIGSTOP) == 0 &&
+          ptrace(PTRACE_DETACH, pid, NULL, 0) == 0) {
          Char pidbuf[15];
          Char file[30];

CVS commit by thughes: 

Add support for the FBIOGET_VSCREENINFO and FBIOGET_FSCREENINFO ioctls
based on a patch from Paul Olav Tvete <paul@...>.

CCMAIL: 77022-done@...


  M +20 -0     vg_syscalls.c   1.94
  M +1 -0      vg_unsafe.h   1.26


--- valgrind/coregrind/vg_syscalls.c  #1.93:1.94
@@ -3232,4 +3232,15 @@ PRE(ioctl)
       break;
 
+   case FBIOGET_VSCREENINFO: /* 0x4600 */
+      SYSCALL_TRACK( pre_mem_write,tid,
+                     "ioctl(FBIOGET_VSCREENINFO)", arg3,
+                     sizeof(struct fb_var_screeninfo));
+      break;
+   case FBIOGET_FSCREENINFO: /* 0x4602 */
+      SYSCALL_TRACK( pre_mem_write,tid,
+                     "ioctl(FBIOGET_FSCREENINFO)", arg3,
+                     sizeof(struct fb_fix_screeninfo));
+      break;
+
       /* We don't have any specific information on it, so
          try to do something reasonable based on direction and
@@ -3585,4 +3596,13 @@ POST(ioctl)
       break;
 
+   case FBIOGET_VSCREENINFO: //0x4600
+      if (res == 0)
+         VG_TRACK( post_mem_write,arg3, sizeof(struct fb_var_screeninfo));
+      break;
+   case FBIOGET_FSCREENINFO: //0x4602
+      if (res == 0)
+         VG_TRACK( post_mem_write,arg3, sizeof(struct fb_fix_screeninfo));
+      break;
+
       /* We don't have any specific information on it, so
          try to do something reasonable based on direction and

--- valgrind/coregrind/vg_unsafe.h  #1.25:1.26
@@ -64,4 +64,5 @@
 #include <signal.h>       /* for siginfo_t */
 #include <linux/timex.h>  /* for adjtimex */
+#include <linux/fb.h>     /* for fb_* structs */
 
 #define __USE_LARGEFILE64

On Wed, 21 Apr 2004, Tom Hughes wrote:

> Add support for the FBIOGET_VSCREENINFO and FBIOGET_FSCREENINFO ioctls
> based on a patch from Paul Olav Tvete <paul@...>.

Hmm;  we have an unsatisfactory situation at the moment... #including new
headers for IOCTLs is a bit dangerous, because some of these headers
aren't universal.  This has prevented us from applying a bunch of IOCTLs
like this previously.  At least, that's my understanding of it.

N

In message <Pine.SOL.4.58.0404211658180.14947@...>
          Nicholas Nethercote <njn25@...> wrote:

> On Wed, 21 Apr 2004, Tom Hughes wrote:
> 
> > Add support for the FBIOGET_VSCREENINFO and FBIOGET_FSCREENINFO ioctls
> > based on a patch from Paul Olav Tvete <paul@...>.
> 
> Hmm;  we have an unsatisfactory situation at the moment... #including new
> headers for IOCTLs is a bit dangerous, because some of these headers
> aren't universal.  This has prevented us from applying a bunch of IOCTLs
> like this previously.  At least, that's my understanding of it.

So should configure be made to probe for the header then, and only
include that code if it exists? Presumably a system without the header
wouldn't suport the ioctl anyway?

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Wed, 21 Apr 2004, Tom Hughes wrote:

> > Hmm;  we have an unsatisfactory situation at the moment... #including new
> > headers for IOCTLs is a bit dangerous, because some of these headers
> > aren't universal.  This has prevented us from applying a bunch of IOCTLs
> > like this previously.  At least, that's my understanding of it.
>
> So should configure be made to probe for the header then, and only
> include that code if it exists?

I guess;  nobody's ever looked at it thoroughly, AFAIK.

> Presumably a system without the header wouldn't suport the ioctl anyway?

Yes;  the problem is compilation errors.

N

CVS commit by thughes: 

Cope with AT_xCACHEBSIZE not being defined, which they aren't on systems
with 2.2 kernels and, it seems, on some systems with 2.4 kernels.

CCMAIL: 79179-done@...


  M +12 -0     vg_main.c   1.151


--- valgrind/coregrind/vg_main.c  #1.150:1.151
@@ -51,4 +51,16 @@
 #include <unistd.h>
 
+#ifndef AT_DCACHEBSIZE
+#define AT_DCACHEBSIZE          19
+#endif /* AT_DCACHEBSIZE */
+
+#ifndef AT_ICACHEBSIZE
+#define AT_ICACHEBSIZE          20
+#endif /* AT_ICACHEBSIZE */
+
+#ifndef AT_UCACHEBSIZE
+#define AT_UCACHEBSIZE          21
+#endif /* AT_UCACHEBSIZE */
+
 #ifndef AT_SYSINFO
 #define AT_SYSINFO              32

On Thu, 22 Apr 2004, Tom Hughes wrote:

> Cope with AT_xCACHEBSIZE not being defined, which they aren't on systems
> with 2.2 kernels and, it seems, on some systems with 2.4 kernels.
>
> --- valgrind/coregrind/vg_main.c  #1.150:1.151
> @@ -51,4 +51,16 @@
>  #include <unistd.h>
>
> +#ifndef AT_DCACHEBSIZE
> +#define AT_DCACHEBSIZE          19
> +#endif /* AT_DCACHEBSIZE */
> +
> +#ifndef AT_ICACHEBSIZE
> +#define AT_ICACHEBSIZE          20
> +#endif /* AT_ICACHEBSIZE */
> +
> +#ifndef AT_UCACHEBSIZE
> +#define AT_UCACHEBSIZE          21
> +#endif /* AT_UCACHEBSIZE */
> +
>  #ifndef AT_SYSINFO
>  #define AT_SYSINFO              32

Would it be better to conditionally include the cases that use these?  Ie.
mention them if they are defined, rather than defining them if they are
not?

Sorry for the pickiness.

N

In message <Pine.SOL.4.58.0404221924500.11785@...>
          Nicholas Nethercote <njn25@...> wrote:

> On Thu, 22 Apr 2004, Tom Hughes wrote:
> 
> > Cope with AT_xCACHEBSIZE not being defined, which they aren't on systems
> > with 2.2 kernels and, it seems, on some systems with 2.4 kernels.
> >
> > --- valgrind/coregrind/vg_main.c  #1.150:1.151
> > @@ -51,4 +51,16 @@
> >  #include <unistd.h>
> >
> > +#ifndef AT_DCACHEBSIZE
> > +#define AT_DCACHEBSIZE          19
> > +#endif /* AT_DCACHEBSIZE */
> > +
> > +#ifndef AT_ICACHEBSIZE
> > +#define AT_ICACHEBSIZE          20
> > +#endif /* AT_ICACHEBSIZE */
> > +
> > +#ifndef AT_UCACHEBSIZE
> > +#define AT_UCACHEBSIZE          21
> > +#endif /* AT_UCACHEBSIZE */
> > +
> >  #ifndef AT_SYSINFO
> >  #define AT_SYSINFO              32
> 
> Would it be better to conditionally include the cases that use these?  Ie.
> mention them if they are defined, rather than defining them if they are
> not?

I did wonder about that, but as Jeremy had already done some other
ones that way I decided to follow suit.

I think the history is that they are PPC specific values that were
added in 2.4 and then later made conditional - after 2.4.22 at a guess
since my headers have then unconditionally but 2.4.25 apparently
doesn't.

Given that I guess they are meaningless if not defined so there's
no need to worry about the act that valgrind will moan if it sees
them and doesn't have code to handle them.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

CVS commit by nethercote: 

Fix bug in helper_{IN,OUT} -- they weren't preserving %eflags as they should.


  M +6 -0      vg_helpers.S   1.32


--- valgrind/coregrind/vg_helpers.S  #1.31:1.32
@@ -133,4 +133,6 @@
         movl    16(%esp), %eax
         movl    12(%esp), %edx
+
+        pushfl
         cmpl    $4, %eax
         je      in_dword
@@ -146,4 +148,5 @@
         inl     (%dx),%eax
 in_done:
+        popfl
         movl    %eax,12(%esp)
         popl    %edx
@@ -165,4 +168,6 @@
         movl    16(%esp), %edx
         movl    12(%esp), %eax
+
+        pushfl
         cmpl    $4, 20(%esp)
         je      out_dword
@@ -178,4 +183,5 @@
         outl    %eax,(%dx)
 out_done:
+        popfl
         popl    %edx
         popl    %eax

CVS commit by nethercote: 

Split some combined error messages, so they are more informative.  Also return
EPERM where appropriate, instead of EINVAL.


  M +19 -7     vg_scheduler.c   1.148


--- valgrind/coregrind/vg_scheduler.c  #1.147:1.148
@@ -2369,7 +2369,14 @@ void do_pthread_cond_wait ( ThreadId tid
              && VG_(threads)[tid].status == VgTs_Runnable);
 
-   if (mutex == NULL || cond == NULL) {
+   if (mutex == NULL) {
       VG_(record_pthread_error)( tid, 
-         "pthread_cond_wait/timedwait: cond or mutex is NULL");
+         "pthread_cond_wait/timedwait: mutex is NULL");
+      SET_PTHREQ_RETVAL(tid, VKI_EINVAL);
+      return;
+   }
+
+   if (cond == NULL) {
+      VG_(record_pthread_error)( tid, 
+         "pthread_cond_wait/timedwait: cond is NULL");
       SET_PTHREQ_RETVAL(tid, VKI_EINVAL);
       return;
@@ -2397,10 +2404,15 @@ void do_pthread_cond_wait ( ThreadId tid
 
    /* Barf if we don't currently hold the mutex. */
-   if (mutex->__vg_m_count == 0 /* nobody holds it */
-       || (ThreadId)mutex->__vg_m_owner != tid /* we don't hold it */) {
+   if (mutex->__vg_m_count == 0 /* nobody holds it */) {
          VG_(record_pthread_error)( tid, 
-            "pthread_cond_wait/timedwait: mutex is unlocked "
-            "or is locked but not owned by thread");
-      SET_PTHREQ_RETVAL(tid, VKI_EINVAL);
+            "pthread_cond_wait/timedwait: mutex is unlocked");
+      SET_PTHREQ_RETVAL(tid, VKI_EPERM);
+      return;
+   }
+
+   if ((ThreadId)mutex->__vg_m_owner != tid /* we don't hold it */) {
+         VG_(record_pthread_error)( tid, 
+            "pthread_cond_wait/timedwait: mutex is locked by another thread");
+      SET_PTHREQ_RETVAL(tid, VKI_EPERM);
       return;
    }

CVS commit by nethercote: 

Tighten MOV's sanity checking slightly


  M +1 -1      vg_translate.c   1.78


--- valgrind/coregrind/vg_translate.c  #1.77:1.78
@@ -416,5 +416,5 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
                || u->size == 10 || u->size == 28 || u->size == 108)
 #  define SZ4m ((u->tag1 == TempReg || u->tag1 == RealReg) \
-                      ? (u->size == 4) : True)
+                      ? (u->size == 4) : SZi)
 
 /* For these ones, two cases:

CVS commit by rjwalsh: 

Implement syscall 258, for those of use running Fedora Core 2.


  M +6 -0      vg_syscalls.c   1.96


--- valgrind/coregrind/vg_syscalls.c  #1.95:1.96
@@ -1266,4 +1266,9 @@ PRE(get_thread_area)
 }
 
+PRE(set_tid_address)
+{
+   MAYBE_PRINTF("set_tid_address ( %p )\n", arg1);
+}
+
 PRE(setresgid)
 {
@@ -5202,4 +5207,5 @@ static const struct sys_info special_sys
    SYSB_(set_thread_area,       False),
    SYSB_(get_thread_area,       False),
+   SYSB_(set_tid_address,       False),
 
    SYSB_(execve,                False),

CVS commit by nethercote: 

Fix comment


  M +1 -1      vg_from_ucode.c   1.77


--- valgrind/coregrind/vg_from_ucode.c  #1.76:1.77
@@ -2285,5 +2285,5 @@ static void emit_call_patchme( void )
 
       if (dis)
-         VG_(printf)("\n\t\tud2; ud2; nop /* call VG_(patchme) */\n");
+         VG_(printf)("\n\t\tud2; ud2; nop /* call VG_(patch_me) */\n");
    }
 }

CVS commit by nethercote: 

Added "repne movs", not official but seems to occur.  Also restructured the
rep/repe/repne cases to use a switch instead of if/else, as it's cleaner. 


  M +47 -34    vg_to_ucode.c   1.138


--- valgrind/coregrind/vg_to_ucode.c  #1.137:1.138
@@ -6208,5 +6208,6 @@ static Addr disInstr ( UCodeBlock* cb, A
       break;
 
-   case 0xF2: { /* REPNE prefix insn */
+   /* REPNE prefix insn */
+   case 0xF2: { 
       Addr eip_orig = eip - 1;
       vg_assert(sorb == 0);
@@ -6212,12 +6213,27 @@ static Addr disInstr ( UCodeBlock* cb, A
       vg_assert(sorb == 0);
       abyte = getUChar(eip); eip++;
+
       if (abyte == 0x66) { sz = 2; abyte = getUChar(eip); eip++; }
+      *isEnd = True;         
 
-      if (abyte == 0xAE || abyte == 0xAF) { /* REPNE SCAS<sz> */
-         if (abyte == 0xAE) sz = 1;
+      switch (abyte) {
+      /* According to the Intel manual, "repne movs" should never occur, but
+       * in practice it has happened, so allow for it here... */
+      case 0xA4: sz = 1;   /* REPNE MOVS<sz> */
+      case 0xA5: 
+         dis_REP_op ( cb, CondNZ, dis_MOVS, sz, eip_orig, eip, "repne movs" );
+         break;
+
+      case 0xA6: sz = 1;   /* REPNE CMPS<sz> */
+      case 0xA7:
+         dis_REP_op ( cb, CondNZ, dis_CMPS, sz, eip_orig, eip, "repne cmps" );
+         break;
+
+      case 0xAE: sz = 1;   /* REPNE SCAS<sz> */
+      case 0xAF:
          dis_REP_op ( cb, CondNZ, dis_SCAS, sz, eip_orig, eip, "repne scas" );
-         *isEnd = True;         
-      }
-      else {
+         break;
+
+      default:
          goto decode_failure;
       }
@@ -6233,44 +6249,41 @@ static Addr disInstr ( UCodeBlock* cb, A
 
       if (abyte == 0x66) { sz = 2; abyte = getUChar(eip); eip++; }
+      *isEnd = True;
 
-      if (abyte == 0xA4 || abyte == 0xA5) { /* REP MOV<sz> */
-         if (abyte == 0xA4) sz = 1;
+      switch (abyte) {
+      case 0xA4: sz = 1;   /* REP MOVS<sz> */
+      case 0xA5:
          dis_REP_op ( cb, CondAlways, dis_MOVS, sz, eip_orig, eip, "rep movs" );
-         *isEnd = True;
-      }
-      else 
-      if (abyte == 0xA6 || abyte == 0xA7) { /* REPE CMP<sz> */
-         if (abyte == 0xA6) sz = 1;
+         break;
+
+      case 0xA6: sz = 1;   /* REPE CMP<sz> */
+      case 0xA7:
          dis_REP_op ( cb, CondZ, dis_CMPS, sz, eip_orig, eip, "repe cmps" );
-         *isEnd = True;
-      } 
-      else
-      if (abyte == 0xAA || abyte == 0xAB) { /* REP STOS<sz> */
-         if (abyte == 0xAA) sz = 1;
+         break;
+
+      case 0xAA: sz = 1;   /* REP STOS<sz> */
+      case 0XAB:
          dis_REP_op ( cb, CondAlways, dis_STOS, sz, eip_orig, eip, "rep stos" );
-         *isEnd = True;
-      }
-      else
-      if (abyte == 0xAE || abyte == 0xAF) { /* REPE SCAS<sz> */
-         if (abyte == 0xAE) sz = 1;
+         break;
+
+      case 0xAE: sz = 1;   /* REPE SCAS<sz> */
+      case 0xAF: 
          dis_REP_op ( cb, CondZ, dis_SCAS, sz, eip_orig, eip, "repe scas" );
-         *isEnd = True;         
-      }
-      else
-      if (abyte == 0x90) { /* REP NOP (PAUSE) */
+         break;
+      
+      case 0x90:           /* REP NOP (PAUSE) */
          /* a hint to the P4 re spin-wait loop */
          DIP("rep nop (P4 pause)\n");
          jmp_lit(cb, eip);
          LAST_UINSTR(cb).jmpkind = JmpYield;
-         *isEnd = True;
-      }
-      else
-      if (abyte == 0xC3) { /* REP RET */
+         break;
+
+      case 0xC3:           /* REP RET */
          /* AMD K7/K8-specific optimisation; faster than vanilla RET */
          dis_ret(cb, 0);
-         *isEnd = True;
          DIP("rep ret\n");
-      }
-      else {
+         break;
+
+      default:
          goto decode_failure;
       }

CVS commit by fitzhardinge: 

Oops - fix up broken assert.


  M +1 -1      vg_signals.c   1.69


--- valgrind/coregrind/vg_signals.c  #1.68:1.69
@@ -442,5 +442,5 @@ void VG_(handle_SCSS_change) ( Bool forc
                    == skss_old.skss_per_sig[sig].skss_flags);
          vg_assert(ksa_old.ksa_restorer 
-                   == NULL);
+                   == VG_(sigreturn));
          VG_(ksigaddset)( &ksa_old.ksa_mask, VKI_SIGKILL );
          VG_(ksigaddset)( &ksa_old.ksa_mask, VKI_SIGSTOP );

CVS commit by thughes: 

Changed cancellation wrappers to use dlsym(RTLD_NEXT) to look up the
libc version of the wrapped function when forwarding the call rather
than trying to call the internal __libc_xxx version of the routine
as many of those are marked as GLIBC_PRIVATE in recent releases.

CCMAIL: 82026-done@...


  M +114 -116  vg_libpthread.c   1.152


--- valgrind/coregrind/vg_libpthread.c  #1.151:1.152
@@ -2043,17 +2043,19 @@ void ** (*__libc_internal_tsd_address) 
    ------------------------------------------------------------------ */
 
-#ifdef GLIBC_2_1
-extern
-int __sigaction
-             (int signum, 
-              const struct sigaction *act,  
-              struct  sigaction *oldact);
-#else
-extern
-int __libc_sigaction
+#define FORWARD(name, args...) \
+  ({ \
+    static name##_t name##_ptr = NULL; \
+    if (name##_ptr == NULL) { \
+      name##_ptr = (name##_t)dlsym(RTLD_NEXT, #name); \
+      my_assert(name##_ptr != NULL); \
+    } \
+    name##_ptr(args); \
+  })
+
+typedef
+int (*sigaction_t)
              (int signum, 
               const struct sigaction *act,  
               struct  sigaction *oldact);
-#endif
 int sigaction(int signum, 
               const struct sigaction *act,  
@@ -2061,23 +2063,19 @@ int sigaction(int signum, 
 {
    __my_pthread_testcancel();
-#  ifdef GLIBC_2_1
-   return __sigaction(signum, act, oldact);
-#  else
-   return __libc_sigaction(signum, act, oldact);
-#  endif
+   return FORWARD(sigaction, signum, act, oldact);
 }
 
-extern 
-int __libc_accept(int fd, struct sockaddr *addr, socklen_t *len);
+typedef 
+int (*__accept_t)(int fd, struct sockaddr *addr, socklen_t *len);
 
 WEAK int __accept(int fd, struct sockaddr *addr, socklen_t *len)
 {
    __my_pthread_testcancel();
-   return __libc_accept(fd, addr, len);
+   return FORWARD(__accept, fd, addr, len);
 }
 strong_alias(__accept, accept);
 
-extern
-int  __libc_connect(int  sockfd,  
+typedef
+int (*connect_t)(int sockfd,  
                     const  struct  sockaddr  *serv_addr, 
                     socklen_t addrlen);
@@ -2088,134 +2086,134 @@ int  connect(int  sockfd,  
 {
    __my_pthread_testcancel();
-   return __libc_connect(sockfd, serv_addr, addrlen);
+   return FORWARD(connect, sockfd, serv_addr, addrlen);
 }
 
 
-extern
-int __libc_fcntl(int fd, int cmd, long arg);
+typedef
+int (*fcntl_t)(int fd, int cmd, long arg);
 WEAK
 int fcntl(int fd, int cmd, long arg)
 {
    __my_pthread_testcancel();
-   return __libc_fcntl(fd, cmd, arg);
+   return FORWARD(fcntl, fd, cmd, arg);
 }
 
 
-extern 
-ssize_t __libc_write(int fd, const void *buf, size_t count);
+typedef 
+ssize_t (*write_t)(int fd, const void *buf, size_t count);
 WEAK
 ssize_t write(int fd, const void *buf, size_t count)
 {
    __my_pthread_testcancel();
-   return __libc_write(fd, buf, count);
+   return FORWARD(write, fd, buf, count);
 }
 
 
-extern 
-ssize_t __libc_read(int fd, void *buf, size_t count);
+typedef
+ssize_t (*read_t)(int fd, void *buf, size_t count);
 WEAK
 ssize_t read(int fd, void *buf, size_t count)
 {
    __my_pthread_testcancel();
-   return __libc_read(fd, buf, count);
+   return FORWARD(read, fd, buf, count);
 }
 
-extern
-int __libc_open64(const char *pathname, int flags, mode_t mode);
+typedef
+int (*open64_t)(const char *pathname, int flags, mode_t mode);
 /* WEAK */
 int open64(const char *pathname, int flags, mode_t mode)
 {
-   return __libc_open64(pathname, flags, mode);
+   return FORWARD(open64, pathname, flags, mode);
 }
 
-extern
-int __libc_open(const char *pathname, int flags, mode_t mode);
+typedef
+int (*open_t)(const char *pathname, int flags, mode_t mode);
 /* WEAK */
 int open(const char *pathname, int flags, mode_t mode)
 {
-   return __libc_open(pathname, flags, mode);
+   return FORWARD(open, pathname, flags, mode);
 }
 
-extern
-int __libc_close(int fd);
+typedef
+int (*close_t)(int fd);
 WEAK
 int close(int fd)
 {
    __my_pthread_testcancel();
-   return __libc_close(fd);
+   return FORWARD(close, fd);
 }
 
 
-extern
-pid_t __libc_waitpid(pid_t pid, int *status, int options);
+typedef
+pid_t (*waitpid_t)(pid_t pid, int *status, int options);
 WEAK
 pid_t waitpid(pid_t pid, int *status, int options)
 {
    __my_pthread_testcancel();
-   return __libc_waitpid(pid, status, options);
+   return FORWARD(waitpid, pid, status, options);
 }
 
 
-extern
-int __libc_nanosleep(const struct timespec *req, struct timespec *rem);
+typedef
+int (*nanosleep_t)(const struct timespec *req, struct timespec *rem);
 WEAK
 int __nanosleep(const struct timespec *req, struct timespec *rem)
 {
    __my_pthread_testcancel();
-   return __libc_nanosleep(req, rem);
+   return FORWARD(nanosleep, req, rem);
 }
 
-extern
-int __libc_pause(void);
+typedef
+int (*pause_t)(void);
 WEAK
 int __pause(void)
 {
    __my_pthread_testcancel();
-   return __libc_pause();
+   return FORWARD(pause);
 }
 
 
-extern
-int __libc_tcdrain(int fd);
+typedef
+int (*tcdrain_t)(int fd);
 WEAK
 int __tcdrain(int fd)
 {
    __my_pthread_testcancel();
-   return __libc_tcdrain(fd);
+   return FORWARD(tcdrain, fd);
 }
 
 
-extern
-int __libc_fsync(int fd);
+typedef
+int (*fsync_t)(int fd);
 WEAK
 int fsync(int fd)
 {
    __my_pthread_testcancel();
-   return __libc_fsync(fd);
+   return FORWARD(fsync, fd);
 }
 
 
-extern
-off_t __libc_lseek(int fildes, off_t offset, int whence);
+typedef
+off_t (*lseek_t)(int fildes, off_t offset, int whence);
 WEAK
 off_t lseek(int fildes, off_t offset, int whence)
 {
    __my_pthread_testcancel();
-   return __libc_lseek(fildes, offset, whence);
+   return FORWARD(lseek, fildes, offset, whence);
 }
 
 
-extern
-__off64_t __libc_lseek64(int fildes, __off64_t offset, int whence);
+typedef
+__off64_t (*lseek64_t)(int fildes, __off64_t offset, int whence);
 WEAK
 __off64_t lseek64(int fildes, __off64_t offset, int whence)
 {
    __my_pthread_testcancel();
-   return __libc_lseek64(fildes, offset, whence);
+   return FORWARD(lseek64, fildes, offset, whence);
 }
 
 
-extern 
-ssize_t __libc_pread64 (int __fd, void *__buf, size_t __nbytes,
+typedef 
+ssize_t (*__pread64_t) (int __fd, void *__buf, size_t __nbytes,
                         __off64_t __offset);
 ssize_t __pread64 (int __fd, void *__buf, size_t __nbytes,
@@ -2223,10 +2221,10 @@ ssize_t __pread64 (int __fd, void *__buf
 {
    __my_pthread_testcancel();
-   return __libc_pread64(__fd, __buf, __nbytes, __offset);
+   return FORWARD(__pread64, __fd, __buf, __nbytes, __offset);
 }
 
 
-extern
-ssize_t __libc_pwrite64 (int __fd, const void *__buf, size_t __nbytes,
+typedef
+ssize_t (*__pwrite64_t) (int __fd, const void *__buf, size_t __nbytes,
                         __off64_t __offset);
 ssize_t __pwrite64 (int __fd, const void *__buf, size_t __nbytes,
@@ -2234,68 +2232,68 @@ ssize_t __pwrite64 (int __fd, const void
 {
    __my_pthread_testcancel();
-   return __libc_pwrite64(__fd, __buf, __nbytes, __offset);
+   return FORWARD(__pwrite64, __fd, __buf, __nbytes, __offset);
 }
 
 
-extern 
-ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset);
+typedef 
+ssize_t (*pwrite_t)(int fd, const void *buf, size_t count, off_t offset);
 WEAK
 ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset)
 {
    __my_pthread_testcancel();
-   return __libc_pwrite(fd, buf, count, offset);
+   return FORWARD(pwrite, fd, buf, count, offset);
 }
 
 
-extern 
-ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset);
+typedef 
+ssize_t (*pread_t)(int fd, void *buf, size_t count, off_t offset);
 WEAK
 ssize_t pread(int fd, void *buf, size_t count, off_t offset)
 {
    __my_pthread_testcancel();
-   return __libc_pread(fd, buf, count, offset);
+   return FORWARD(pread, fd, buf, count, offset);
 }
 
-extern
-int __libc_recv(int s, void *msg, size_t len, int flags);
+typedef
+int (*recv_t)(int s, void *msg, size_t len, int flags);
 WEAK
 int recv(int s, void *msg, size_t len, int flags)
 {
    __my_pthread_testcancel();
-   return __libc_recv(s, msg, len, flags);
+   return FORWARD(recv, s, msg, len, flags);
 }
 
-extern
-int __libc_send(int s, const void *msg, size_t len, int flags);
+typedef
+int (*send_t)(int s, const void *msg, size_t len, int flags);
 WEAK
 int send(int s, const void *msg, size_t len, int flags)
 {
    __my_pthread_testcancel();
-   return __libc_send(s, msg, len, flags);
+   return FORWARD(send, s, msg, len, flags);
 }
 
 
-extern 
-int __libc_sendmsg(int s, const struct msghdr *msg, int flags);
+typedef 
+int (*sendmsg_t)(int s, const struct msghdr *msg, int flags);
 WEAK
 int sendmsg(int s, const struct msghdr *msg, int flags)
 {
    __my_pthread_testcancel();
-   return __libc_sendmsg(s, msg, flags);
+   return FORWARD(sendmsg, s, msg, flags);
 }
 
 
-extern
-int __libc_recvmsg(int s, struct msghdr *msg, int flags);
+typedef
+int (*recvmsg_t)(int s, struct msghdr *msg, int flags);
 WEAK
 int recvmsg(int s, struct msghdr *msg, int flags)
 {
    __my_pthread_testcancel();
-   return __libc_recvmsg(s, msg, flags);
+   return FORWARD(recvmsg, s, msg, flags);
 }
 
 
-extern
-int __libc_recvfrom(int s, void *buf, size_t len, int flags,
+typedef
+int (*recvfrom_t)(int s, void *buf, size_t len, int flags,
                     struct sockaddr *from, socklen_t *fromlen);
 WEAK
@@ -2304,10 +2302,10 @@ int recvfrom(int s, void *buf, size_t le
 {
    __my_pthread_testcancel();
-   return __libc_recvfrom(s, buf, len, flags, from, fromlen);
+   return FORWARD(recvfrom, s, buf, len, flags, from, fromlen);
 }
 
 
-extern
-int __libc_sendto(int s, const void *msg, size_t len, int flags, 
+typedef
+int (*sendto_t)(int s, const void *msg, size_t len, int flags, 
                   const struct sockaddr *to, socklen_t tolen);
 WEAK
@@ -2316,35 +2314,35 @@ int sendto(int s, const void *msg, size_
 {
    __my_pthread_testcancel();
-   return __libc_sendto(s, msg, len, flags, to, tolen);
+   return FORWARD(sendto, s, msg, len, flags, to, tolen);
 }
 
 
-extern 
-int __libc_system(const char* str);
+typedef 
+int (*system_t)(const char* str);
 WEAK
 int system(const char* str)
 {
    __my_pthread_testcancel();
-   return __libc_system(str);
+   return FORWARD(system, str);
 }
 
 
-extern
-pid_t __libc_wait(int *status);
+typedef
+pid_t (*wait_t)(int *status);
 WEAK
 pid_t wait(int *status)
 {
    __my_pthread_testcancel();
-   return __libc_wait(status);
+   return FORWARD(wait, status);
 }
 
 
-extern
-int __libc_msync(const void *start, size_t length, int flags);
+typedef
+int (*msync_t)(const void *start, size_t length, int flags);
 WEAK
 int msync(const void *start, size_t length, int flags)
 {
    __my_pthread_testcancel();
-   return __libc_msync(start, length, flags);
+   return FORWARD(msync, start, length, flags);
 }
 
@@ -2367,19 +2365,19 @@ weak_alias(__tcdrain, tcdrain)
 
 
-extern  
-void __libc_longjmp(jmp_buf env, int val) __attribute((noreturn));
+typedef  
+void (*longjmp_t)(jmp_buf env, int val) __attribute((noreturn));
 /* not weak: WEAK */
 void longjmp(jmp_buf env, int val)
 {
-   __libc_longjmp(env, val);
+   FORWARD(longjmp, env, val);
 }
 
 
-extern void __libc_siglongjmp (sigjmp_buf env, int val)
+typedef void (*siglongjmp_t) (sigjmp_buf env, int val)
                                __attribute__ ((noreturn));
 void siglongjmp(sigjmp_buf env, int val)
 {
    kludged("siglongjmp", "(it ignores cleanup handlers)");
-   __libc_siglongjmp(env, val);
+   FORWARD(siglongjmp, env, val);
 }
 
@@ -2434,6 +2432,6 @@ void run_fork_handlers ( int what )
 }
 
-extern
-pid_t __libc_fork(void);
+typedef
+pid_t (*__fork_t)(void);
 pid_t __fork(void)
 {
@@ -2443,5 +2441,5 @@ pid_t __fork(void)
 
    run_fork_handlers(0 /* prepare */);
-   pid = __libc_fork();
+   pid = FORWARD(__fork);
    if (pid == 0) {
       /* I am the child */

On Thu, 2004-06-03 at 20:00 +0200, Tom Hughes wrote:
> CVS commit by thughes: 
> 
> Changed cancellation wrappers to use dlsym(RTLD_NEXT) to look up the
> libc version of the wrapped function when forwarding the call rather
> than trying to call the internal __libc_xxx version of the routine
> as many of those are marked as GLIBC_PRIVATE in recent releases.

Will this work if libc is stripped?

I was just working on an alternative fix for this by having private
versions of the __libc_ functions, at least for syscalls.  

	J

In message <1086300319.892.6.camel@...>
          Jeremy Fitzhardinge <jeremy@...> wrote:

> On Thu, 2004-06-03 at 20:00 +0200, Tom Hughes wrote:
>
> > Changed cancellation wrappers to use dlsym(RTLD_NEXT) to look up the
> > libc version of the wrapped function when forwarding the call rather
> > than trying to call the internal __libc_xxx version of the routine
> > as many of those are marked as GLIBC_PRIVATE in recent releases.
> 
> Will this work if libc is stripped?

You can't strip the dynamic symbol table from a shared library if
you want it to actually work... Note that it isn't the __libc_xxx
functions I'm forwarding to, it's the original names that are being
overridden by the pthread library.

The only thing I'm not sure about is statically linked programs
but I'm not sure you can statically link a multithreaded program.

> I was just working on an alternative fix for this by having private
> versions of the __libc_ functions, at least for syscalls.

The problem is that even the ones that appear to be simple system
call wrappers aren't always - witness the fcntl issue where it
sometimes calls the fcntl64 system call instead.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Thu, 3 Jun 2004, Tom Hughes wrote:

> > > Changed cancellation wrappers to use dlsym(RTLD_NEXT) to look up the
> > > libc version of the wrapped function when forwarding the call rather
> > > than trying to call the internal __libc_xxx version of the routine
> > > as many of those are marked as GLIBC_PRIVATE in recent releases.
> >
> > Will this work if libc is stripped?
>
> You can't strip the dynamic symbol table from a shared library if
> you want it to actually work... Note that it isn't the __libc_xxx
> functions I'm forwarding to, it's the original names that are being
> overridden by the pthread library.
>
> The only thing I'm not sure about is statically linked programs
> but I'm not sure you can statically link a multithreaded program.

You can -- I just tried it.  But Memcheck didn't like it, gave lots of
uninitialised warnings and then bombed out with:

  ==29475== Valgrind detected that your program requires
  ==29475== the following unimplemented functionality:
  ==29475==    clone(): not supported by Valgrind.
     We do now support programs linked against
     libpthread.so, though.  Re-run with -v and ensure that
     you are picking up Valgrind's implementation of libpthread.so.

I guess V's libpthread.so isn't overriding the statically linked system
one.

N

On Thu, 2004-06-03 at 23:51 +0100, Tom Hughes wrote:
>  Note that it isn't the __libc_xxx
> functions I'm forwarding to, it's the original names that are being
> overridden by the pthread library.

Right, OK.

> The only thing I'm not sure about is statically linked programs
> but I'm not sure you can statically link a multithreaded program.

You can, but we basically lose.

> > I was just working on an alternative fix for this by having private
> > versions of the __libc_ functions, at least for syscalls.
> 
> The problem is that even the ones that appear to be simple system
> call wrappers aren't always - witness the fcntl issue where it
> sometimes calls the fcntl64 system call instead.

Yeah, I wasn't relishing debugging all that.  Your approach looks fine.

	J

In message <Pine.SOL.4.58.0406040840040.11757@...>
        Nicholas Nethercote <njn25@...> wrote:

> On Thu, 3 Jun 2004, Tom Hughes wrote:
>
>> The only thing I'm not sure about is statically linked programs
>> but I'm not sure you can statically link a multithreaded program.
>
> You can -- I just tried it.  But Memcheck didn't like it, gave lots of
> uninitialised warnings and then bombed out with:
>
>   ==29475== Valgrind detected that your program requires
>   ==29475== the following unimplemented functionality:
>   ==29475==    clone(): not supported by Valgrind.
>      We do now support programs linked against
>      libpthread.so, though.  Re-run with -v and ensure that
>      you are picking up Valgrind's implementation of libpthread.so.
>
> I guess V's libpthread.so isn't overriding the statically linked system
> one.

Well it won't - if you're statically linked against libpthread then
the dynamic linker won't try and load the dynamic version because it
won't be listed as a dependency and all the calls to the functions in
it will have been resolved anyway.

I wasn't sure it would work even without valgrind because of the way
libpthread normally uses dynamic linker tricks to override functions
in the main C library but I guess there must be weak symbol tricks or
something to make it work in static links.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

On Fri, 4 Jun 2004, Tom Hughes wrote:

> > I guess V's libpthread.so isn't overriding the statically linked system
> > one.
>
> Well it won't - if you're statically linked against libpthread then
> the dynamic linker won't try and load the dynamic version because it
> won't be listed as a dependency and all the calls to the functions in
> it will have been resolved anyway.
>
> I wasn't sure it would work even without valgrind because of the way
> libpthread normally uses dynamic linker tricks to override functions
> in the main C library but I guess there must be weak symbol tricks or
> something to make it work in static links.

Could V use its interception mechanism here?  Likewise for malloc() et al
for statically linked binaries?

N

On Friday 04 June 2004 09:59, Nicholas Nethercote wrote:
> On Fri, 4 Jun 2004, Tom Hughes wrote:
> > I wasn't sure it would work even without valgrind because of the way
> > libpthread normally uses dynamic linker tricks to override functions
> > in the main C library but I guess there must be weak symbol tricks or
> > something to make it work in static links.
>
> Could V use its interception mechanism here?  Likewise for malloc() et al
> for statically linked binaries?

This would be at compile time: the user has to link with V'pthread then. Or is 
this already possible?

Josef

On Fri, 4 Jun 2004, Josef Weidendorfer wrote:

> > Could V use its interception mechanism here?  Likewise for malloc() et al
> > for statically linked binaries?
>
> This would be at compile time: the user has to link with V'pthread then. Or is
> this already possible?

Not necessarily;  AIUI, V has a mechanism whereby if it's told to
translate some code that in at the start of a particular function which it
wants to intercept, it doesn't translate the original but translates its
own version instead.  But I could be wrong...

N

CVS commit by thughes: 

There is no __accept in any libc or libpthread that I can find so
it isn't clear why we were intercepting that and only aliasing accept
to it. Switched to intercepting accept directly instead.

CCMAIL: 76869-done@...


  M +4 -4      vg_libpthread.c   1.153


--- valgrind/coregrind/vg_libpthread.c  #1.152:1.153
@@ -2067,12 +2067,12 @@ int sigaction(int signum, 
 
 typedef 
-int (*__accept_t)(int fd, struct sockaddr *addr, socklen_t *len);
+int (*accept_t)(int fd, struct sockaddr *addr, socklen_t *len);
 
-WEAK int __accept(int fd, struct sockaddr *addr, socklen_t *len)
+WEAK
+int accept(int fd, struct sockaddr *addr, socklen_t *len)
 {
    __my_pthread_testcancel();
-   return FORWARD(__accept, fd, addr, len);
+   return FORWARD(accept, fd, addr, len);
 }
-strong_alias(__accept, accept);
 
 typedef

> Not necessarily;  AIUI, V has a mechanism whereby if it's told to
> translate some code that in at the start of a particular function which i=
t
> wants to intercept, it doesn't translate the original but translates its
> own version instead.  But I could be wrong...

Yup - that's what it does.  Look in coregrind/vg_symtab2.c for
VG_(add_redirect_addr) and VG_(add_redirect_sym).  I've not tried this
with symbols or addresses from static libraries, but in theory it should
work.

Regards,
 Robert.

--=20
Robert Walsh
Amalgamated Durables, Inc.  -  "We don't make the things you buy."
Email: rjwalsh@...

CVS commit by thughes: 

Add support for separate debug files, which are just separate ELF files
containing the relevant debug sections and located using the information
in the .gnu_debuglink section of the main file along with some search
rules and checksum logic borrowed from binutils/gdb.

CCMAIL: 82872-done@...


  M +199 -1    vg_symtab2.c   1.79


--- valgrind/coregrind/vg_symtab2.c  #1.78:1.79
@@ -1004,4 +1004,142 @@ void read_symtab( SegInfo* si, Char* tab
 }
 
+/*
+ * This routine for calculating the CRC for a separate debug file
+ * is GPLed code borrowed from binutils.
+ */
+static UInt
+calc_gnu_debuglink_crc32(UInt crc, const UChar *buf, Int len)
+{
+  static const UInt crc32_table[256] =
+    {
+      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+      0x2d02ef8d
+    };
+  const UChar *end;
+
+  crc = ~crc & 0xffffffff;
+  for (end = buf + len; buf < end; ++ buf)
+    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
+  return ~crc & 0xffffffff;;
+}
+
+/*
+ * Try and open a separate debug file, ignoring any where the CRC does
+ * not match the value from the main object file.
+ */
+static
+Addr open_debug_file( Char* name, UInt crc, UInt* size )
+{
+   Int fd;
+   struct vki_stat stat_buf;
+   Addr addr;
+
+   if ((fd = VG_(open)(name, VKI_O_RDONLY, 0)) < 0)
+      return 0;
+
+   if (VG_(fstat)(fd, &stat_buf) != 0) {
+      VG_(close)(fd);
+      return 0;
+   }
+
+   *size = stat_buf.st_size;
+   
+   if ((addr = (Addr)VG_(mmap)(NULL, *size, VKI_PROT_READ,
+                               VKI_MAP_PRIVATE|VKI_MAP_NOSYMS, fd, 0)) == (Addr)-1) {
+      VG_(close)(fd);
+      return 0;
+   }
+
+   VG_(close)(fd);
+   
+   if (calc_gnu_debuglink_crc32(0, (UChar*)addr, *size) != crc) {
+      VG_(munmap)((void*)addr, *size);
+      return 0;
+   }
+   
+   return addr;
+}
+
+/*
+ * Try and find a seperated debug file for a given object file.
+ */
+static
+Addr find_debug_file( Char* objpath, Char* debugname, UInt crc, UInt* size )
+{
+   Char *objdir = VG_(strdup)(objpath);
+   Char *objdirptr;
+   Char *debugpath;
+   Addr addr = 0;
+  
+   if ((objdirptr = VG_(strrchr)(objdir, '/')) != NULL)
+      *objdirptr = '\0';
+
+   debugpath = VG_(malloc)(VG_(strlen)(objdir) + VG_(strlen)(debugname) + 16);
+   
+   VG_(sprintf)(debugpath, "%s/%s", objdir, debugname);
+
+   if ((addr = open_debug_file(debugpath, crc, size)) == 0) {
+      VG_(sprintf)(debugpath, "%s/.debug/%s", objdir, debugname);
+      if ((addr = open_debug_file(debugpath, crc, size)) == 0) {
+         VG_(sprintf)(debugpath, "/usr/lib/debug%s/%s", objdir, debugname);
+         addr = open_debug_file(debugpath, crc, size);
+      }
+   }
+
+   VG_(free)(debugpath);
+   VG_(free)(objdir);
+   
+   return addr;
+}
 
 /* Read the symbols from the object/exe specified by the SegInfo into
@@ -1019,4 +1157,6 @@ Bool vg_read_lib_symbols ( SegInfo* si )
    Addr          oimage;
    UInt          n_oimage;
+   Addr          dimage = 0;
+   UInt          n_dimage = 0;
    struct vki_stat stat_buf;
 
@@ -1200,4 +1340,5 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       UChar*     o_dynstr     = NULL; /* .dynstr */
       Elf32_Sym* o_dynsym     = NULL; /* .dynsym */
+      Char*      debuglink    = NULL; /* .gnu_debuglink */
       UChar*     stab         = NULL; /* .stab         (stabs)  */
       UChar*     stabstr      = NULL; /* .stabstr      (stabs)  */
@@ -1211,4 +1352,5 @@ Bool vg_read_lib_symbols ( SegInfo* si )
       UInt       o_dynstr_sz     = 0;
       UInt       o_dynsym_sz     = 0;
+      UInt       debuglink_sz    = 0;
       UInt       stab_sz         = 0;
       UInt       stabstr_sz      = 0;
@@ -1245,4 +1387,6 @@ Bool vg_read_lib_symbols ( SegInfo* si )
          else FIND(".strtab",       o_strtab,     o_strtab_sz,   0, UChar*)
 
+         else FIND(".gnu_debuglink", debuglink,   debuglink_sz,  0, Char*)
+
          else FIND(".stab",         stab,         stab_sz,       0, UChar*)
          else FIND(".stabstr",      stabstr,      stabstr_sz,    0, UChar*)
@@ -1269,4 +1413,57 @@ Bool vg_read_lib_symbols ( SegInfo* si )
                   o_dynstr, o_dynstr_sz);
 
+      /* Did we find a debuglink section? */
+      if (debuglink != NULL) {
+         UInt crc_offset = (VG_(strlen)(debuglink) + 4) & ~3;
+         UInt crc;
+
+         vg_assert(crc_offset + sizeof(UInt) <= debuglink_sz);
+
+         /* Extract the CRC from the debuglink section */
+         crc = *(UInt *)(debuglink + crc_offset);
+
+         /* See if we can find a matching debug file */
+         if ((dimage = find_debug_file(si->filename, debuglink, crc, &n_dimage)) != 0) {
+            ehdr = (Elf32_Ehdr*)dimage;
+
+            if (n_dimage >= sizeof(Elf32_Ehdr) && VG_(is_object_file)(ehdr))
+            {
+               shdr = (Elf32_Shdr*)(dimage + ehdr->e_shoff);
+               sh_strtab = (UChar*)(dimage + shdr[ehdr->e_shstrndx].sh_offset);
+
+               /* Find all interesting sections */
+               for (i = 0; i < ehdr->e_shnum; i++) {
+#                 define FIND(sec_name, sec_data, sec_size, type) \
+                  if (0 == VG_(strcmp)(sec_name, sh_strtab + shdr[i].sh_name)) { \
+                     if (0 != sec_data) \
+                        VG_(core_panic)("repeated section!\n"); \
+                     sec_data = (type)(dimage + shdr[i].sh_offset); \
+                     sec_size = shdr[i].sh_size; \
+                     TRACE_SYMTAB( "%18s: %p .. %p\n", \
+                                   sec_name, sec_data, sec_data + sec_size - 1); \
+                     if ( shdr[i].sh_offset + sec_size > n_dimage ) { \
+                        VG_(symerr)("   section beyond image end?!"); \
+                        goto out; \
+                     } \
+                  }
+
+                  /* Nb: must find where .got and .plt sections will be in the
+                   * executable image, not in the object image transiently loaded. */
+                       FIND(".stab",         stab,         stab_sz,       UChar*)
+                  else FIND(".stabstr",      stabstr,      stabstr_sz,    UChar*)
+                  else FIND(".debug_line",   debug_line,   debug_line_sz, UChar*)
+                  else FIND(".debug",        dwarf1d,      dwarf1d_sz,    UChar*)
+                  else FIND(".line",         dwarf1l,      dwarf1l_sz,    UChar*)
+
+#                 undef FIND
+         
+                  /* Check some sizes */
+                  vg_assert((o_dynsym_sz % sizeof(Elf32_Sym)) == 0);
+                  vg_assert((o_symtab_sz % sizeof(Elf32_Sym)) == 0);
+               }
+            }
+         }
+      }
+
       /* Read the stabs and/or dwarf2 debug information, if any. */
       if (stab != NULL && stabstr != NULL) {
@@ -1292,5 +1489,6 @@ Bool vg_read_lib_symbols ( SegInfo* si )
 
   out:
-   /* Last, but not least, heave the oimage back overboard. */
+   /* Last, but not least, heave the image(s) back overboard. */
+   if (dimage) VG_(munmap) ( (void*)dimage, n_dimage );
    VG_(munmap) ( (void*)oimage, n_oimage );
    return res;

CVS commit by thughes: 

When cancelling a thread that is waiting on a condition variable we
need to relock the associated mutex before running the cancellation
handlers.

This patch ensures that the mutex is reaquired in the above case and
also makes pthread_join and pthread_cond_wait act as cancellation points
as required by the POSIX threads standard.

Based on patch from Joseph Link <joelink@...>.

CCMAIL: 81297-done@...


  M +90 -34    vg_scheduler.c   1.150


--- valgrind/coregrind/vg_scheduler.c  #1.149:1.150
@@ -1335,6 +1335,4 @@ void make_thread_jump_to_cancelhdlr ( Th
    VG_(proxy_abort_syscall)(tid);
 
-   VG_(threads)[tid].status = VgTs_Runnable;
-
    /* Make sure we aren't cancelled again whilst handling this
       cancellation. */
@@ -1346,4 +1344,49 @@ void make_thread_jump_to_cancelhdlr ( Th
       print_sched_event(tid, msg_buf);
    }
+
+   if(VG_(threads)[tid].status == VgTs_WaitCV) {
+      /* posix says we must reaquire mutex before handling cancelation */
+      vg_pthread_mutex_t* mx;
+      vg_pthread_cond_t* cond;
+      
+      mx = VG_(threads)[tid].associated_mx;
+      cond = VG_(threads)[tid].associated_cv;
+      VG_TRACK( pre_mutex_lock, tid, mx );
+
+      if (mx->__vg_m_owner == VG_INVALID_THREADID) {
+         /* Currently unheld; hand it out to thread tid. */
+         vg_assert(mx->__vg_m_count == 0);
+         VG_(threads)[tid].status        = VgTs_Runnable;
+         VG_(threads)[tid].associated_cv = NULL;
+         VG_(threads)[tid].associated_mx = NULL;
+         mx->__vg_m_owner = (_pthread_descr)tid;
+         mx->__vg_m_count = 1;
+         /* .m_edx already holds pth_cond_wait success value (0) */
+
+         VG_TRACK( post_mutex_lock, tid, mx );
+
+         if (VG_(clo_trace_pthread_level) >= 1) {
+            VG_(sprintf)(msg_buf, "%s   cv %p: RESUME with mx %p",
+                                  "pthread_cancel", cond, mx );
+            print_pthread_event(tid, msg_buf);
+         }
+
+      } else {
+         /* Currently held.  Make thread tid be blocked on it. */
+         vg_assert(mx->__vg_m_count > 0);
+         VG_(threads)[tid].status        = VgTs_WaitMX;
+         VG_(threads)[tid].associated_cv = NULL;
+         VG_(threads)[tid].associated_mx = mx;
+         SET_PTHREQ_RETVAL(tid, 0); /* pth_cond_wait success value */
+
+         if (VG_(clo_trace_pthread_level) >= 1) {
+            VG_(sprintf)(msg_buf, "%s   cv %p: BLOCK for mx %p",
+                                  "pthread_cancel", cond, mx );
+            print_pthread_event(tid, msg_buf);
+         }
+      }
+   } else {
+      VG_(threads)[tid].status = VgTs_Runnable;
+   }
 }
 
@@ -1699,6 +1742,9 @@ void do__set_cancelpend ( ThreadId tid, 
 
    /* Perhaps we can nuke the cancellee right now? */
-   if (!VG_(threads)[cee].cancel_ty) /* if PTHREAD_CANCEL_ASYNCHRONOUS */
+   if (!VG_(threads)[cee].cancel_ty || /* if PTHREAD_CANCEL_ASYNCHRONOUS */
+       (VG_(threads)[cee].status != VgTs_Runnable &&
+        VG_(threads)[cee].status != VgTs_WaitMX)) {
       do__testcancel(cee);
+   }
 }
 
@@ -1752,4 +1798,8 @@ void do_pthread_join ( ThreadId tid, 
    }
 
+   if(VG_(threads)[tid].cancel_pend != NULL &&
+      VG_(threads)[tid].cancel_st) {
+      make_thread_jump_to_cancelhdlr ( tid );
+   } else {
    /* Mark this thread as waiting for the joinee. */
    VG_(threads)[tid].status = VgTs_WaitJoinee;
@@ -1769,4 +1819,5 @@ void do_pthread_join ( ThreadId tid, 
       print_sched_event(tid, msg_buf);
    }
+   }
 }
 
@@ -2432,4 +2483,8 @@ void do_pthread_cond_wait ( ThreadId tid
    }
 
+   if(VG_(threads)[tid].cancel_pend != NULL &&
+      VG_(threads)[tid].cancel_st) {
+      make_thread_jump_to_cancelhdlr ( tid );
+   } else {
    /* Queue ourselves on the condition. */
    VG_(threads)[tid].status        = VgTs_WaitCV;
@@ -2449,4 +2504,5 @@ void do_pthread_cond_wait ( ThreadId tid
    /* Release the mutex. */
    release_one_thread_waiting_on_mutex ( mutex, "pthread_cond_wait " );
+   }
 }

As of today's patch (yes, autogen.sh was run this time):

if gcc -DHAVE_CONFIG_H -I. -I. -I..  -I./demangle -I../include -I./x86 
-DVG_LIBDIR="\"/usr/local/lib/valgrind"\"   -Winline -Wall -Wshadow -O 
-fno-omit-frame-pointer -mpreferred-stack-boundary=2 -g -DELFSZ=32 
-MT vg_scheduler.o -MD -MP -MF ".deps/vg_scheduler.Tpo" -c -o 
vg_scheduler.o vg_scheduler.c; \
then mv -f ".deps/vg_scheduler.Tpo" ".deps/vg_scheduler.Po"; else rm 
-f ".deps/vg_scheduler.Tpo"; exit 1; fi
vg_scheduler.c: In function `make_thread_jump_to_cancelhdlr':
vg_scheduler.c:1362: error: `_pthread_descr' undeclared (first use in 
this function)
vg_scheduler.c:1362: error: (Each undeclared identifier is reported 
only once
vg_scheduler.c:1362: error: for each function it appears in.)
vg_scheduler.c:1362: error: syntax error before "tid"


======================================
Bob Friesenhahn
bfriesen@...
http://www.simplesystems.org/users/bfriesen

CVS commit by thughes: 

Fixed cast to work on NPTL systems.


  M +1 -1      vg_scheduler.c   1.151


--- valgrind/coregrind/vg_scheduler.c  #1.150:1.151
@@ -1360,5 +1360,5 @@ void make_thread_jump_to_cancelhdlr ( Th
          VG_(threads)[tid].associated_cv = NULL;
          VG_(threads)[tid].associated_mx = NULL;
-         mx->__vg_m_owner = (_pthread_descr)tid;
+         mx->__vg_m_owner = (/*_pthread_descr*/void*)tid;
          mx->__vg_m_count = 1;
          /* .m_edx already holds pth_cond_wait success value (0) */

In message <Pine.SOC.4.60.0406130926460.3760@...>
          Bob Friesenhahn <bfriesen@...> wrote:

> As of today's patch (yes, autogen.sh was run this time):
> 
> if gcc -DHAVE_CONFIG_H -I. -I. -I..  -I./demangle -I../include -I./x86
> -DVG_LIBDIR="\"/usr/local/lib/valgrind"\"   -Winline -Wall -Wshadow -O
> -fno-omit-frame-pointer -mpreferred-stack-boundary=2 -g -DELFSZ=32
> -MT vg_scheduler.o -MD -MP -MF ".deps/vg_scheduler.Tpo" -c -o
> vg_scheduler.o vg_scheduler.c; \
> then mv -f ".deps/vg_scheduler.Tpo" ".deps/vg_scheduler.Po"; else rm
> -f ".deps/vg_scheduler.Tpo"; exit 1; fi
> vg_scheduler.c: In function `make_thread_jump_to_cancelhdlr':
> vg_scheduler.c:1362: error: `_pthread_descr' undeclared (first use in
> this function)
> vg_scheduler.c:1362: error: (Each undeclared identifier is reported
> only once
> vg_scheduler.c:1362: error: for each function it appears in.)
> vg_scheduler.c:1362: error: syntax error before "tid"

This should be fixed now. I missed something when tweaking a patch
to apply to CVS instead of the 2.0.0 tree it was written for, and
the result only worked with linuxthread headers and not NPTL headers.

Tom

-- 
Tom Hughes (thh@...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/

CVS commit by fitzhardinge: 

Fix problem with FC2's vdso (sysinfo) page, which lives at a low,
random address.  This gets unmapped as part of the client setup, and
causes syscalls to fail as a result.  This patch simply disregards the
sysinfo page.  It seems like a blunt fix, but I don't think anything
depends on a sysinfo page.


  M +5 -0      stage1.c   1.9


--- valgrind/coregrind/stage1.c  #1.8:1.9
@@ -133,4 +133,9 @@ static void *fix_auxv(void *v_init_esp, 
          auxv->u.a_val = info->entry;
          break;
+
+      case AT_SYSINFO:
+      case AT_SYSINFO_EHDR:
+         auxv->a_type = AT_IGNORE;
+         break;
       }
    }

CVS commit by nethercote: 

Unbreak compilation due to missing #define.


  M +2 -0      stage1.c   1.10


--- valgrind/coregrind/stage1.c  #1.9:1.10
@@ -135,5 +135,7 @@ static void *fix_auxv(void *v_init_esp, 
 
       case AT_SYSINFO:
+#ifdef AT_SYSINFO_EHDR
       case AT_SYSINFO_EHDR:
+#endif
          auxv->a_type = AT_IGNORE;
          break;

CVS commit by nethercote: 

Cater for systems lacking AT_SYSINFO.


  M +4 -0      stage1.c   1.11


--- valgrind/coregrind/stage1.c  #1.10:1.11
@@ -134,5 +134,8 @@ static void *fix_auxv(void *v_init_esp, 
          break;
 
+#if (defined(AT_SYSINFO) || defined(AT_SYSINFO_EHDR))
+#ifdef AT_SYSINFO
       case AT_SYSINFO:
+#endif
 #ifdef AT_SYSINFO_EHDR
       case AT_SYSINFO_EHDR:
@@ -140,4 +143,5 @@ static void *fix_auxv(void *v_init_esp, 
          auxv->a_type = AT_IGNORE;
          break;
+#endif
       }
    }

CVS commit by ossi: 

make "make dist" work.


  M +1 -0      Makefile.am   1.73


--- valgrind/coregrind/Makefile.am  #1.72:1.73
@@ -25,4 +25,5 @@
         vg_libpthread.vs valgrind.vs \
         gen_toolint.pl toolfuncs.def \
+        gen_intercepts.pl vg_replace_malloc.c.base vg_intercept.c.base \
         vg_replace_malloc.c

CVS commit by thughes: 

Add support for the HDIO_GET_IDENTITY ioctl based on patch
from Jim McDonald <jim@...>.

CCMAIL: 83340-done@...


  M +12 -0     vg_syscalls.c   1.99
  M +1 -0      vg_unsafe.h   1.29


--- valgrind/coregrind/vg_syscalls.c  #1.98:1.99
@@ -3326,4 +3326,10 @@ PRE(ioctl)
 #           endif /* BLKGETSIZE */
 
+      /* Hard disks */
+   case HDIO_GET_IDENTITY: /* 0x030d */
+      SYSCALL_TRACK( pre_mem_write,tid, "ioctl(HDIO_GET_IDENTITY)", arg3,
+                     sizeof(struct hd_driveid) );
+      break;
+
       /* CD ROM stuff (??)  */
    case CDROM_GET_MCN:
@@ -3781,4 +3787,10 @@ POST(ioctl)
 #           endif /* BLKGETSIZE */
 
+      /* Hard disks */
+   case HDIO_GET_IDENTITY: /* 0x030d */
+      if (res == 0)
+         VG_TRACK( post_mem_write,arg3, sizeof(struct hd_driveid));
+      break;
+
       /* CD ROM stuff (??)  */
    case CDROMSUBCHNL:

--- valgrind/coregrind/vg_unsafe.h  #1.28:1.29
@@ -64,4 +64,5 @@
 #include <signal.h>       /* for siginfo_t */
 #include <linux/timex.h>  /* for adjtimex */
+#include <linux/hdreg.h>  /* for hard drive ioctls */
 #ifdef HAVE_LINUX_FB_H
 #include <linux/fb.h>     /* for fb_* structs */

CVS commit by thughes: 

Prevent applications from blocking SIGVGINT in the proxy threads.


  M +4 -2      vg_proxylwp.c   1.15


--- valgrind/coregrind/vg_proxylwp.c  #1.14:1.15
@@ -682,5 +682,6 @@ static Int proxylwp(void *v)
             vg_assert(px->state == PXS_SigACK);
             appsigmask = req.sigmask;
-            VG_(ksigdelset)(&appsigmask, VKI_SIGVGKILL);  /* but allow SIGVGKILL to interrupt */
+            VG_(ksigdelset)(&appsigmask, VKI_SIGVGKILL);  /* but allow SIGVGKILL */
+            VG_(ksigdelset)(&appsigmask, VKI_SIGVGINT);   /*       and SIGVGINT to interrupt */
             px->state = PXS_WaitReq;
             reply.req = PX_BAD; /* don't reply */
@@ -689,5 +690,6 @@ static Int proxylwp(void *v)
          case PX_SetSigmask:
             appsigmask = req.sigmask;
-            VG_(ksigdelset)(&appsigmask, VKI_SIGVGKILL);   /* but allow SIGVGKILL to interrupt */
+            VG_(ksigdelset)(&appsigmask, VKI_SIGVGKILL);  /* but allow SIGVGKILL */
+            VG_(ksigdelset)(&appsigmask, VKI_SIGVGINT);   /*       and SIGVGINT to interrupt */
 
             vg_assert(px->state == PXS_WaitReq ||

CVS commit by nethercote: 

Remove two no-longer-used global vars.


  M +0 -5      vg_main.c   1.158


--- valgrind/coregrind/vg_main.c  #1.157:1.158
@@ -162,9 +162,4 @@ Char** VG_(client_envp);
 UInt VG_(sigstack)[VG_SIGSTACK_SIZE_W];
 
-/* Saving stuff across system calls. */
-__attribute__ ((aligned (16)))
-UInt VG_(real_sse_state_saved_over_syscall)[VG_SIZE_OF_SSESTATE_W];
-Addr VG_(esp_saved_over_syscall);
-
 /* jmp_buf for fatal signals */
 Int     VG_(fatal_sigNo) = -1;

CVS commit by nethercote: 

Convert VG_(exitcode), a global variable, into a local variable.


  M +1 -6      vg_include.h   1.196
  M +4 -8      vg_main.c   1.161
  M +3 -3      vg_scheduler.c   1.152


--- valgrind/coregrind/vg_include.h  #1.195:1.196
@@ -981,5 +981,5 @@ typedef
 
 /* The scheduler. */
-extern VgSchedReturnCode VG_(scheduler) ( void );
+extern VgSchedReturnCode VG_(scheduler) ( Int* exit_code );
 
 extern void VG_(scheduler_init) ( void );
@@ -1475,9 +1475,4 @@ extern UInt VG_(dispatch_ctr);
 extern ThreadId VG_(last_run_tid);
 
-/* This is the argument to __NR_exit() supplied by the first thread to
-   call that syscall.  We eventually pass that to __NR_exit() for
-   real. */
-extern Int VG_(exitcode);
-
 /* If we're doing the default action of a fatal signal */
 extern jmp_buf VG_(fatal_signal_jmpbuf);

--- valgrind/coregrind/vg_main.c  #1.160:1.161
@@ -180,9 +180,4 @@ ThreadId VG_(last_run_tid) = 0;
 Bool VG_(logging_to_filedes) = True;
 
-/* This is the argument to __NR_exit() supplied by the first thread to
-   call that syscall.  We eventually pass that to __NR_exit() for
-   real. */
-Int VG_(exitcode) = 0;
-
 
 /*====================================================================*/
@@ -2634,4 +2629,5 @@ int main(int argc, char **argv)
    UInt * client_auxv;
    VgSchedReturnCode src;
+   Int exitcode = 0;
    vki_rlimit zero = { 0, 0 };
 
@@ -2977,5 +2973,5 @@ int main(int argc, char **argv)
    if (__builtin_setjmp(&VG_(fatal_signal_jmpbuf)) == 0) {
       VG_(fatal_signal_set) = True;
-      src = VG_(scheduler)();
+      src = VG_(scheduler)( &exitcode );
    } else
       src = VgSrc_FatalSig;
@@ -3004,5 +3000,5 @@ int main(int argc, char **argv)
       VG_(show_all_errors)();
 
-   SK_(fini)( VG_(exitcode) );
+   SK_(fini)( exitcode );
 
    VG_(do_sanity_checks)( True /*include expensive checks*/ );
@@ -3046,5 +3042,5 @@ int main(int argc, char **argv)
             the arg to __NR_exit(), so we just do __NR_exit() with
             that arg. */
-         VG_(exit)( VG_(exitcode) );
+         VG_(exit)( exitcode );
          /* NOT ALIVE HERE! */
          VG_(core_panic)("entered the afterlife in main() -- ExitSyscall");

--- valgrind/coregrind/vg_scheduler.c  #1.151:1.152
@@ -877,5 +877,5 @@ void idle ( void )
    * The specified number of basic blocks has gone by.
 */
-VgSchedReturnCode VG_(scheduler) ( void )
+VgSchedReturnCode VG_(scheduler) ( Int* exitcode )
 {
    ThreadId tid, tid_next;
@@ -957,5 +957,5 @@ VgSchedReturnCode VG_(scheduler) ( void 
          /* All threads have exited - pretend someone called exit() */
          if (n_waiting_for_reaper == n_exists) {
-            VG_(exitcode) = 0;  /* ? */
+            *exitcode = 0;      /* ? */
             return VgSrc_ExitSyscall;
          }
@@ -1109,5 +1109,5 @@ VgSchedReturnCode VG_(scheduler) ( void 
 
                /* If __NR_exit, remember the supplied argument. */
-               VG_(exitcode) = VG_(threads)[tid].m_ebx; /* syscall arg1 */
+               *exitcode = VG_(threads)[tid].m_ebx; /* syscall arg1 */
 
                /* Only run __libc_freeres if the tool says it's ok and

CVS commit by nethercote: 

Remove unused #define


  M +0 -3      vg_main.c   1.162


--- valgrind/coregrind/vg_main.c  #1.161:1.162
@@ -75,7 +75,4 @@
 #endif  /* AT_SECURE */
 
-/* Amount to reserve for Valgrind's internal heap */
-#define VALGRIND_HEAPSIZE       (128*1024*1024)
-
 /* Amount to reserve for Valgrind's internal mappings */
 #define VALGRIND_MAPSIZE        (128*1024*1024)

CVS commit by nethercote: 


Reduce rounding size for gap between shadow memory and Valgrind's space from
64MB to 1MB.  Gives tools a bit more address space to play with.


  M +1 -1      vg_main.c   1.163


--- valgrind/coregrind/vg_main.c  #1.162:1.163
@@ -82,5 +82,5 @@
 
 /* size multiple for client address space */
-#define CLIENT_SIZE_MULTIPLE    (64 * 1024*1024)
+#define CLIENT_SIZE_MULTIPLE    (1 * 1024*1024)
 
 #define ISSPACE(cc)      ((cc) == ' ' || (cc) == '\t' || (cc) == '\n')

CVS commit by nethercote: 

Changed (client-heap-size : client-map-seg-size) ratio from 3:1 to 1:2.
As a result, can now mmap much more memory (eg. for Memcheck, 850MB up from
250MB, for Nulgrind 1750MB up from 700MB).  The heap is smaller, but that
doesn't matter much, since programs use brk() directly only rarely, and
malloc() falls back on mmap() if brk() fails anyway.

Also changed the debug info printing for memory layout slightly.


  M +31 -16    vg_main.c   1.165


--- valgrind/coregrind/vg_main.c  #1.164:1.165
@@ -84,5 +84,6 @@
 #define CLIENT_SIZE_MULTIPLE    (1 * 1024*1024)
 
-#define ISSPACE(cc)      ((cc) == ' ' || (cc) == '\t' || (cc) == '\n')
+/* Proportion of client space for its heap (rest is for mmaps + stack) */
+#define CLIENT_HEAP_PROPORTION   0.333
 
 /*====================================================================*/
@@ -496,13 +497,4 @@ static void layout_client_space(Addr arg
    VG_(valgrind_end)      = ROUNDUP(argc_addr, 0x10000); /* stack */
 
-   if (0)
-      printf("client base:        %x\n"
-             "valgrind base--end: %x--%x (%x)\n"
-             "valgrind mmap end:  %x\n\n",
-             VG_(client_base),
-             VG_(valgrind_base), VG_(valgrind_end),
-             VG_(valgrind_end) - VG_(valgrind_base),
-             VG_(valgrind_mmap_end));
-
    as_pad((void *)VG_(client_base), (void *)VG_(valgrind_base));
 }
@@ -518,4 +510,7 @@ static void layout_remaining_space(float
    VG_(client_end)     = VG_(client_base) + client_size;
    VG_(client_mapbase) = PGROUNDDN((client_size/4)*3); /* where !FIXED mmap goes */
+
+   /* where !FIXED mmap goes */
+   VG_(client_mapbase) = PGROUNDDN((addr_t)(client_size * CLIENT_HEAP_PROPORTION)); 
    VG_(client_trampoline_code) = VG_(client_end) - VKI_BYTES_PER_PAGE;
 
@@ -523,11 +518,27 @@ static void layout_remaining_space(float
    VG_(shadow_end)  = VG_(shadow_base) + shadow_size;
 
+#define SEGSIZE(a,b) ((VG_(b) - VG_(a))/(1024*1024))
+
    if (0)
-      printf("client base--end:   %x--%x (%x)\n"
-             "client mapbase:     %x\n"
-             "shadow base--end:   %x--%x (%x)\n\n",
-             VG_(client_base), VG_(client_end), client_size,
-             VG_(client_mapbase),
-             VG_(shadow_base), VG_(shadow_end), shadow_size);
+      VG_(printf)(
+         "client_base        %8x (%dMB)\n"
+         "client_mapbase     %8x (%dMB)\n"
+         "client_end         %8x (%dMB)\n"
+         "shadow_base        %8x (%dMB)\n"
+         "shadow_end         %8x (%dMB)\n"
+         "valgrind_base      %8x (%dMB)\n"
+         "valgrind_mmap_end  %8x (%dMB)\n"
+         "valgrind_end       %8x\n",
+         VG_(client_base),       SEGSIZE(client_base,       client_mapbase),
+         VG_(client_mapbase),    SEGSIZE(client_mapbase,    client_end),
+         VG_(client_end),        SEGSIZE(client_end,        shadow_base),
+         VG_(shadow_base),       SEGSIZE(shadow_base,       shadow_end),
+         VG_(shadow_end),        SEGSIZE(shadow_end,        valgrind_base),
+         VG_(valgrind_base),     SEGSIZE(valgrind_base,     valgrind_mmap_end),
+         VG_(valgrind_mmap_end), SEGSIZE(valgrind_mmap_end, valgrind_end),
+         VG_(valgrind_end)
+      );
+
+#undef SEGSIZE
 
    // Ban redzone
@@ -574,4 +585,6 @@ static char* get_file_clo(char* dir)
 }
 
+#define ISSPACE(cc)      ((cc) == ' ' || (cc) == '\t' || (cc) == '\n')
+
 static Int count_args(char* s)
 {
@@ -610,4 +623,6 @@ static char** copy_args( char* s, char**
 }
 
+#undef ISSPACE
+
 // Augment command line with arguments from environment and .valgrindrc
 // files.

CVS commit by nethercote: 

Printing slightly more informative message when mmap fails.


  M +3 -1      vg_symtab2.c   1.80


--- valgrind/coregrind/vg_symtab2.c  #1.79:1.80
@@ -1189,5 +1189,7 @@ Bool vg_read_lib_symbols ( SegInfo* si )
    if (oimage == ((Addr)(-1))) {
       VG_(message)(Vg_UserMsg,
-                   "mmap failed on %s", si->filename );
+                   "warning: mmap failed on %s", si->filename );
+      VG_(message)(Vg_UserMsg,
+                   "         no symbols or debug info loaded" );
       return False;
    }

CVS commit by nethercote: 

typo


  M +1 -1      vg_errcontext.c   1.54


--- valgrind/coregrind/vg_errcontext.c  #1.53:1.54
@@ -239,5 +239,5 @@ static void gen_suppression(Error* err)
       } else {
          VG_(printf)("   ???:???       "
-                     "# unknown, suppression will not work, sorry)\n");
+                     "# unknown, suppression will not work, sorry\n");
       }
       i++;

CVS commit by thughes: 

Commit the patch from bug 69508 that seeks to make more of the pthread
stack attribute related functions work properly as it seems to be a
sensible thing to improve even if it isn't enough to get the JVM running
under valgrind now.


  M +16 -0     vg_include.h   1.198
  M +56 -47    vg_libpthread.c   1.156
  M +2 -2      vg_libpthread_unimp.c   1.45
  M +50 -15    vg_scheduler.c   1.153


--- valgrind/coregrind/vg_include.h  #1.197:1.198
@@ -494,4 +494,7 @@ extern Bool  VG_(is_inside_segment_mmapd
 #define VG_USERREQ__GET_MALLOCFUNCS         0x3030
 
+/* Get stack information for a thread. */
+#define VG_USERREQ__GET_STACK_INFO          0x3033
+
 /* Cosmetic ... */
 #define VG_USERREQ__GET_PTHREAD_TRACE_LEVEL 0x3101
@@ -715,4 +718,13 @@ typedef
    CleanupType;
 
+/* Information on a thread's stack. */
+typedef
+   struct {
+      Addr base;
+      UInt size;
+      UInt guardsize;
+   }
+   StackInfo;
+
 /* An entry in a threads's cleanup stack. */
 typedef
@@ -862,4 +874,8 @@ typedef
    Addr stack_base;
 
+   /* The allocated size of this thread's stack's guard area (permanently
+      zero if this is ThreadId == 0, since we didn't allocate its stack) */
+   UInt stack_guard_size;
+
    /* Address of the highest legitimate word in this stack.  This is
       used for error messages only -- not critical for execution

--- valgrind/coregrind/vg_libpthread.c  #1.155:1.156
@@ -416,4 +416,7 @@ int pthread_attr_init(pthread_attr_t *at
       guess the following is OK. */
    vg_attr->__vg_guardsize = VKI_BYTES_PER_PAGE;
+   /* No special stack yet. */
+   vg_attr->__vg_stackaddr = 0;
+   vg_attr->__vg_stacksize = VG_PTHREAD_STACK_SIZE;
    return 0;
 }
@@ -452,20 +454,11 @@ int pthread_attr_setinheritsched(pthread
 
 WEAK
-int pthread_attr_setstacksize (pthread_attr_t *__attr,
-                               size_t __stacksize)
+int pthread_attr_setstacksize (pthread_attr_t *attr,
+                               size_t stacksize)
 {
-   size_t limit;
-   char buf[1024];
-
-   ensure_valgrind("pthread_attr_setstacksize");
-   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 
-                                 - 1000; /* paranoia */
-   if (__stacksize < limit)
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   vg_attr->__vg_stacksize = stacksize;
       return 0;
-   snprintf(buf, sizeof(buf), "pthread_attr_setstacksize: "
-            "requested size %d >= VG_PTHREAD_STACK_SIZE\n   "
-            "edit vg_include.h and rebuild.", __stacksize);
-   buf[sizeof(buf)-1] = '\0'; /* Make sure it is zero terminated */
-   barf(buf);
 }
 
@@ -528,6 +521,7 @@ int pthread_attr_getscope ( const pthrea
 int pthread_getattr_np (pthread_t thread, pthread_attr_t *attr)
 {
+   StackInfo si;
+   int res;
    int    detached;
-   size_t limit;
    vg_pthread_attr_t* vg_attr;
    CONVERT(attr, attr, vg_attr);
@@ -535,6 +529,4 @@ int pthread_getattr_np (pthread_t thread
    ensure_valgrind("pthread_getattr_np");
    kludged("pthread_getattr_np", NULL);
-   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 
-                                 - 1000; /* paranoia */
    vg_attr->__vg_detachstate = PTHREAD_CREATE_JOINABLE;
    vg_attr->__vg_schedpolicy = SCHED_OTHER;
@@ -542,8 +534,11 @@ int pthread_getattr_np (pthread_t thread
    vg_attr->__vg_inheritsched = PTHREAD_EXPLICIT_SCHED;
    vg_attr->__vg_scope = PTHREAD_SCOPE_SYSTEM;
-   vg_attr->__vg_guardsize = VKI_BYTES_PER_PAGE;
-   vg_attr->__vg_stackaddr = NULL;
+   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,
+                           VG_USERREQ__GET_STACK_INFO,
+                           thread, &si, 0, 0 );
+   vg_attr->__vg_guardsize = si.guardsize;
+   vg_attr->__vg_stackaddr = (void *)si.base;
    vg_attr->__vg_stackaddr_set = 0;
-   vg_attr->__vg_stacksize = limit;
+   vg_attr->__vg_stacksize = si.size;
    VALGRIND_MAGIC_SEQUENCE(detached, (-1) /* default */,
                            VG_USERREQ__SET_OR_GET_DETACH, 
@@ -556,27 +551,40 @@ int pthread_getattr_np (pthread_t thread
 
 
-/* Bogus ... */
+WEAK
+int pthread_attr_getstack ( const pthread_attr_t * attr,
+                            void ** stackaddr,
+                            size_t *stacksize )
+{
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   ensure_valgrind("pthread_attr_getstack");
+   if (stackaddr)
+      *stackaddr = vg_attr->__vg_stackaddr;
+   if (stacksize)
+      *stacksize = vg_attr->__vg_stacksize;
+   return 0;
+}
+
 WEAK
 int pthread_attr_getstackaddr ( const pthread_attr_t * attr,
                                 void ** stackaddr )
 {
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
    ensure_valgrind("pthread_attr_getstackaddr");
-   kludged("pthread_attr_getstackaddr", "(it always sets stackaddr to zero)");
    if (stackaddr)
-      *stackaddr = NULL;
+      *stackaddr = vg_attr->__vg_stackaddr;
    return 0;
 }
 
-/* Not bogus (!) */
 WEAK
-int pthread_attr_getstacksize ( const pthread_attr_t * _attr, 
-                                size_t * __stacksize )
+int pthread_attr_getstacksize ( const pthread_attr_t * attr, 
+                                size_t * stacksize )
 {
-   size_t limit;
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
    ensure_valgrind("pthread_attr_getstacksize");
-   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 
-                                 - 1000; /* paranoia */
-   if (__stacksize)
-      *__stacksize = limit;
+   if (stacksize)
+      *stacksize = vg_attr->__vg_stacksize;
    return 0;
 }
@@ -601,23 +609,13 @@ int pthread_attr_getschedpolicy(const pt
 
 
-/* This is completely bogus.  We reject all attempts to change it from
-   VKI_BYTES_PER_PAGE.  I don't have a clue what it's for so it seems
-   safest to be paranoid. */
 WEAK 
 int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 {
-   static int moans = N_MOANS;
-
-   if (guardsize == VKI_BYTES_PER_PAGE)
-      return 0;
-
-   if (moans-- > 0) 
-       ignored("pthread_attr_setguardsize",
-               "(it ignores any guardsize != 4096)");
-
+   vg_pthread_attr_t* vg_attr;
+   CONVERT(attr, attr, vg_attr);
+   vg_attr->__vg_guardsize = guardsize;
    return 0;
 }
 
-/* A straight copy of the LinuxThreads code. */
 WEAK 
 int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
@@ -1122,4 +1120,5 @@ pthread_create (pthread_t *__restrict __
    NewThreadInfo* info;
    int            gs;
+   StackInfo      si;
    vg_pthread_attr_t* __vg_attr;
    CONVERT(attr, __attr, __vg_attr);
@@ -1169,7 +1168,17 @@ pthread_create (pthread_t *__restrict __
    sigprocmask(SIG_SETMASK, NULL, &info->sigmask);
 
+   if (__attr) {
+      si.base = (Addr)__vg_attr->__vg_stackaddr;
+      si.size = __vg_attr->__vg_stacksize;
+      si.guardsize = __vg_attr->__vg_guardsize;
+   } else {
+      si.base = (Addr)NULL;
+      si.size = VG_PTHREAD_STACK_SIZE;
+      si.guardsize = VKI_BYTES_PER_PAGE;
+   }
+   
    VALGRIND_MAGIC_SEQUENCE(tid_child, VG_INVALID_THREADID /* default */,
                            VG_USERREQ__APPLY_IN_NEW_THREAD,
-                           &thread_wrapper, info, 0, 0);
+                           &thread_wrapper, info, &si, 0);
    my_assert(tid_child != VG_INVALID_THREADID);
 

--- valgrind/coregrind/vg_libpthread_unimp.c  #1.44:1.45
@@ -226,6 +226,6 @@ weak_alias(_IO_ftrylockfile, ftrylockfil
 //__attribute__((weak)) void pthread_attr_getguardsize ( void )
 //                      { vgPlain_unimp("pthread_attr_getguardsize"); }
-__attribute__((weak)) void pthread_attr_getstack ( void )
-                      { vgPlain_unimp("pthread_attr_getstack"); }
+//__attribute__((weak)) void pthread_attr_getstack ( void )
+//                      { vgPlain_unimp("pthread_attr_getstack"); }
 __attribute__((weak)) void pthread_attr_getstackaddr ( void )
                       { vgPlain_unimp("pthread_attr_getstackaddr"); }

--- valgrind/coregrind/vg_scheduler.c  #1.152:1.153
@@ -597,4 +597,5 @@ void VG_(scheduler_init) ( void )
       VG_(threads)[i].stack_size           = 0;
       VG_(threads)[i].stack_base           = (Addr)NULL;
+      VG_(threads)[i].stack_guard_size     = 0;
       VG_(threads)[i].stack_highest_word   = (Addr)NULL;
    }
@@ -1292,7 +1293,4 @@ void VG_(need_resched) ( ThreadId prefer
 #include <errno.h>
 
-#define VG_PTHREAD_STACK_MIN \
-   (VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB)
-
 /*  /usr/include/bits/pthreadtypes.h:
     typedef unsigned long int pthread_t;
@@ -1877,5 +1875,6 @@ static
 void do__apply_in_new_thread ( ThreadId parent_tid,
                                void* (*fn)(void *), 
-                               void* arg )
+                               void* arg,
+                               StackInfo *si )
 {
    Addr     new_stack;
@@ -1928,5 +1927,8 @@ void do__apply_in_new_thread ( ThreadId 
    /* Consider allocating the child a stack, if the one it already has
       is inadequate. */
-   new_stk_szb = VG_PTHREAD_STACK_MIN;
+   new_stk_szb = si->size + VG_AR_CLIENT_STACKBASE_REDZONE_SZB + si->guardsize;
+   new_stk_szb = (new_stk_szb + VKI_BYTES_PER_PAGE - 1) & ~VKI_BYTES_PER_PAGE;
+    
+   VG_(threads)[tid].stack_guard_size = si->guardsize;
 
    if (new_stk_szb > VG_(threads)[tid].stack_size) {
@@ -1934,8 +1936,6 @@ void do__apply_in_new_thread ( ThreadId 
          allocating a stack for the main thread. */
       vg_assert(tid != 1);
-      /* for now, we don't handle the case of anything other than
-         assigning it for the first time. */
-      vg_assert(VG_(threads)[tid].stack_size == 0);
-      vg_assert(VG_(threads)[tid].stack_base == (Addr)NULL);
+      if (VG_(threads)[tid].stack_size > 0)
+         VG_(client_free)(VG_(threads)[tid].stack_base);
       new_stack = VG_(client_alloc)(0, new_stk_szb, 
                                     VKI_PROT_READ | VKI_PROT_WRITE | VKI_PROT_EXEC, 
@@ -1958,5 +1958,6 @@ void do__apply_in_new_thread ( ThreadId 
 
    VG_TRACK ( die_mem_stack, VG_(threads)[tid].stack_base, 
-                           + new_stk_szb - VG_AR_CLIENT_STACKBASE_REDZONE_SZB);
+                             VG_(threads)[tid].stack_size
+                             - VG_AR_CLIENT_STACKBASE_REDZONE_SZB);
    VG_TRACK ( ban_mem_stack, VG_(threads)[tid].m_esp, 
                              VG_AR_CLIENT_STACKBASE_REDZONE_SZB );
@@ -2919,4 +2920,32 @@ void do__get_fhstack_entry ( ThreadId ti
 }
 
+
+static
+void do__get_stack_info ( ThreadId tid, ThreadId which, StackInfo* si )
+{
+   Char msg_buf[100];
+   
+   vg_assert(VG_(is_valid_tid)(tid) 
+             && VG_(threads)[tid].status == VgTs_Runnable);
+   
+   if (VG_(clo_trace_sched)) {
+      VG_(sprintf)(msg_buf, "get_stack_info for tid %d", which );
+      print_pthread_event(tid, msg_buf);
+   }
+
+   if (!VG_(is_valid_tid)(which)) {
+      SET_PTHREQ_RETVAL(tid, -1);
+      return;
+   }
+
+   si->base = VG_(threads)[which].stack_base;
+   si->size = VG_(threads)[which].stack_size
+              - VG_AR_CLIENT_STACKBASE_REDZONE_SZB
+              - VG_(threads)[which].stack_guard_size;
+   si->guardsize = VG_(threads)[which].stack_guard_size;
+
+   SET_PTHREQ_RETVAL(tid, 0);
+}
+
 /* ---------------------------------------------------------------------
    Specifying shadow register values
@@ -3154,5 +3183,5 @@ void do_client_request ( ThreadId tid )
       case VG_USERREQ__APPLY_IN_NEW_THREAD:
          do__apply_in_new_thread ( tid, (void*(*)(void*))arg[1], 
-                                        (void*)arg[2] );
+                                        (void*)arg[2], (StackInfo*)(arg[3]) );
          break;
 
@@ -3195,4 +3224,8 @@ void do_client_request ( ThreadId tid )
          break;
 
+      case VG_USERREQ__GET_STACK_INFO:
+         do__get_stack_info( tid, (Int)(arg[1]), (StackInfo*)(arg[2]) );
+         break;
+
 
       case VG_USERREQ__GET_SIGRT_MIN:
@@ -3375,5 +3408,8 @@ void scheduler_sanity ( void )
          stack_used = (Addr)VG_(threads)[i].stack_highest_word 
                       - (Addr)VG_(threads)[i].m_esp;
-
+         Int
+         stack_avail = VG_(threads)[i].stack_size
+                       - VG_AR_CLIENT_STACKBASE_REDZONE_SZB
+                       - VG_(threads)[i].stack_guard_size;
          /* This test is a bit bogus - it doesn't take into account
             alternate signal stacks, for a start.  Also, if a thread
@@ -3381,10 +3417,9 @@ void scheduler_sanity ( void )
             isn't the right answer. */
          if (0 && i > 1 /* not the root thread */ 
-             && stack_used 
-                >= (VG_PTHREAD_STACK_MIN - 1000 /* paranoia */)) {
+             && stack_used >= stack_avail) {
             VG_(message)(Vg_UserMsg,
                "Error: STACK OVERFLOW: "
                "thread %d: stack used %d, available %d", 
-               i, stack_used, VG_PTHREAD_STACK_MIN );
+               i, stack_used, stack_avail );
             VG_(message)(Vg_UserMsg,
                "Terminating Valgrind.  If thread(s) "

> Changed (client-heap-size : client-map-seg-size) ratio from 3:1 to 1:2.
> As a result, can now mmap much more memory (eg. for Memcheck, 850MB up from
> 250MB, for Nulgrind 1750MB up from 700MB). 

That's good.  However, is tht 850MB all in one lump, or in a lot
of small pieces?  Memcheck gives quite a large overhead per
allocation (100+ bytes?), and I wonder if that has any influence
on the optimal settings?  For stuff like KDE and OpenOffice the
average allocation size is small (50-100 bytes) so perhaps
it's worth adjusting the parameters optimally for that?

J

CVS commit by thughes: 

Removed duplicate call to rw_remap.


  M +0 -1      vg_libpthread.c   1.157


--- valgrind/coregrind/vg_libpthread.c  #1.156:1.157
@@ -3161,5 +3161,4 @@ int pthread_rwlock_unlock ( pthread_rwlo
    if (0) printf ("pthread_rwlock_unlock\n");
    rwl = rw_remap ( orig );
-   rwl = rw_remap ( orig );
    res = __pthread_mutex_lock(&rwl->mx);
    my_assert(res == 0);

On Sun, 27 Jun 2004, Julian Seward wrote:

>> Changed (client-heap-size : client-map-seg-size) ratio from 3:1 to 1:2.
>> As a result, can now mmap much more memory (eg. for Memcheck, 850MB up from
>> 250MB, for Nulgrind 1750MB up from 700MB).
>
> That's good.  However, is tht 850MB all in one lump, or in a lot
> of small pieces?  Memcheck gives quite a large overhead per
> allocation (100+ bytes?), and I wonder if that has any influence
> on the optimal settings?  For stuff like KDE and OpenOffice the
> average allocation size is small (50-100 bytes) so perhaps
> it's worth adjusting the parameters optimally for that?

The 850MB would be all in one lump if it wasn't for stupid 
/lib/tls/libc.so sitting fixed at 0x42000000.  As it is, the biggest map I 
can create are (before and after my change):

                  before          after
                  ------          -----
   Memcheck       266MB           614MB
   Addrcheck      625MB           1444MB
   Nulgrind       703MB           1757MB

But I don't see how that's related to KDE having small allocation sizes...

N

CVS commit by nethercote: 


Fixed variable name mixup, removed no-longer-used VG_STACK_SIZE_W.


  M +1 -2      vg_include.h   1.199
  M +3 -2      vg_mylibc.c   1.76


--- valgrind/coregrind/vg_include.h  #1.198:1.199
@@ -129,6 +129,5 @@
 #define VG_N_SUPP_CALLERS  4
 
-/* Valgrind's stack sizes, in words */
-#define VG_STACK_SIZE_W       10000
+/* Valgrind's signal stack size, in words */
 #define VG_SIGSTACK_SIZE_W    10000
 

--- valgrind/coregrind/vg_mylibc.c  #1.75:1.76
@@ -1182,6 +1182,7 @@ static inline ExeContext *get_real_execo
    asm("movl %%ebp, %0; movl %%esp, %1" : "=r" (ebp), "=r" (esp));
    stacktop = VG_(valgrind_end);
-   if (esp >= (Addr)&VG_(sigstack)[0] && esp < (Addr)&VG_(sigstack)[VG_STACK_SIZE_W])
-      stacktop = (Addr)&VG_(sigstack)[VG_STACK_SIZE_W];
+   if (esp >= (Addr)&VG_(sigstack)[0] && 
+       esp < (Addr)&VG_(sigstack)[VG_SIGSTACK_SIZE_W])
+      stacktop = (Addr)&VG_(sigstack)[VG_SIGSTACK_SIZE_W];
       
    ec = VG_(get_ExeContext2)(ret, ebp, esp, stacktop);

CVS commit by jseward: 

Fix confusing and wrong comment in definition of live ranges in
reg-alloc.  (Comment change only).


  M +1 -1      vg_translate.c   1.79


--- valgrind/coregrind/vg_translate.c  #1.78:1.79
@@ -1942,5 +1942,5 @@ typedef
       /* Becomes live for the first time after this insn ... */
       Int live_after;
-      /* Becomes dead for the last time after this insn ... */
+      /* Becomes dead for the last time before this insn ... */
       Int dead_before;
       /* The "home" spill slot, if needed.  Never changes. */

CVS commit by nethercote: 


Fixed --sloppy-malloc and --trace-malloc, debugging options that I broke a
while back (sorry).


  M +2 -2      vg_malloc2.c   1.24


--- valgrind/coregrind/vg_malloc2.c  #1.23:1.24
@@ -67,6 +67,6 @@ Bool VG_(replacement_malloc_process_cmd_
    }
 
-   else VG_BOOL_CLO("--sloppy-malloc=yes", VG_(clo_sloppy_malloc))
-   else VG_BOOL_CLO("--trace-malloc=yes",  VG_(clo_trace_malloc))
+   else VG_BOOL_CLO("--sloppy-malloc", VG_(clo_sloppy_malloc))
+   else VG_BOOL_CLO("--trace-malloc",  VG_(clo_trace_malloc))
    else 
       return False;

CVS commit by nethercote: 

Change allocation failure message which is no longer true thanks to FV.


  M +2 -9      vg_mylibc.c   1.77


--- valgrind/coregrind/vg_mylibc.c  #1.76:1.77
@@ -1709,13 +1709,6 @@ void* VG_(get_memory_from_mmap) ( Int nB
                tot_alloc);
    VG_(printf)("\n");
-   VG_(printf)("This may mean that you have run out of swap space,\n");
-   VG_(printf)("since running programs on valgrind increases their memory\n");
-   VG_(printf)("usage at least 3 times.  You might want to use 'top'\n");
-   VG_(printf)("to determine whether you really have run out of swap.\n");
-   VG_(printf)("If so, you may be able to work around it by adding a\n");
-   VG_(printf)("temporary swap file -- this is easier than finding a\n");
-   VG_(printf)("new swap partition.  Go ask your sysadmin(s) [politely!]\n");
-   VG_(printf)("\n");
-   VG_(printf)("VG_(get_memory_from_mmap): out of memory!  Fatal!  Bye!\n");
+   VG_(printf)("Sorry.  You could try using a tool that uses less memory;\n");
+   VG_(printf)("eg. addrcheck instead of memcheck.\n");
    VG_(printf)("\n");
    VG_(exit)(1);

CVS commit by nethercote: 


Removed the 'place-holder' behaviour of VG_(mmap).  Previously, VG_(mmap) would
add a segment mapping to the segment skip-list, and then often the caller of
VG_(mmap) would do another one for the same segment, just to change the SF_*
flags.  Now VG_(mmap) gets passed the appropriate SF_* flags so it can do it
directly.   This results in shorter, simpler code, and less work at runtime.

Also, strengthened checking in VG_(mmap), POST(mmap), POST(mmap2) -- now if the
result is not in the right place, it aborts rather than unmapping and
continuing.  This is because if it's not in the right place, something has
gone badly wrong.


  M +2 -2      vg_include.h   1.200
  M +4 -6      vg_memory.c   1.54
  M +17 -29    vg_mylibc.c   1.78
  M +7 -9      vg_signals.c   1.71
  M +5 -2      vg_symtab2.c   1.81
  M +9 -16     vg_syscalls.c   1.104


--- valgrind/coregrind/vg_include.h  #1.199:1.200
@@ -1151,6 +1151,6 @@ extern Int VG_(nanosleep)( const struct 
 
 /* system/mman.h */
-extern void* VG_(mmap)( void* start, UInt length,
-                        UInt prot, UInt flags, UInt fd, UInt offset );
+extern void* VG_(mmap)( void* start, UInt length, UInt prot, UInt flags,
+                        UInt sf_flags, UInt fd, UInt offset );
 extern Int  VG_(munmap)( void* start, Int length );
 extern Int  VG_(mprotect)( void *start, Int length, UInt prot );

--- valgrind/coregrind/vg_memory.c  #1.53:1.54
@@ -678,9 +678,9 @@ Bool VG_(is_addressable)(Addr p, Int siz
 
 // Returns 0 on failure.
-Addr VG_(client_alloc)(Addr addr, UInt len, UInt prot, UInt flags)
+Addr VG_(client_alloc)(Addr addr, UInt len, UInt prot, UInt sf_flags)
 {
    len = PGROUNDUP(len);
 
-   if (!(flags & SF_FIXED))
+   if (!(sf_flags & SF_FIXED))
       addr = VG_(find_map_space)(addr, len, True);
 
@@ -689,10 +689,8 @@ Addr VG_(client_alloc)(Addr addr, UInt l
       return 0;
 
-   flags |= SF_CORE;
-
    if (VG_(mmap)((void *)addr, len, prot,
                  VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT,
-                 -1, 0) == (void *)addr) {
-      VG_(map_segment)(addr, len, prot, flags);
+                 sf_flags | SF_CORE, -1, 0) == (void *)addr) 
+   {
       return addr;
    }

--- valgrind/coregrind/vg_mylibc.c  #1.77:1.78
@@ -266,5 +266,5 @@ static Addr mmap_inner(void *start, UInt
 /* Returns -1 on failure. */
 void* VG_(mmap)( void* start, UInt length, 
-                 UInt prot, UInt flags, UInt fd, UInt offset)
+                 UInt prot, UInt flags, UInt sf_flags, UInt fd, UInt offset)
 {
    Addr  res;
@@ -272,43 +272,31 @@ void* VG_(mmap)( void* start, UInt lengt
    if (!(flags & VKI_MAP_FIXED)) {
       start = (void *)VG_(find_map_space)((Addr)start, length, !!(flags & VKI_MAP_CLIENT));
-      if (start == 0)
-         return (void *)-1;
 
       flags |= VKI_MAP_FIXED;
    }
+   if (start == 0)
+      return (void *)-1;
 
    res = mmap_inner(start, length, prot, flags, fd, offset);
 
+   // Check it ended up in the right place.
    if (!VG_(is_kerror)(res)) {
-      UInt sf_flags = SF_MMAP;
-
-      if (flags & VKI_MAP_FIXED)
-         sf_flags |= SF_FIXED;
-      if (flags & VKI_MAP_SHARED)
-         sf_flags |= SF_SHARED;
-      if (!(flags & VKI_MAP_ANONYMOUS))
-         sf_flags |= SF_FILE;
-      if (!(flags & VKI_MAP_CLIENT))
-         sf_flags |= SF_VALGRIND;
-      if (flags & VKI_MAP_NOSYMS)
-         sf_flags |= SF_NOSYMS;
-
-      /* placeholder - caller will update flags etc if they want */
-      VG_(map_fd_segment)(res, length, prot, sf_flags, fd, offset, NULL);
-
       if (flags & VKI_MAP_CLIENT) {
-         if (res < VG_(client_base) || res >= VG_(client_end)) {
-            VG_(munmap)((void *)res, length);
-            res = -1;
-         }
+         vg_assert(VG_(client_base) <= res && res+length < VG_(client_end));
       } else {
-         if (res < VG_(valgrind_base) || res >= VG_(valgrind_end)) {
-            VG_(munmap)((void *)res, length);
-            res = -1;
-         }
+         vg_assert(VG_(valgrind_base) <= res && res+length < VG_(valgrind_end));
       }
    }
 
+   if (!VG_(is_kerror)(res)) {
+      sf_flags |= SF_MMAP;
+      if (  flags & VKI_MAP_FIXED)      sf_flags |= SF_FIXED;
+      if (  flags & VKI_MAP_SHARED)     sf_flags |= SF_SHARED;
+      if (!(flags & VKI_MAP_ANONYMOUS)) sf_flags |= SF_FILE;
+      if (!(flags & VKI_MAP_CLIENT))    sf_flags |= SF_VALGRIND;
+      if (  flags & VKI_MAP_NOSYMS)     sf_flags |= SF_NOSYMS;
    
+      VG_(map_fd_segment)(res, length, prot, sf_flags, fd, offset, NULL);
+   }
 
    return VG_(is_kerror)(res) ? ((void*)(-1)) : (void*)res;

--- valgrind/coregrind/vg_signals.c  #1.70:1.71
@@ -2142,13 +2142,11 @@ void vg_sync_signalhandler ( Int sigNo, 
          */
          Addr base = PGROUNDDN(esp);
-         Char *ret = VG_(mmap)((Char *)base, seg->addr - base, 
-                               VKI_PROT_READ | VKI_PROT_WRITE | VKI_PROT_EXEC,
-                               VKI_MAP_PRIVATE | VKI_MAP_FIXED | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT,
-                               -1, 0);
-         if ((Addr)ret == base) {
-            VG_(map_segment)(base, seg->addr - base,
+        if ((void*)-1 != VG_(mmap)((Char *)base, seg->addr - base,
                              VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
-                             SF_STACK|SF_GROWDOWN);
-            return;             /* restart instruction */
+                              VKI_MAP_PRIVATE|VKI_MAP_FIXED|VKI_MAP_ANONYMOUS|VKI_MAP_CLIENT,
+                              SF_STACK|SF_GROWDOWN,
+                              -1, 0))
+         {
+           return;             // extension succeeded, restart instruction
          }
          /* Otherwise fall into normal signal handling */

--- valgrind/coregrind/vg_symtab2.c  #1.80:1.81
@@ -1096,5 +1096,7 @@ Addr open_debug_file( Char* name, UInt c
    
    if ((addr = (Addr)VG_(mmap)(NULL, *size, VKI_PROT_READ,
-                               VKI_MAP_PRIVATE|VKI_MAP_NOSYMS, fd, 0)) == (Addr)-1) {
+                               VKI_MAP_PRIVATE|VKI_MAP_NOSYMS, 
+                               0, fd, 0)) == (Addr)-1) 
+   {
       VG_(close)(fd);
       return 0;
@@ -1183,5 +1185,6 @@ Bool vg_read_lib_symbols ( SegInfo* si )
 
    oimage = (Addr)VG_(mmap)( NULL, n_oimage, 
-                             VKI_PROT_READ, VKI_MAP_PRIVATE|VKI_MAP_NOSYMS, fd, 0 );
+                             VKI_PROT_READ, VKI_MAP_PRIVATE|VKI_MAP_NOSYMS, 
+                             0, fd, 0 );
 
    VG_(close)(fd);

--- valgrind/coregrind/vg_syscalls.c  #1.103:1.104
@@ -1021,10 +1021,9 @@ static Addr do_brk(Addr newbrk)
          if (newaddr == current) {
             ret = newbrk;
-         } else if (VG_(mmap)((void *)current , newaddr-current,
-                              VKI_PROT_READ | VKI_PROT_WRITE | VKI_PROT_EXEC,
-                              VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS | VKI_MAP_FIXED | VKI_MAP_CLIENT,
-                              -1, 0) >= 0) {
-            VG_(map_segment)(current, newaddr-current, VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
-                             SF_FIXED|SF_BRK);
+         } else if ((void*)-1 != VG_(mmap)((void*)current, newaddr-current,
+               VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
+               VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS|VKI_MAP_FIXED|VKI_MAP_CLIENT,
+               SF_FIXED|SF_BRK, -1, 0)) 
+         {
             ret = newbrk;
          }
@@ -3993,8 +3992,5 @@ POST(mmap2)
 {
    if (!VG_(is_kerror)(res)) {
-      if (!valid_client_addr(res, arg2, tid, "mmap2")) {
-         VG_(munmap)((void *)res, arg2);
-         res = -VKI_ENOMEM;
-      } else
+      vg_assert(valid_client_addr(res, arg2, tid, "mmap2"));
          mmap_segment( (Addr)res, arg2, arg3, arg4, arg5, arg6 * (ULong)VKI_BYTES_PER_PAGE );
    }
@@ -4047,8 +4043,5 @@ PRE(mmap)
 
       if (!VG_(is_kerror)(res)) {
-         if (!valid_client_addr(res, a2, tid, "mmap")) {
-            VG_(munmap)((void *)res, a2);
-            res = -VKI_ENOMEM;
-         } else
+         vg_assert(valid_client_addr(res, a2, tid, "mmap"));
             mmap_segment( (Addr)res, a2, a3, a4, a5, a6 );
       }

CVS commit by nethercote: 

Remove out-of-date comment -- should have been removed when VG_(mmap)() was
changed to accept the sf_flags argument.


  M +0 -1      vg_memory.c   1.55


--- valgrind/coregrind/vg_memory.c  #1.54:1.55
@@ -336,5 +336,4 @@ void VG_(map_file_segment)(Addr addr, UI
 
    if (s != NULL && s->addr == addr && s->len == len) {
-      /* This probably means we're just updating the flags */
       recycled = True;
       recycleseg(s);

CVS commit by nethercote: 

Comment changes only.


  M +8 -1      vg_memory.c   1.56


--- valgrind/coregrind/vg_memory.c  #1.55:1.56
@@ -673,5 +673,5 @@ Bool VG_(is_addressable)(Addr p, Int siz
 
 /*--------------------------------------------------------------------*/
-/*--- manage allocation of memory on behalf of the client          ---*/
+/*--- Manage allocation of memory on behalf of the client          ---*/
 /*--------------------------------------------------------------------*/
 
@@ -710,4 +710,8 @@ void VG_(client_free)(Addr addr)
 }
 
+/*--------------------------------------------------------------------*/
+/*--- Querying memory layout                                       ---*/
+/*--------------------------------------------------------------------*/
+
 Bool VG_(is_client_addr)(Addr a)
 {
@@ -755,4 +759,7 @@ Addr VG_(get_shadow_size)(void)
 }
 
+/*--------------------------------------------------------------------*/
+/*--- manage allocation of memory on behalf of the client          ---*/
+/*--------------------------------------------------------------------*/
 
 void VG_(init_shadow_range)(Addr p, UInt sz, Bool call_init)

CVS commit by nethercote: 


A few changes:
- removed an unnecessary VG_(unmap_range)() call in do_brk() -- the
  VG_(munmap)() just before it does it anyway.
- inlined mprotect_segment() and munmap_segment() because it's more concise and
  easier to understand that way.
- a couple of minor formatting changes
- added and cleaned up a couple of comments


  M +31 -55    vg_syscalls.c   1.105


--- valgrind/coregrind/vg_syscalls.c  #1.104:1.105
@@ -216,5 +216,5 @@ void VG_(mash_colon_env)(Char *varp, con
 
 /* ---------------------------------------------------------------------
-   Doing mmap, munmap, mremap, mprotect
+   Doing mmap, mremap
    ------------------------------------------------------------------ */
 
@@ -268,41 +268,4 @@ void mmap_segment ( Addr a, UInt len, UI
 
 static
-void munmap_segment ( Addr a, UInt len )
-{
-   /* Addr orig_a   = a;
-      Addr orig_len = len; */
-
-   mash_addr_and_len(&a, &len);
-
-   VG_(unmap_range)(a, len);
-
-   /*
-   VG_(printf)("MUNMAP: correct (%p for %d) to (%p for %d) %s\n", 
-      orig_a, orig_len, a, len, (orig_a!=start || orig_len!=length) 
-                                    ? "CHANGE" : "");
-   */
-
-   VG_TRACK( die_mem_munmap, a, len );
-}
-
-static 
-void mprotect_segment ( Addr a, UInt len, Int prot )
-{
-   Bool rr, ww, xx;
-
-   VG_(mprotect_range)(a, len, prot);
-
-   rr = prot & VKI_PROT_READ;
-   ww = prot & VKI_PROT_WRITE;
-   xx = prot & VKI_PROT_EXEC;
-
-   // if removing exe permission, should check and remove from exe_seg list
-   // if adding, should check and add to exe_seg list
-   // easier to ignore both cases -- both v. unlikely?
-   mash_addr_and_len(&a, &len);
-   VG_TRACK( change_mem_mprotect, a, len, rr, ww, xx );
-}
-
-static 
 Addr mremap_segment ( Addr old_addr, UInt old_size,
                       Addr new_addr, UInt new_size,
@@ -1037,5 +1000,4 @@ static Addr do_brk(Addr newbrk)
          if (newaddr != current) {
             VG_(munmap)((void *)newaddr, current - newaddr);
-            VG_(unmap_range)(newaddr, current-newaddr);
          }
          ret = newbrk;
@@ -1556,4 +1518,6 @@ PRE(madvise)
 PRE(mremap)
 {
+   // Nb: this is different to the glibc version described in the man pages,
+   // which lacks the fifth 'new_address' argument.
    /* void* mremap(void * old_address, size_t old_size, 
       size_t new_size, unsigned long flags, void * new_address); */
@@ -2785,5 +2749,5 @@ POST(ipc)
          UInt segmentSize = get_shm_size ( shmid );
          if ( segmentSize > 0 ) {
-            UInt prot;
+            UInt prot = VKI_PROT_READ|VKI_PROT_WRITE;
             /* we don't distinguish whether it's read-only or
              * read-write -- it doesn't matter really. */
@@ -2791,9 +2755,7 @@ POST(ipc)
                       True, True, False );
 
-            prot = VKI_PROT_READ|VKI_PROT_WRITE;
             if (!(shmflag & 010000)) /* = SHM_RDONLY */
                prot &= ~VKI_PROT_WRITE;
-            VG_(map_segment)(addr, segmentSize, prot,
-                             SF_SHARED | SF_SHM);
+            VG_(map_segment)(addr, segmentSize, prot, SF_SHARED|SF_SHM);
          }
       }
@@ -3964,12 +3926,8 @@ PRE(mkdir)
 PRE(mmap2)
 {
-   /* My impression is that this is exactly like __NR_mmap 
-      except that all 6 args are passed in regs, rather than in 
-      a memory-block.
-      
-      Almost.  The big difference is that the file offset is specified
-      in pagesize units rather than bytes, so that it can be used for
-      files bigger than 2^32 bytes. - JSGF
-   */
+   // Exactly like __NR_mmap except:
+   //  - all 6 args are passed in regs, rather than in a memory-block.
+   //  - the file offset is specified in pagesize units rather than bytes,
+   //    so that it can be used for files bigger than 2^32 bytes.
    /* void* mmap(void *start, size_t length, int prot, 
       int flags, int fd, off_t offset); 
@@ -3983,7 +3941,8 @@ PRE(mmap2)
    } else {
       arg1 = VG_(find_map_space)(arg1, arg2, True);
-      arg4 |= VKI_MAP_FIXED;
       if (arg1 == 0)
          res = -VKI_ENOMEM;
+      else 
+         arg4 |= VKI_MAP_FIXED;
    }
 }
@@ -4061,5 +4020,17 @@ PRE(mprotect)
 POST(mprotect)
 {
-   mprotect_segment( arg1, arg2, arg3 );
+   Addr a    = arg1;
+   UInt len  = arg2;
+   Int  prot = arg3;
+   Bool rr = prot & VKI_PROT_READ;
+   Bool ww = prot & VKI_PROT_WRITE;
+   Bool xx = prot & VKI_PROT_EXEC;
+
+   // if removing exe permission, should check and remove from exe_seg list
+   // if adding, should check and add to exe_seg list
+   // easier to ignore both cases -- both v. unlikely?
+   mash_addr_and_len(&a, &len);
+   VG_(mprotect_range)(a, len, prot);
+   VG_TRACK( change_mem_mprotect, a, len, rr, ww, xx );
 }
 
@@ -4076,5 +4047,10 @@ PRE(munmap)
 POST(munmap)
 {
-   munmap_segment( arg1, arg2 );
+   Addr a   = arg1;
+   UInt len = arg2;
+
+   mash_addr_and_len(&a, &len);
+   VG_(unmap_range)(a, len);
+   VG_TRACK( die_mem_munmap, a, len );
 }

CVS commit by nethercote: 

Remove out-of-date comment.


  M +0 -3      vg_syscalls.c   1.106


--- valgrind/coregrind/vg_syscalls.c  #1.105:1.106
@@ -4027,7 +4027,4 @@ POST(mprotect)
    Bool xx = prot & VKI_PROT_EXEC;
 
-   // if removing exe permission, should check and remove from exe_seg list
-   // if adding, should check and add to exe_seg list
-   // easier to ignore both cases -- both v. unlikely?
    mash_addr_and_len(&a, &len);
    VG_(mprotect_range)(a, len, prot);

CVS commit by nethercote: 

Whoops, fix comment.


  M +1 -1      vg_memory.c   1.57


--- valgrind/coregrind/vg_memory.c  #1.56:1.57
@@ -760,5 +760,5 @@ Addr VG_(get_shadow_size)(void)
 
 /*--------------------------------------------------------------------*/
-/*--- manage allocation of memory on behalf of the client          ---*/
+/*--- Handling shadow memory                                       ---*/
 /*--------------------------------------------------------------------*/

CVS commit by nethercote: 

Format wibble


  M +1 -2      vg_syscalls.c   1.107


--- valgrind/coregrind/vg_syscalls.c  #1.106:1.107
@@ -2752,6 +2752,5 @@ POST(ipc)
             /* we don't distinguish whether it's read-only or
              * read-write -- it doesn't matter really. */
-            VG_TRACK( new_mem_mmap, addr, segmentSize, 
-                      True, True, False );
+            VG_TRACK( new_mem_mmap, addr, segmentSize, True, True, False );
 
             if (!(shmflag & 010000)) /* = SHM_RDONLY */

CVS commit by nethercote: 

Format wibble.


  M +1 -1      vg_mylibc.c   1.79

CVS commit by nethercote: 

Added assertion checking to a whole bunch of mmap() and munmap() calls.  I used
assertions because if these calls fail, it's a bug in Valgrind.


  M +18 -11    vg_main.c   1.167
  M +2 -1      vg_scheduler.c   1.155
  M +11 -4     vg_symtab2.c   1.82
  M +2 -1      vg_syscalls.c   1.108


--- valgrind/coregrind/vg_main.c  #1.166:1.167
@@ -502,4 +502,7 @@ static void layout_client_space(Addr arg
 static void layout_remaining_space(float ratio)
 {
+   Int   ires;
+   void* vres;
+   
    /* This tries to give the client as large as possible address space while
     * taking into account the tool's shadow needs.  */
@@ -543,15 +546,19 @@ static void layout_remaining_space(float
 
    // Ban redzone
-   mmap((void *)VG_(client_end), REDZONE_SIZE, PROT_NONE,
+   vres = mmap((void *)VG_(client_end), REDZONE_SIZE, PROT_NONE,
         MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
+   vg_assert((void*)-1 != vres);
 
    // Make client hole
-   munmap((void*)VG_(client_base), client_size);
+   ires = munmap((void*)VG_(client_base), client_size);
+   vg_assert(0 == ires);
 
    // Map shadow memory.
    // Initially all inaccessible, incrementally initialized as it is used
-   if (shadow_size != 0)
-      mmap((char *)VG_(shadow_base), shadow_size, PROT_NONE,
+   if (shadow_size != 0) {
+      vres = mmap((char *)VG_(shadow_base), shadow_size, PROT_NONE,
          MAP_PRIVATE|MAP_ANON|MAP_FIXED, -1, 0);
+      vg_assert((void*)-1 != vres);
+   }
 }
 
@@ -981,4 +988,5 @@ static Addr setup_client_stack(char **or
                                UInt** client_auxv)
 {
+   void* res;
    char **cpp;
    char *strtab;                /* string table */
@@ -1067,9 +1075,8 @@ static Addr setup_client_stack(char **or
 
    /* allocate a stack - mmap enough space for the stack */
-   mmap((void *)PGROUNDDN(cl_esp),
-        VG_(client_end) - PGROUNDDN(cl_esp),
+   res = mmap((void *)PGROUNDDN(cl_esp), VG_(client_end) - PGROUNDDN(cl_esp),
         PROT_READ | PROT_WRITE | PROT_EXEC, 
         MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
-   
+   vg_assert((void*)-1 != res); 
 
    /* ==================== copy client stack ==================== */

--- valgrind/coregrind/vg_scheduler.c  #1.154:1.155
@@ -1940,6 +1940,7 @@ void do__apply_in_new_thread ( ThreadId 
          VG_(client_free)(VG_(threads)[tid].stack_base);
       new_stack = VG_(client_alloc)(0, new_stk_szb, 
-                                    VKI_PROT_READ | VKI_PROT_WRITE | VKI_PROT_EXEC, 
+                                    VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, 
                                     SF_STACK);
+      vg_assert(0 != new_stack);
       VG_(threads)[tid].stack_base = new_stack;
       VG_(threads)[tid].stack_size = new_stk_szb;

--- valgrind/coregrind/vg_symtab2.c  #1.81:1.82
@@ -1106,5 +1106,6 @@ Addr open_debug_file( Char* name, UInt c
    
    if (calc_gnu_debuglink_crc32(0, (UChar*)addr, *size) != crc) {
-      VG_(munmap)((void*)addr, *size);
+      int res = VG_(munmap)((void*)addr, *size);
+      vg_assert(0 == res);
       return 0;
    }
@@ -1493,9 +1494,15 @@ Bool vg_read_lib_symbols ( SegInfo* si )
    res = True;
 
-  out:
+  out: {
+   Int m_res;
    /* Last, but not least, heave the image(s) back overboard. */
-   if (dimage) VG_(munmap) ( (void*)dimage, n_dimage );
-   VG_(munmap) ( (void*)oimage, n_oimage );
+   if (dimage) {
+      m_res = VG_(munmap) ( (void*)dimage, n_dimage );
+      vg_assert(0 == m_res);
+   }
+   m_res = VG_(munmap) ( (void*)oimage, n_oimage );
+   vg_assert(0 == m_res);
    return res;
+  } 
 }
 

--- valgrind/coregrind/vg_syscalls.c  #1.107:1.108
@@ -999,5 +999,6 @@ static Addr do_brk(Addr newbrk)
 
          if (newaddr != current) {
-            VG_(munmap)((void *)newaddr, current - newaddr);
+            int res = VG_(munmap)((void *)newaddr, current - newaddr);
+            vg_assert(0 == res);
          }
          ret = newbrk;

CVS commit by nethercote: 

Removed some unnecessary is_kerror() checks.

Fixed nanosleep's formatting.


  M +20 -27    vg_syscalls.c   1.109


--- valgrind/coregrind/vg_syscalls.c  #1.108:1.109
@@ -3950,8 +3950,6 @@ PRE(mmap2)
 POST(mmap2)
 {
-   if (!VG_(is_kerror)(res)) {
       vg_assert(valid_client_addr(res, arg2, tid, "mmap2"));
       mmap_segment( (Addr)res, arg2, arg3, arg4, arg5, arg6 * (ULong)VKI_BYTES_PER_PAGE );
-   }
 }
 
@@ -4062,5 +4060,4 @@ PRE(mincore)
 POST(mincore)
 {
-   if (!VG_(is_kerror)(res))
       VG_TRACK( post_mem_write, arg3, (arg2 + 4096 - 1) / 4096 );  
 }
@@ -5164,5 +5161,4 @@ PRE(clock_gettime)
 POST(clock_gettime)
 {
-    if (!VG_(is_kerror)(res) && res == 0)
        VG_TRACK( post_mem_write, arg2, sizeof(struct timespec) );
 }
@@ -5192,5 +5188,4 @@ PRE(futex)
 POST(futex)
 {
-   if (!VG_(is_kerror)(res)) {
       VG_TRACK( post_mem_write, arg1, sizeof(int) );
       if (arg2 == VKI_FUTEX_FD) {
@@ -5203,5 +5198,4 @@ POST(futex)
          }
       }
-   }
 }
 
@@ -5359,5 +5353,4 @@ PRE(sigpending)
 POST(sigpending)
 {
-   if ( !VG_( is_kerror )( res ) && res == 0 )
       VG_TRACK( post_mem_write, arg1, sizeof( vki_ksigset_t ) ) ;
 }

CVS commit by nethercote: 

Removed some code from VG_(client_alloc)() that could be left to VG_(mmap)().

Added a comment about stack extension failure.


  M +8 -13     vg_memory.c   1.58
  M +8 -0      vg_scheduler.c   1.156


--- valgrind/coregrind/vg_memory.c  #1.57:1.58
@@ -681,18 +681,13 @@ Addr VG_(client_alloc)(Addr addr, UInt l
    len = PGROUNDUP(len);
 
-   if (!(sf_flags & SF_FIXED))
-      addr = VG_(find_map_space)(addr, len, True);
-
-   // Don't do the mapping if we couldn't find space!
-   if (0 == addr)
-      return 0;
+   sk_assert(!(sf_flags & SF_FIXED));
+   sk_assert(0 == addr);
 
-   if (VG_(mmap)((void *)addr, len, prot,
-                 VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT,
-                 sf_flags | SF_CORE, -1, 0) == (void *)addr) 
-   {
+   addr = (Addr)VG_(mmap)((void *)addr, len, prot, 
+                          VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT,
+                          sf_flags | SF_CORE, -1, 0);
+   if ((Addr)-1 != addr)
       return addr;
-   }
-
+   else
    return 0;
 }

--- valgrind/coregrind/vg_scheduler.c  #1.155:1.156
@@ -1942,4 +1942,12 @@ void do__apply_in_new_thread ( ThreadId 
                                     VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, 
                                     SF_STACK);
+      // Given the low number of threads Valgrind can handle, stack
+      // allocation should pretty much always succeed, so having an
+      // assertion here isn't too bad.  However, probably better would be
+      // this:
+      //
+      //   if (0 == new_stack) 
+      //      SET_PTHREQ_RETVAL(parent_tid, -VKI_EAGAIN);
+      //   
       vg_assert(0 != new_stack);
       VG_(threads)[tid].stack_base = new_stack;

CVS commit by nethercote: 

Add some more assertion checking where it was lacking.


  M +9 -6      vg_mylibc.c   1.80


--- valgrind/coregrind/vg_mylibc.c  #1.79:1.80
@@ -406,10 +406,13 @@ void* VG_(brk) ( void* end_data_segment 
 
    if (brkpage != endpage) {
-      if (brkpage > endpage)
-         munmap_inner((void *)brkpage, brkpage-endpage);
-      else
-         mmap_inner((void *)brkpage, endpage-brkpage, 
+      if (brkpage > endpage) {
+         Int res = munmap_inner((void *)brkpage, brkpage-endpage);
+         vg_assert(0 == res);
+      } else {
+         Addr res = mmap_inner((void *)brkpage, endpage-brkpage, 
                     VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
                     VKI_MAP_FIXED|VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS, -1, 0);
+         vg_assert((Addr)-1 != res);
+      }
    }
    VG_(curbrk) = (Char *)__curbrk = end_data_segment;

CVS commit by nethercote: 

Update VG_(mmap)() in #if'd out branch.


  M +1 -1      vg_transtab.c   1.29


--- valgrind/coregrind/vg_transtab.c  #1.28:1.29
@@ -401,5 +401,5 @@ Int maybe_commission_sector ( void )
          //VG_(unlink)(buf);
          VG_(do_syscall)(__NR_ftruncate, fd, PGROUNDUP(vg_tc_sector_szB));
-         vg_tc[s] = VG_(mmap)(0, PGROUNDUP(vg_tc_sector_szB), VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, VKI_MAP_SHARED, fd, 0);
+         vg_tc[s] = VG_(mmap)(0, PGROUNDUP(vg_tc_sector_szB), VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, VKI_MAP_SHARED, 0, fd, 0);
          VG_(close)(fd);
 #endif

CVS commit by nethercote: 

Intercept 'nothrow' versions of delete and delete[].


  M +8 -0      vg_replace_malloc.c.base   1.2


--- valgrind/coregrind/vg_replace_malloc.c.base  #1.1:1.2
@@ -133,7 +133,15 @@
 FREE( __builtin_delete,     __builtin_delete     );
 FREE( _ZdlPv,               __builtin_delete     );
+
+// operator delete(void*, std::nothrow_t const&)
+FREE( _ZdlPvRKSt9nothrow_t, __builtin_delete     );
+
 FREE( __builtin_vec_delete, __builtin_vec_delete );
 FREE( _ZdaPv,               __builtin_vec_delete );
 
+// operator delete[](void*, std::nothrow_t const&)
+FREE( _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
+
+
 LIBALIAS(void*, calloc, ( Int nmemb, Int size ))
 {

CVS commit by nethercote: 


Merged Valgrind's heap and stack.  This has two main advantages:

1. It simplifies various things a bit.

2. Valgrind/tools will run out of memory later than currently in many
circumstances.  This is good news esp. for Calltree.

Some things were going in V's 128MB heap, and some were going in V's 128MB map
segment.  Now all these things are going into a single 256MB map segment.
stage2 has been moved down to 0xb0000000, the start of the 256MB map segment.
The .so files needed by it are placed at 0xb1000000 (that's the map_base).

This required some bootstrapping at startup for memory -- we need to allocate
memory to create the segments skip-list which lets us allocate memory...
solution was to make the first superblock allocated a special static one.
That's pretty simple and enough to get things going.

Removed vg_glibc.c which wasn't doing anything anyway.

Removed VG_(brk) and associated stuff, made all the things that were calling it
call VG_(mmap)() instead.

Removed VG_(valgrind_mmap_end) which was no longer needed.

Rejigged the startup order a bit as necessary.

Moved an important comment from ume.c to vg_main.c where it should be.


  M +1 -2      Makefile.am   1.75
  M +1 -1      stage1.c   1.13
  M +0 -42     ume.c   1.11
  M +0 -4      vg_include.h   1.201
  M +97 -88    vg_main.c   1.169
  M +31 -8     vg_malloc2.c   1.27
  M +1 -1      vg_memory.c   1.59
  M +4 -56     vg_mylibc.c   1.81
  R            vg_glibc.c   1.2


--- valgrind/coregrind/Makefile.am  #1.74:1.75
@@ -53,5 +53,4 @@
         vg_execontext.c \
         vg_from_ucode.c \
-        vg_glibc.c \
         vg_hashtable.c \
         vg_helpers.S \
@@ -82,5 +81,5 @@
 stage2_DEPENDENCIES = $(srcdir)/valgrind.vs x86/stage2.lds
 stage2_LDFLAGS=-Wl,--export-dynamic -Wl,-e,_ume_entry  -g \
-        -Wl,-defsym,kickstart_base=0xb8000000 \
+        -Wl,-defsym,kickstart_base=0xb0000000 \
         -Wl,-T,x86/stage2.lds \
         -Wl,-version-script $(srcdir)/valgrind.vs 

--- valgrind/coregrind/stage1.c  #1.12:1.13
@@ -180,5 +180,5 @@ static void hoops(void)
       - something else?
     */
-   info.map_base = 0xb0000000;
+   info.map_base = 0xb1000000;
    info.argv = NULL;
 

--- valgrind/coregrind/ume.c  #1.10:1.11
@@ -29,46 +29,4 @@
 */
 
-/*
-  User-mode exec
-
-  This bootstraps Valgrind.  This code decides on the layout of the
-  client and Valgrind address spaces, loads valgrind.so and the
-  skin.so into the valgrind part, loads the client executable (and the
-  dynamic linker, if necessary) into the client part, and calls into
-  Valgrind proper.
-
-  The code is careful not to allow spurious mappings to appear in the
-  wrong parts of the address space.  In particular, to make sure
-  dlopen puts things in the right place, it will pad out the forbidden
-  chunks of address space so that dlopen is forced to put things where
-  we want them.
-
-  The memory map it creates is:
-
-  CLIENT_BASE    +-------------------------+
-                 | client address space    |
-                 :                         :
-                 :                         :
-                 | client stack            |
-  client_end     +-------------------------+
-                 | redzone                 |
-  shadow_base    +-------------------------+
-                 |                         |
-                 : shadow memory for skins :
-                 | (may be 0 sized)        |
-  shadow_end     +-------------------------+
-                 : gap (may be 0 sized)    :
-  valgrind_base  +-------------------------+
-                 | valgrind .so files      |
-                 | and mappings            |
-  valgrind_mmap_end                        -
-                 | kickstart executable    |
-                 -                         -
-                 | valgrind heap  vvvvvvvvv|
-  valgrind_end   -                         -
-                 | valgrind stack ^^^^^^^^^|
-                 +-------------------------+
-                 : kernel                  :
- */
 
 #define _GNU_SOURCE

--- valgrind/coregrind/vg_include.h  #1.200:1.201
@@ -1134,7 +1134,4 @@ __attribute__ ((__noreturn__))
 extern void  VG_(core_panic)      ( Char* str );
 
-/* VG_(brk) not public so skins cannot screw with curr_dataseg_end */
-extern void* VG_(brk) ( void* end_data_segment );
-
 /* Skins use VG_(strdup)() which doesn't expose ArenaId */
 extern Char* VG_(arena_strdup) ( ArenaId aid, const Char* s);
@@ -1439,5 +1436,4 @@ extern Addr VG_(shadow_base);	/* skin's 
 extern Addr VG_(shadow_end);
 extern Addr VG_(valgrind_base); /* valgrind's address range */
-extern Addr VG_(valgrind_mmap_end);
 extern Addr VG_(valgrind_end);
 

--- valgrind/coregrind/vg_main.c  #1.168:1.169
@@ -75,7 +75,4 @@
 #endif  /* AT_SECURE */
 
-/* Amount to reserve for Valgrind's internal mappings */
-#define VALGRIND_MAPSIZE        (128*1024*1024)
-
 /* redzone gap between client address space and shadow */
 #define REDZONE_SIZE            (1 * 1024*1024)
@@ -112,5 +109,4 @@ Addr VG_(shadow_end);
 
 Addr VG_(valgrind_base);         /* valgrind's address range */
-Addr VG_(valgrind_mmap_end);     /* valgrind's mmaps are between valgrind_base and here */
 Addr VG_(valgrind_end);
 
@@ -493,6 +489,5 @@ static void layout_client_space(Addr arg
 {
    VG_(client_base)       = CLIENT_BASE;
-   VG_(valgrind_mmap_end) = (addr_t)&kickstart_base; /* end of V's mmaps */
-   VG_(valgrind_base)     = VG_(valgrind_mmap_end) - VALGRIND_MAPSIZE;
+   VG_(valgrind_base)     = (addr_t)&kickstart_base;
    VG_(valgrind_end)      = ROUNDUP(argc_addr, 0x10000); /* stack */
 
@@ -531,5 +526,4 @@ static void layout_remaining_space(float
          "shadow_end         %8x (%dMB)\n"
          "valgrind_base      %8x (%dMB)\n"
-         "valgrind_mmap_end  %8x (%dMB)\n"
          "valgrind_end       %8x\n",
          VG_(client_base),       SEGSIZE(client_base,       client_mapbase),
@@ -538,6 +532,5 @@ static void layout_remaining_space(float
          VG_(shadow_base),       SEGSIZE(shadow_base,       shadow_end),
          VG_(shadow_end),        SEGSIZE(shadow_end,        valgrind_base),
-         VG_(valgrind_base),     SEGSIZE(valgrind_base,     valgrind_mmap_end),
-         VG_(valgrind_mmap_end), SEGSIZE(valgrind_mmap_end, valgrind_end),
+         VG_(valgrind_base),     SEGSIZE(valgrind_base,     valgrind_end),
          VG_(valgrind_end)
       );
@@ -2640,4 +2633,51 @@ void VG_(do_sanity_checks) ( Bool force_
 /*====================================================================*/
 
+/*
+  This code decides on the layout of the client and Valgrind address
+  spaces, loads valgrind.so and the skin.so into the valgrind part,
+  loads the client executable (and the dynamic linker, if necessary)
+  into the client part, and calls into Valgrind proper.
+
+  The code is careful not to allow spurious mappings to appear in the
+  wrong parts of the address space.  In particular, to make sure
+  dlopen puts things in the right place, it will pad out the forbidden
+  chunks of address space so that dlopen is forced to put things where
+  we want them.
+
+  The memory map it creates is:
+
+  CLIENT_BASE    +-------------------------+
+                 | client address space    |
+                 :                         :
+                 :                         :
+                 | client stack            |
+  client_end     +-------------------------+
+                 | redzone                 |
+  shadow_base    +-------------------------+
+                 |                         |
+                 : shadow memory for skins :
+                 | (may be 0 sized)        |
+  shadow_end     +-------------------------+
+                 : gap (may be 0 sized)    :
+  valgrind_base  +-------------------------+
+                 | kickstart executable    |
+                 | valgrind heap  vvvvvvvvv| (barely used)
+                 -                         -
+                 | valgrind .so files      |
+                 | and mappings            |
+                 -                         -
+                 | valgrind stack ^^^^^^^^^|
+  valgrind_end   +-------------------------+
+                 : kernel                  :
+
+  Nb: Before we can do general allocations with VG_(arena_malloc)() and
+  VG_(mmap)(), we need to build the segment skip-list, so we know where
+  we can put things.  However, building that structure requires
+  allocating memory.  So we need to a bootstrapping process.  It's done
+  by making VG_(arena_malloc)() have a special static superblock that's
+  used for the first 1MB's worth of allocations.  This is enough to
+  build the segment skip-list.
+*/
+
 static int prmap(void *start, void *end, const char *perm, off_t off, 
                  int maj, int min, int ino) {
@@ -2690,5 +2730,5 @@ int main(int argc, char **argv)
    //--------------------------------------------------------------
    // Check we were launched by stage1
-   //   p: n/a  [must be first step]
+   //   p: n/a
    //--------------------------------------------------------------
    scan_auxv();
@@ -2737,5 +2777,5 @@ int main(int argc, char **argv)
    //==============================================================
    // Can use VG_(malloc)() and VG_(arena_malloc)() only after load_tool()
-   // -- redzone size is now set.
+   // -- redzone size is now set.  This is checked by vg_malloc2.c.
    //==============================================================
    
@@ -2786,10 +2826,4 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // Read /proc/self/maps into a buffer
-   //   p: all memory layout, environment setup   [so memory maps are right]
-   //--------------------------------------------------------------
-   VG_(read_procselfmaps)();
-
-   //--------------------------------------------------------------
    // atfork
    //   p: n/a
@@ -2805,12 +2839,27 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // Setup tool
-   //   p: VG_(read_procselfmaps)()  [so if sk_pre_clo_init calls
-   //        VG_(malloc), any mmap'd superblocks aren't erroneously
-   //        identified later as being owned by the client]
-   // XXX: is that necessary, now that we look for V's segments separately?
-   // XXX: alternatively, if sk_pre_clo_init does use VG_(malloc)(), is it
-   //      wrong to ignore any segments that might add in parse_procselfmaps?
+   // Read /proc/self/maps into a buffer
+   //   p: all memory layout, environment setup   [so memory maps are right]
+   //--------------------------------------------------------------
+   VG_(read_procselfmaps)();
+
+   //--------------------------------------------------------------
+   // Build segment map (Valgrind segments only)
+   //   p: read proc/self/maps
+   //   p: sk_pre_clo_init()  [to setup new_mem_startup tracker]
+   //--------------------------------------------------------------
+   VG_(parse_procselfmaps) ( build_valgrind_map_callback );
+
+   //==============================================================
+   // Can use VG_(arena_malloc)() with non-CORE arena after segments set up
+   //==============================================================
+
+   //--------------------------------------------------------------
+   // Init tool: pre_clo_init, process cmd line, post_clo_init
    //   p: setup_client_stack() [for 'VG_(client_arg[cv]']
+   //   p: load_tool()               [for 'tool']
+   //   p: setup_file_descriptors()  [for 'VG_(fd_xxx_limit)']
+   //   p: parse_procselfmaps        [so VG segments are setup so tool can
+   //                                 call VG_(malloc)]
    //--------------------------------------------------------------
    (*toolinfo->sk_pre_clo_init)();
@@ -2818,20 +2867,34 @@ int main(int argc, char **argv)
    VG_(sanity_check_needs)();
 
-   //--------------------------------------------------------------
    // If --tool and --help/--help-debug was given, now give the core+tool
    // help message
-   //   p: pre_clo_init()
-   //--------------------------------------------------------------
    if (need_help) {
       usage(/*--help-debug?*/2 == need_help);
    }
+   process_cmd_line_options(client_auxv, tool);
+
+   SK_(post_clo_init)();
 
    //--------------------------------------------------------------
-   // Process Valgrind's + tool's command-line options
-   //   p: load_tool()               [for 'tool']
-   //   p: setup_file_descriptors()  [for 'VG_(fd_xxx_limit)']
-   //   p: sk_pre_clo_init           [to set 'command_line_options' need]
+   // Build segment map (all segments)
+   //   p: setup_client_stack()  [for 'esp_at_startup']
+   //   p: init tool             [for 'new_mem_startup']
    //--------------------------------------------------------------
-   process_cmd_line_options(client_auxv, tool);
+   esp_at_startup___global_arg = esp_at_startup;
+   VG_(parse_procselfmaps) ( build_segment_map_callback );  /* everything */
+   esp_at_startup___global_arg = 0;
+   
+   //--------------------------------------------------------------
+   // Initialize our trampoline page (which is also sysinfo stuff)
+   //   p: setup_client_stack()  [for 'esp_at_startup']
+   //--------------------------------------------------------------
+   VG_(memcpy)( (void *)VG_(client_trampoline_code),
+                &VG_(trampoline_code_start), VG_(trampoline_code_length) );
+   VG_(mprotect)( (void *)VG_(client_trampoline_code),
+                 VG_(trampoline_code_length), VKI_PROT_READ|VKI_PROT_EXEC );
+
+   //==============================================================
+   // Can use VG_(map)() after segments set up
+   //==============================================================
 
    //--------------------------------------------------------------
@@ -2848,10 +2911,4 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // Setup tool, post command-line processing
-   //   p: process_cmd_line_options  [tool assumes it]
-   //--------------------------------------------------------------
-   SK_(post_clo_init)();
-
-   //--------------------------------------------------------------
    // Set up baseBlock
    //   p: {pre,post}_clo_init()  [for tool helper registration]
@@ -2908,50 +2965,4 @@ int main(int argc, char **argv)
 
    //--------------------------------------------------------------
-   // Reserve Valgrind's kickstart, heap and stack
-   //   p: XXX ???
-   //--------------------------------------------------------------
-   VG_(map_segment)(VG_(valgrind_mmap_end),
-                    VG_(valgrind_end)-VG_(valgrind_mmap_end),
-                    VKI_PROT_NONE, SF_VALGRIND|SF_FIXED);
-
-   //--------------------------------------------------------------
-   // Identify Valgrind's segments
-   //   p: read proc/self/maps
-   //   p: VG_(map_segment)   [XXX ???]
-   //   p: sk_pre_clo_init()  [to setup new_mem_startup tracker]
-   //--------------------------------------------------------------
-   VG_(parse_procselfmaps) ( build_valgrind_map_callback );
-
-   // XXX: I can't see why these two need to be separate;  could they be
-   // folded together?  If not, need a comment explaining why.
-   //
-   // XXX: can we merge reading and parsing of /proc/self/maps?
-   //
-   // XXX: can we dynamically allocate the /proc/self/maps buffer? (or mmap
-   //      it?)  Or does that disturb its contents...
-
-   //--------------------------------------------------------------
-   // Build segment map (all segments)
-   //   p: setup_client_stack()  [for 'esp_at_startup']
-   //--------------------------------------------------------------
-   esp_at_startup___global_arg = esp_at_startup;
-   VG_(parse_procselfmaps) ( build_segment_map_callback );  /* everything */
-   esp_at_startup___global_arg = 0;
-   
-   //==============================================================
-   // Can only use VG_(map)() after VG_(map_segment)()  [XXX ???]
-   //==============================================================
-
-   //--------------------------------------------------------------
-   // Build segment map (all segments)
-   //   p: setup_client_stack()  [for 'esp_at_startup']
-   //--------------------------------------------------------------
-   /* Initialize our trampoline page (which is also sysinfo stuff) */
-   VG_(memcpy)( (void *)VG_(client_trampoline_code),
-                &VG_(trampoline_code_start), VG_(trampoline_code_length) );
-   VG_(mprotect)( (void *)VG_(client_trampoline_code),
-                 VG_(trampoline_code_length), VKI_PROT_READ|VKI_PROT_EXEC );
-
-   //--------------------------------------------------------------
    // Read suppression file
    //   p: process_cmd_line_options()  [for VG_(clo_suppressions)]

--- valgrind/coregrind/vg_malloc2.c  #1.26:1.27
@@ -188,4 +188,6 @@ void* align_upwards ( void* p, Int align
 /*------------------------------------------------------------*/
 
+#define CORE_ARENA_MIN_SZW    262144
+
 /* The arena structures themselves. */
 static Arena vg_arena[VG_N_ARENAS];
@@ -247,8 +249,14 @@ static
 void ensure_mm_init ( void )
 {
-   Int client_rz_szW;
+   static Int  client_rz_szW;
    static Bool init_done = False;
    
-   if (init_done) return;
+   if (init_done) {
+      // Make sure the client arena's redzone size never changes.  Could
+      // happen if VG_(arena_malloc) was called too early, ie. before the
+      // tool was loaded.
+      vg_assert(client_rz_szW == VG_(vg_malloc_redzone_szB)/4);
+      return;
+   }
 
    /* Use checked red zones (of various sizes) for our internal stuff,
@@ -259,5 +267,5 @@ void ensure_mm_init ( void )
       zone words are unchanged. */
 
-   arena_init ( &vg_arena[VG_AR_CORE],      "core",     2, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_CORE],      "core",     2, True, CORE_ARENA_MIN_SZW, False );
 
    arena_init ( &vg_arena[VG_AR_TOOL],      "tool",     2, True, 262144, False );
@@ -317,8 +325,14 @@ Bool VG_(is_inside_segment_mmapd_by_low_
 /*------------------------------------------------------------*/
 
+// If not enough memory available, either aborts (for non-client memory)
+// or returns 0 (for client memory).
 static
 Superblock* newSuperblock ( Arena* a, Int cszW )
 {
+   static Bool called_before = False;
+   static Word bootstrap_superblock[CORE_ARENA_MIN_SZW];
+   Int cszB;
    Superblock* sb;
+
    cszW += 2; /* Take into account sb->next and sb->n_words fields */
    if (cszW < a->min_sblockW) cszW = a->min_sblockW;
@@ -325,8 +339,18 @@ Superblock* newSuperblock ( Arena* a, In
    while ((cszW % VKI_WORDS_PER_PAGE) > 0) cszW++;
 
-   if (a->clientmem) {
+   cszB = cszW * sizeof(Word);
+
+   if (!called_before) {
+      // First time we're called -- use the special static bootstrap
+      // superblock (see comment at top of main() for details).
+      called_before = True;
+      vg_assert(a == &vg_arena[VG_AR_CORE]);
+      vg_assert(CORE_ARENA_MIN_SZW*sizeof(Word) >= cszB);
+      sb = (Superblock*)bootstrap_superblock;
+
+   } else if (a->clientmem) {
       // client allocation -- return 0 to client if it fails
       sb = (Superblock *)
-           VG_(client_alloc)(0, cszW * sizeof(Word), 
+           VG_(client_alloc)(0, cszB,
                              VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, 0);
       if (NULL == sb) {
@@ -335,9 +359,8 @@ Superblock* newSuperblock ( Arena* a, In
    } else {
       // non-client allocation -- abort if it fails
-      sb = VG_(get_memory_from_mmap) ( cszW * sizeof(Word), 
-                                       "newSuperblock" );
+      sb = VG_(get_memory_from_mmap) ( cszB, "newSuperblock" );
    }
    sb->n_payload_words = cszW - 2;
-   a->bytes_mmaped += cszW * sizeof(Word);
+   a->bytes_mmaped += cszB;
    if (0)
       VG_(message)(Vg_DebugMsg, "newSuperblock, %d payload words", 

--- valgrind/coregrind/vg_memory.c  #1.58:1.59
@@ -494,5 +494,5 @@ Addr VG_(find_map_space)(Addr addr, UInt
    Segment *s;
    Addr ret;
-   Addr limit = (for_client ? VG_(client_end) : VG_(valgrind_mmap_end));
+   Addr limit = (for_client ? VG_(client_end) : VG_(valgrind_end));
 
    if (addr == 0)

--- valgrind/coregrind/vg_mylibc.c  #1.80:1.81
@@ -373,52 +373,4 @@ Int VG_(nanosleep)( const struct vki_tim
 }
 
-extern Char _end;
-Char *VG_(curbrk) = NULL;
-extern void *__curbrk;          /* in glibc */
-
-void* VG_(brk) ( void* end_data_segment )
-{
-   Addr end;
-   Addr brkpage;
-   Addr endpage;
-
-   if (VG_(curbrk) == NULL) {
-      VG_(curbrk) = &_end;
-      __curbrk = (void *)VG_(curbrk);
-   }
-   
-   end = (Addr)end_data_segment;
-   brkpage = PGROUNDUP(VG_(curbrk));
-   endpage = PGROUNDUP(end);
-
-   if (0 && VG_(curbrk) != __curbrk)
-      VG_(printf)("__curbrk changed unexpectedly: VG_(curbrk)=%p, __curbrk=%p\n",
-                  VG_(curbrk), __curbrk);
-
-   if (0)
-      VG_(printf)("brk(end_data_segment=%p); brkpage=%p endpage=%p end=%p curbrk=%p &_end=%p\n",
-                  end_data_segment, brkpage, endpage, end, VG_(curbrk), &_end);
-
-   if (endpage < (Addr)&_end) {
-      __curbrk = (void *)VG_(curbrk);
-      return (void *)VG_(curbrk);
-   }
-
-   if (brkpage != endpage) {
-      if (brkpage > endpage) {
-         Int res = munmap_inner((void *)brkpage, brkpage-endpage);
-         vg_assert(0 == res);
-      } else {
-         Addr res = mmap_inner((void *)brkpage, endpage-brkpage, 
-                       VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
-                       VKI_MAP_FIXED|VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS, -1, 0);
-         vg_assert((Addr)-1 != res);
-      }
-   }
-   VG_(curbrk) = (Char *)__curbrk = end_data_segment;
-
-   return end_data_segment;
-}
-
 
 /* ---------------------------------------------------------------------
@@ -1676,14 +1628,10 @@ void* VG_(get_memory_from_mmap) ( Int nB
    static UInt tot_alloc = 0;
    void* p;
-   Char *b = VG_(brk)(0);
-
-   p = (void *)PGROUNDUP(b);
-   b = VG_(brk)(p + PGROUNDUP(nBytes));
-
-   if (b != (p + PGROUNDUP(nBytes)))
-       p = (void *)-1;
+   p = VG_(mmap)(0, nBytes,
+                 VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC,
+                 VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS, 0, -1, 0);
 
    if (p != ((void*)(-1))) {
-      vg_assert(p >= (void *)VG_(valgrind_mmap_end) && p < (void *)VG_(valgrind_end));
+      vg_assert(p >= (void*)VG_(valgrind_base) && p < (void*)VG_(valgrind_end));
       tot_alloc += (UInt)nBytes;
       if (0)

CVS commit by nethercote: 



If new/new[] fails and should throw an exception, abort instead, since we can't
throw exceptions.


  M +27 -7     vg_replace_malloc.c.base   1.3


--- valgrind/coregrind/vg_replace_malloc.c.base  #1.2:1.3
@@ -64,4 +64,6 @@
    ret VG_INTERCEPT(soname:libc.so.6, ##name) args
 
+extern void _exit(int);
+
 /*------------------------------------------------------------*/
 /*--- Replacing malloc() et al                             ---*/
@@ -107,15 +109,35 @@
    return v; \
 }
+
+#define ALLOC2(fff, vgfff) \
+LIBALIAS(void *, fff, (Int n)) \
+{ \
+   void* v; \
+ \
+   MALLOC_TRACE(#fff "(%d)", n ); \
+   MAYBE_SLOPPIFY(n); \
+   if (!init_done) init(); \
+ \
+   v = (void*)VALGRIND_NON_SIMD_CALL1( info.sk_##vgfff, n ); \
+   MALLOC_TRACE(" = %p", v ); \
+   if (NULL == v) { \
+      VALGRIND_PRINTF_BACKTRACE( \
+         "new/new[] failed and should throw an exception, but Valgrind\n" \
+         "   cannot throw exceptions and so is aborting instead.  Sorry."); \
+         _exit(1); \
+   } \
+   return v; \
+}
 ALLOC( malloc,              malloc            );
-ALLOC( __builtin_new,       __builtin_new     );
-ALLOC( _Znwj,               __builtin_new     );
+ALLOC2(__builtin_new,       __builtin_new     );
+ALLOC2(_Znwj,               __builtin_new     );
 
 // operator new(unsigned, std::nothrow_t const&)
 ALLOC( _ZnwjRKSt9nothrow_t, __builtin_new     );
 
-ALLOC( __builtin_vec_new,   __builtin_vec_new );
-ALLOC( _Znaj,               __builtin_vec_new );
+ALLOC2(__builtin_vec_new,   __builtin_vec_new );
+ALLOC2(_Znaj,               __builtin_vec_new );
 
-// operator new[](unsigned, std::nothrow_t const&
+// operator new[](unsigned, std::nothrow_t const&)
 ALLOC( _ZnajRKSt9nothrow_t, __builtin_vec_new );
 
@@ -246,6 +268,4 @@
 /* Bomb out if we get any of these. */
 
-extern void _exit(int);
-
 static void panic(const char *str)
 {

CVS commit by thughes: 

Implement support for the async I/O system calls in 2.6 kernels. This
requires padding of the address space around calls to io_setup in order
to constrain the kernel's choice of address for the I/O context.

Based on patch from Scott Smith <scott-kde@...> with various
enhancements, this fixes bug #83060.


  M +3 -0      vg_include.h   1.202
  M +56 -0     vg_memory.c   1.60
  M +141 -0    vg_syscalls.c   1.110


--- valgrind/coregrind/vg_include.h  #1.201:1.202
@@ -1605,4 +1605,7 @@ extern Bool     VG_(seg_contains)(const 
 extern Bool     VG_(seg_overlaps)(const Segment *s, Addr ptr, UInt size);
 
+extern void VG_(pad_address_space)(void);
+extern void VG_(unpad_address_space)(void);
+
 extern __attribute__((regparm(1))) 
        void VG_(unknown_esp_update) ( Addr new_ESP );

--- valgrind/coregrind/vg_memory.c  #1.59:1.60
@@ -546,4 +546,60 @@ Addr VG_(find_map_space)(Addr addr, UInt
 }
 
+void VG_(pad_address_space)(void)
+{
+   Addr addr = VG_(client_base);
+   Segment *s = VG_(SkipNode_First)(&sk_segments);
+   UInt args[6];
+   Addr ret;
+   
+   args[2] = 0;
+   args[3] = VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS;
+   args[4] = -1;
+   args[5] = 0;
+   
+   while (s && addr < VG_(valgrind_end)) {
+      if (addr < s->addr) {
+         args[0] = (UInt)addr;
+         args[1] = s->addr - addr;
+         
+         ret = VG_(do_syscall)(__NR_mmap, (UInt)args);
+      }
+        
+      addr = s->addr + s->len;
+      s = VG_(SkipNode_Next)(&sk_segments, s);
+   }
+
+   if (addr < VG_(valgrind_end)) {
+      args[0] = (UInt)addr;
+      args[1] = VG_(valgrind_end) - addr;
+
+      ret = VG_(do_syscall)(__NR_mmap, (UInt)args);
+   }
+
+   return;
+}
+
+void VG_(unpad_address_space)(void)
+{
+   Addr addr = VG_(client_base);
+   Segment *s = VG_(SkipNode_First)(&sk_segments);
+   Int ret;
+
+   while (s && addr < VG_(valgrind_end)) {
+      if (addr < s->addr) {
+         ret = VG_(do_syscall)(__NR_munmap, (UInt)addr, s->addr - addr);
+      }
+         
+      addr = s->addr + s->len;
+      s = VG_(SkipNode_Next)(&sk_segments, s);
+   }
+
+   if (addr < VG_(valgrind_end)) {
+      ret = VG_(do_syscall)(__NR_munmap, (UInt)addr, VG_(valgrind_end) - addr);
+   }
+
+   return;
+}
+
 Segment *VG_(find_segment)(Addr a)
 {

--- valgrind/coregrind/vg_syscalls.c  #1.109:1.110
@@ -5359,4 +5359,138 @@ PREALIAS(rt_sigpending, sigpending);
 POSTALIAS(rt_sigpending, sigpending);
 
+PRE(io_setup)
+{
+   UInt size;
+   Addr addr;
+
+   /* long io_setup (unsigned nr_events, aio_context_t *ctxp); */
+   MAYBE_PRINTF("io_setup ( %ul, %p )\n",arg1,arg2);
+   SYSCALL_TRACK( pre_mem_write, tid, "io_setup(ctxp)",
+                  arg2, sizeof(vki_aio_context_t) );
+   
+   size = PGROUNDUP(sizeof(vki_aio_ring) + arg1 * sizeof(vki_io_event));
+   addr = VG_(find_map_space)(0, size, True);
+   VG_(map_segment)(addr, size, VKI_PROT_READ|VKI_PROT_EXEC, SF_FIXED);
+   
+   VG_(pad_address_space)();
+   res = VG_(do_syscall)(SYSNO, arg1, arg2);
+   VG_(unpad_address_space)();
+
+   if (res == 0) {
+      vki_aio_ring *r = *(vki_aio_ring **)arg2;
+        
+      vg_assert(addr == (Addr)r);
+      vg_assert(valid_client_addr(addr, size, tid, "io_setup"));
+                
+      VG_TRACK( new_mem_mmap, addr, size, True, True, False );
+      VG_TRACK( post_mem_write, arg2, sizeof(vki_aio_context_t) );
+   }
+   else {
+      VG_(unmap_range)(addr, size);
+   }
+}
+
+PRE(io_destroy)
+{
+   Segment *s = VG_(find_segment)(arg1);
+   vki_aio_ring *r = *(vki_aio_ring **)arg1;
+   UInt size = PGROUNDUP(sizeof(vki_aio_ring) + r->nr * sizeof(vki_io_event));
+
+   /* long io_destroy (aio_context_t ctx); */
+   MAYBE_PRINTF("io_destroy ( %ul )\n",arg1);
+
+   res = VG_(do_syscall)(SYSNO, arg1);
+   
+   if (res == 0 && s != NULL && VG_(seg_contains)(s, arg1, size)) {
+      VG_TRACK( die_mem_munmap, arg1, size );
+      VG_(unmap_range)(arg1, size);
+   }
+}
+
+PRE(io_getevents)
+{
+   /* long io_getevents (aio_context_t ctx_id, long min_nr, long nr,
+                         struct io_event *events, struct timespec *timeout); */
+   MAYBE_PRINTF("io_getevents ( %ul, %l, %l, %p, %p )\n",arg1,arg2,arg3,arg4,arg5);
+   if (arg3 > 0)
+      SYSCALL_TRACK( pre_mem_write, tid, "io_getevents(events)",
+                     arg4, sizeof(vki_io_event)*arg3 );
+   if (arg5 != (UInt)NULL)
+      SYSCALL_TRACK( pre_mem_read, tid, "io_getevents(timeout)",
+                     arg5, sizeof(struct timespec));
+}
+
+POST(io_getevents)
+{
+   int i;
+
+   if (res > 0) {
+      VG_TRACK( post_mem_write, arg4, sizeof(vki_io_event)*res );
+      for (i = 0; i < res; i++) {
+         const vki_io_event *vev = ((vki_io_event *)arg4) + i;
+         const vki_iocb *cb = (vki_iocb *)(UInt)vev->obj;
+
+         switch (cb->aio_lio_opcode) {
+         case VKI_IOCB_CMD_PREAD:
+            if (vev->result > 0)
+               VG_TRACK( post_mem_write, cb->aio_buf, vev->result );
+            break;
+            
+         case VKI_IOCB_CMD_PWRITE:
+            break;
+           
+         default:
+            VG_(message)(Vg_DebugMsg,"Warning: unhandled io_getevents opcode: %u\n",cb->aio_lio_opcode);
+            break;
+         }
+      }
+   }
+}
+
+PRE(io_submit)
+{
+   int i;
+
+   /* long io_submit (aio_context_t ctx_id, long nr, struct iocb **iocbpp); */
+   MAYBE_PRINTF("io_submit( %ul, %l, %p )\n",arg1,arg2,arg3);
+   SYSCALL_TRACK( pre_mem_read, tid, "io_submit(iocbpp)",
+                  arg3, sizeof(vki_iocb *)*arg2 );
+   for (i = 0; i < arg2; i++) {
+      vki_iocb *cb = ((vki_iocb **)arg3)[i];
+      SYSCALL_TRACK( pre_mem_read, tid, "io_submit(iocb)",
+                     (UInt)cb, sizeof(vki_iocb) );
+      switch (cb->aio_lio_opcode) {
+      case VKI_IOCB_CMD_PREAD:
+         SYSCALL_TRACK( pre_mem_write, tid, "io_submit(PREAD)",
+                        cb->aio_buf, cb->aio_nbytes );
+         break;
+
+      case VKI_IOCB_CMD_PWRITE:
+         SYSCALL_TRACK( pre_mem_read, tid, "io_submit(PWRITE)",
+                        cb->aio_buf, cb->aio_nbytes );
+         break;
+        
+      default:
+         VG_(message)(Vg_DebugMsg,"Warning: unhandled io_submit opcode: %u\n",cb->aio_lio_opcode);
+         break;
+      }
+   }
+}
+
+PRE(io_cancel)
+{
+   /* long io_cancel (aio_context_t ctx_id, struct iocb *iocb,
+                      struct io_event *result); */
+   MAYBE_PRINTF("io_cancel( %ul, %p, %p )\n",arg1,arg2,arg3);
+   SYSCALL_TRACK( pre_mem_read, tid, "io_cancel(iocb)",
+                  arg2, sizeof(vki_iocb) );
+   SYSCALL_TRACK( pre_mem_write, tid, "io_cancel(result)",
+                  arg3, sizeof(vki_io_event) );
+}
+
+POST(io_cancel)
+{
+   VG_TRACK( post_mem_write, arg3, sizeof(vki_io_event) );
+}
 
 #undef SYSNO
@@ -5415,4 +5549,7 @@ static const struct sys_info special_sys
    SYSB_(mremap,                False),
 
+   SYSB_(io_setup,              False),
+   SYSB_(io_destroy,            False),
+
 #if SIGNAL_SIMULATION
    SYSBA(sigaltstack,           False),
@@ -5627,4 +5764,8 @@ static const struct sys_info sys_info[] 
    SYSBA(getitimer,             True), /* not blocking, but must run in LWP context */
 
+   SYSBA(io_getevents,          True),
+   SYSB_(io_submit,             False),
+   SYSBA(io_cancel,             False),
+
 #if !SIGNAL_SIMULATION
    SYSBA(sigaltstack,           False),

On Fri, 16 Jul 2004, Tom Hughes wrote:

> Implement support for the async I/O system calls in 2.6 kernels. This
> requires padding of the address space around calls to io_setup in order
> to constrain the kernel's choice of address for the I/O context.
>
> Based on patch from Scott Smith <scott-kde@...> with various
> enhancements, this fixes bug #83060.

Tom,

Can you please add a couple of brief comments to explain why the padding 
is necessary and how it works?  Thanks.

N

CVS commit by thughes: 

Add comments to explain the address space padding technology.


  M +13 -0     vg_memory.c   1.61


--- valgrind/coregrind/vg_memory.c  #1.60:1.61
@@ -546,4 +546,15 @@ Addr VG_(find_map_space)(Addr addr, UInt
 }
 
+/* Pad the entire process address space, from VG_(client_base)
+   to VG_(valgrind_end) by creating an anonymous and inaccessible
+   mapping over any part of the address space which is not covered
+   by an entry in the segment list.
+
+   This is designed for use around system calls which allocate
+   memory in the process address space without providing a way to
+   control it's location such as io_setup. By choosing a suitable
+   address with VG_(find_map_space) and then adding a segment for
+   it and padding the address space valgrind can ensure that the
+   kernel has no choice but to put the memory where we want it. */
 void VG_(pad_address_space)(void)
 {
@@ -580,4 +591,6 @@ void VG_(pad_address_space)(void)
 }
 
+/* Removed the address space padding added by VG_(pad_address_space)
+   by removing any mappings that it created. */
 void VG_(unpad_address_space)(void)
 {

CVS commit by nethercote: 

apostrophe pedantry;  comment change only


  M +1 -1      vg_memory.c   1.62
  M +1 -1      vg_syscalls.c   1.111


--- valgrind/coregrind/vg_memory.c  #1.61:1.62
@@ -553,5 +553,5 @@ Addr VG_(find_map_space)(Addr addr, UInt
    This is designed for use around system calls which allocate
    memory in the process address space without providing a way to
-   control it's location such as io_setup. By choosing a suitable
+   control its location such as io_setup. By choosing a suitable
    address with VG_(find_map_space) and then adding a segment for
    it and padding the address space valgrind can ensure that the

--- valgrind/coregrind/vg_syscalls.c  #1.110:1.111
@@ -451,5 +451,5 @@ static OpenFd *allocated_fds;
 static int fd_count = 0;
 
-/* Given a file descriptor, attempt to deduce it's filename.  To do this,
+/* Given a file descriptor, attempt to deduce its filename.  To do this,
    we use /proc/self/fd/<FD>.  If this doesn't point to a file, or if it
    doesn't exist, we just return NULL.  Otherwise, we return a pointer

CVS commit by thughes: 

Fix typo in comment.


  M +1 -1      vg_memory.c   1.63


--- valgrind/coregrind/vg_memory.c  #1.62:1.63
@@ -591,5 +591,5 @@ void VG_(pad_address_space)(void)
 }
 
-/* Removed the address space padding added by VG_(pad_address_space)
+/* Remove the address space padding added by VG_(pad_address_space)
    by removing any mappings that it created. */
 void VG_(unpad_address_space)(void)

CVS commit by nethercote: 

Support FBLD, FBSTP.  Patch courtesy of Jani Monoses.


  M +4 -0      vg_to_ucode.c   1.140


--- valgrind/coregrind/vg_to_ucode.c  #1.139:1.140
@@ -2546,6 +2546,10 @@ Addr dis_fpu ( UCodeBlock* cb, 
             case 3: /* FISTP word-integer */
                return dis_fpu_mem(cb, sorb, 2, wr, eip, first_byte); 
+            case 4: /* FBLD extended-real */
+               return dis_fpu_mem(cb, sorb, 10, rd, eip, first_byte);
             case 5: /* FILD qword-integer */
                return dis_fpu_mem(cb, sorb, 8, rd, eip, first_byte); 
+            case 6: /* FBSTP extended-real */
+               return dis_fpu_mem(cb, sorb, 10, wr, eip, first_byte);
             case 7: /* FISTP qword-integer */
                return dis_fpu_mem(cb, sorb, 8, wr, eip, first_byte);

CVS commit by thughes: 

Make sure init_global_thread_specific_state() set the global_init_done
flag before the call to __uselocale() in order to avoid deadlock.

CCMAIL: 77952-done@...


  M +10 -3     vg_libpthread.c   1.158


--- valgrind/coregrind/vg_libpthread.c  #1.157:1.158
@@ -2044,10 +2044,17 @@ init_global_thread_specific_state ( void
    my_assert(pthread_self() == 1);
 
-   /* Initialise thread specific data for the root thread. */
-   init_thread_specific_state();
+   /* Signify init done - we shouldn't really do this until after
+      the call to init_thread_specific_state() but that routine makes
+      a call to __uselocale() that may bring us back here as that
+      routine will call __libc_tsd_set() which will call us.
 
-   /* Signify init done. */
+      We can get away with marking the init as done now because
+      the important bits of init_thread_specific_state() are done
+      before the call to __uselocale() is made. */
    global_init_done = 1;
 
+   /* Initialise thread specific data for the root thread. */
+   init_thread_specific_state();
+
    /* Install a cleanup routine to handle the root thread exiting */
    _pthread_cleanup_push(NULL, cleanup_root, NULL);

CVS commit by nethercote: 

Add a bunch of asserts to check the results of calls to system malloc().

Assertions are arguably not the right thing here, but the practice is
widespread and we're not planning on making asserts optional, and it's a lot
better than no checking.


  M +3 -0      ume.c   1.13
  M +8 -0      vg_main.c   1.172


--- valgrind/coregrind/ume.c  #1.12:1.13
@@ -245,4 +245,5 @@ struct elfinfo *readelf(int fd, const ch
    int phsz;
 
+   assert(e);
    e->fd = fd;
 
@@ -283,4 +284,5 @@ struct elfinfo *readelf(int fd, const ch
    phsz = sizeof(ESZ(Phdr)) * e->e.e_phnum;
    e->p = malloc(phsz);
+   assert(e->p);
 
    if (pread(fd, e->p, phsz, e->e.e_phoff) != phsz) {
@@ -423,4 +425,5 @@ static int load_ELF(char *hdr, int len, 
          int baseaddr_set;
 
+         assert(buf);
          pread(fd, buf, ph->p_filesz, ph->p_offset);
          buf[ph->p_filesz] = '\0';

--- valgrind/coregrind/vg_main.c  #1.171:1.172
@@ -654,4 +654,5 @@ static void augment_command_line(Int* vg
       vg_argv = malloc( (vg_argc + env_arg_count + f1_arg_count 
                           + f2_arg_count + 2) * sizeof(char **));
+      vg_assert(vg_argv);
       to      = vg_argv;
 
@@ -712,4 +713,5 @@ static void get_command_line( int argc, 
 
       vg_argv = malloc(sizeof(char **) * (vg_argc + 1));
+      vg_assert(vg_argv);
 
       cpp = vg_argv;
@@ -843,4 +845,5 @@ static char **fix_environment(char **ori
    inject_path_len = sizeof(inject_so) + vgliblen + preloadlen + 16;
    inject_path = malloc(inject_path_len);
+   vg_assert(inject_path);
 
    if (preload)
@@ -858,4 +861,5 @@ static char **fix_environment(char **ori
    /* Allocate a new space */
    ret = malloc(sizeof(char *) * (envc+3+1)); /* 3 new entries + NULL */
+   vg_assert(ret);
 
    /* copy it over */
@@ -876,4 +880,5 @@ static char **fix_environment(char **ori
             int len = strlen(*cpp) + vgliblen*2 + 16;
             char *cp = malloc(len);
+            vg_assert(cp);
 
             snprintf(cp, len, "%s%s:%s",
@@ -888,4 +893,5 @@ static char **fix_environment(char **ori
          int len = strlen(*cpp) + inject_path_len;
          char *cp = malloc(len);
+         vg_assert(cp);
 
          snprintf(cp, len, "%s%s:%s",
@@ -905,4 +911,5 @@ static char **fix_environment(char **ori
       int len = ld_library_path_len + vgliblen*2 + 16;
       char *cp = malloc(len);
+      vg_assert(cp);
 
       snprintf(cp, len, "%s%s", ld_library_path, VG_(libdir));
@@ -914,4 +921,5 @@ static char **fix_environment(char **ori
       int len = ld_preload_len + inject_path_len;
       char *cp = malloc(len);
+      vg_assert(cp);
       
       snprintf(cp, len, "%s%s",

CVS commit by thughes: 

Only treat colons in the switch name as important when looking for a
toolname to check - colons in the switch value are now ignored.

CCMAIL: 85416-done@...


  M +5 -2      vg_main.c   1.173


--- valgrind/coregrind/vg_main.c  #1.172:1.173
@@ -1690,9 +1690,12 @@ static void process_cmd_line_options( UI
 
       Char* arg = VG_(vg_argv)[i];
+      Char* colon = arg;
 
-      // XXX: allow colons in options, for Josef
+      /* Look for a colon in the switch name */
+      while (*colon && *colon != ':' && *colon != '=')
+         colon++;
 
       /* Look for matching "--toolname:foo" */
-      if (VG_(strstr)(arg, ":")) {
+      if (*colon == ':') {
          if (VG_CLO_STREQN(2,            arg,                "--") && 
              VG_CLO_STREQN(toolname_len, arg+2,              toolname) &&

CVS commit by thughes: 

Some systems seem to need linux/netlink.h for linux/fs.h to compile
correctly, so we include it beforehand in case.


  M +1 -0      vg_unsafe.h   1.31


--- valgrind/coregrind/vg_unsafe.h  #1.30:1.31
@@ -65,4 +65,5 @@
 #include <linux/timex.h>  /* for adjtimex */
 #include <linux/hdreg.h>  /* for hard drive ioctls */
+#include <linux/netlink.h>/* Some systems need this for linux/fs.h */
 #include <linux/fs.h>     /* for filing system ioctls */
 #ifdef HAVE_LINUX_FB_H

CVS commit by jseward: 

gcc sometimes generates "sbbl %reg,%reg" to convert the carry flag
into 0 or -1 in reg.  This has no actual dependency on reg, but
memcheck can't see that, and so will yelp if reg contains garbage.  A
simple fix is to put zero into reg before we start, zapping any
undefinedness it might otherwise contain.

Hopefully fixes #84978 (unconfirmed)


  M +14 -0     vg_to_ucode.c   1.141


--- valgrind/coregrind/vg_to_ucode.c  #1.140:1.141
@@ -1115,4 +1115,18 @@ Addr dis_op2_G_E ( UCodeBlock* cb, 
       }
 
+      /* gcc sometimes generates "sbbl %reg,%reg" to convert the carry
+         flag into 0 or -1 in reg.  This has no actual dependency on
+         reg, but memcheck can't see that, and so will yelp if reg
+         contains garbage.  A simple fix is to put zero into reg
+         before we start, zapping any undefinedness it might otherwise
+         contain.
+      */
+      if (opc == SBB && gregOfRM(rm) == eregOfRM(rm)) {
+         Int tzero = newTemp(cb);
+         uInstr2(cb, MOV, size, Literal, 0, TempReg, tzero);
+         uLiteral(cb, 0);
+         uInstr2(cb, PUT, size, TempReg, tzero, ArchReg, eregOfRM(rm));
+      }
+
       uInstr2(cb, GET, size, ArchReg, eregOfRM(rm), TempReg, tmp);

CVS commit by jseward: 

Fix extremely obscure bug in xadd picked up by QEMU's test suite.  The
(almost useless) instruction "xadd %reg,%reg" gave the wrong answer
due to a subtlety of the order in which the destination registers are
PUTted to.


  M +1 -1      vg_to_ucode.c   1.142


--- valgrind/coregrind/vg_to_ucode.c  #1.141:1.142
@@ -3138,6 +3138,6 @@ Addr dis_xadd_G_E ( UCodeBlock* cb, 
       uInstr2(cb, ADD, sz, TempReg, tmpd, TempReg, tmpt);
       setFlagsFromUOpcode(cb, ADD);
-      uInstr2(cb, PUT, sz, TempReg, tmpt, ArchReg, eregOfRM(rm));
       uInstr2(cb, PUT, sz, TempReg, tmpd, ArchReg, gregOfRM(rm));
+      uInstr2(cb, PUT, sz, TempReg, tmpt, ArchReg, eregOfRM(rm));
       DIP("xadd%c %s, %s\n", 
           nameISize(sz), nameIReg(sz,gregOfRM(rm)), nameIReg(sz,eregOfRM(rm)));

CVS commit by jseward: 

Fix scary bug causing mis-identification of SSE stores vs loads.


  M +2 -2      vg_to_ucode.c   1.143


--- valgrind/coregrind/vg_to_ucode.c  #1.142:1.143
@@ -4883,5 +4883,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                     //(insn[1] == 0x10 || insn[1] == 0x11)
                     // ? "movups" : "movaps";
-      Bool store = False; //insn[1] == 0x29 || insn[1] == 11;
+      Bool store = False; //insn[1] == 0x29 || insn[1] == 0x11;
       eip = dis_SSE3_load_store_or_mov
                ( cb, sorb, eip+2, 16, store, name,
@@ -4904,5 +4904,5 @@ static Addr disInstr ( UCodeBlock* cb, A
       UChar* name = (insn[1] == 0x10 || insn[1] == 0x11)
                     ? "movups" : "movaps";
-      Bool store = insn[1] == 0x29 || insn[1] == 11;
+      Bool store = insn[1] == 0x29 || insn[1] == 0x11;
       vg_assert(sz == 2 || sz == 4);
       if (sz == 4) {

CVS commit by thughes: 

Move the decoding of SFENCE out of the SSE only part of disInstr as it
exists on Athlon's that have MMXEXT support and those don't have SSE state
so won't decode it where it was.

CCMAIL: 85947-done@...


  M +19 -3     vg_to_ucode.c   1.144


--- valgrind/coregrind/vg_to_ucode.c  #1.143:1.144
@@ -3985,8 +3985,8 @@ static Addr disInstr ( UCodeBlock* cb, A
    }
 
-   /* LFENCE/MFENCE/SFENCE -- flush pending operations to memory */
+   /* LFENCE/MFENCE -- flush pending operations to memory */
    if (insn[0] == 0x0F && insn[1] == 0xAE
        && (epartIsReg(insn[2]))
-       && (gregOfRM(insn[2]) >= 5 && gregOfRM(insn[2]) <= 7))
+       && (gregOfRM(insn[2]) >= 5 && gregOfRM(insn[2]) <= 6))
    {
       vg_assert(sz == 4);
@@ -3995,5 +3995,5 @@ static Addr disInstr ( UCodeBlock* cb, A
                   Lit16, (((UShort)0x0F) << 8) | (UShort)0xAE,
                   Lit16, (UShort)insn[2] );
-      DIP("sfence\n");
+      DIP("%sfence\n", gregOfRM(insn[2]) == 5 ? "l" : "m");
       goto decode_success;
    }
@@ -6853,4 +6853,20 @@ static Addr disInstr ( UCodeBlock* cb, A
          break;
 
+      case 0xAE: /* SFENCE */
+         vg_assert(sz == 4);
+         modrm = getUChar(eip);
+         if (!epartIsReg(modrm)) {
+            goto decode_failure;
+         }
+         if (gregOfRM(modrm) != 7) {
+            goto decode_failure;
+         }
+         eip += lengthAMode(eip);
+         uInstr2(cb, SSE3, 0,  /* ignore sz for internal ops */
+                     Lit16, (((UShort)0x0F) << 8) | (UShort)0xAE,
+                     Lit16, (UShort)modrm );
+         DIP("sfence\n");
+         break;
+
       case 0x71: case 0x72: case 0x73: {
          /* (sz==4): PSLL/PSRA/PSRL mmxreg by imm8 */

CVS commit by nethercote: 

make non-exported function static


  M +1 -1      ume.c   1.15


--- valgrind/coregrind/ume.c  #1.14:1.15
@@ -56,5 +56,5 @@ static struct stat padstat;
 extern int kickstart_base;      /* linker created */
 
-void check_mmap(void* res, void* base, int len)
+static void check_mmap(void* res, void* base, int len)
 {
    if ((void*)-1 == res) {

CVS commit by nethercote: 


Remove unused global variable.


  M +0 -3      stage1.c   1.14


--- valgrind/coregrind/stage1.c  #1.13:1.14
@@ -48,5 +48,4 @@
 
 static int stack[SIGSTKSZ*4];
-static int our_argc;
 
 /* Where we expect to find all our aux files (namely, stage2) */
@@ -218,6 +217,4 @@ int main(int argc, char **argv)
    assert(ume_exec_esp != NULL);
 
-   our_argc = argc;
-
    /* Set the address space limit as high as it will go, since we make
       a lot of very large mappings. */

CVS commit by nethercote: 

Remove accidental double assignment.  Also don't assume that VG_(client_base)
is zero.


  M +2 -3      vg_main.c   1.175


--- valgrind/coregrind/vg_main.c  #1.174:1.175
@@ -507,8 +507,7 @@ static void layout_remaining_space(float
 
    VG_(client_end)     = VG_(client_base) + client_size;
-   VG_(client_mapbase) = PGROUNDDN((client_size/4)*3); /* where !FIXED mmap goes */
-
    /* where !FIXED mmap goes */
-   VG_(client_mapbase) = PGROUNDDN((addr_t)(client_size * CLIENT_HEAP_PROPORTION)); 
+   VG_(client_mapbase) = VG_(client_base) +
+         PGROUNDDN((addr_t)(client_size * CLIENT_HEAP_PROPORTION));
 
    VG_(shadow_base) = VG_(client_end) + REDZONE_SIZE;

CVS commit by nethercote: 

Neaten up ume.h:  don't export readelf(), mapelf, and struct elfinfo;  improve
formatting too.


  M +7 -0      ume.c   1.16
  M +39 -24    ume.h   1.6


--- valgrind/coregrind/ume.c  #1.15:1.16
@@ -51,4 +51,11 @@
 #include "vg_include.h"
 
+struct elfinfo
+{
+   ESZ(Ehdr)    e;
+   ESZ(Phdr)    *p;
+   int          fd;
+};
+
 static int padfile = -1;
 static struct stat padstat;

--- valgrind/coregrind/ume.h  #1.5:1.6
@@ -1,3 +1,8 @@
 
+/*--------------------------------------------------------------------*/
+/*--- A header file used by both stage1 and stage2.                ---*/
+/*---                                                        ume.h ---*/
+/*--------------------------------------------------------------------*/
+
 /*
    This file is part of Valgrind, an extensible x86 protected-mode
@@ -31,4 +36,8 @@
 #include <sys/types.h>
 
+/*------------------------------------------------------------*/
+/*--- General stuff                                        ---*/
+/*------------------------------------------------------------*/
+
 #if     ELFSZ == 64
 #define ESZ(x)  Elf64_##x
@@ -42,27 +51,34 @@
 typedef ESZ(Addr) addr_t;
 
+/*------------------------------------------------------------*/
+/*--- Loading ELF files                                    ---*/
+/*------------------------------------------------------------*/
+
 struct exeinfo
 {
-   addr_t       map_base;       /* INPUT: if non-zero, base address of mappings  */
-
-   addr_t       exe_base;       /* INOUT: lowest (allowed) address of exe       */
-   addr_t       exe_end;        /* INOUT: highest (allowed) address     */
+   addr_t map_base;     // INPUT: if non-zero, base address of mappings
+   char** argv;         // INPUT: the original argv
 
-   addr_t       phdr;           /* address phdr was mapped at           */
-   int          phnum;          /* number of phdrs                      */
-   addr_t       interp_base;    /* where interpreter (ld.so) was mapped */
-   addr_t       entry;          /* entrypoint in main executable        */
-   addr_t       init_eip;       /* initial eip                          */
-   addr_t       brkbase;        /* base address of brk segment          */
+   addr_t exe_base;     // INOUT: lowest (allowed) address of exe
+   addr_t exe_end;      // INOUT: highest (allowed) address
 
-   /* these are the extra args added by #! scripts */
-   char         *argv0;         /* INPUT: the interpreter name */
-   char         *argv1;         /* INPUT: the args for the interpreter */
+   addr_t phdr;         // address phdr was mapped at
+   int    phnum;        // number of phdrs
+   addr_t interp_base;  // where interpreter (ld.so) was mapped
+   addr_t entry;        // entrypoint in main executable
+   addr_t init_eip;     // initial eip
+   addr_t brkbase;      // base address of brk segment
 
-   char         **argv;         /* INPUT: the original argv */
+   // These are the extra args added by #! scripts
+   char*  argv0;        // INPUT: the interpreter name
+   char*  argv1;        // INPUT: the args for the interpreter
 };
 
 int do_exec(const char *exe, struct exeinfo *info);
 
+/*------------------------------------------------------------*/
+/*--- Address space padding                                ---*/
+/*------------------------------------------------------------*/
+
 void foreach_map(int (*fn)(void *start, void *end,
                            const char *perm, off_t offset,
@@ -74,13 +91,7 @@ int  as_getpadfd(void);
 void as_setpadfd(int);
 
-struct elfinfo
-{
-   ESZ(Ehdr)    e;
-   ESZ(Phdr)    *p;
-   int          fd;
-};
-
-struct elfinfo *readelf(int fd, const char *filename);
-ESZ(Addr) mapelf(struct elfinfo *e, ESZ(Addr) base);
+/*------------------------------------------------------------*/
+/*--- Finding and dealing with auxv                        ---*/
+/*------------------------------------------------------------*/
 
 struct ume_auxv
@@ -101,2 +112,6 @@ struct ume_auxv *find_auxv(int *orig_esp
 
 #endif /* _COREGRIND_UME_H */
+
+/*--------------------------------------------------------------------*/
+/*--- end                                                    ume.h ---*/
+/*--------------------------------------------------------------------*/

CVS commit by nethercote: 

Merge equivalent if statements.


  M +0 -2      vg_mylibc.c   1.82


--- valgrind/coregrind/vg_mylibc.c  #1.81:1.82
@@ -287,7 +287,5 @@ void* VG_(mmap)( void* start, UInt lengt
          vg_assert(VG_(valgrind_base) <= res && res+length < VG_(valgrind_end));
       }
-   }
 
-   if (!VG_(is_kerror)(res)) {
       sf_flags |= SF_MMAP;
       if (  flags & VKI_MAP_FIXED)      sf_flags |= SF_FIXED;

CVS commit by thughes: 

Add support for allowing the POST function for a system call to be called
even when the system call fails, and allow the PRE function to modify the
system call flags.

Also fix nanosleep so that it only marks the returned time as defined
if the system call exited with EINTR due to be interrupted.


  M +3 -0      vg_include.h   1.203
  M +1 -0      vg_scheduler.c   1.157
  M +243 -238  vg_syscalls.c   1.113


--- valgrind/coregrind/vg_include.h  #1.202:1.203
@@ -806,4 +806,7 @@ typedef
    Int syscallno;
 
+   /* If VgTs_WaitSys, this is the syscall flags */
+   UInt sys_flags;
+
    /* Details about this thread's proxy LWP */
    ProxyLWP *proxy;

--- valgrind/coregrind/vg_scheduler.c  #1.156:1.157
@@ -573,4 +573,5 @@ void mostly_clear_thread_record ( Thread
 
    VG_(threads)[tid].syscallno            = -1;
+   VG_(threads)[tid].sys_flags            = 0;
    VG_(threads)[tid].sys_pre_res          = NULL;
 

--- valgrind/coregrind/vg_syscalls.c  #1.112:1.113
@@ -1044,4 +1044,6 @@ static Bool fd_allowed(Int fd, const Cha
    ------------------------------------------------------------------ */
 
+#define MayBlock   (1 << 0)
+#define PostOnFail (1 << 1)
 
 #define PRE(x)  \
@@ -4077,7 +4079,5 @@ PRE(nanosleep)
 POST(nanosleep)
 {
-   /* Somewhat bogus ... is only written by the kernel if
-      res == -1 && errno == EINTR. */
-   if (arg2 != (UInt)NULL)
+   if (arg2 != (UInt)NULL && res == -VKI_EINTR)
       VG_TRACK( post_mem_write, arg2, sizeof(struct timespec) );
 }
@@ -5505,10 +5505,10 @@ POST(io_cancel)
 
 struct sys_info {
-   Bool may_block;              /* is a potentially blocking syscall */
+   UInt flags;
    void (*before)(ThreadId tid, ThreadState *tst);
    void (*after)(ThreadId tid, ThreadState *tst);
 };
-#define SYSB_(name, blk)        [__NR_##name] = { blk, before_##name, NULL }
-#define SYSBA(name, blk)        [__NR_##name] = { blk, before_##name, after_##name }
+#define SYSB_(name, flags)      [__NR_##name] = { flags, before_##name, NULL }
+#define SYSBA(name, flags)      [__NR_##name] = { flags, before_##name, after_##name }
 
 static void bad_before(ThreadId tid, ThreadState *tst)
@@ -5536,27 +5536,27 @@ static const struct sys_info bad_sys = {
 static const struct sys_info special_sys[] = {
    /* special */
-   SYSB_(exit_group,            False),
-   SYSB_(exit,                  False),
-   SYSB_(clone,                 False),
+   SYSB_(exit_group,            0),
+   SYSB_(exit,                  0),
+   SYSB_(clone,                 0),
 
-   SYSB_(modify_ldt,            False),
-   SYSB_(set_thread_area,       False),
-   SYSB_(get_thread_area,       False),
-   SYSB_(set_tid_address,       False),
+   SYSB_(modify_ldt,            0),
+   SYSB_(set_thread_area,       0),
+   SYSB_(get_thread_area,       0),
+   SYSB_(set_tid_address,       0),
 
-   SYSB_(execve,                False),
-   SYSB_(brk,                   False),
-   SYSB_(mmap,                  False),
-   SYSB_(mremap,                False),
+   SYSB_(execve,                0),
+   SYSB_(brk,                   0),
+   SYSB_(mmap,                  0),
+   SYSB_(mremap,                0),
 
-   SYSB_(io_setup,              False),
-   SYSB_(io_destroy,            False),
+   SYSB_(io_setup,              0),
+   SYSB_(io_destroy,            0),
 
 #if SIGNAL_SIMULATION
-   SYSBA(sigaltstack,           False),
-   SYSBA(rt_sigaction,          False),
-   SYSBA(sigaction,             False),
-   SYSBA(rt_sigprocmask,        False),
-   SYSBA(sigprocmask,           False),
+   SYSBA(sigaltstack,           0),
+   SYSBA(rt_sigaction,          0),
+   SYSBA(sigaction,             0),
+   SYSBA(rt_sigprocmask,        0),
+   SYSBA(sigprocmask,           0),
 #endif /* SIGNAL_SIMULATION */
 };
@@ -5564,215 +5564,215 @@ static const struct sys_info special_sys
 
 static const struct sys_info sys_info[] = {
-   SYSBA(ptrace,                False),
-   SYSB_(mount,                 True),
-   SYSB_(umount,                False),
+   SYSBA(ptrace,                0),
+   SYSB_(mount,                 MayBlock),
+   SYSB_(umount,                0),
 
-   SYSB_(setresgid,             False),
-   SYSB_(vhangup,               False),
-   SYSB_(iopl,                  False),
+   SYSB_(setresgid,             0),
+   SYSB_(vhangup,               0),
+   SYSB_(iopl,                  0),
 
-   SYSB_(setxattr,              True),
-   SYSB_(lsetxattr,             True),
-   SYSB_(fsetxattr,             True),
-   SYSBA(getxattr,              True),
-   SYSBA(lgetxattr,             True),
-   SYSBA(fgetxattr,             True),
-   SYSBA(listxattr,             True),
-   SYSBA(llistxattr,            True),
-   SYSBA(flistxattr,            True),
-   SYSB_(removexattr,           True),
-   SYSB_(lremovexattr,          True),
-   SYSB_(fremovexattr,          True),
+   SYSB_(setxattr,              MayBlock),
+   SYSB_(lsetxattr,             MayBlock),
+   SYSB_(fsetxattr,             MayBlock),
+   SYSBA(getxattr,              MayBlock),
+   SYSBA(lgetxattr,             MayBlock),
+   SYSBA(fgetxattr,             MayBlock),
+   SYSBA(listxattr,             MayBlock),
+   SYSBA(llistxattr,            MayBlock),
+   SYSBA(flistxattr,            MayBlock),
+   SYSB_(removexattr,           MayBlock),
+   SYSB_(lremovexattr,          MayBlock),
+   SYSB_(fremovexattr,          MayBlock),
 
-   SYSB_(quotactl,              False),
-   SYSBA(lookup_dcookie,        False),
+   SYSB_(quotactl,              0),
+   SYSBA(lookup_dcookie,        0),
 
-   SYSB_(truncate64,            True),
-   SYSB_(fdatasync,             True),
-   SYSB_(msync,                 True),
+   SYSB_(truncate64,            MayBlock),
+   SYSB_(fdatasync,             MayBlock),
+   SYSB_(msync,                 MayBlock),
 
-   SYSBA(getpmsg,               True),
-   SYSB_(putpmsg,               True),
+   SYSBA(getpmsg,               MayBlock),
+   SYSB_(putpmsg,               MayBlock),
 
-   SYSBA(syslog,                True),
-   SYSB_(personality,           False),
-   SYSB_(chroot,                False),
-   SYSB_(madvise,               True),
-   SYSB_(nice,                  False),
-   SYSB_(setresgid32,           False),
-   SYSB_(setfsuid32,            False),
-   SYSBA(_sysctl,               False),
+   SYSBA(syslog,                MayBlock),
+   SYSB_(personality,           0),
+   SYSB_(chroot,                0),
+   SYSB_(madvise,               MayBlock),
+   SYSB_(nice,                  0),
+   SYSB_(setresgid32,           0),
+   SYSB_(setfsuid32,            0),
+   SYSBA(_sysctl,               0),
 
-   SYSB_(sched_getscheduler,    False), /* ??? */
-   SYSB_(sched_setscheduler,    False), /* ??? */
+   SYSB_(sched_getscheduler,    0),     /* ??? */
+   SYSB_(sched_setscheduler,    0),     /* ??? */
 
-   SYSB_(mlock,                 True),
-   SYSB_(munlock,               True),
-   SYSB_(mlockall,              True),
-   SYSB_(munlockall,            True),
+   SYSB_(mlock,                 MayBlock),
+   SYSB_(munlock,               MayBlock),
+   SYSB_(mlockall,              MayBlock),
+   SYSB_(munlockall,            MayBlock),
 
-   SYSB_(sched_get_priority_max,        False), /* ??? */
-   SYSB_(sched_get_priority_min,        False), /* ??? */
+   SYSB_(sched_get_priority_max,        0),     /* ??? */
+   SYSB_(sched_get_priority_min,        0),     /* ??? */
 
-   SYSB_(setpriority,           False),
-   SYSB_(getpriority,           False),
+   SYSB_(setpriority,           0),
+   SYSB_(getpriority,           0),
 
-   SYSB_(setfsgid,              False),
-   SYSB_(setregid,              False),
-   SYSB_(setresuid,             False),
-   SYSB_(setfsuid,              False),
+   SYSB_(setfsgid,              0),
+   SYSB_(setregid,              0),
+   SYSB_(setresuid,             0),
+   SYSB_(setfsuid,              0),
 
-   SYSBA(sendfile,              True),
-   SYSBA(sendfile64,            True),
-   SYSB_(pwrite64,              True),
-   SYSB_(sync,                  True),
-   SYSBA(fstatfs,               False),
-   SYSB_(getsid,                False),
-   SYSBA(pread64,               True),
-   SYSB_(mknod,                 False),
-   SYSB_(flock,                 True),
-   SYSB_(init_module,           True),
-   SYSB_(ioperm,                False),
-   SYSBA(capget,                False),
-   SYSB_(capset,                False),
-   SYSB_(access,                False),
-   SYSB_(chdir,                 False),
-   SYSB_(chmod,                 False),
-   SYSB_(chown32,               False),
-   SYSB_(lchown32,              False),
-   SYSB_(chown,                 False),
-   SYSBA(close,                 False),
-   SYSBA(dup,                   False),
-   SYSBA(dup2,                  False),
-   SYSBA(fcntl,                 True),
-   SYSB_(fchdir,                False),
-   SYSB_(fchown32,              False),
-   SYSB_(fchown,                False),
-   SYSB_(fchmod,                False),
-   SYSBA(fcntl64,               True),
-   SYSBA(fstat,                 False),
-   SYSBA(fork,                  False),
-   SYSB_(fsync,                 True),
-   SYSB_(ftruncate,             True),
-   SYSB_(ftruncate64,           True),
-   SYSBA(getdents,              True),
-   SYSBA(getdents64,            True),
-   SYSBA(getgroups32,           True),
-   SYSBA(getgroups,             False),
-   SYSBA(getcwd,                False),
-   SYSB_(geteuid,               False),
-   SYSB_(geteuid32,             False),
-   SYSB_(getegid,               False),
-   SYSB_(getegid32,             False),
-   SYSB_(getgid,                False),
-   SYSB_(getgid32,              False),
-   SYSB_(getpid,                False),
-   SYSB_(getpgid,               False),
-   SYSB_(getpgrp,               False),
-   SYSB_(getppid,               False),
-   SYSBA(getresgid,             False),
-   SYSBA(getresgid32,           False),
-   SYSBA(getresuid,             False),
-   SYSBA(getresuid32,           False),
-   SYSBA(ugetrlimit,            False),
-   SYSBA(getrlimit,             False),
-   SYSBA(getrusage,             False),
-   SYSBA(gettimeofday,          False),
-   SYSB_(getuid,                False),
-   SYSB_(getuid32,              False),
-   SYSBA(ipc,                   True),
-   SYSBA(ioctl,                 True),
-   SYSBA(kill,                  False),
-   SYSB_(link,                  True),
-   SYSB_(lseek,                 False),
-   SYSBA(_llseek,               False),
-   SYSBA(lstat,                 False),
-   SYSBA(lstat64,               False),
-   SYSB_(mkdir,                 True),
-   SYSBA(mprotect,              False),
-   SYSBA(munmap,                False),
-   SYSBA(mincore,               False),
-   SYSBA(nanosleep,             True),
-   SYSB_(_newselect,            True),
-   SYSBA(open,                  True),
-   SYSBA(read,                  True),
-   SYSB_(write,                 True),
-   SYSBA(creat,                 True),
-   SYSBA(pipe,                  False),
-   SYSBA(poll,                  True),
-   SYSBA(epoll_create,          False),
-   SYSB_(epoll_ctl,             False),
-   SYSBA(epoll_wait,            True),
-   SYSBA(readlink,              False),
-   SYSBA(readv,                 True),
-   SYSB_(rename,                False),
-   SYSB_(rmdir,                 True),
-   SYSBA(sched_setparam,        False), /* ??? */
-   SYSBA(sched_getparam,        False), /* ??? */
-   SYSB_(sched_yield,           False), /* ??? */
-   SYSB_(select,                True),
-   SYSB_(setfsgid32,            False),
-   SYSB_(setgid32,              False),
-   SYSB_(setgid,                False),
-   SYSB_(setsid,                False),
-   SYSB_(setgroups32,           False),
-   SYSB_(setgroups,             False),
-   SYSBA(setpgid,               False),
-   SYSB_(setregid32,            False),
-   SYSB_(setresuid32,           False),
-   SYSB_(setreuid32,            False),
-   SYSB_(setreuid,              False),
-   SYSB_(setrlimit,             False),
-   SYSB_(setuid32,              False),
-   SYSB_(setuid,                False),
-   SYSBA(socketcall,            True),
-   SYSBA(stat,                  False),
-   SYSBA(statfs,                False),
-   SYSBA(statfs64,              False),
-   SYSB_(symlink,               True),
-   SYSBA(stat64,                False),
-   SYSBA(fstat64,               False),
-   SYSBA(sysinfo,               False),
-   SYSBA(time,                  False),
-   SYSBA(times,                 False),
-   SYSB_(truncate,              True),
-   SYSB_(umask,                 False),
-   SYSB_(unlink,                True),
-   SYSBA(uname,                 False),
-   SYSB_(utime,                 True),
-   SYSB_(utimes,                False),
-   SYSBA(waitpid,               True),
-   SYSBA(wait4,                 True),
-   SYSB_(writev,                True),
-   SYSB_(prctl,                 True),
-   SYSBA(adjtimex,              False),
-   SYSBA(mmap2,                 False),
-   SYSBA(clock_gettime,         False),
-   SYSBA(futex,                 True),
-   SYSB_(acct,                  False),
+   SYSBA(sendfile,              MayBlock),
+   SYSBA(sendfile64,            MayBlock),
+   SYSB_(pwrite64,              MayBlock),
+   SYSB_(sync,                  MayBlock),
+   SYSBA(fstatfs,               0),
+   SYSB_(getsid,                0),
+   SYSBA(pread64,               MayBlock),
+   SYSB_(mknod,                 0),
+   SYSB_(flock,                 MayBlock),
+   SYSB_(init_module,           MayBlock),
+   SYSB_(ioperm,                0),
+   SYSBA(capget,                0),
+   SYSB_(capset,                0),
+   SYSB_(access,                0),
+   SYSB_(chdir,                 0),
+   SYSB_(chmod,                 0),
+   SYSB_(chown32,               0),
+   SYSB_(lchown32,              0),
+   SYSB_(chown,                 0),
+   SYSBA(close,                 0),
+   SYSBA(dup,                   0),
+   SYSBA(dup2,                  0),
+   SYSBA(fcntl,                 MayBlock),
+   SYSB_(fchdir,                0),
+   SYSB_(fchown32,              0),
+   SYSB_(fchown,                0),
+   SYSB_(fchmod,                0),
+   SYSBA(fcntl64,               MayBlock),
+   SYSBA(fstat,                 0),
+   SYSBA(fork,                  0),
+   SYSB_(fsync,                 MayBlock),
+   SYSB_(ftruncate,             MayBlock),
+   SYSB_(ftruncate64,           MayBlock),
+   SYSBA(getdents,              MayBlock),
+   SYSBA(getdents64,            MayBlock),
+   SYSBA(getgroups32,           MayBlock),
+   SYSBA(getgroups,             0),
+   SYSBA(getcwd,                0),
+   SYSB_(geteuid,               0),
+   SYSB_(geteuid32,             0),
+   SYSB_(getegid,               0),
+   SYSB_(getegid32,             0),
+   SYSB_(getgid,                0),
+   SYSB_(getgid32,              0),
+   SYSB_(getpid,                0),
+   SYSB_(getpgid,               0),
+   SYSB_(getpgrp,               0),
+   SYSB_(getppid,               0),
+   SYSBA(getresgid,             0),
+   SYSBA(getresgid32,           0),
+   SYSBA(getresuid,             0),
+   SYSBA(getresuid32,           0),
+   SYSBA(ugetrlimit,            0),
+   SYSBA(getrlimit,             0),
+   SYSBA(getrusage,             0),
+   SYSBA(gettimeofday,          0),
+   SYSB_(getuid,                0),
+   SYSB_(getuid32,              0),
+   SYSBA(ipc,                   MayBlock),
+   SYSBA(ioctl,                 MayBlock),
+   SYSBA(kill,                  0),
+   SYSB_(link,                  MayBlock),
+   SYSB_(lseek,                 0),
+   SYSBA(_llseek,               0),
+   SYSBA(lstat,                 0),
+   SYSBA(lstat64,               0),
+   SYSB_(mkdir,                 MayBlock),
+   SYSBA(mprotect,              0),
+   SYSBA(munmap,                0),
+   SYSBA(mincore,               0),
+   SYSBA(nanosleep,             MayBlock|PostOnFail),
+   SYSB_(_newselect,            MayBlock),
+   SYSBA(open,                  MayBlock),
+   SYSBA(read,                  MayBlock),
+   SYSB_(write,                 MayBlock),
+   SYSBA(creat,                 MayBlock),
+   SYSBA(pipe,                  0),
+   SYSBA(poll,                  MayBlock),
+   SYSBA(epoll_create,          0),
+   SYSB_(epoll_ctl,             0),
+   SYSBA(epoll_wait,            MayBlock),
+   SYSBA(readlink,              0),
+   SYSBA(readv,                 MayBlock),
+   SYSB_(rename,                0),
+   SYSB_(rmdir,                 MayBlock),
+   SYSBA(sched_setparam,        0),     /* ??? */
+   SYSBA(sched_getparam,        0),     /* ??? */
+   SYSB_(sched_yield,           0),     /* ??? */
+   SYSB_(select,                MayBlock),
+   SYSB_(setfsgid32,            0),
+   SYSB_(setgid32,              0),
+   SYSB_(setgid,                0),
+   SYSB_(setsid,                0),
+   SYSB_(setgroups32,           0),
+   SYSB_(setgroups,             0),
+   SYSBA(setpgid,               0),
+   SYSB_(setregid32,            0),
+   SYSB_(setresuid32,           0),
+   SYSB_(setreuid32,            0),
+   SYSB_(setreuid,              0),
+   SYSB_(setrlimit,             0),
+   SYSB_(setuid32,              0),
+   SYSB_(setuid,                0),
+   SYSBA(socketcall,            MayBlock),
+   SYSBA(stat,                  0),
+   SYSBA(statfs,                0),
+   SYSBA(statfs64,              0),
+   SYSB_(symlink,               MayBlock),
+   SYSBA(stat64,                0),
+   SYSBA(fstat64,               0),
+   SYSBA(sysinfo,               0),
+   SYSBA(time,                  0),
+   SYSBA(times,                 0),
+   SYSB_(truncate,              MayBlock),
+   SYSB_(umask,                 0),
+   SYSB_(unlink,                MayBlock),
+   SYSBA(uname,                 0),
+   SYSB_(utime,                 MayBlock),
+   SYSB_(utimes,                0),
+   SYSBA(waitpid,               MayBlock),
+   SYSBA(wait4,                 MayBlock),
+   SYSB_(writev,                MayBlock),
+   SYSB_(prctl,                 MayBlock),
+   SYSBA(adjtimex,              0),
+   SYSBA(mmap2,                 0),
+   SYSBA(clock_gettime,         0),
+   SYSBA(futex,                 MayBlock),
+   SYSB_(acct,                  0),
 
    /* new signal handling makes these normal blocking syscalls */
-   SYSB_(pause,                 True),
-   SYSB_(sigsuspend,            True),
-   SYSB_(rt_sigsuspend,         True),
-   SYSBA(rt_sigtimedwait,       True),
-   SYSBA(rt_sigqueueinfo,       False),
+   SYSB_(pause,                 MayBlock),
+   SYSB_(sigsuspend,            MayBlock),
+   SYSB_(rt_sigsuspend,         MayBlock),
+   SYSBA(rt_sigtimedwait,       MayBlock),
+   SYSBA(rt_sigqueueinfo,       0),
 
-   SYSBA(sigpending,            True), /* not blocking, but must run in LWP context */
-   SYSBA(rt_sigpending,         True), /* not blocking, but must run in LWP context */
-   SYSB_(alarm,                 True), /* not blocking, but must run in LWP context */
-   SYSBA(setitimer,             True), /* not blocking, but must run in LWP context */
-   SYSBA(getitimer,             True), /* not blocking, but must run in LWP context */
+   SYSBA(sigpending,            MayBlock), /* not blocking, but must run in LWP context */
+   SYSBA(rt_sigpending,         MayBlock), /* not blocking, but must run in LWP context */
+   SYSB_(alarm,                 MayBlock), /* not blocking, but must run in LWP context */
+   SYSBA(setitimer,             MayBlock), /* not blocking, but must run in LWP context */
+   SYSBA(getitimer,             MayBlock), /* not blocking, but must run in LWP context */
 
-   SYSBA(io_getevents,          True),
-   SYSB_(io_submit,             False),
-   SYSBA(io_cancel,             False),
+   SYSBA(io_getevents,          MayBlock),
+   SYSB_(io_submit,             0),
+   SYSBA(io_cancel,             0),
 
 #if !SIGNAL_SIMULATION
-   SYSBA(sigaltstack,           False),
-   SYSBA(rt_sigaction,          False),
-   SYSBA(sigaction,             False),
-   SYSBA(rt_sigprocmask,        False),
-   SYSBA(sigprocmask,           False),
+   SYSBA(sigaltstack,           0),
+   SYSBA(rt_sigaction,          0),
+   SYSBA(sigaction,             0),
+   SYSBA(rt_sigprocmask,        0),
+   SYSBA(sigprocmask,           0),
 #endif /* !SIGNAL_SIMULATION */
 };
@@ -5836,8 +5836,10 @@ Bool VG_(pre_syscall) ( ThreadId tid )
    }
 
+   tst->sys_flags = sys->flags;
+
    /* Do any pre-syscall actions */
    if (VG_(needs).syscall_wrapper) {
       VGP_PUSHCC(VgpSkinSysWrap);
-      tst->sys_pre_res = SK_(pre_syscall)(tid, syscallno, /*isBlocking*/sys->may_block);
+      tst->sys_pre_res = SK_(pre_syscall)(tid, syscallno, /*isBlocking*/(sys->flags & MayBlock) != 0);
       VGP_POPCC(VgpSkinSysWrap);
    }
@@ -5846,5 +5848,5 @@ Bool VG_(pre_syscall) ( ThreadId tid )
                 VG_(getpid)(), tid, syscallno, 
                 special ? " special" : "",
-                sys->may_block ? " blocking" : "");
+                (sys->flags & MayBlock) != 0 ? " blocking" : "");
 
    if (special) {
@@ -5854,8 +5856,10 @@ Bool VG_(pre_syscall) ( ThreadId tid )
          appropriate tests, but also performs the syscall itself and
          sets the result.  Special syscalls cannot block. */
-      vg_assert(sys->may_block == False);
+      vg_assert((tst->sys_flags & MayBlock) == 0);
 
       (sys->before)(tst->tid, tst);
 
+      vg_assert(tst->sys_flags == sys->flags);
+
       syscall_done = True;
    } else {
@@ -5866,5 +5870,5 @@ Bool VG_(pre_syscall) ( ThreadId tid )
             anything - just pretend the syscall happened. */
          syscall_done = True;
-      } else if (sys->may_block) {
+      } else if ((tst->sys_flags & MayBlock) != 0) {
          /* Issue to worker.  If we're waiting on the syscall because
             it's in the hands of the ProxyLWP, then set the thread
@@ -5945,5 +5949,6 @@ void VG_(post_syscall) ( ThreadId tid, B
 
    if (!restarted) {
-      if (!VG_(is_kerror)(tst->m_eax) && sys->after != NULL)
+      if (sys->after != NULL &&
+          ((tst->sys_flags & PostOnFail) != 0 || !VG_(is_kerror)(tst->m_eax)))
          (sys->after)(tst->tid, tst);

CVS commit by nethercote: 

Removed unused VG_AR_CLIENT_STACKBASE_REDZONE_SZW.


  M +1 -4      vg_include.h   1.204


--- valgrind/coregrind/vg_include.h  #1.203:1.204
@@ -1019,8 +1019,5 @@ extern Int     VG_(longjmpd_on_signal);
    thread stacks, for paranoia reasons.  This can be arbitrary, and
    doesn't really need to be set at compile time. */
-#define VG_AR_CLIENT_STACKBASE_REDZONE_SZW 4
-
-#define VG_AR_CLIENT_STACKBASE_REDZONE_SZB \
-   (VG_AR_CLIENT_STACKBASE_REDZONE_SZW * VKI_BYTES_PER_WORD)
+#define VG_AR_CLIENT_STACKBASE_REDZONE_SZB   16
 
 /* Junk to fill up a thread's shadow regs with when shadow regs aren't

CVS commit by nethercote: 

Remove redundant duplicates of stuff in vg_kerneliface.h.


  M +0 -5      vg_proxylwp.c   1.16


--- valgrind/coregrind/vg_proxylwp.c  #1.15:1.16
@@ -880,9 +880,4 @@ static Int do_futex(void *addr, Int op, 
 }
 
-#define VKI_FUTEX_WAIT          0
-#define VKI_FUTEX_WAKE          1
-#define VKI_FUTEX_FD            2
-#define VKI_FUTEX_REQUEUE       3
-
 static Int have_settid = -1;    /* -1 -> unknown */

CVS commit by nethercote: 

Fix bug #86254 -- symtab sorting was going array in very obscure circumstances
due to a signed/unsigned int problem.


  M +9 -3      vg_symtab2.c   1.83


--- valgrind/coregrind/vg_symtab2.c  #1.82:1.83
@@ -398,5 +398,7 @@ static Int compare_RiSym(void *va, void 
    RiSym *b = (RiSym *)vb;
    
-   return a->addr - b->addr;
+   if (a->addr < b->addr) return -1;
+   if (a->addr > b->addr) return  1;
+   return 0;
 }
 
@@ -605,5 +607,7 @@ static Int compare_ScopeRange(void *va, 
    ScopeRange *b = (ScopeRange *)vb;
    
-   return a->addr - b->addr;
+   if (a->addr < b->addr) return -1;
+   if (a->addr > b->addr) return  1;
+   return 0;
 }
 
@@ -674,5 +678,7 @@ static Int compare_RiLoc(void *va, void 
    RiLoc *b = (RiLoc *)vb;
 
-   return a->addr - b->addr;
+   if (a->addr < b->addr) return -1;
+   if (a->addr > b->addr) return  1;
+   return 0;
 }

CVS commit by nethercote: 


Cleaned up vg_include.h:
- removed various things that are no longer used
- made (module-)local some things that were global
- improved the formatting in places

Removed about 160 lines of code, and non-trivially reduced the number 
of global entities.


  M +4 -3      vg_from_ucode.c   1.78
  M +32 -109   vg_include.h   1.205
  M +1 -32     vg_main.c   1.179
  M +0 -22     vg_malloc2.c   1.28
  M +2 -11     vg_messages.c   1.11
  M +7 -42     vg_mylibc.c   1.83
  M +0 -1      vg_needs.c   1.16
  M +3 -4      vg_proxylwp.c   1.17
  M +17 -5     vg_scheduler.c   1.158
  M +23 -20    vg_symtab2.c   1.84
  M +29 -30    vg_syscalls.c   1.116
  M +6 -0      vg_translate.c   1.80


--- valgrind/coregrind/vg_from_ucode.c  #1.77:1.78
@@ -2173,5 +2173,6 @@ static void emit_ret ( void )
 /* Predicate used in sanity checks elsewhere - returns true if any
    jump-site is an actual chained jump */
-Bool VG_(is_chained_jumpsite)(Addr a)
+__attribute__((unused))
+static Bool is_chained_jumpsite(Addr a)
 {
    UChar *cp = (UChar *)a;
@@ -2193,5 +2194,5 @@ Bool is_fresh_jumpsite(UChar *cp)
 /* Predicate used in sanity checks elsewhere - returns true if all
    jump-sites are calls to VG_(patch_me) */
-Bool VG_(is_unchained_jumpsite)(Addr a)
+static Bool is_unchained_jumpsite(Addr a)
 {
    UChar *cp = (UChar *)a;
@@ -2233,5 +2234,5 @@ void VG_(unchain_jumpsite)(Addr a)
    UChar *cp = (UChar *)a;
 
-   if (VG_(is_unchained_jumpsite)(a))
+   if (is_unchained_jumpsite(a))
       return;                   /* don't write unnecessarily */
 

--- valgrind/coregrind/vg_include.h  #1.204:1.205
@@ -141,13 +141,4 @@
 
 /* ---------------------------------------------------------------------
-   Basic types
-   ------------------------------------------------------------------ */
-
-/* Just pray that gcc's constant folding works properly ... */
-#define BITS(bit7,bit6,bit5,bit4,bit3,bit2,bit1,bit0)               \
-   ( ((bit7) << 7) | ((bit6) << 6) | ((bit5) << 5) | ((bit4) << 4)  \
-     | ((bit3) << 3) | ((bit2) << 2) | ((bit1) << 1) | (bit0))
-
-/* ---------------------------------------------------------------------
    Command-line-settable options
    ------------------------------------------------------------------ */
@@ -279,11 +270,7 @@ extern void VG_(intercept_libc_freeres_w
 
 /* ---------------------------------------------------------------------
-   Debugging and profiling stuff
+   Profiling stuff
    ------------------------------------------------------------------ */
 
-/* Create a log file into which messages can be dumped. */
-extern void VG_(startup_logging) ( void );
-extern void VG_(shutdown_logging)( void );
-
 extern void VGP_(init_profiling) ( void );
 extern void VGP_(done_profiling) ( void );
@@ -399,9 +385,4 @@ extern void  VG_(show_all_arena_stats) (
 extern Bool  VG_(is_empty_arena) ( ArenaId aid );
 
-/* Returns True if aa is inside any block mmap'd /dev/zero
-   by our low-level memory manager. */
-extern Bool  VG_(is_inside_segment_mmapd_by_low_level_MM)( Addr aa );
-
-
 /* ---------------------------------------------------------------------
    Exports of vg_intercept.c
@@ -630,10 +611,7 @@ typedef struct _LDT_ENTRY {
 
 /* Alloc & copy, and dealloc. */
-extern VgLdtEntry* 
-         VG_(allocate_LDT_for_thread) ( VgLdtEntry* parent_ldt );
-extern void       
-         VG_(deallocate_LDT_for_thread) ( VgLdtEntry* ldt );
-extern void       
-         VG_(clear_TLS_for_thread) ( VgLdtEntry* tls );
+extern VgLdtEntry* VG_(allocate_LDT_for_thread)   ( VgLdtEntry* parent_ldt );
+extern void        VG_(deallocate_LDT_for_thread) ( VgLdtEntry* ldt );
+extern void        VG_(clear_TLS_for_thread)      ( VgLdtEntry* tls );
 
 /* Simulate the modify_ldt syscall. */
@@ -1083,16 +1061,11 @@ extern void VG_(route_signals) ( void );
 extern void VG_(do__NR_sigaltstack)   ( ThreadId tid );
 extern void VG_(do__NR_sigaction)     ( ThreadId tid );
-extern void VG_(do__NR_sigprocmask)   ( ThreadId tid,
-                                        Int how, 
+extern void VG_(do__NR_sigprocmask)   ( ThreadId tid, Int how, 
                                         vki_ksigset_t* set,
                                         vki_ksigset_t* oldset );
-extern void VG_(do_pthread_sigmask_SCSS_upd) ( ThreadId tid,
-                                               Int how, 
+extern void VG_(do_pthread_sigmask_SCSS_upd) ( ThreadId tid, Int how, 
                                                vki_ksigset_t* set,
                                                vki_ksigset_t* oldset );
-extern void VG_(send_signal_to_thread) ( ThreadId thread,
-                                         Int signo );
-
-extern void VG_(do_sigpending) ( ThreadId tid, vki_ksigset_t* set );
+extern void VG_(send_signal_to_thread) ( ThreadId thread, Int signo );
 
 
@@ -1138,12 +1111,5 @@ extern Char* VG_(arena_strdup) ( ArenaId
 
 extern Int VG_(fcntl) ( Int fd, Int cmd, Int arg );
-extern Int VG_(select)( Int n, 
-                        vki_fd_set* readfds, 
-                        vki_fd_set* writefds, 
-                        vki_fd_set* exceptfds, 
-                        struct vki_timeval * timeout );
 extern Int VG_(poll)( struct vki_pollfd *, UInt nfds, Int timeout);
-extern Int VG_(nanosleep)( const struct vki_timespec *req, 
-                           struct vki_timespec *rem );
 
 /* system/mman.h */
@@ -1163,6 +1129,4 @@ extern Int VG_(connect_via_socket)( UCha
 
 /* Environment manipulations */
-extern Char **VG_(env_clone) ( Char **oldenv );
-extern Char* VG_(env_getenv) ( Char **env, Char* varname );
 extern Char **VG_(env_setenv) ( Char ***envp, const Char* varname, const Char *val );
 extern void  VG_(env_unsetenv) ( Char **env, const Char *varname );
@@ -1178,15 +1142,4 @@ extern void VG_(send_bytes_to_logging_si
 
 /* ---------------------------------------------------------------------
-   Definitions for the JITter (vg_translate.c, vg_to_ucode.c,
-   vg_from_ucode.c).
-   ------------------------------------------------------------------ */
-
-#define VG_IS_FLAG_SUBSET(set1,set2) \
-   (( ((FlagSet)set1) & ((FlagSet)set2) ) == ((FlagSet)set1) )
-
-#define VG_UNION_FLAG_SETS(set1,set2) \
-   ( ((FlagSet)set1) | ((FlagSet)set2) )
-
-/* ---------------------------------------------------------------------
    Exports of vg_demangle.c
    ------------------------------------------------------------------ */
@@ -1205,6 +1158,4 @@ extern void   VG_(print_UInstr_histogram
 extern void   VG_(unchain_jumpsite)       ( Addr jumpsite );
 extern Addr   VG_(get_jmp_dest)           ( Addr jumpsite );
-extern Bool   VG_(is_unchained_jumpsite)  ( Addr jumpsite );
-extern Bool   VG_(is_chained_jumpsite)    ( Addr jumpsite );
 
 /* ---------------------------------------------------------------------
@@ -1377,6 +1328,6 @@ extern 
 void VG_(parse_procselfmaps) (
    void (*record_mapping)( Addr addr, UInt len, Char rr, Char ww, Char xx, 
-                           UInt dev, UInt ino, ULong foff, const UChar *filename )
-);
+                           UInt dev, UInt ino, ULong foff,
+                           const UChar *filename ) );
 
 
@@ -1390,5 +1341,4 @@ extern Bool VG_(is_object_file)   ( cons
 extern void VG_(mini_stack_dump)  ( Addr eips[], UInt n_eips );
 extern SegInfo * VG_(read_seg_symbols) ( Segment *seg );
-extern void VG_(unload_symbols)   ( Addr start, UInt length );
 extern void VG_(symtab_incref)    ( SegInfo * );
 extern void VG_(symtab_decref)    ( SegInfo *, Addr a, UInt len );
@@ -1400,9 +1350,5 @@ extern void VG_(setup_code_redirect_tabl
 
 /* Redirection machinery */
-extern void VG_(add_redirect_sym)(const Char *from_lib, const Char *from_sym,
-                                  const Char *to_lib, const Char *to_sym);
-extern void VG_(add_redirect_addr)(const Char *from_lib, const Char *from_sym,
-                                   Addr to_addr);
-extern Addr VG_(code_redirect)    (Addr orig);
+extern Addr VG_(code_redirect) ( Addr orig );
 
 /* ---------------------------------------------------------------------
@@ -1464,21 +1410,7 @@ extern Int    VG_(vg_argc);
 extern Char **VG_(vg_argv);
 
-/* Indicates presence, and holds address of client's sysinfo page, a
-   feature of some modern kernels used to provide vsyscalls, etc. */
-extern Bool VG_(sysinfo_page_exists);
-extern Addr VG_(sysinfo_page_addr);
-
-/* Walk through a colon separated list variable, removing entries
-   which match pattern. */
-extern void VG_(mash_colon_env)(Char *varp, const Char *pattern);
-
 /* Something of a function looking for a home ... start up debugger. */
 extern void VG_(start_debugger) ( Int tid );
 
-/* VG_(bbs_done) in include/vg_skin.h */
-
-/* 64-bit counter for the number of bbs to go before a debug exit. */
-extern ULong VG_(bbs_to_go);
-
 /* Counts downwards in vg_run_innerloop. */
 extern UInt VG_(dispatch_ctr);
@@ -1538,8 +1470,4 @@ extern UInt VG_(num_scheduling_events_MI
 extern UInt VG_(num_scheduling_events_MAJOR);
 
-/* Insert and extract the D flag from eflags */
-UInt VG_(insertDflag)(UInt eflags, Int d);
-Int VG_(extractDflag)(UInt eflags);
-
 /* ---------------------------------------------------------------------
    Exports of vg_memory.c
@@ -1551,19 +1479,19 @@ Int VG_(extractDflag)(UInt eflags);
    We try to encode everything we know about a particular segment here.
 */
-#define SF_FIXED        (1 <<  0) /* client asked for MAP_FIXED                 */
-#define SF_SHARED       (1 <<  1) /* shared                                     */
-#define SF_SHM          (1 <<  2) /* SYSV SHM (also SF_SHARED)                  */
-#define SF_MMAP         (1 <<  3) /* mmap memory                                */
-#define SF_FILE         (1 <<  4) /* mapping is backed by a file                */
-#define SF_STACK        (1 <<  5) /* is a stack                                 */
-#define SF_GROWDOWN     (1 <<  6) /* segment grows down                         */
-#define SF_GROWUP       (1 <<  7) /* segment grows up                           */
-#define SF_EXEC         (1 <<  8) /* segment created by exec                    */
-#define SF_DYNLIB       (1 <<  9) /* mapped from dynamic library                */
-#define SF_NOSYMS       (1 << 10) /* don't load syms, even if present           */
-#define SF_BRK          (1 << 11) /* brk segment                                */
-#define SF_CORE         (1 << 12) /* allocated by core on behalf of the client  */
-#define SF_VALGRIND     (1 << 13) /* a valgrind-internal mapping - not in client*/
-#define SF_CODE         (1 << 14) /* segment contains cached code               */
+#define SF_FIXED    (1 <<  0) // client asked for MAP_FIXED
+#define SF_SHARED   (1 <<  1) // shared
+#define SF_SHM      (1 <<  2) // SYSV SHM (also SF_SHARED)
+#define SF_MMAP     (1 <<  3) // mmap memory
+#define SF_FILE     (1 <<  4) // mapping is backed by a file
+#define SF_STACK    (1 <<  5) // is a stack
+#define SF_GROWDOWN (1 <<  6) // segment grows down
+#define SF_GROWUP   (1 <<  7) // segment grows up
+#define SF_EXEC     (1 <<  8) // segment created by exec
+#define SF_DYNLIB   (1 <<  9) // mapped from dynamic library
+#define SF_NOSYMS   (1 << 10) // don't load syms, even if present
+#define SF_BRK      (1 << 11) // brk segment
+#define SF_CORE     (1 << 12) // allocated by core on behalf of the client
+#define SF_VALGRIND (1 << 13) // a valgrind-internal mapping - not in client
+#define SF_CODE     (1 << 14) // segment contains cached code
 
 struct _Segment {
@@ -1629,7 +1557,7 @@ extern void VG_(proxy_waitsig)  ( void )
 extern void VG_(proxy_wait_sys) (ThreadId tid, Bool restart);
 
-extern void VG_(proxy_shutdown) ( void );       /* shut down the syscall workers */
-extern Int  VG_(proxy_resfd)    ( void );       /* FD something can select on to know 
-                                                   a syscall finished */
+extern void VG_(proxy_shutdown) ( void ); // shut down the syscall workers
+extern Int  VG_(proxy_resfd)    ( void ); // FD something can select on to know 
+                                          //  a syscall finished
 
 /* Sanity-check the whole proxy-LWP machinery */
@@ -1642,8 +1570,4 @@ extern void VG_(proxy_handlesig)( const 
                                   const struct vki_sigcontext *sigcontext );
 
-/* Get the PID/TID of the ProxyLWP. */
-extern Int VG_(proxy_id)(ThreadId tid);
-
-
 /* ---------------------------------------------------------------------
    Exports of vg_syscalls.c
@@ -1654,5 +1578,4 @@ extern Char *VG_(resolve_filename)(Int f
 extern Bool VG_(pre_syscall) ( ThreadId tid );
 extern void VG_(post_syscall)( ThreadId tid, Bool restart );
-extern void VG_(restart_syscall) ( ThreadId tid );
 
 extern Bool VG_(is_kerror) ( Int res );
@@ -1666,4 +1589,8 @@ extern void VG_(init_preopened_fds) ( vo
 extern void VG_(fd_stats) ( void );
 
+/* Walk through a colon separated list variable, removing entries
+   which match pattern. */
+extern void VG_(mash_colon_env)(Char *varp, const Char *pattern);
+
 /* ---------------------------------------------------------------------
    Exports of vg_transtab.c
@@ -1673,6 +1600,4 @@ extern void VG_(fd_stats) ( void );
 extern Addr VG_(tt_fast)[VG_TT_FAST_SIZE];
 
-extern void VG_(get_tt_tc_used) ( UInt* tt_used, UInt* tc_used );
-
 extern void VG_(add_to_trans_tab) ( Addr orig_addr,  Int orig_size,
                                     Addr trans_addr, Int trans_size,

--- valgrind/coregrind/vg_main.c  #1.178:1.179
@@ -117,9 +117,4 @@ vki_rlimit VG_(client_rlimit_data);
 Bool VG_(have_ssestate);
 
-/* Indicates presence, and holds address of client's sysinfo page, a
-   feature of some modern kernels used to provide vsyscalls, etc. */
-Bool VG_(sysinfo_page_exists) = False;
-Addr VG_(sysinfo_page_addr) = 0;
-
 /* stage1 (main) executable */
 Int  VG_(vgexecfd) = -1;
@@ -1676,7 +1671,5 @@ static void process_cmd_line_options( UI
       switch(auxp[0]) {
       case VKI_AT_SYSINFO:
-         VG_(sysinfo_page_exists) = True;
          auxp[1] = (Int)(VG_(client_trampoline_code) + VG_(tramp_syscall_offset));
-         VG_(sysinfo_page_addr) = auxp[1];
          break;
       }
@@ -2174,27 +2167,4 @@ static Int baB_off = 0;
 
 
-UInt VG_(insertDflag)(UInt eflags, Int d)
-{
-   vg_assert(d == 1 || d == -1);
-   eflags &= ~EFlagD;
-
-   if (d < 0)
-      eflags |= EFlagD;
-
-   return eflags;
-}
-
-Int VG_(extractDflag)(UInt eflags)
-{
-   Int ret;
-
-   if (eflags & EFlagD)
-      ret = -1;
-   else
-      ret = 1;
-
-   return ret;
-}
-
 /* Returns the offset, in words. */
 static Int alloc_BaB ( Int words )
@@ -3075,6 +3045,5 @@ int main(int argc, char **argv)
    switch (src) {
       case VgSrc_ExitSyscall: /* the normal way out */
-         vg_assert(VG_(last_run_tid) > 0 
-                   && VG_(last_run_tid) < VG_N_THREADS);
+         vg_assert(VG_(last_run_tid) > 0 && VG_(last_run_tid) < VG_N_THREADS);
          VG_(proxy_shutdown)();
 

--- valgrind/coregrind/vg_malloc2.c  #1.27:1.28
@@ -299,26 +299,4 @@ void ensure_mm_init ( void )
 
 
-/* Returns True if aa is inside any segment mmap'd /dev/zero
-   by our low-level memory manager. */
-Bool VG_(is_inside_segment_mmapd_by_low_level_MM)( Addr aa )
-{
-   ArenaId ar;
-   Superblock* sb;
-
-   ensure_mm_init();
-
-   for (ar = 0; ar < VG_N_ARENAS; ar++) {
-      for (sb = vg_arena[ar].sblocks; sb; sb = sb->next) {
-         Addr sb_first_word = (Addr)sb;
-         Addr sb_last_word  
-            = (Addr)&(sb->payload_words[sb->n_payload_words-1]);
-         if (aa >= sb_first_word && aa <= sb_last_word)
-            return True;
-      }
-   }
-   return False;
-}
-
-
 /*------------------------------------------------------------*/
 /*--- Superblock management stuff                          ---*/

--- valgrind/coregrind/vg_messages.c  #1.10:1.11
@@ -2,5 +2,5 @@
 /*--------------------------------------------------------------------*/
 /*--- For sending error/informative messages.                      ---*/
-/*---                                                 vg_message.c ---*/
+/*---                                                vg_messages.c ---*/
 /*--------------------------------------------------------------------*/
 
@@ -127,14 +127,5 @@ void VG_(send_bytes_to_logging_sink) ( C
 }
 
-
-void VG_(startup_logging) ( void )
-{
-}
-
-void VG_(shutdown_logging) ( void )
-{
-}
-
 /*--------------------------------------------------------------------*/
-/*--- end                                             vg_message.c ---*/
+/*--- end                                            vg_messages.c ---*/
 /*--------------------------------------------------------------------*/

--- valgrind/coregrind/vg_mylibc.c  #1.82:1.83
@@ -335,22 +335,4 @@ Int VG_(fcntl) ( Int fd, Int cmd, Int ar
 }
 
-/* Returns -1 on error. */
-Int VG_(select)( Int n, 
-                 vki_fd_set* readfds, 
-                 vki_fd_set* writefds, 
-                 vki_fd_set* exceptfds, 
-                 struct vki_timeval * timeout )
-{
-   Int res;
-   UInt args[5];
-   args[0] = n;
-   args[1] = (UInt)readfds;
-   args[2] = (UInt)writefds;
-   args[3] = (UInt)exceptfds;
-   args[4] = (UInt)timeout;
-   res = VG_(do_syscall)(__NR_select, (UInt)(&(args[0])) );
-   return VG_(is_kerror)(res) ? -1 : res;
-}
-
 Int VG_(poll)( struct vki_pollfd *ufds, UInt nfds, Int timeout)
 {
@@ -360,15 +342,4 @@ Int VG_(poll)( struct vki_pollfd *ufds, 
 }
 
-/* Returns -1 on error, 0 if ok, 1 if interrupted. */
-Int VG_(nanosleep)( const struct vki_timespec *req, 
-                    struct vki_timespec *rem )
-{
-   Int res;
-   res = VG_(do_syscall)(__NR_nanosleep, (UInt)req, (UInt)rem);
-   if (res == -VKI_EINVAL) return -1;
-   if (res == -VKI_EINTR)  return 1;
-   return 0;
-}
-
 
 /* ---------------------------------------------------------------------
@@ -1147,5 +1118,4 @@ static void report_and_quit ( const Char
    VG_(printf)("In the bug report, send all the above text, the valgrind\n");
    VG_(printf)("version, and what Linux distro you are using.  Thanks.\n\n");
-   VG_(shutdown_logging)();
    VG_(exit)(1);
 }
@@ -1351,5 +1321,5 @@ Bool VG_(getcwd_alloc) ( Char** out )
 
 /* clone the environment */
-Char **VG_(env_clone) ( Char **oldenv )
+static Char **env_clone ( Char **oldenv )
 {
    Char **oldenvp;
@@ -1433,10 +1403,12 @@ Char **VG_(env_setenv) ( Char ***envp, c
 }
 
-Char* VG_(env_getenv) ( Char **env, Char* varname )
+/* We do getenv without libc's help by snooping around in
+   VG_(client_envp) as determined at startup time. */
+Char *VG_(getenv)(Char *varname)
 {
    Int i, n;
    n = VG_(strlen)(varname);
-   for (i = 0; env[i] != NULL; i++) {
-      Char* s = env[i];
+   for (i = 0; VG_(client_envp)[i] != NULL; i++) {
+      Char* s = VG_(client_envp)[i];
       if (VG_(strncmp)(varname, s, n) == 0 && s[n] == '=') {
          return & s[n+1];
@@ -1446,11 +1418,4 @@ Char* VG_(env_getenv) ( Char **env, Char
 }
 
-/* We do getenv without libc's help by snooping around in
-   VG_(client_envp) as determined at startup time. */
-Char *VG_(getenv)(Char *varname)
-{
-   return VG_(env_getenv)(VG_(client_envp), varname);
-}
-
 /* Support for getrlimit. */
 Int VG_(getrlimit) (Int resource, struct vki_rlimit *rlim)
@@ -1548,5 +1513,5 @@ Int VG_(system) ( Char* cmd )
          Char* buf;
 
-         envp = VG_(env_clone)(VG_(client_envp));
+         envp = env_clone(VG_(client_envp));
          
          for (i = 0; envp[i] != NULL; i++) {

--- valgrind/coregrind/vg_needs.c  #1.15:1.16
@@ -126,5 +126,4 @@ void VG_(sanity_check_needs) ( void)
 
 #undef CHECK_NOT
-#undef INVALID_Bool
 }
 

--- valgrind/coregrind/vg_proxylwp.c  #1.16:1.17
@@ -1373,10 +1373,9 @@ void VG_(proxy_sanity)(void)
 
 /* Get the PID/TID of the ProxyLWP. */
-Int VG_(proxy_id)(ThreadId tid)
+__attribute__((unused))
+static Int proxy_id(ThreadId tid)
 {
    ThreadState *tst = VG_(get_ThreadState)(tid);
-   ProxyLWP *proxy = tst->proxy;
-
-   return proxy->lwp;
+   return tst->proxy->lwp;
 }
 

--- valgrind/coregrind/vg_scheduler.c  #1.157:1.158
@@ -333,4 +333,17 @@ ThreadId VG_(get_current_or_recent_tid) 
 }
 
+static UInt insertDflag(UInt eflags, Int d)
+{
+   vg_assert(d == 1 || d == -1);
+   eflags &= ~EFlagD;
+   if (d < 0) eflags |= EFlagD;
+   return eflags;
+}
+
+static Int extractDflag(UInt eflags)
+{
+   return ( eflags & EFlagD ? -1 : 1 );
+}
+
 /* Copy the saved state of a thread into VG_(baseBlock), ready for it
    to be run. */
@@ -360,5 +373,5 @@ void VG_(load_thread_state) ( ThreadId t
       = VG_(threads)[tid].m_eflags & ~EFlagD;
    VG_(baseBlock)[VGOFF_(m_dflag)] 
-      = VG_(extractDflag)(VG_(threads)[tid].m_eflags);
+      = extractDflag(VG_(threads)[tid].m_eflags);
    VG_(baseBlock)[VGOFF_(m_eip)] = VG_(threads)[tid].m_eip;
 
@@ -452,5 +465,5 @@ void VG_(save_thread_state) ( ThreadId t
    VG_(threads)[tid].m_esp = VG_(baseBlock)[VGOFF_(m_esp)];
    VG_(threads)[tid].m_eflags 
-      = VG_(insertDflag)(VG_(baseBlock)[VGOFF_(m_eflags)],
+      = insertDflag(VG_(baseBlock)[VGOFF_(m_eflags)],
                          VG_(baseBlock)[VGOFF_(m_dflag)]);
    VG_(threads)[tid].m_eip = VG_(baseBlock)[VGOFF_(m_eip)];
@@ -1049,6 +1062,5 @@ VgSchedReturnCode VG_(scheduler) ( Int* 
             if (trans_addr == (Addr)0) {
                /* Not found; we need to request a translation. */
-               create_translation_for( 
-                  tid, VG_(threads)[tid].m_eip ); 
+               create_translation_for( tid, VG_(threads)[tid].m_eip ); 
                trans_addr = VG_(search_transtab) ( VG_(threads)[tid].m_eip ); 
                if (trans_addr == (Addr)0)

--- valgrind/coregrind/vg_symtab2.c  #1.83:1.84
@@ -831,4 +831,8 @@ VG_(intercept_demangle)(const Char* symb
 }
 
+// Forward declaration
+static void add_redirect_addr(const Char *from_lib, const Char *from_sym,
+                              Addr to_addr);
+
 static
 void handle_intercept( SegInfo* si, Char* symbol, Elf32_Sym* sym)
@@ -844,5 +848,5 @@ void handle_intercept( SegInfo* si, Char
    *func = '\0';
 
-   VG_(add_redirect_addr)(lib, func+1, si->offset + sym->st_value);
+   add_redirect_addr(lib, func+1, si->offset + sym->st_value);
    VG_(free)(lib);
 }
@@ -1596,5 +1600,5 @@ SegInfo *VG_(read_seg_symbols) ( Segment
    maintain the no-overlapping invariant.
 */
-void VG_(unload_symbols) ( Addr start, UInt length )
+static void unload_symbols ( Addr start, UInt length )
 {
    SegInfo *prev, *curr;
@@ -1634,5 +1638,5 @@ void VG_(symtab_decref)(SegInfo *si, Add
    vg_assert(si->ref >= 1);
    if (--si->ref == 0)
-      VG_(unload_symbols)(si->start, si->size);
+      unload_symbols(si->start, si->size);
 }
 
@@ -2450,5 +2454,5 @@ static Bool resolve_redir_allsegs(CodeRe
 
 /* Redirect a lib/symbol reference to a function at lib/symbol */
-void VG_(add_redirect_sym)(const Char *from_lib, const Char *from_sym,
+static void add_redirect_sym(const Char *from_lib, const Char *from_sym,
                            const Char *to_lib, const Char *to_sym)
 {
@@ -2476,5 +2480,5 @@ void VG_(add_redirect_sym)(const Char *f
 
 /* Redirect a lib/symbol reference to a function at lib/symbol */
-void VG_(add_redirect_addr)(const Char *from_lib, const Char *from_sym,
+static void add_redirect_addr(const Char *from_lib, const Char *from_sym,
                             Addr to_addr)
 {
@@ -2523,5 +2527,5 @@ void VG_(setup_code_redirect_table) ( vo
 
    for(i = 0; i < sizeof(redirects)/sizeof(*redirects); i++) {
-      VG_(add_redirect_sym)("soname:libc.so.6",         redirects[i].from,
+      add_redirect_sym("soname:libc.so.6",       redirects[i].from,
                             "soname:libpthread.so.0",   redirects[i].to);
    }
@@ -2531,5 +2535,5 @@ void VG_(setup_code_redirect_table) ( vo
       special sysinfo unwind hack in vg_execontext.c will kick in.
    */
-   VG_(add_redirect_addr)("soname:ld-linux.so.2", "_dl_sysinfo_int80",
+   add_redirect_addr("soname:ld-linux.so.2", "_dl_sysinfo_int80",
                           VG_(client_trampoline_code)+VG_(tramp_syscall_offset));
    
@@ -2538,12 +2542,11 @@ void VG_(setup_code_redirect_table) ( vo
       implementations of said, in mac_replace_strmem.c.
     */
-   VG_(add_redirect_sym)("soname:libc.so.6", "stpcpy",
+   add_redirect_sym("soname:libc.so.6", "stpcpy",
                          "*vgpreload_memcheck.so*", "stpcpy");
-   VG_(add_redirect_sym)("soname:libc.so.6", "strnlen",
+   add_redirect_sym("soname:libc.so.6", "strnlen",
                          "*vgpreload_memcheck.so*", "strnlen");
-
-   VG_(add_redirect_sym)("soname:ld-linux.so.2", "stpcpy",
+   add_redirect_sym("soname:ld-linux.so.2", "stpcpy",
                          "*vgpreload_memcheck.so*", "stpcpy");
-   VG_(add_redirect_sym)("soname:ld-linux.so.2", "strchr",
+   add_redirect_sym("soname:ld-linux.so.2", "strchr",
                          "*vgpreload_memcheck.so*", "strchr");
 }

--- valgrind/coregrind/vg_syscalls.c  #1.115:1.116
@@ -5909,4 +5909,32 @@ Bool VG_(pre_syscall) ( ThreadId tid )
 }
 
+static void restart_syscall(ThreadId tid)
+{
+   ThreadState* tst;
+   tst = VG_(get_ThreadState)(tid);
+
+   vg_assert(tst != NULL);
+   vg_assert(tst->status == VgTs_WaitSys);
+   vg_assert(tst->syscallno != -1);
+
+   tst->m_eax = tst->syscallno;
+   tst->m_eip -= 2;             /* sizeof(int $0x80) */
+
+   /* Make sure our caller is actually sane, and we're really backing
+      back over a syscall.
+
+      int $0x80 == CD 80 
+   */
+   {
+      UChar *p = (UChar *)tst->m_eip;
+      
+      if (p[0] != 0xcd || p[1] != 0x80)
+         VG_(message)(Vg_DebugMsg, 
+                      "?! restarting over syscall at %p %02x %02x\n",
+                      tst->m_eip, p[0], p[1]);
+
+      vg_assert(p[0] == 0xcd && p[1] == 0x80);
+   }
+}
 
 void VG_(post_syscall) ( ThreadId tid, Bool restart )
@@ -5955,5 +5983,5 @@ void VG_(post_syscall) ( ThreadId tid, B
       if (restart) {
          restarted = True;
-         VG_(restart_syscall)(tid);
+         restart_syscall(tid);
       } else
          tst->m_eax = -VKI_EINTR;
@@ -5985,33 +6013,4 @@ void VG_(post_syscall) ( ThreadId tid, B
 }
 
-void VG_(restart_syscall)(ThreadId tid)
-{
-   ThreadState* tst;
-   tst = VG_(get_ThreadState)(tid);
-
-   vg_assert(tst != NULL);
-   vg_assert(tst->status == VgTs_WaitSys);
-   vg_assert(tst->syscallno != -1);
-
-   tst->m_eax = tst->syscallno;
-   tst->m_eip -= 2;             /* sizeof(int $0x80) */
-
-   /* Make sure our caller is actually sane, and we're really backing
-      back over a syscall.
-
-      int $0x80 == CD 80 
-   */
-   {
-      UChar *p = (UChar *)tst->m_eip;
-      
-      if (p[0] != 0xcd || p[1] != 0x80)
-         VG_(message)(Vg_DebugMsg, 
-                      "?! restarting over syscall at %p %02x %02x\n",
-                      tst->m_eip, p[0], p[1]);
-
-      vg_assert(p[0] == 0xcd && p[1] == 0x80);
-   }
-}
-
 /*--------------------------------------------------------------------*/
 /*--- end                                            vg_syscalls.c ---*/

--- valgrind/coregrind/vg_translate.c  #1.79:1.80
@@ -43,4 +43,10 @@
 /*------------------------------------------------------------*/
 
+#define VG_IS_FLAG_SUBSET(set1,set2) \
+   (( ((FlagSet)set1) & ((FlagSet)set2) ) == ((FlagSet)set1) )
+
+#define VG_UNION_FLAG_SETS(set1,set2) \
+   ( ((FlagSet)set1) | ((FlagSet)set2) )
+
 /* This one is called by the core */
 UCodeBlock* VG_(alloc_UCodeBlock) ( void )

CVS commit by nethercote: 


Replaced three global variables in vg_include.h with a single global function;
much neater.


  M +2 -9      vg_include.h   1.206
  M +24 -12    vg_scheduler.c   1.159
  M +5 -19     vg_signals.c   1.73


--- valgrind/coregrind/vg_include.h  #1.205:1.206
@@ -984,13 +984,6 @@ extern void VG_(scheduler_init) ( void )
 extern void VG_(pp_sched_status) ( void );
 
-/* vg_oursignalhandler() might longjmp().  Here's the jmp_buf. */
-extern jmp_buf VG_(scheduler_jmpbuf);
-/* This says whether scheduler_jmpbuf is actually valid.  Needed so
-   that our signal handler doesn't longjmp when the buffer isn't
-   actually valid. */
-extern Bool    VG_(scheduler_jmpbuf_valid);
-/* ... and if so, here's the signal which caused it to do so. */
-extern Int     VG_(longjmpd_on_signal);
-
+// Longjmp back to the scheduler and thus enter the sighandler immediately.
+extern void VG_(resume_scheduler) ( Int sigNo, vki_ksiginfo_t *info );
 
 /* The red-zone size which we put at the bottom (highest address) of

--- valgrind/coregrind/vg_scheduler.c  #1.158:1.159
@@ -89,11 +89,11 @@ static ThreadId vg_tid_last_in_baseBlock
 
 /* vg_oursignalhandler() might longjmp().  Here's the jmp_buf. */
-jmp_buf VG_(scheduler_jmpbuf);
+jmp_buf scheduler_jmpbuf;
 /* This says whether scheduler_jmpbuf is actually valid.  Needed so
    that our signal handler doesn't longjmp when the buffer isn't
    actually valid. */
-Bool    VG_(scheduler_jmpbuf_valid) = False;
+Bool    scheduler_jmpbuf_valid = False;
 /* ... and if so, here's the signal which caused it to do so. */
-Int     VG_(longjmpd_on_signal);
+Int     longjmpd_on_signal;
 /* If the current thread gets a syncronous unresumable signal, then
    its details are placed here by the signal handler, to be passed to
@@ -524,4 +524,16 @@ void VG_(save_thread_state) ( ThreadId t
 
 
+void VG_(resume_scheduler)(Int sigNo, vki_ksiginfo_t *info)
+{
+   if (scheduler_jmpbuf_valid) {
+      /* Can't continue; must longjmp back to the scheduler and thus
+         enter the sighandler immediately. */
+      VG_(memcpy)(&VG_(unresumable_siginfo), info, sizeof(vki_ksiginfo_t));
+   
+      longjmpd_on_signal = sigNo;
+      __builtin_longjmp(scheduler_jmpbuf,1);
+   }
+}
+
 /* Run the thread tid for a while, and return a VG_TRC_* value to the
    scheduler indicating what happened. */
@@ -532,5 +544,5 @@ UInt run_thread_for_a_while ( ThreadId t
    vg_assert(VG_(is_valid_tid)(tid));
    vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
-   vg_assert(!VG_(scheduler_jmpbuf_valid));
+   vg_assert(!scheduler_jmpbuf_valid);
 
    VGP_PUSHCC(VgpRun);
@@ -540,19 +552,19 @@ UInt run_thread_for_a_while ( ThreadId t
    vg_assert(VG_(unresumable_siginfo).si_signo == 0);
 
-   if (__builtin_setjmp(VG_(scheduler_jmpbuf)) == 0) {
+   if (__builtin_setjmp(scheduler_jmpbuf) == 0) {
       /* try this ... */
-      VG_(scheduler_jmpbuf_valid) = True;
+      scheduler_jmpbuf_valid = True;
       trc = VG_(run_innerloop)();
-      VG_(scheduler_jmpbuf_valid) = False;
+      scheduler_jmpbuf_valid = False;
       /* We get here if the client didn't take a fault. */
    } else {
       /* We get here if the client took a fault, which caused our
          signal handler to longjmp. */
-      VG_(scheduler_jmpbuf_valid) = False;
+      scheduler_jmpbuf_valid = False;
       vg_assert(trc == 0);
       trc = VG_TRC_UNRESUMABLE_SIGNAL;
    }
 
-   vg_assert(!VG_(scheduler_jmpbuf_valid));
+   vg_assert(!scheduler_jmpbuf_valid);
 
    VG_(save_thread_state) ( tid );
@@ -644,5 +656,5 @@ void VG_(scheduler_init) ( void )
 
    /* Not running client code right now. */
-   VG_(scheduler_jmpbuf_valid) = False;
+   scheduler_jmpbuf_valid = False;
 
    /* Proxy for main thread */
@@ -1235,8 +1247,8 @@ VgSchedReturnCode VG_(scheduler) ( Int* 
                       VG_(unresumable_siginfo).si_signo == VKI_SIGILL  ||
                       VG_(unresumable_siginfo).si_signo == VKI_SIGFPE);
-            vg_assert(VG_(longjmpd_on_signal) == VG_(unresumable_siginfo).si_signo);
+            vg_assert(longjmpd_on_signal == VG_(unresumable_siginfo).si_signo);
 
             /* make sure we've unblocked the signals which the handler blocked */
-            VG_(unblock_host_signal)(VG_(longjmpd_on_signal));
+            VG_(unblock_host_signal)(longjmpd_on_signal);
 
             VG_(deliver_signal)(tid, &VG_(unresumable_siginfo), False);

--- valgrind/coregrind/vg_signals.c  #1.72:1.73
@@ -65,6 +65,5 @@
    the only signals it needs to handle.
 
-   If we get a synchronous signal, the details are placed into
-   VG_(unresumable_siginfo) and we longjmp back into the scheduler,
+   If we get a synchronous signal, we longjmp back into the scheduler,
    since we can't resume executing the client code.  The scheduler
    immediately starts signal delivery to the thread which generated
@@ -101,5 +100,4 @@ static void vg_async_signalhandler ( Int
 static void vg_babyeater           ( Int sigNo, vki_ksiginfo_t *info, struct vki_ucontext * );
 static void proxy_sigvg_handler    ( Int sigNo, vki_ksiginfo_t *info, struct vki_ucontext * );
-static void resume_scheduler(Int signo, vki_ksiginfo_t *info);
 
 static Bool is_correct_sigmask(void);
@@ -1835,5 +1833,5 @@ void VG_(synth_fault_perms)(ThreadId tid
    info._sifields._sigfault._addr = (void*)addr;
 
-   resume_scheduler(VKI_SIGSEGV, &info);
+   VG_(resume_scheduler)(VKI_SIGSEGV, &info);
    VG_(deliver_signal)(tid, &info, False);
 }
@@ -1851,5 +1849,5 @@ void VG_(synth_fault_mapping)(ThreadId t
    info._sifields._sigfault._addr = (void*)addr;
 
-   resume_scheduler(VKI_SIGSEGV, &info);
+   VG_(resume_scheduler)(VKI_SIGSEGV, &info);
    VG_(deliver_signal)(tid, &info, False);
 }
@@ -1866,5 +1864,5 @@ void VG_(synth_fault)(ThreadId tid)
    info._sifields._sigfault._addr = (void*)0;
 
-   resume_scheduler(VKI_SIGSEGV, &info);
+   VG_(resume_scheduler)(VKI_SIGSEGV, &info);
    VG_(deliver_signal)(tid, &info, False);
 }
@@ -2025,16 +2023,4 @@ void vg_async_signalhandler ( Int sigNo,
 }
 
-static void resume_scheduler(Int sigNo, vki_ksiginfo_t *info)
-{
-   if (VG_(scheduler_jmpbuf_valid)) {
-      /* Can't continue; must longjmp back to the scheduler and thus
-         enter the sighandler immediately. */
-      VG_(memcpy)(&VG_(unresumable_siginfo), info, sizeof(vki_ksiginfo_t));
-   
-      VG_(longjmpd_on_signal) = sigNo;
-      __builtin_longjmp(VG_(scheduler_jmpbuf),1);
-   }
-}
-
 /* 
    Recieve a sync signal from the host. 
@@ -2177,5 +2163,5 @@ void vg_sync_signalhandler ( Int sigNo, 
    /* Can't continue; must longjmp back to the scheduler and thus
       enter the sighandler immediately. */
-   resume_scheduler(sigNo, info);
+   VG_(resume_scheduler)(sigNo, info);
 
    if (info->si_code <= VKI_SI_USER) {

CVS commit by nethercote: 

Factor out commonality between VG_(synth_fault*)().


  M +13 -27    vg_signals.c   1.74


--- valgrind/coregrind/vg_signals.c  #1.73:1.74
@@ -1821,7 +1821,5 @@ static void vg_default_action(const vki_
 }
 
-/* Synthesize a fault where the address is OK, but the page
-   permissions are bad */
-void VG_(synth_fault_perms)(ThreadId tid, Addr addr)
+static void synth_fault_common(ThreadId tid, Addr addr, Int si_code)
 {
    vki_ksiginfo_t info;
@@ -1830,5 +1828,5 @@ void VG_(synth_fault_perms)(ThreadId tid
 
    info.si_signo = VKI_SIGSEGV;
-   info.si_code = 2;
+   info.si_code = si_code;
    info._sifields._sigfault._addr = (void*)addr;
 
@@ -1837,33 +1835,21 @@ void VG_(synth_fault_perms)(ThreadId tid
 }
 
-/* Synthesize a fault where the address there's nothing mapped at the
-   address */
-void VG_(synth_fault_mapping)(ThreadId tid, Addr addr)
+// Synthesize a fault where the address is OK, but the page
+// permissions are bad.
+void VG_(synth_fault_perms)(ThreadId tid, Addr addr)
 {
-   vki_ksiginfo_t info;
-
-   vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
-
-   info.si_signo = VKI_SIGSEGV;
-   info.si_code = 1;
-   info._sifields._sigfault._addr = (void*)addr;
+   synth_fault_common(tid, addr, 2);
+}
 
-   VG_(resume_scheduler)(VKI_SIGSEGV, &info);
-   VG_(deliver_signal)(tid, &info, False);
+// Synthesize a fault where the address there's nothing mapped at the address.
+void VG_(synth_fault_mapping)(ThreadId tid, Addr addr)
+{
+   synth_fault_common(tid, addr, 1);
 }
 
-/* Synthesize a misc memory fault */
+// Synthesize a misc memory fault.
 void VG_(synth_fault)(ThreadId tid)
 {
-   vki_ksiginfo_t info;
-
-   vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
-
-   info.si_signo = VKI_SIGSEGV;
-   info.si_code = 0x80;
-   info._sifields._sigfault._addr = (void*)0;
-
-   VG_(resume_scheduler)(VKI_SIGSEGV, &info);
-   VG_(deliver_signal)(tid, &info, False);
+   synth_fault_common(tid, 0, 0x80);
 }

CVS commit by nethercote: 


Fold VG_(send_signal_to_thread)() into vg_scheduler.c, so it doesn't need to be
exported any more.


  M +0 -2      vg_include.h   1.207
  M +4 -1      vg_scheduler.c   1.160
  M +0 -14     vg_signals.c   1.75


--- valgrind/coregrind/vg_include.h  #1.206:1.207
@@ -1060,6 +1060,4 @@ extern void VG_(do_pthread_sigmask_SCSS_
                                                vki_ksigset_t* set,
                                                vki_ksigset_t* oldset );
-extern void VG_(send_signal_to_thread) ( ThreadId thread, Int signo );
-
 
 /* Modify the current thread's state once we have detected it is

--- valgrind/coregrind/vg_scheduler.c  #1.159:1.160
@@ -2826,4 +2826,5 @@ void do_pthread_kill ( ThreadId tid, /* 
                        Int sig )
 {
+   ThreadState* tst;
    Char msg_buf[100];
 
@@ -2856,5 +2857,7 @@ void do_pthread_kill ( ThreadId tid, /* 
    }
 
-   VG_(send_signal_to_thread)( thread, sig );
+   tst = VG_(get_ThreadState)(thread);
+   vg_assert(NULL != tst->proxy);
+   VG_(proxy_sendsig)(thread, sig);
    SET_PTHREQ_RETVAL(tid, 0);
 }

--- valgrind/coregrind/vg_signals.c  #1.74:1.75
@@ -731,18 +731,4 @@ void VG_(do_pthread_sigmask_SCSS_upd) ( 
 
 
-void VG_(send_signal_to_thread) ( ThreadId thread, Int sig )
-{
-   ThreadState *tst;
-
-   vg_assert(VG_(is_valid_tid)(thread));
-   vg_assert(sig >= 1 && sig <= VKI_KNSIG);
-   
-   tst = VG_(get_ThreadState)(thread);
-   vg_assert(tst->proxy != NULL);
-
-   VG_(proxy_sendsig)(thread, sig);
-}
-
-
 /* ---------------------------------------------------------------------
    LOW LEVEL STUFF TO DO WITH SIGNALS: IMPLEMENTATION

CVS commit by nethercote: 

Make the Supp and Error types local to vg_errcontext.h;  they don't need to be
global.


  M +133 -0    vg_errcontext.c   1.55
  M +0 -79     vg_include.h   1.208
  M +0 -62     vg_needs.c   1.17


--- valgrind/coregrind/vg_errcontext.c  #1.54:1.55
@@ -54,4 +54,137 @@ static Supp* is_suppressible_error ( Err
 
 /*------------------------------------------------------------*/
+/*--- Error type                                           ---*/
+/*------------------------------------------------------------*/
+
+/* Note: it is imperative this doesn't overlap with (0..) at all, as skins
+ * effectively extend it by defining their own enums in the (0..) range. */
+typedef
+   enum { 
+      PThreadErr      = -1,   // Pthreading error
+   }
+   CoreErrorKind;
+
+/* Errors.  Extensible (via the 'extra' field).  Tools can use a normal
+   enum (with element values in the normal range (0..)) for `ekind'. 
+   Functions for getting/setting the tool-relevant fields are in
+   include/vg_skin.h.
+
+   When errors are found and recorded with VG_(maybe_record_error)(), all
+   the tool must do is pass in the four parameters;  core will
+   allocate/initialise the error record.
+*/
+struct _Error {
+   struct _Error* next;
+   // NULL if unsuppressed; or ptr to suppression record.
+   Supp* supp;
+   Int count;
+   ThreadId tid;
+
+   // The tool-specific part
+   ExeContext* where;      // Initialised by core
+   Int ekind;              // Used by ALL.  Must be in the range (0..)
+   Addr addr;              // Used frequently
+   Char* string;           // Used frequently
+   void* extra;            // For any tool-specific extras
+};
+
+ExeContext* VG_(get_error_where) ( Error* err )
+{
+   return err->where;
+}
+
+ErrorKind VG_(get_error_kind) ( Error* err )
+{
+   return err->ekind;
+}
+
+Addr VG_(get_error_address) ( Error* err )
+{
+   return err->addr;
+}
+
+Char* VG_(get_error_string) ( Error* err )
+{
+   return err->string;
+}
+
+void* VG_(get_error_extra)  ( Error* err )
+{
+   return err->extra;
+}
+
+/*------------------------------------------------------------*/
+/*--- Suppression type                                     ---*/
+/*------------------------------------------------------------*/
+
+/* Note: it is imperative this doesn't overlap with (0..) at all, as tools
+ * effectively extend it by defining their own enums in the (0..) range. */
+typedef
+   enum {
+      PThreadSupp = -1,    /* Matches PThreadErr */
+   }
+   CoreSuppKind;
+
+/* For each caller specified for a suppression, record the nature of
+   the caller name.  Not of interest to tools. */
+typedef
+   enum { 
+      ObjName,    /* Name is of an shared object file. */
+      FunName     /* Name is of a function. */
+   }
+   SuppLocTy;
+
+/* Suppressions.  Tools can get/set tool-relevant parts with functions
+   declared in include/vg_skin.h.  Extensible via the 'extra' field. 
+   Tools can use a normal enum (with element values in the normal range
+   (0..)) for `skind'. */
+struct _Supp {
+   struct _Supp* next;
+   Int count;     // The number of times this error has been suppressed.
+   Char* sname;   // The name by which the suppression is referred to.
+   /* First two (name of fn where err occurs, and immediate caller)
+    * are mandatory;  extra two are optional. */
+   SuppLocTy caller_ty[VG_N_SUPP_CALLERS];
+   Char*     caller   [VG_N_SUPP_CALLERS];
+
+   /* The tool-specific part */
+   SuppKind skind;   // What kind of suppression.  Must use the range (0..).
+   Char* string;     // String -- use is optional.  NULL by default.
+   void* extra;      // Anything else -- use is optional.  NULL by default.
+};
+
+SuppKind VG_(get_supp_kind) ( Supp* su )
+{
+   return su->skind;
+}
+
+Char* VG_(get_supp_string) ( Supp* su )
+{
+   return su->string;
+}
+
+void* VG_(get_supp_extra)  ( Supp* su )
+{
+   return su->extra;
+}
+
+
+void VG_(set_supp_kind)   ( Supp* su, SuppKind skind )
+{
+   su->skind = skind;
+}
+
+void VG_(set_supp_string) ( Supp* su, Char* string )
+{
+   su->string = string;
+}
+
+void VG_(set_supp_extra)  ( Supp* su, void* extra )
+{
+   su->extra = extra;
+}
+
+
+/*------------------------------------------------------------*/
 /*--- Helper fns                                           ---*/
 /*------------------------------------------------------------*/

--- valgrind/coregrind/vg_include.h  #1.207:1.208
@@ -1216,83 +1216,4 @@ extern ExeContext* VG_(get_ExeContext2) 
    ------------------------------------------------------------------ */
 
-/* Note: it is imperative this doesn't overlap with (0..) at all, as skins
- * effectively extend it by defining their own enums in the (0..) range. */
-typedef
-   enum {
-      PThreadSupp = -1,    /* Matches PThreadErr */
-   }
-   CoreSuppKind;
-
-/* For each caller specified for a suppression, record the nature of
-   the caller name.  Not of interest to skins. */
-typedef
-   enum { 
-      ObjName,    /* Name is of an shared object file. */
-      FunName     /* Name is of a function. */
-   }
-   SuppLocTy;
-
-/* Suppressions.  Skins can get/set skin-relevant parts with functions
-   declared in include/vg_skin.h.  Extensible via the 'extra' field. 
-   Skins can use a normal enum (with element values in the normal range
-   (0..)) for `skind'. */
-struct _Supp {
-   struct _Supp* next;
-   /* The number of times this error has been suppressed. */
-   Int count;
-   /* The name by which the suppression is referred to. */
-   Char* sname;
-   /* First two (name of fn where err occurs, and immediate caller)
-    * are mandatory;  extra two are optional. */
-   SuppLocTy caller_ty[VG_N_SUPP_CALLERS];
-   Char*     caller   [VG_N_SUPP_CALLERS];
-
-   /* The skin-specific part */
-   /* What kind of suppression.  Must use the range (0..) */
-   SuppKind skind;
-   /* String -- use is optional.  NULL by default. */
-   Char* string;
-   /* Anything else -- use is optional.  NULL by default. */
-   void* extra;
-};
-
-/* Note: it is imperative this doesn't overlap with (0..) at all, as skins
- * effectively extend it by defining their own enums in the (0..) range. */
-typedef
-   enum { 
-      PThreadErr      = -1,   /* Pthreading error */
-   }
-   CoreErrorKind;
-
-/* Errors.  Extensible (via the 'extra' field).  Skins can use a normal
-   enum (with element values in the normal range (0..)) for `ekind'. 
-   Functions for getting/setting the skin-relevant fields are in
-   include/vg_skin.h.
-
-   When errors are found and recorded with VG_(maybe_record_error)(), all
-   the skin must do is pass in the four parameters;  core will
-   allocate/initialise the error record.
-*/
-struct _Error {
-   struct _Error* next;
-   /* NULL if unsuppressed; or ptr to suppression record. */
-   Supp* supp;
-   Int count;
-   ThreadId tid;
-
-   /* The skin-specific part */
-   /* Initialised by core */
-   ExeContext* where;
-   /* Used by ALL.  Must be in the range (0..) */
-   Int ekind;
-   /* Used frequently */
-   Addr addr;
-   /* Used frequently */
-   Char* string;
-   /* For any skin-specific extras */
-   void* extra;
-};
-
-
 extern void VG_(load_suppressions)    ( void );
 

--- valgrind/coregrind/vg_needs.c  #1.16:1.17
@@ -192,66 +192,4 @@ UInstr* VG_(get_last_instr) ( UCodeBlock
    
 /*--------------------------------------------------------------------*/
-/* Suppressions */
-
-SuppKind VG_(get_supp_kind) ( Supp* su )
-{
-   return su->skind;
-}
-
-Char* VG_(get_supp_string) ( Supp* su )
-{
-   return su->string;
-}
-
-void* VG_(get_supp_extra)  ( Supp* su )
-{
-   return su->extra;
-}
-
-
-void VG_(set_supp_kind)   ( Supp* su, SuppKind skind )
-{
-   su->skind = skind;
-}
-
-void VG_(set_supp_string) ( Supp* su, Char* string )
-{
-   su->string = string;
-}
-
-void VG_(set_supp_extra)  ( Supp* su, void* extra )
-{
-   su->extra = extra;
-}
-
-/*--------------------------------------------------------------------*/
-/* Errors */
-
-ExeContext* VG_(get_error_where) ( Error* err )
-{
-   return err->where;
-}
-
-ErrorKind VG_(get_error_kind) ( Error* err )
-{
-   return err->ekind;
-}
-
-Addr VG_(get_error_address) ( Error* err )
-{
-   return err->addr;
-}
-
-Char* VG_(get_error_string) ( Error* err )
-{
-   return err->string;
-}
-
-void* VG_(get_error_extra)  ( Error* err )
-{
-   return err->extra;
-}
-
-/*--------------------------------------------------------------------*/
 /*--- end                                               vg_needs.c ---*/
 /*--------------------------------------------------------------------*/

CVS commit by nethercote: 


Make VG_(n_errs_found) local;  replace globally with a 'get' function.  Renamed
vg_n_errs_suppressed too.


  M +18 -16    vg_errcontext.c   1.56
  M +2 -2      vg_include.h   1.209
  M +1 -1      vg_scheduler.c   1.161


--- valgrind/coregrind/vg_errcontext.c  #1.55:1.56
@@ -44,8 +44,8 @@ static Supp* vg_suppressions = NULL;
 
 /* Running count of unsuppressed errors detected. */
-UInt VG_(n_errs_found) = 0;
+static UInt n_errs_found = 0;
 
 /* Running count of suppressed errors detected. */
-static UInt vg_n_errs_suppressed = 0;
+static UInt n_errs_suppressed = 0;
 
 /* forwards ... */
@@ -114,4 +114,9 @@ void* VG_(get_error_extra)  ( Error* err
 }
 
+UInt VG_(get_n_errs_found)( void )
+{
+   return n_errs_found;
+}
+
 /*------------------------------------------------------------*/
 /*--- Suppression type                                     ---*/
@@ -424,5 +429,5 @@ void VG_(maybe_record_error) ( ThreadId 
    if (VG_(clo_error_limit) 
        && (vg_n_errs_shown >= M_VG_COLLECT_NO_ERRORS_AFTER_SHOWN
-           || VG_(n_errs_found) >= M_VG_COLLECT_NO_ERRORS_AFTER_FOUND)) {
+           || n_errs_found >= M_VG_COLLECT_NO_ERRORS_AFTER_FOUND)) {
       if (!stopping_message) {
          VG_(message)(Vg_UserMsg, "");
@@ -483,7 +488,7 @@ void VG_(maybe_record_error) ( ThreadId 
             /* Deal correctly with suppressed errors. */
             p->supp->count++;
-            vg_n_errs_suppressed++;      
+            n_errs_suppressed++;         
          } else {
-            VG_(n_errs_found)++;
+            n_errs_found++;
          }
 
@@ -540,5 +545,5 @@ void VG_(maybe_record_error) ( ThreadId 
    vg_errors = p;
    if (p->supp == NULL) {
-      VG_(n_errs_found)++;
+      n_errs_found++;
       if (!is_first_shown_context)
          VG_(message)(Vg_UserMsg, "");
@@ -548,5 +553,5 @@ void VG_(maybe_record_error) ( ThreadId 
       do_actions_on_error(p, /*allow_db_attach*/True);
    } else {
-      vg_n_errs_suppressed++;
+      n_errs_suppressed++;
       p->supp->count++;
    }
@@ -558,5 +563,5 @@ void VG_(maybe_record_error) ( ThreadId 
    comparing stuff.  But they can be suppressed;  returns True if it is
    suppressed.  Bool `print_error' dictates whether to print the error. 
-   Bool `count_error' dictates whether to count the error in VG_(n_errs_found)
+   Bool `count_error' dictates whether to count the error in n_errs_found.
 */
 Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, Char* s,
@@ -579,5 +584,5 @@ Bool VG_(unique_error) ( ThreadId tid, E
    if (NULL == is_suppressible_error(&err)) {
       if (count_error)
-         VG_(n_errs_found)++;
+         n_errs_found++;
 
       if (print_error) {
@@ -592,5 +597,5 @@ Bool VG_(unique_error) ( ThreadId tid, E
 
    } else {
-      vg_n_errs_suppressed++;
+      n_errs_suppressed++;
       return True;
    }
@@ -610,6 +615,4 @@ void VG_(record_pthread_error) ( ThreadI
 }
 
-/*------------------------------*/
-
 void VG_(show_all_errors) ( void )
 {
@@ -637,6 +640,6 @@ void VG_(show_all_errors) ( void )
                 "ERROR SUMMARY: "
                 "%d errors from %d contexts (suppressed: %d from %d)",
-                VG_(n_errs_found), n_err_contexts, 
-                vg_n_errs_suppressed, n_supp_contexts );
+                n_errs_found, n_err_contexts, 
+                n_errs_suppressed, n_supp_contexts );
 
    if (VG_(clo_verbosity) <= 1)
@@ -686,6 +689,5 @@ void VG_(show_all_errors) ( void )
                    "IN SUMMARY: "
                    "%d errors from %d contexts (suppressed: %d from %d)",
-                   VG_(n_errs_found), n_err_contexts, 
-                   vg_n_errs_suppressed,
+                   n_errs_found, n_err_contexts, n_errs_suppressed,
                    n_supp_contexts );
       VG_(message)(Vg_UserMsg, "");

--- valgrind/coregrind/vg_include.h  #1.208:1.209
@@ -1224,5 +1224,5 @@ extern void VG_(show_all_errors)      ( 
 extern Bool VG_(is_action_requested) ( Char* action, Bool* clo );
 
-extern UInt VG_(n_errs_found);
+extern UInt VG_(get_n_errs_found)     ( void );
 
 /* ---------------------------------------------------------------------

--- valgrind/coregrind/vg_scheduler.c  #1.160:1.161
@@ -3345,5 +3345,5 @@ void do_client_request ( ThreadId tid )
 
       case VG_USERREQ__COUNT_ERRORS:  
-         SET_CLREQ_RETVAL( tid, VG_(n_errs_found) );
+         SET_CLREQ_RETVAL( tid, VG_(get_n_errs_found)() );
          break;

CVS commit by nethercote: 

Tweak to remove another global variable from vg_include.h


  M +2 -3      vg_include.h   1.210
  M +9 -8      vg_main.c   1.180
  M +2 -2      vg_signals.c   1.76


--- valgrind/coregrind/vg_include.h  #1.209:1.210
@@ -1332,6 +1332,5 @@ extern ThreadId VG_(last_run_tid);
 
 /* If we're doing the default action of a fatal signal */
-extern jmp_buf VG_(fatal_signal_jmpbuf);
-extern Bool    VG_(fatal_signal_set);           /* jmp_buf is valid */
+extern jmp_buf* VG_(fatal_signal_jmpbuf_ptr);
 extern Int     VG_(fatal_sigNo);                /* the fatal signal */
 

--- valgrind/coregrind/vg_main.c  #1.179:1.180
@@ -152,8 +152,9 @@ Char** VG_(client_envp);
 UInt VG_(sigstack)[VG_SIGSTACK_SIZE_W];
 
-/* jmp_buf for fatal signals */
+/* jmp_buf for fatal signals;  VG_(fatal_signal_jmpbuf_ptr) is NULL until
+   the time is right that it can be used. */
 Int     VG_(fatal_sigNo) = -1;
-Bool    VG_(fatal_signal_set) = False;
-jmp_buf VG_(fatal_signal_jmpbuf);
+jmp_buf* VG_(fatal_signal_jmpbuf_ptr) = NULL;
+jmp_buf  fatal_signal_jmpbuf;
 
 /* Counts downwards in VG_(run_innerloop). */
@@ -2981,10 +2982,10 @@ int main(int argc, char **argv)
    VGP_PUSHCC(VgpSched);
 
-   if (__builtin_setjmp(&VG_(fatal_signal_jmpbuf)) == 0) {
-      VG_(fatal_signal_set) = True;
+   VG_(fatal_signal_jmpbuf_ptr) = &fatal_signal_jmpbuf;
+   if (__builtin_setjmp(VG_(fatal_signal_jmpbuf_ptr)) == 0) {
       src = VG_(scheduler)( &exitcode );
-   } else
+   } else {
       src = VgSrc_FatalSig;
-
+   }
    VGP_POPCC(VgpSched);
 

--- valgrind/coregrind/vg_signals.c  #1.75:1.76
@@ -1796,7 +1796,7 @@ static void vg_default_action(const vki_
       }
 
-      if (VG_(fatal_signal_set)) {
+      if (NULL != VG_(fatal_signal_jmpbuf_ptr)) {
          VG_(fatal_sigNo) = sigNo;
-         __builtin_longjmp(VG_(fatal_signal_jmpbuf), 1);
+         __builtin_longjmp(*VG_(fatal_signal_jmpbuf_ptr), 1);
       }
    }

CVS commit by nethercote: 

Sanity counters don't need to be in vg_include.h.


  M +8 -9      vg_main.c   1.181


--- valgrind/coregrind/vg_main.c  #1.180:1.181
@@ -215,6 +215,6 @@ UInt VG_(total_reg_rank) = 0;
 
 /* Counts pertaining to internal sanity checking. */
-UInt VG_(sanity_fast_count) = 0;
-UInt VG_(sanity_slow_count) = 0;
+static UInt sanity_fast_count = 0;
+static UInt sanity_slow_count = 0;
 
 /* Counts pertaining to the scheduler. */
@@ -271,6 +271,5 @@ static void show_counts ( void )
    VG_(message)(Vg_DebugMsg, 
                 "   sanity: %d cheap, %d expensive checks.",
-                VG_(sanity_fast_count), 
-                VG_(sanity_slow_count) );
+                sanity_fast_count, sanity_slow_count );
    VG_(print_ccall_stats)();
 }
@@ -2558,5 +2557,5 @@ void VG_(do_sanity_checks) ( Bool force_
    /* --- First do all the tests that we can do quickly. ---*/
 
-   VG_(sanity_fast_count)++;
+   sanity_fast_count++;
 
    /* Check stuff pertaining to the memory check system. */
@@ -2575,8 +2574,8 @@ void VG_(do_sanity_checks) ( Bool force_
    if ( force_expensive
      || VG_(clo_sanity_level) > 1
-     || (VG_(clo_sanity_level) == 1 && (VG_(sanity_fast_count) % 25) == 0)) {
+     || (VG_(clo_sanity_level) == 1 && (sanity_fast_count % 25) == 0)) {
 
       VGP_PUSHCC(VgpCoreExpensiveSanity);
-      VG_(sanity_slow_count)++;
+      sanity_slow_count++;
 
       VG_(proxy_sanity)();
@@ -2586,5 +2585,5 @@ void VG_(do_sanity_checks) ( Bool force_
 #     endif
 
-      if ((VG_(sanity_fast_count) % 250) == 0)
+      if ((sanity_fast_count % 250) == 0)
          VG_(sanity_check_tc_tt)();
 
@@ -2595,5 +2594,5 @@ void VG_(do_sanity_checks) ( Bool force_
       }
       /* 
-      if ((VG_(sanity_fast_count) % 500) == 0) VG_(mallocSanityCheckAll)(); 
+      if ((sanity_fast_count % 500) == 0) VG_(mallocSanityCheckAll)(); 
       */
       VGP_POPCC(VgpCoreExpensiveSanity);

CVS commit by nethercote: 


sanity_*_count don't need to be in vg_include.h.

Also hide the reg-alloc counters, and replace with a printing function.


  M +12 -29    vg_include.h   1.211
  M +1 -7      vg_main.c   1.182
  M +22 -5     vg_translate.c   1.81


--- valgrind/coregrind/vg_include.h  #1.210:1.211
@@ -1185,4 +1185,5 @@ extern void  VG_(saneUCodeBlock)      ( 
 extern Bool  VG_(saneUCodeBlockCalls) ( UCodeBlock* cb );
 
+extern void VG_(print_reg_alloc_stats) ( void );
 
 /* ---------------------------------------------------------------------
@@ -1359,22 +1360,4 @@ extern UInt VG_(unchained_jumps_done);
 
 
-/* Counts pertaining to the register allocator. */
-
-/* total number of uinstrs input to reg-alloc */
-extern UInt VG_(uinstrs_prealloc);
-
-/* total number of uinstrs added due to spill code */
-extern UInt VG_(uinstrs_spill);
-
-/* number of bbs requiring spill code */
-extern UInt VG_(translations_needing_spill);
-
-/* total of register ranks over all translations */
-extern UInt VG_(total_reg_rank);
-
-/* Counts pertaining to internal sanity checking. */
-extern UInt VG_(sanity_fast_count);
-extern UInt VG_(sanity_slow_count);
-
 /* Counts pertaining to the scheduler. */
 extern UInt VG_(num_scheduling_events_MINOR);

--- valgrind/coregrind/vg_main.c  #1.181:1.182
@@ -262,11 +262,5 @@ static void show_counts ( void )
                      VG_(tt_fast_misses));
 
-   VG_(message)(Vg_DebugMsg, 
-                "reg-alloc: %d t-req-spill, "
-                "%d+%d orig+spill uis, %d total-reg-r.",
-                VG_(translations_needing_spill),
-                VG_(uinstrs_prealloc),
-                VG_(uinstrs_spill),
-                VG_(total_reg_rank) );
+   VG_(print_reg_alloc_stats)();
    VG_(message)(Vg_DebugMsg, 
                 "   sanity: %d cheap, %d expensive checks.",

--- valgrind/coregrind/vg_translate.c  #1.80:1.81
@@ -38,4 +38,21 @@
 #define dis       VG_(print_codegen)
 
+/*------------------------------------------------------------*/
+/*--- Reg-alloc stats                                      ---*/
+/*------------------------------------------------------------*/
+
+static UInt n_uinstrs_prealloc;           // # uinstrs input to reg-alloc
+static UInt n_uinstrs_spill;              // # uinstrs added due to spill code
+static UInt n_translations_needing_spill; // # bbs requiring spill code
+static UInt n_total_reg_rank; // total of register ranks over all translations
+
+void VG_(print_reg_alloc_stats)(void)
+{
+   VG_(message)(Vg_DebugMsg, 
+                "reg-alloc: %d t-req-spill, "
+                "%d+%d orig+spill uis, %d total-reg-r.",
+                n_translations_needing_spill, 
+                n_uinstrs_prealloc, n_uinstrs_spill, n_total_reg_rank );
+}
 
 /*---------------------------------------------