Merge r9533..9536 (add tests/{asm.h,sys_mman.h,malloc.h} from the DARWIN

branch.



git-svn-id: svn://svn.valgrind.org/valgrind/trunk@9537

Makefile.tool-tests.am

@@ -1,3 +1,5 @@
+# This file is used for tool tests, and also in perf/Makefile.am.
+
 include $(top_srcdir)/Makefile.flags.am     # For AM_FLAG_M3264_PRI
 
 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/include \

exp-ptrcheck/tests/mm.c

@@ -1,4 +1,4 @@
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <unistd.h>
 #include "arith_include1.c"
 

massif/tests/custom_alloc.c

@@ -1,5 +1,5 @@
 #include <unistd.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <assert.h>
 #include <stdlib.h>
 
@@ -14,7 +14,7 @@
 void* get_superblock(void)
 {
    void* p = mmap( 0, SUPERBLOCK_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC,
-                   MAP_PRIVATE|MAP_ANON, -1, 0 );
+                   MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
 
    assert(p != ((void*)(-1)));
 

massif/tests/malloc_usable.c

@@ -1,11 +1,11 @@
 #include <assert.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <stdlib.h>
 #include <stdio.h>
 
 int main(void)
 {
-#  if !defined(_AIX)
+#  if !defined(VGO_aix5)
    // Because our allocations are in multiples of 8 or 16, 99 will round up
    // to 104 or 112.
    int* x = malloc(99);

memcheck/tests/addressable.c

@@ -1,6 +1,6 @@
 /* Test different kinds of addressability and definedness */
 #include "../memcheck.h"
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <stdio.h>
 #include <sys/resource.h>
 #include <unistd.h>

memcheck/tests/amd64/sse_memory.c

@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <string.h>
 
 typedef  unsigned char  V128[16];
@@ -148,7 +148,7 @@ void do_##insn ( void )                    \
    }                                       \
    for (i = 0; i < 5; i++) {               \
       randRMArgs(&margs);                  \
-      buf = memalign(16,mem_size);         \
+      buf = memalign16(mem_size);          \
       randomise(buf,mem_size);             \
       r_m_##insn(&margs,buf);              \
       showRM(#insn, &margs, buf, mem_size, res_mask);\

memcheck/tests/badjump.c

@@ -1,3 +1,4 @@
+#include "tests/sys_mman.h"
 
 int main ( void )
 {
@@ -7,12 +8,13 @@ int main ( void )
       uniform behaviour on all supported targets - a jump to 0xE000000
       - the following is needed. */
    unsigned long long int fake_fndescr[3];
-   fake_fndescr[0] = 0xE000000;
+   fake_fndescr[0] = (unsigned long long int)get_unmapped_page();
    fake_fndescr[1] = 0;
    fake_fndescr[2] = 0;
    return ((int(*)(void)) fake_fndescr) ();
 #else
-   char* p = (char*)0xE000000;
+   char* p = get_unmapped_page();
    return ((int(*)(void)) p) ();
 #endif
 }
+

memcheck/tests/custom_alloc.c

@@ -1,5 +1,5 @@
 #include <unistd.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <assert.h>
 #include <stdlib.h>
 
@@ -14,7 +14,7 @@
 void* get_superblock(void)
 {
    void* p = mmap( 0, SUPERBLOCK_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC,
-                   MAP_PRIVATE|MAP_ANON, -1, 0 );
+                   MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
 
    assert(p != ((void*)(-1)));
 

memcheck/tests/file_locking.c

@@ -9,7 +9,7 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>

memcheck/tests/linux/stack_switch.c

@@ -6,7 +6,7 @@
 #include <sched.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <sys/syscall.h>
 #include <sys/wait.h>
 #include <unistd.h>

memcheck/tests/mallinfo.c

@@ -1,4 +1,4 @@
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h> // getopt()

memcheck/tests/malloc_usable.c

@@ -1,11 +1,11 @@
 #include <assert.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <stdlib.h>
 #include <stdio.h>
 
 int main(void)
 {
-#  if !defined(_AIX)
+#  if !defined(VGO_aix5)
    // Because Memcheck marks any slop as inaccessible, it doesn't round up
    // sizes for malloc_usable_size().
    int* x = malloc(99);

memcheck/tests/memalign2.c

@@ -14,16 +14,17 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <assert.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <errno.h>
 
 int main ( void )
 {
-#  if defined(_AIX)
+#  if defined(VGO_aix5)
    // AIX 5.2 has neither memalign() nor posix_memalign();  do nothing.
 
 #  else
    // Nb: assuming VG_MIN_MALLOC_SZB is 8!
+   // DDD: (this is no longer true)
    // Should work with both 32-bit and 64-bit pointers, though.
 
    int* p;

memcheck/tests/mempool.c

@@ -1,5 +1,5 @@
 #include <unistd.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <assert.h>
 #include <stdlib.h>
 

memcheck/tests/mmaptest.c

@@ -2,7 +2,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 int main()
 {

memcheck/tests/origin1-yes.c

@@ -13,7 +13,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <unistd.h>
 #include "../memcheck.h"
 

memcheck/tests/pointer-trace.c

@@ -5,7 +5,7 @@
 
 #include <stdio.h>
 #include "memcheck/memcheck.h"
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <stdlib.h>
 #include <fcntl.h>
 #include <unistd.h>

memcheck/tests/sh-mem-random.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include "memcheck/memcheck.h"
 
 // All the sizes here are in *bytes*, not bits.

memcheck/tests/sigaltstack.c

@@ -3,7 +3,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 void sig_handler(int sig){
   int var;
@@ -19,7 +19,7 @@ int main(int argv, char** argc) {
   // ask for an alt stack with EXEC permissions,
   // since signal returning requires execution of code on the stack.      
   char *stk = (char *)mmap(0, size, PROT_READ|PROT_WRITE|PROT_EXEC, 
-                                    MAP_ANON|MAP_PRIVATE, -1, 0);
+                                    MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
   sigstk.ss_sp = stk;
 
   sigstk.ss_size = size;

memcheck/tests/signal2.c

@@ -2,19 +2,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
+#include "tests/sys_mman.h"
 
-void sig_hdlr ( int signo )
-{
-   printf ( "caught sig segv\n" );
-   exit(1);
+void sig_hdlr ( int signo ) {
+   printf ( "caught sig segv\n" ); exit(1);
 }
 
-int main ( void )
-{
+int main ( void ) {
+   char* badplace;
    printf ( "installing sig handler\n" );
    signal(SIGSEGV, sig_hdlr);
    printf ( "doing bad thing\n" );
-   * (int*) 65536 = 0;
+   badplace = get_unmapped_page();
+   *(int*)badplace = 0;
    printf ( "exited normally ?!\n" );
    return 0;
 }
+

memcheck/tests/stack_changes.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ucontext.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 #include "valgrind.h"
 
@@ -39,7 +39,7 @@ int init_context(mycontext *uc)
     }
 
     stack = (void *)mmap(0, STACK_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC,
-                                        MAP_ANON|MAP_PRIVATE, -1, 0);
+                                        MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
 
     if (stack == (void*)-1) {
         perror("mmap");

memcheck/tests/str_tester.c

@@ -463,6 +463,7 @@ test_strchr (void)
    }
 }
 
+// DDD: better done by testing for the function.
 #if !defined(_AIX)
 static void
 test_strchrnul (void)
@@ -499,6 +500,7 @@ test_strchrnul (void)
 }
 #endif /* !defined(_AIX) */
 
+// DDD: better done by testing for the function.
 #if !defined(_AIX)
 static void
 test_rawmemchr (void)
@@ -574,6 +576,7 @@ test_strrchr (void)
    }
 }
 
+// DDD: better done by testing for the function.
 #if !defined(_AIX)
 static void
 test_memrchr (void)

memcheck/tests/x86-linux/bug133694.c

@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 int main(int argc, char **argv)
 {

memcheck/tests/x86/Makefile.am

@@ -28,12 +28,17 @@ EXTRA_DIST = $(noinst_SCRIPTS) \
 check_PROGRAMS = \
 	bug152022 \
 	espindola2 \
-	fxsave \
 	int3-x86 \
-	fpeflags pushfpopf \
+	fpeflags \
+        fprem \
+        fxsave \
+	more_x86_fp \
+        pushfpopf \
 	pushfw_x86 \
-	pushpopmem sse_memory tronical \
-	more_x86_fp fprem xor-undef-x86
+	pushpopmem \
+        sse_memory \
+        tronical \
+        xor-undef-x86
 
 AM_CFLAGS   += @FLAG_M32@ $(FLAG_MMMX) $(FLAG_MSSE)
 AM_CXXFLAGS += @FLAG_M32@ $(FLAG_MMMX) $(FLAG_MSSE)

memcheck/tests/x86/fxsave.c

@@ -1,7 +1,8 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <malloc.h>
+#include "tests/asm.h"
+#include "tests/malloc.h"
 #include <string.h>
 
 const unsigned int vec0[4]
@@ -34,14 +35,14 @@ void do_zeroise ( void )
     "fldz\n\t"
     "fldz\n\t"
     "finit\n");
-   asm __volatile__("movups vecZ, %xmm0");
-   asm __volatile__("movups vecZ, %xmm1");
-   asm __volatile__("movups vecZ, %xmm2");
-   asm __volatile__("movups vecZ, %xmm3");
-   asm __volatile__("movups vecZ, %xmm4");
-   asm __volatile__("movups vecZ, %xmm5");
-   asm __volatile__("movups vecZ, %xmm6");
-   asm __volatile__("movups vecZ, %xmm7");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm0");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm1");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm2");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm3");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm4");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm5");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm6");
+   asm __volatile__("movups " VG_SYM(vecZ) ", %xmm7");
    asm __volatile__(
       "pushl $0\n\t"
       "ldmxcsr 0(%esp)\n\t"
@@ -58,8 +59,8 @@ void do_setup_then_fxsave ( void* p )
    asm __volatile__("fldlg2");
    asm __volatile__("fld %st(3)");
    asm __volatile__("fld %st(3)");
-   asm __volatile__("movups vec0, %xmm0");
-   asm __volatile__("movups vec1, %xmm1");
+   asm __volatile__("movups " VG_SYM(vec0) ", %xmm0");
+   asm __volatile__("movups " VG_SYM(vec1) ", %xmm1");
    asm __volatile__("xorps %xmm2, %xmm2");
    asm __volatile__("movaps %xmm2, %xmm3");
    asm __volatile__("movaps %xmm2, %xmm4");
@@ -102,9 +103,9 @@ void show ( unsigned char* buf, int xx )
 
 int main ( int argc, char** argv )
 {
-   unsigned char* buf1 = memalign(16,512);
-   unsigned char* buf2 = memalign(16,512);
-   unsigned char* buf3 = memalign(16,512);
+   unsigned char* buf1 = memalign16(512);
+   unsigned char* buf2 = memalign16(512);
+   unsigned char* buf3 = memalign16(512);
    int xx = argc > 1;
    printf("Re-run with any arg to suppress least-significant\n"
           "   16 bits of FP numbers\n");

none/tests/amd64/bug137714-amd64.c

@@ -1,6 +1,6 @@
 
 #include <stdio.h>
-#include <malloc.h>
+#include <stdlib.h>
 #include <assert.h>
 
 typedef  unsigned char  UChar;

none/tests/amd64/faultstatus.c

@@ -6,7 +6,7 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <setjmp.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <unistd.h>
 
 struct test {

none/tests/amd64/nibz_bennee_mmap.c

@@ -27,7 +27,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 int main(int argc, char **argv)
 {

none/tests/amd64/redundantRexW.c

@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <malloc.h>  /* for memalign */
 #include <assert.h>
+#include "tests/malloc.h"
 
 typedef  unsigned char  UChar;
 
@@ -168,12 +169,8 @@ int main ( void )
 {
    XMMRegs* regs;
    Mem*     mem;
-   regs = memalign(16, sizeof(XMMRegs)); assert(regs);
-   mem  = memalign(16, sizeof(Mem)); assert(mem);
-
-   /* Both have to be 16-aligned so we can do movapd et al */
-   assert( 0 == (0xFL & (unsigned long int)regs) );
-   assert( 0 == (0xFL & (unsigned long int)mem) );
+   regs = memalign16(sizeof(XMMRegs) + 16);
+   mem  = memalign16(sizeof(Mem) + 16);
 
    /* addpd mem, reg   66 49 0f 58 48 00  rex.WB addpd  0x0(%r8),%xmm1 */
    {

none/tests/amd64/smc1.c

@@ -31,7 +31,7 @@
 
 #include <stdio.h>
 #include <assert.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 typedef unsigned long long int Addr;
 typedef unsigned char UChar;

none/tests/amd64/ssse3_misaligned.c

@@ -1,5 +1,5 @@
 
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -8,9 +8,7 @@
 
 void maybe_fault ( int delta )
 {
-   char* x = memalign(16/*alignment*/,32/*size*/);
-   assert(x);
-   assert(0 == ((16-1) & (unsigned long)x));
+   char* x = memalign16(32);
    memset(x, 0, 32);
    __asm__ __volatile__(
       "pabsb (%0),%%xmm7"

none/tests/faultstatus.c

@@ -6,7 +6,7 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <setjmp.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <unistd.h>
 
 /*

none/tests/linux/mremap.c

@@ -1,5 +1,5 @@
 #define _GNU_SOURCE
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <stdio.h>
 #include <stdlib.h>
 

none/tests/linux/mremap2.c

@@ -2,7 +2,7 @@
 
 #include <stdio.h>
 
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/types.h>

none/tests/map_unaligned.c

@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 int main(int argc, char **argv)
 {

none/tests/map_unmap.c

@@ -1,5 +1,5 @@
 #include <stdio.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <stdlib.h>
 #include <unistd.h>
 
@@ -10,7 +10,7 @@ static unsigned int pagesize;
 
 static void *domap(void)
 {
-	void *ret = mmap(0, LEN, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+	void *ret = mmap(0, LEN, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 
 	if (ret == (void *)-1) {
 		perror("mmap");

none/tests/munmap_exe.c

@@ -1,5 +1,5 @@
 #include <unistd.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -11,7 +11,7 @@ int main()
 {
     void* m;
     
-    m = mmap(NULL, 100, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_ANON, -1, 0);
+    m = mmap(NULL, 100, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 
     if (m == (void*)-1) {
        fprintf(stderr, "error mmapping\n");

none/tests/ppc32/jm-insns.c

@@ -166,7 +166,7 @@ case I chased).
 
 
 #include <stdint.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 /* Something of the same size as void*, so can be safely be coerced
    to/from a pointer type. Also same size as the host's gp registers. */
@@ -229,8 +229,6 @@ register HWord_t r17 __asm__ ("r17");
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>    // getopt
-#include <malloc.h>
-
 
 
 #ifndef __powerpc64__
@@ -4403,7 +4401,7 @@ static void build_viargs_table (void)
 {
 #if !defined (ALTIVEC_ARGS_LARGE)
    unsigned int i=2;
-   viargs = memalign(16, i * sizeof(vector unsigned int));
+   viargs = memalign16(i * sizeof(vector unsigned int));
    viargs[0] = (vector unsigned int) { 0x01020304,0x05060708,0x090A0B0C,0x0E0D0E0F };
    AB_DPRINTF_VEC32x4( viargs[0] );
    viargs[1] = (vector unsigned int) { 0xF1F2F3F4,0xF5F6F7F8,0xF9FAFBFC,0xFEFDFEFF };
@@ -4459,7 +4457,7 @@ static void build_vfargs_table (void)
 
 #if !defined (ALTIVEC_ARGS_LARGE)
    nb_vfargs = 12;
-   vfargs = memalign(16, nb_vfargs * sizeof(vector float));
+   vfargs = memalign16(nb_vfargs * sizeof(vector float));
 
    // 4 values:
    for (s=0; s<2; s++) {
@@ -4474,7 +4472,7 @@ static void build_vfargs_table (void)
    }
 #else
    nb_vfargs = 50;
-   vfargs = memalign(16, nb_vfargs * sizeof(vector float));
+   vfargs = memalign16(nb_vfargs * sizeof(vector float));
 
    for (s=0; s<2; s++) {
       for (_exp=0x0; ; _exp += 0x3F ) {
@@ -6763,7 +6761,7 @@ static void test_av_int_st_three_regs (const char *name,
    vector unsigned int* viargs_priv;
 
    // private viargs table to store to
-   viargs_priv = memalign(16,(nb_viargs * sizeof(vector unsigned int)));
+   viargs_priv = memalign16(nb_viargs * sizeof(vector unsigned int));
    for (i=0; i<nb_viargs; i++)
       viargs_priv[i] = (vector unsigned int) { 0,0,0,0 };
 

none/tests/ppc32/test_fx.c

@@ -1,6 +1,6 @@
 
 #include <stdio.h>
-#include <malloc.h>
+#include <stdlib.h>
 
 double do_fsqrt ( double x )
 {

none/tests/ppc32/test_gx.c

@@ -1,6 +1,6 @@
 
 #include <stdio.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 
 /* This is a Marie Celeste instruction.  Some IBM documents think it
    exists, others don't.  The same appears to be true for

none/tests/x86/Makefile.am

@@ -59,19 +59,36 @@ EXTRA_DIST = $(noinst_SCRIPTS) \
 	yield.stderr.exp yield.stdout.exp yield.disabled
 
 check_PROGRAMS = \
-	badseg bt_everything bt_literal \
+	badseg \
+	bt_everything \
+	bt_literal \
 	bug125959-x86 \
 	bug126147-x86 \
 	bug132813-x86 \
 	bug135421-x86 \
 	bug137714-x86 \
 	bug152818-x86 \
-	cmpxchg8b cpuid cse_fail \
-	faultstatus fcmovnu fpu_lazy_eflags fxtract \
-	getseg incdec_alt $(INSN_TESTS) \
+	cmpxchg8b \
+        cpuid \
+        cse_fail \
+	faultstatus \
+        fcmovnu \
+        fpu_lazy_eflags \
+        fxtract \
+	getseg \
+        incdec_alt \
+        $(INSN_TESTS) \
+        int \
 	jcxz \
-	lahf looper movx int pushpopseg sbbmisc \
-	seg_override sigcontext smc1 yield
+	lahf \
+        looper \
+        movx \
+        pushpopseg \
+        sbbmisc \
+	seg_override \
+        sigcontext \
+        smc1 \
+        yield
 if BUILD_SSSE3_TESTS
  check_PROGRAMS += ssse3_misaligned
 endif

none/tests/x86/bug126147-x86.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -19,10 +19,8 @@
 extern char *mystrncpy(char *dest, const char *src, size_t n);
 asm(
 ".text\n"
-".globl mystrncpy\n"
-".type mystrncpy,@function\n"
 "\n"
-"mystrncpy:\n"
+VG_SYM(mystrncpy) ":\n"
 "	pushl %esi\n"
 "	pushl %edi\n"
 "	movl %esp, %ecx\n"
@@ -32,20 +30,19 @@ asm(
 "\n"
 "	movl %edi, %edx\n"
 "	cld\n"
-".Lzzloop:\n"
+"0:\n"
 "	dec %ecx\n"
-"	js .Lzzout\n"
+"	js 1f\n"
 "	lodsb\n"
 "	stosb\n"
 "	or %al, %al\n"
-"	jnz .Lzzloop\n"
+"	jnz 0b\n"
 "	repnz stosb\n"
-".Lzzout:\n"
+"1:\n"
 "	movl %edx, %eax\n"
 "	popl %edi\n"
 "	popl %esi\n"
 "	ret\n"
-".previous\n"
 "\n"
 );
 
@@ -66,8 +63,7 @@ extern int __ltostr(char *s, unsigned int size, unsigned long i,
                              unsigned int base, int UpCase);
 asm(
 ".text\n"
-".globl __ltostr\n"
-"__ltostr:\n"
+VG_SYM(__ltostr) ":\n"
 "        pushl %esi\n"
 "        pushl %edi              # destination\n"
 "        pushl %ebp\n"
@@ -79,27 +75,27 @@ asm(
 "        movl 0x1c(%eax), %eax   # dividend\n"
 "        decl %ecx\n"
 "        movl %ecx, %esi\n"
-"        movl $('A'-0xa), %ebp\n"
+"        movl $55, %ebp          # 55 == char(A)-10\n"
 "        xorl %edx, %edx         # must be 0 -- used by idiv\n"
 "        cmpl $0x0, 36(%esp)     # check for uppercase\n"
-"        jnz .Lyynext\n"
+"        jnz 0f\n"
 "        addl $0x20, %ebp        # set lowercase\n"
-".Lyynext:\n"
+"0:\n"
 "        idiv %ebx, %eax\n"
 "        cmpb $0x9, %dl\n"
-"        jg .Lyynext2\n"
-"        addb $'0', %dl\n"
-"        jmp .Lyystos\n"
-".Lyynext2:\n"
+"        jg 1f\n"
+"        addb $48, %dl           # 48 == '0'\n"
+"        jmp 2f\n"
+"1:\n"
 "        addl %ebp, %edx\n"
-".Lyystos:\n"
+"2:\n"
 "        movb %dl, (%edi, %ecx)\n"
 "        xorl %edx, %edx\n"
 "        decl %ecx\n"
-"        jz .Lyyout\n"
+"        jz 3f\n"
 "        orl %eax, %eax\n"
-"        jnz .Lyynext\n"
-".Lyyout:\n"
+"        jnz 0b\n"
+"3:\n"
 "        cld\n"
 "        movl %esi, %ebx\n"
 "        leal 1(%edi, %ecx), %esi\n"
@@ -113,7 +109,6 @@ asm(
 "        popl %edi\n"
 "        popl %esi\n"
 "        ret\n"
-".previous\n"
 );
 
 #define STREQ(a, b)     (strcmp((a), (b)) == 0)

none/tests/x86/cmpxchg8b.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 
 typedef unsigned long long int ULong;
@@ -14,7 +14,7 @@ UInt zout;
 
 extern void foo ( void );
 asm("\n"
-    "foo:\n"
+    VG_SYM(foo) ":\n"
     "\tpushl %eax\n"
     "\tpushl %ebx\n"
     "\tpushl %ecx\n"
@@ -22,18 +22,18 @@ asm("\n"
 
     "\txorl %eax, %eax\n" // get eflags in a known state
 
-    "\tmovl eax,%eax\n"
-    "\tmovl ebx,%ebx\n"
-    "\tmovl ecx,%ecx\n"
-    "\tmovl edx,%edx\n"
-    "\tcmpxchg8b m64\n"
-    "\tmovl %eax,eax\n"
-    "\tmovl %ebx,ebx\n"
-    "\tmovl %ecx,ecx\n"
-    "\tmovl %edx,edx\n"
+    "\tmovl " VG_SYM(eax) ",%eax\n"
+    "\tmovl " VG_SYM(ebx) ",%ebx\n"
+    "\tmovl " VG_SYM(ecx) ",%ecx\n"
+    "\tmovl " VG_SYM(edx) ",%edx\n"
+    "\tcmpxchg8b " VG_SYM(m64) "\n"
+    "\tmovl %eax," VG_SYM(eax) "\n"
+    "\tmovl %ebx," VG_SYM(ebx) "\n"
+    "\tmovl %ecx," VG_SYM(ecx) "\n"
+    "\tmovl %edx," VG_SYM(edx) "\n"
     "\tpushfl\n"
     "\tpopl %eax\n"
-    "\tmovl %eax,zout\n"
+    "\tmovl %eax," VG_SYM(zout) "\n"
 
     "\tpopl %edx\n"
     "\tpopl %ecx\n"

none/tests/x86/faultstatus.c

@@ -6,7 +6,7 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <setjmp.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 #include <unistd.h>
 
 struct test {

none/tests/x86/fcmovnu.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 
 double zzz;
@@ -15,7 +15,7 @@ int main ( void )
     "movl $0,%esi\n\t"
     "add %esi,%esi\n\t"
     "fcmovnu %st(1), %st(0)\n\t"
-    "fstl zzz\n\t"
+    "fstl " VG_SYM(zzz) "\n\t"
     "finit\n\t"
     "popl %esi\n\t"
     );

none/tests/x86/fxtract.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 #include <math.h>
 
@@ -6,13 +6,12 @@ double arg, res1, res2;
 
 extern void do_fxtract ( void );
 asm("\n"
-".global do_fxtract\n"
-"do_fxtract:\n"
+VG_SYM(do_fxtract) ":\n"
 "\tfinit\n"
-"\tfldl arg\n"
+"\tfldl " VG_SYM(arg) "\n"
 "\tfxtract\n"
-"\tfstpl res1\n"
-"\tfstpl res2\n"
+"\tfstpl " VG_SYM(res1) "\n"
+"\tfstpl " VG_SYM(res2) "\n"
 "\tret"
 );
 

none/tests/x86/incdec_alt.c

@@ -1,51 +1,52 @@
 
 /* A test of the alternative (redundant) encodings for {inc,dec}{w,l}. */
 
+#include "tests/asm.h"
 #include <stdio.h>
 
 int r1,r2,r3,r4,r5,r6,r7,r8,a1,a2;
 
 extern void foo ( void );
 asm("\n"
-"foo:\n"
+VG_SYM(foo) ":\n"
 "\tpushl $0\n"
 "\tpopfl\n"
-"\tmovl a1,%eax\n"
-"\tmovl a2,%edx\n"
+"\tmovl " VG_SYM(a1) ",%eax\n"
+"\tmovl " VG_SYM(a2) ",%edx\n"
 
 /* inc %eax */
 "\t.byte 0xFF\n"
 "\t.byte 0xC0\n"
 
-"\tmovl %eax,r1\n"
+"\tmovl %eax," VG_SYM(r1) "\n"
 "\tpushfl\n"
-"\tpopl r2\n"
+"\tpopl " VG_SYM(r2) "\n"
 
 /* inc %dx */
 "\t.byte 0x66\n"
 "\t.byte 0xFF\n"
 "\t.byte 0xC2\n"
 
-"\tmovl %edx,r3\n"
+"\tmovl %edx," VG_SYM(r3) "\n"
 "\tpushfl\n"
-"\tpopl r4\n"
+"\tpopl " VG_SYM(r4) "\n"
 
 /* dec %edx */
 "\t.byte 0xFF\n"
 "\t.byte 0xCA\n"
 
-"\tmovl %edx,r5\n"
+"\tmovl %edx," VG_SYM(r5) "\n"
 "\tpushfl\n"
-"\tpopl r6\n"
+"\tpopl " VG_SYM(r6) "\n"
 
 /* dec %ax */
 "\t.byte 0x66\n"
 "\t.byte 0xFF\n"
 "\t.byte 0xC8\n"
 
-"\tmovl %eax,r7\n"
+"\tmovl %eax," VG_SYM(r7) "\n"
 "\tpushfl\n"
-"\tpopl r8\n"
+"\tpopl " VG_SYM(r8) "\n"
 
 "\tret\n"
 );

none/tests/x86/jcxz.c

@@ -11,12 +11,12 @@ UInt test_jcxz ( UInt arg )
    __asm__ __volatile__(
       "movl %0,%%ecx\n\t"
       "movl $0,%%eax\n"
-      ".Lxyzzy1:\n\t"
-      "jcxz .Lfoobar1\n\t"
+      "0:\n\t"
+      "jcxz 1f\n\t"
       "addl $1, %%eax\n\t"
       "subl $1, %%ecx\n\t"
-      "jmp .Lxyzzy1\n"
-      ".Lfoobar1:\n\t"
+      "jmp 0b\n"
+      "1:\n\t"
       "movl %%eax, %1"
       : /*out*/ : /*in*/ "m"(block[0]),
                          "m"(block[1]) : /*trash*/ "eax","ecx","cc","memory"
@@ -32,12 +32,12 @@ UInt test_jecxz ( UInt arg )
    __asm__ __volatile__(
       "movl %0,%%ecx\n\t"
       "movl $0,%%eax\n"
-      ".Lxyzzy2:\n\t"
-      "jecxz .Lfoobar2\n\t"
+      "0:\n\t"
+      "jecxz 1f\n\t"
       "addl $1, %%eax\n\t"
       "subl $1, %%ecx\n\t"
-      "jmp .Lxyzzy2\n"
-      ".Lfoobar2:\n\t"
+      "jmp 0b\n"
+      "1:\n\t"
       "movl %%eax, %1"
       : /*out*/ : /*in*/ "m"(block[0]),
                          "m"(block[1]) : /*trash*/ "eax","ecx","cc","memory"

none/tests/x86/lahf.c

@@ -1,9 +1,9 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 
 extern int foo_1 ( void );
 asm("\n"
-"foo_1:\n"
+VG_SYM(foo_1) ":\n"
 "\tpushl $0\n"
 "\tpopfl\n"
 "\tmovl $0xFFFFFFFF, %eax\n"
@@ -15,7 +15,7 @@ asm("\n"
 
 extern int foo_0 ( void );
 asm("\n"
-"foo_0:\n"
+VG_SYM(foo_0) ":\n"
 "\tpushl $0\n"
 "\tpopfl\n"
 "\tmovl $0x0, %eax\n"

none/tests/x86/looper.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 
 int arg = 0;
@@ -7,19 +7,18 @@ int res = 0;
 extern void loop_plain ( void );
 asm("\n"
 ".text\n"
-".globl loop_plain\n"
-"loop_plain:\n"
+VG_SYM(loop_plain) ":\n"
 "\tpushl %ecx\n"
 "\tmovl $999, %eax\n"
-"\tmovl arg, %ecx\n"
+"\tmovl " VG_SYM(arg) ", %ecx\n"
 
-".Lmn123plain:\n"
+"0:\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
-"\tloop .Lmn123plain\n"
+"\tloop 0b\n"
 
-"\tmovl %eax, res\n"
+"\tmovl %eax, " VG_SYM(res) "\n"
 "\tpopl %ecx\n"
 "\tret\n"
 );
@@ -27,19 +26,18 @@ asm("\n"
 extern void loop_ne ( void );
 asm("\n"
 ".text\n"
-".globl loop_ne\n"
-"loop_ne:\n"
+VG_SYM(loop_ne) ":\n"
 "\tpushl %ecx\n"
 "\tmovl $999, %eax\n"
-"\tmovl arg, %ecx\n"
+"\tmovl " VG_SYM(arg) ", %ecx\n"
 
-".Lmn123ne:\n"
+"0:\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
-"\tloopne .Lmn123ne\n"
+"\tloopne 0b\n"
 
-"\tmovl %eax, res\n"
+"\tmovl %eax, " VG_SYM(res) "\n"
 "\tpopl %ecx\n"
 "\tret\n"
 );
@@ -47,13 +45,12 @@ asm("\n"
 extern void loop_e ( void );
 asm("\n"
 ".text\n"
-".globl loop_e\n"
-"loop_e:\n"
+VG_SYM(loop_e) ":\n"
 "\tpushl %ecx\n"
 "\tmovl $999, %eax\n"
-"\tmovl arg, %ecx\n"
+"\tmovl " VG_SYM(arg) ", %ecx\n"
 
-".Lmn123e:\n"
+"0:\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
 "\tdecl %eax\n"
@@ -61,9 +58,9 @@ asm("\n"
 "\tpushfl\n"
 "\txorl $64, 0(%esp)\n"
 "\tpopfl\n"
-"\tloope .Lmn123e\n"
+"\tloope 0b\n"
 
-"\tmovl %eax, res\n"
+"\tmovl %eax, " VG_SYM(res) "\n"
 "\tpopl %ecx\n"
 "\tret\n"
 );

none/tests/x86/sbbmisc.c

@@ -1,4 +1,4 @@
-
+#include "tests/asm.h"
 #include <stdio.h>
 
 char in_b, out_b1, out_b2, in_b2;
@@ -9,17 +9,17 @@ int in_l, out_l1, out_l2;
 
 extern void sbb_ib_al ( void );
 asm("\n"
-"sbb_ib_al:\n"
+VG_SYM(sbb_ib_al) ":\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tclc\n"
 "\tsbbb $5, %al\n"
-"\tmovb %al, out_b1\n"
+"\tmovb %al, " VG_SYM(out_b1) "\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tstc\n"
 "\tsbbb $5, %al\n"
-"\tmovb %al, out_b2\n"
+"\tmovb %al, " VG_SYM(out_b2) "\n"
 
 "\tret\n"
 );
@@ -27,17 +27,17 @@ asm("\n"
 
 extern void sbb_iw_ax ( void );
 asm("\n"
-"sbb_iw_ax:\n"
+VG_SYM(sbb_iw_ax) ":\n"
 
-"\tmovw in_w, %ax\n"
+"\tmovw " VG_SYM(in_w) ", %ax\n"
 "\tclc\n"
 "\tsbbw $555, %ax\n"
-"\tmovw %ax, out_w1\n"
+"\tmovw %ax, " VG_SYM(out_w1) "\n"
 
-"\tmovw in_w, %ax\n"
+"\tmovw " VG_SYM(in_w) ", %ax\n"
 "\tstc\n"
 "\tsbbw $555, %ax\n"
-"\tmovw %ax, out_w2\n"
+"\tmovw %ax, " VG_SYM(out_w2) "\n"
 
 "\tret\n"
 );
@@ -45,17 +45,17 @@ asm("\n"
 
 extern void sbb_il_eax ( void );
 asm("\n"
-"sbb_il_eax:\n"
+VG_SYM(sbb_il_eax) ":\n"
 
-"\tmovl in_l, %eax\n"
+"\tmovl " VG_SYM(in_l) ", %eax\n"
 "\tclc\n"
 "\tsbbl $555666, %eax\n"
-"\tmovl %eax, out_l1\n"
+"\tmovl %eax, " VG_SYM(out_l1) "\n"
 
-"\tmovl in_l, %eax\n"
+"\tmovl " VG_SYM(in_l) ", %eax\n"
 "\tstc\n"
 "\tsbbl $555666, %eax\n"
-"\tmovl %eax, out_l2\n"
+"\tmovl %eax, " VG_SYM(out_l2) "\n"
 
 "\tret\n"
 );
@@ -63,17 +63,17 @@ asm("\n"
 
 extern void sbb_eb_gb ( void );
 asm("\n"
-"sbb_eb_gb:\n"
+VG_SYM(sbb_eb_gb) ":\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tclc\n"
-"\tsbbb in_b2, %al\n"
-"\tmovb %al, out_b1\n"
+"\tsbbb " VG_SYM(in_b2) ", %al\n"
+"\tmovb %al, " VG_SYM(out_b1) "\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tstc\n"
-"\tsbbb in_b2, %al\n"
-"\tmovb %al, out_b2\n"
+"\tsbbb " VG_SYM(in_b2) ", %al\n"
+"\tmovb %al, " VG_SYM(out_b2) "\n"
 
 "\tret\n"
 );
@@ -81,20 +81,20 @@ asm("\n"
 
 extern void sbb_eb_gb_2 ( void );
 asm("\n"
-"sbb_eb_gb_2:\n"
+VG_SYM(sbb_eb_gb_2) ":\n"
 "\tpushl %ecx\n"
 
-"\tmovb in_b, %cl\n"
-"\tmovb in_b2, %dh\n"
+"\tmovb " VG_SYM(in_b) ", %cl\n"
+"\tmovb " VG_SYM(in_b2) ", %dh\n"
 "\tclc\n"
 "\tsbbb %dh,%cl\n"
-"\tmovb %cl, out_b1\n"
+"\tmovb %cl, " VG_SYM(out_b1) "\n"
 
-"\tmovb in_b, %cl\n"
-"\tmovb in_b2, %dh\n"
+"\tmovb " VG_SYM(in_b) ", %cl\n"
+"\tmovb " VG_SYM(in_b2) ", %dh\n"
 "\tstc\n"
 "\tsbbb %dh,%cl\n"
-"\tmovb %cl, out_b2\n"
+"\tmovb %cl, " VG_SYM(out_b2) "\n"
 
 "\tpopl %ecx\n"
 "\tret\n"
@@ -103,17 +103,17 @@ asm("\n"
 
 extern void adc_eb_gb ( void );
 asm("\n"
-"adc_eb_gb:\n"
+VG_SYM(adc_eb_gb) ":\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tclc\n"
-"\tadcb in_b2, %al\n"
-"\tmovb %al, out_b1\n"
+"\tadcb " VG_SYM(in_b2) ", %al\n"
+"\tmovb %al, " VG_SYM(out_b1) "\n"
 
-"\tmovb in_b, %al\n"
+"\tmovb " VG_SYM(in_b) ", %al\n"
 "\tstc\n"
-"\tadcb in_b2, %al\n"
-"\tmovb %al, out_b2\n"
+"\tadcb " VG_SYM(in_b2) ", %al\n"
+"\tmovb %al, " VG_SYM(out_b2) "\n"
 
 "\tret\n"
 );
@@ -121,20 +121,20 @@ asm("\n"
 
 extern void adc_eb_gb_2 ( void );
 asm("\n"
-"adc_eb_gb_2:\n"
+VG_SYM(adc_eb_gb_2) ":\n"
 "\tpushl %ecx\n"
 
-"\tmovb in_b, %cl\n"
-"\tmovb in_b2, %dh\n"
+"\tmovb " VG_SYM(in_b) ", %cl\n"
+"\tmovb " VG_SYM(in_b2) ", %dh\n"
 "\tclc\n"
 "\tadcb %dh,%cl\n"
-"\tmovb %cl, out_b1\n"
+"\tmovb %cl, " VG_SYM(out_b1) "\n"
 
-"\tmovb in_b, %cl\n"
-"\tmovb in_b2, %dh\n"
+"\tmovb " VG_SYM(in_b) ", %cl\n"
+"\tmovb " VG_SYM(in_b2) ", %dh\n"
 "\tstc\n"
 "\tadcb %dh,%cl\n"
-"\tmovb %cl, out_b2\n"
+"\tmovb %cl, " VG_SYM(out_b2) "\n"
 
 "\tpopl %ecx\n"
 "\tret\n"

none/tests/x86/ssse3_misaligned.c

@@ -1,5 +1,5 @@
 
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -8,9 +8,7 @@
 
 void maybe_fault ( int delta )
 {
-   char* x = memalign(16/*alignment*/,32/*size*/);
-   assert(x);
-   assert(0 == ((16-1) & (unsigned long)x));
+   char* x = memalign16(32);
    memset(x, 0, 32);
    __asm__ __volatile__(
       "pabsb (%0),%%xmm7"

perf/Makefile.am

@@ -1,6 +1,5 @@
 
-# For AM_FLAG_M3264_PRI
-include $(top_srcdir)/Makefile.flags.am
+include $(top_srcdir)/Makefile.tool-tests.am
 
 noinst_SCRIPTS = vg_perf
 
@@ -18,9 +17,9 @@ EXTRA_DIST = $(noinst_SCRIPTS) \
 check_PROGRAMS = \
 	bigcode bz2 fbench ffbench heap sarp tinycc
 
-AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/include -I$(top_builddir)/include
-AM_CFLAGS   = -Winline -Wall -Wshadow -g -O $(AM_FLAG_M3264_PRI)
-AM_CXXFLAGS = $(AM_CFLAGS)
+AM_CFLAGS   += -O $(AM_FLAG_M3264_PRI)
+AM_CXXFLAGS += -O $(AM_FLAG_M3264_PRI)
+
 
 # Extra stuff
 bz2_CFLAGS	= $(AM_CFLAGS) -Wno-inline

perf/bigcode.c

@@ -10,7 +10,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
-#include <sys/mman.h>
+#include "tests/sys_mman.h"
 
 #define FN_SIZE   996      // Must be big enough to hold the compiled f()
 #define N_LOOPS   20000    // Should be divisible by four

perf/bz2.c

@@ -6412,7 +6412,7 @@ void set_inbuf ( void )
 }
 
 #include <stdio.h>
-#include <malloc.h>
+#include "tests/malloc.h"
 #include <assert.h>
 
 /* For providing services. */

tests/Makefile.am

@@ -11,6 +11,11 @@ noinst_SCRIPTS = \
 	platform_test \
 	vg_regtest
 
+noinst_HEADERS = \
+	asm.h \
+	malloc.h \
+	sys_mman.h
+
 EXTRA_DIST = $(noinst_SCRIPTS)
 
 check_PROGRAMS = \