Format string fixes for ppc{32,64}-aix5.

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

diff --git a/coregrind/m_debuginfo/readxcoff.c b/coregrind/m_debuginfo/readxcoff.c
index 80846fe8c72544994ec4e48fed7f3b919a1603fc..a21fe3c616ba33c047caae95a23a4ccc530988a7 100644 (file)
--- a/coregrind/m_debuginfo/readxcoff.c
+++ b/coregrind/m_debuginfo/readxcoff.c
@@ -480,7 +480,7 @@ Bool get_csect_bounds ( UChar* start, UWord n_entries,
    if (cssym->n_sclass == C_EXT || cssym->n_sclass == C_HIDEXT) {
       if (cssym->n_numaux == 1) {
          if (CSECT_SMTYP(csaux) == XTY_SD) {
-            if (0) VG_(printf)("GCB: SD: len is %ld\n", CSECT_LEN(csaux));
+            if (0) VG_(printf)("GCB: SD: len is %lld\n", (Long)CSECT_LEN(csaux));
             *first = (UChar*)(cssym->n_value);
             *last = *first + CSECT_LEN(csaux)-1;
            return True;
@@ -635,7 +635,7 @@ HChar* read_symbol_table (
                pot for phase 2. */
             XCoffSym cand;
             if (0) VG_(printf)("SD: len is %d\n", (Int)CSECT_LEN(aux));
-            if (0) VG_(printf)("SD: proposed %p\n", sym->n_value);
+            if (0) VG_(printf)("SD: proposed %#llx\n", (ULong)sym->n_value);
             init_XCoffSym(&cand);
             cand.first = sym->n_value;
             cand.last = cand.first + (UWord)CSECT_LEN(aux) - 1;
@@ -677,7 +677,8 @@ HChar* read_symbol_table (
                   VG_(printf)("LD: in a csect %p %p\n", 
                               csect_first, csect_last);
                   VG_(printf)("CAND: %p .. %p  %s\n", 
-                              (void*)sym->n_value, (void*)csect_last, name);
+                              (void*)sym->n_value, (void*)csect_last, 
+                              "fixme-Name-printing(1)" /*name*/);
                }
                cand.first = sym->n_value;
                cand.last = (Addr)csect_last;
@@ -686,7 +687,8 @@ HChar* read_symbol_table (
                   VG_(printf)("LD: can't compute csect bounds?!\n");
                   VG_(printf)("CAND: %p .. %p  %s\n", 
                               (HChar*)sym->n_value,
-                              (HChar*)sym->n_value+1, name);
+                              (HChar*)sym->n_value+1,
+                               "fixme-Name-printing(2)" /*name*/);
                }
                cand.first = sym->n_value;
                cand.last = cand.first + 1;
@@ -965,7 +967,7 @@ HChar* read_symbol_table (
          if (SHOW && SHOW_SYMS_P3)
             VG_(printf)("Phase3: %5d+%d  BINCL     %s\n",
                          i-1-sym->n_numaux, (Int)sym->n_numaux, 
-                         name );
+                         "fixme-Name-printing(3)" /*name*/ );
          continue;
       }
       /* --- END C_BINCL [beginning of include] --- */
@@ -976,7 +978,7 @@ HChar* read_symbol_table (
          if (SHOW && SHOW_SYMS_P3)
             VG_(printf)("Phase3: %5d+%d  EINCL     %s\n",
                          i-1-sym->n_numaux, (Int)sym->n_numaux, 
-                         name );
+                         "fixme-Name-printing(4)" /*name*/ );
          continue;
       }
       /* --- END C_EINCL [end of include] --- */
@@ -1073,7 +1075,7 @@ HChar* read_symbol_table (
                /* also take the opportunity to trim the symbol's
                   length to something less than established by the
                   initial estimation done by Phases 1 and 2. */
-               if (0) VG_(printf)("trim end from %p to %p\n", 
+               if (0) VG_(printf)("trim end from %#lx to %#lx\n", 
                                   p3currsym->last, fn_end_avma);
                p3currsym->last = fn_end_avma;
             }
@@ -1371,7 +1373,7 @@ HChar* read_symbol_table (
       VG_(printf)("--- BEGIN kludged Phase5 (find TOC pointers) ---\n");
 
    if (SHOW)
-      VG_(printf)("Phase5: actual data segment: %p %p\n",
+      VG_(printf)("Phase5: actual data segment: %#lx %#lx\n",
                   di->data_avma, di->data_avma + di->data_size);
 
    /* Skip obviously-missing data sections. */
@@ -1529,11 +1531,12 @@ HChar* read_symbol_table (
             dis.name = ML_(addStr)(di, &s->name.vec[0], nlen-0 );
          ML_(addSym)( di, &dis );
          if (0 && s->r2known)
-            VG_(printf)("r2 known for %s\n", s->name);
+            VG_(printf)("r2 known for %s\n",
+                        "fixme-Name-printing(5)" /*s->name*/ );
 
         if (guessed_toc)
             VG_(message)(Vg_DebugMsg, "WARNING: assuming toc 0x%lx for %s", 
-                                      s->r2value, s->name);
+                                      s->r2value, dis.name);
       }
    }
 
@@ -1554,14 +1557,14 @@ static void show_loader_section ( struct _DebugInfo* di,
    UChar* strtab_import = NULL;
    UChar* strtab_other  = NULL;
    if (SHOW) {
-      VG_(printf)("   l_version           %lu\n", hdr->l_version);
-      VG_(printf)("   l_nsyms             %ld\n", hdr->l_nsyms);
-      VG_(printf)("   l_nreloc            %ld\n", hdr->l_nreloc);
-      VG_(printf)("   l_istlen (i st len) %ld\n", hdr->l_istlen);
-      VG_(printf)("   l_impoff (i st off) %lu\n", hdr->l_impoff);
-      VG_(printf)("   l_nimpid (# imps)   %ld\n", hdr->l_nimpid);
-      VG_(printf)("   l_stlen  (st len)   %lu\n", hdr->l_stlen);
-      VG_(printf)("   l_stoff  (st off)   %lu\n", hdr->l_stoff);
+      VG_(printf)("   l_version           %llu\n", (ULong)hdr->l_version);
+      VG_(printf)("   l_nsyms             %lld\n", (Long)hdr->l_nsyms);
+      VG_(printf)("   l_nreloc            %lld\n", (Long)hdr->l_nreloc);
+      VG_(printf)("   l_istlen (i st len) %lld\n", (Long)hdr->l_istlen);
+      VG_(printf)("   l_impoff (i st off) %llu\n", (ULong)hdr->l_impoff);
+      VG_(printf)("   l_nimpid (# imps)   %llu\n", (ULong)hdr->l_nimpid);
+      VG_(printf)("   l_stlen  (st len)   %llu\n", (ULong)hdr->l_stlen);
+      VG_(printf)("   l_stoff  (st off)   %llu\n", (ULong)hdr->l_stoff);
    }
 
    if (hdr->l_istlen > 0)
@@ -1571,8 +1574,8 @@ static void show_loader_section ( struct _DebugInfo* di,
 
    if (strtab_import) {
       if (SHOW)
-         VG_(printf)("   Loader Import String Table: %lu bytes\n", 
-                     hdr->l_istlen);
+         VG_(printf)("   Loader Import String Table: %llu bytes\n", 
+                     (ULong)hdr->l_istlen);
       i = 0;
       j = 0;
       while (1) {
@@ -1594,8 +1597,8 @@ static void show_loader_section ( struct _DebugInfo* di,
 
    if (strtab_other) {
       if (SHOW)
-         VG_(printf)("   Loader Other String Table: %lu bytes\n", 
-                     hdr->l_stlen);
+         VG_(printf)("   Loader Other String Table: %llu bytes\n", 
+                     (ULong)hdr->l_stlen);
       i = 0;
       while (1) {
          int len = 0;
@@ -1622,7 +1625,7 @@ static void show_loader_section ( struct _DebugInfo* di,
    }
 
    if (SHOW)
-      VG_(printf)("   Loader Symbol Table: %ld entries\n", hdr->l_nsyms);
+      VG_(printf)("   Loader Symbol Table: %lld entries\n", (Long)hdr->l_nsyms);
    LDSYM* sym = (LDSYM*)(oi_start + sizeof(LDHDR));
    for (i = 0; i < hdr->l_nsyms; i++) {
       Name name = maybeDerefStrTab( (SYMENT*)&sym[i],
@@ -1648,12 +1651,12 @@ static void show_loader_section ( struct _DebugInfo* di,
 
    LDREL* rel = (LDREL*)(&sym[hdr->l_nsyms]);
    if (SHOW)
-      VG_(printf)("   Loader Relocation Table: %ld entries\n", 
-                  hdr->l_nreloc);
+      VG_(printf)("   Loader Relocation Table: %lld entries\n", 
+                  (Long)hdr->l_nreloc);
    for (i = 0; i < hdr->l_nreloc; i++) {
       if (SHOW && SHOW_LD_RELTAB)
-         VG_(printf)("      %3d:  va %016llx  sym %2ld  rty 0x%4x  sec %2d\n",
-                     i, (ULong)rel[i].l_vaddr, rel[i].l_symndx, 
+         VG_(printf)("      %3d:  va %016llx  sym %2lld  rty 0x%4x  sec %2d\n",
+                     i, (ULong)rel[i].l_vaddr, (Long)rel[i].l_symndx, 
                         (Int)rel[i].l_rtype, (Int)rel[i].l_rsecnm);
    }
 
@@ -1729,12 +1732,12 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
 #  endif
 
    if (SHOW) {
-      VG_(printf)("   # of sections     %u\n",     (UInt)t_filehdr->f_nscns);
-      VG_(printf)("   time/date         0x%08lx\n", t_filehdr->f_timdat);
-      VG_(printf)("   symtab foffset    %lu\n", t_filehdr->f_symptr);
-      VG_(printf)("   # symtab entries  %lu\n", t_filehdr->f_nsyms);
-      VG_(printf)("   size of aux hdr   %u\n", (UInt)t_filehdr->f_opthdr);
-      VG_(printf)("   flags             0x%04x\n", (UInt)t_filehdr->f_flags);
+      VG_(printf)("   # of sections     %u\n",       (UInt)t_filehdr->f_nscns);
+      VG_(printf)("   time/date         0x%08llx\n", (ULong)t_filehdr->f_timdat);
+      VG_(printf)("   symtab foffset    %llu\n",     (ULong)t_filehdr->f_symptr);
+      VG_(printf)("   # symtab entries  %llu\n",     (ULong)t_filehdr->f_nsyms);
+      VG_(printf)("   size of aux hdr   %llu\n",     (ULong)t_filehdr->f_opthdr);
+      VG_(printf)("   flags             0x%04x\n",   (UInt)t_filehdr->f_flags);
       if (t_filehdr->f_flags) {
          VG_(printf)("                     ");
          if (t_filehdr->f_flags & F_RELFLG)    VG_(printf)("NoRelocInfo ");
@@ -1801,13 +1804,15 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
          VG_(printf)("   magic        0x%04x (should be 0x010b)\n", 
                      (UInt)t_auxhdr->magic);
          VG_(printf)("   vstamp       0x%04x\n", (UInt)t_auxhdr->vstamp);
-         VG_(printf)("   tsize        %ld\n", t_auxhdr->tsize);
-         VG_(printf)("   dsize        %ld\n", t_auxhdr->dsize);
-         VG_(printf)("   bsize        %ld\n", t_auxhdr->bsize);
-         VG_(printf)("   entry        0x%lx\n", t_auxhdr->entry);
-         VG_(printf)("   text_start   0x%lx (stated)\n", t_auxhdr->text_start);
-         VG_(printf)("   data_start   0x%lx (stated)\n", t_auxhdr->data_start);
-         VG_(printf)("   o_toc        0x%lx\n", t_auxhdr->o_toc);
+         VG_(printf)("   tsize        %lld\n", (Long)t_auxhdr->tsize);
+         VG_(printf)("   dsize        %lld\n", (Long)t_auxhdr->dsize);
+         VG_(printf)("   bsize        %lld\n", (Long)t_auxhdr->bsize);
+         VG_(printf)("   entry        0x%llx\n", (ULong)t_auxhdr->entry);
+         VG_(printf)("   text_start   0x%llx (stated)\n",
+                     (ULong)t_auxhdr->text_start);
+         VG_(printf)("   data_start   0x%llx (stated)\n",
+                     (ULong)t_auxhdr->data_start);
+         VG_(printf)("   o_toc        0x%llx\n", (ULong)t_auxhdr->o_toc);
          VG_(printf)("   o_snentry    %d\n", (Int)t_auxhdr->o_snentry);
          VG_(printf)("   o_sntext     %d\n", (Int)t_auxhdr->o_sntext);
          VG_(printf)("   o_sndata     %d\n", (Int)t_auxhdr->o_sndata);
@@ -1821,8 +1826,8 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
                      (UChar)t_auxhdr->o_modtype[1] );
          VG_(printf)("   o_cpuflag    0x%02x\n", (UInt)t_auxhdr->o_cpuflag);
          VG_(printf)("   o_cputype    0x%02x\n", (UInt)t_auxhdr->o_cputype);
-         VG_(printf)("   o_maxstack   %lu\n", t_auxhdr->o_maxstack);
-         VG_(printf)("   o_maxdata    %lu\n", t_auxhdr->o_maxdata);
+         VG_(printf)("   o_maxstack   %llu\n", (ULong)t_auxhdr->o_maxstack);
+         VG_(printf)("   o_maxdata    %llu\n", (ULong)t_auxhdr->o_maxdata);
          VG_(printf)("   o_debugger   %u\n", t_auxhdr->o_debugger);
          /* printf("   o_textpsize  %u\n", (UInt)t_auxhdr->o_textpsize); */
          /* printf("   o_stackpsize %u\n", (UInt)t_auxhdr->o_stackpsize); */
@@ -1877,16 +1882,16 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
       if (SHOW) {
          VG_(printf)("   --- #%d ---\n", i);
          VG_(printf)("   s_name    %s\n", sname_safe);
-         VG_(printf)("   s_paddr   0x%lx\n", t_scnhdr[i].s_paddr);
-         VG_(printf)("   s_vaddr   0x%lx\n", t_scnhdr[i].s_vaddr);
-         VG_(printf)("   s_size    %ld\n", t_scnhdr[i].s_size);
-         VG_(printf)("   s_scnptr  %ld\n", t_scnhdr[i].s_scnptr);
-         VG_(printf)("   s_relptr  %ld\n", t_scnhdr[i].s_relptr);
-         VG_(printf)("   s_lnnoptr %ld\n", t_scnhdr[i].s_lnnoptr);
-         VG_(printf)("   s_nreloc  %u\n", (UInt)t_scnhdr[i].s_nreloc);
-         VG_(printf)("   s_nlnno   %u\n", (UInt)t_scnhdr[i].s_nlnno);
-         VG_(printf)("   s_flags   0x%lx (%s)\n", 
-                     t_scnhdr[i].s_flags,
+         VG_(printf)("   s_paddr   0x%llx\n", (ULong)t_scnhdr[i].s_paddr);
+         VG_(printf)("   s_vaddr   0x%llx\n", (ULong)t_scnhdr[i].s_vaddr);
+         VG_(printf)("   s_size    %lld\n",   (Long)t_scnhdr[i].s_size);
+         VG_(printf)("   s_scnptr  %lld\n",   (Long)t_scnhdr[i].s_scnptr);
+         VG_(printf)("   s_relptr  %lld\n",   (Long)t_scnhdr[i].s_relptr);
+         VG_(printf)("   s_lnnoptr %lld\n",   (Long)t_scnhdr[i].s_lnnoptr);
+         VG_(printf)("   s_nreloc  %llu\n",   (ULong)t_scnhdr[i].s_nreloc);
+         VG_(printf)("   s_nlnno   %llu\n",   (ULong)t_scnhdr[i].s_nlnno);
+         VG_(printf)("   s_flags   0x%llx (%s)\n", 
+                     (ULong)t_scnhdr[i].s_flags,
                      name_of_scnhdr_s_flags(t_scnhdr[i].s_flags));
       }
       /* find the stabs strings */
@@ -2071,7 +2076,7 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
 
    /* ------------ Symbol Table ------------ */
    if (SHOW)
-      VG_(printf)("\nSymbol Table: %ld entries\n", t_filehdr->f_nsyms);
+      VG_(printf)("\nSymbol Table: %llu entries\n", (ULong)t_filehdr->f_nsyms);
    cursor = oimage;
    cursor += t_filehdr->f_symptr;
    HChar* badness = read_symbol_table( 
@@ -2092,7 +2097,7 @@ Bool read_xcoff_mapped_object ( struct _DebugInfo* di,
    /* ------------ String Table ------------ */
    if (oi_strtab) {
       if (SHOW)
-         VG_(printf)("\nString Table: %u bytes\n", oi_n_strtab);
+         VG_(printf)("\nString Table: %lu bytes\n", oi_n_strtab);
       i = 4;
       while (1) {
          if (i >= oi_n_strtab)
@@ -2416,10 +2421,10 @@ Bool ML_(read_xcoff_debug_info) ( struct _DebugInfo* di,
 
    if (VG_(clo_verbosity) > 1 || VG_(clo_trace_redir)) {
       if (di->memname) {
-         VG_(message)(Vg_DebugMsg, "Reading syms from %s(%s) (%p)",
+         VG_(message)(Vg_DebugMsg, "Reading syms from %s(%s) (%#lx)",
                       di->filename, di->memname, di->text_avma);
       } else {
-         VG_(message)(Vg_DebugMsg, "Reading syms from %s (%p)",
+         VG_(message)(Vg_DebugMsg, "Reading syms from %s (%#lx)",
                       di->filename, di->text_avma);
       }
    }
@@ -2429,10 +2434,10 @@ Bool ML_(read_xcoff_debug_info) ( struct _DebugInfo* di,
       VG_(printf)("---         file: %s\n",  di->filename);
       VG_(printf)("---          mem: %s\n",  di->memname ? di->memname  
                                                          : (UChar*)"(none)" );
-      VG_(printf)("--- t actual vma: %p\n",  di->text_avma);
-      VG_(printf)("--- t actual len: %ld\n", di->text_size);
-      VG_(printf)("--- d actual vma: %p\n",  di->data_avma);
-      VG_(printf)("--- d actual len: %ld\n", di->data_size);
+      VG_(printf)("--- t actual vma: %#lx\n", di->text_avma);
+      VG_(printf)("--- t actual len: %ld\n",  di->text_size);
+      VG_(printf)("--- d actual vma: %#lx\n", di->data_avma);
+      VG_(printf)("--- d actual len: %ld\n",  di->data_size);
    }
 
    if (di->memname) {

diff --git a/coregrind/m_execontext.c b/coregrind/m_execontext.c
index c701820853c7d8bd595f481cd78338fa16a44efc..dde94ff9bdb1eba04793e127d642d121c62b67aa 100644 (file)
--- a/coregrind/m_execontext.c
+++ b/coregrind/m_execontext.c
@@ -150,14 +150,14 @@ void VG_(print_ExeContext_stats) ( void )
    init_ExeContext_storage();
    VG_(message)(Vg_DebugMsg, 
       "   exectx: %'lu lists, %'llu contexts (avg %'llu per list)",
-      ec_htab_size, ec_totstored, ec_totstored / ec_htab_size
+      ec_htab_size, ec_totstored, ec_totstored / (ULong)ec_htab_size
    );
    VG_(message)(Vg_DebugMsg, 
       "   exectx: %'llu searches, %'llu full compares (%'llu per 1000)",
       ec_searchreqs, ec_searchcmps, 
       ec_searchreqs == 0 
-         ? 0L 
-         : ( (ec_searchcmps * 1000) / ec_searchreqs ) 
+         ? 0ULL 
+         : ( (ec_searchcmps * 1000ULL) / ec_searchreqs ) 
    );
    VG_(message)(Vg_DebugMsg, 
       "   exectx: %'llu cmp2, %'llu cmp4, %'llu cmpAll",

diff --git a/coregrind/m_libcproc.c b/coregrind/m_libcproc.c
index cd3d771214b08c696906754929470a16b42ed48d..9ab786fc3ddda929aa935632b1bf1b2734e8a00b 100644 (file)
--- a/coregrind/m_libcproc.c
+++ b/coregrind/m_libcproc.c
@@ -234,7 +234,7 @@ Int VG_(waitpid)(Int pid, Int *status, Int options)
       POSIX. */
    SysRes res = VG_(do_syscall5)(__NR_AIX5_kwaitpid, 
                                  (UWord)status, pid, 4 | options,0,0);
-   if (0) VG_(printf)("waitpid: got 0x%x 0x%x\n", res.res, res.err);
+   if (0) VG_(printf)("waitpid: got 0x%lx 0x%lx\n", res.res, res.err);
    return res.isError ? -1 : res.res;
 #  else
 #    error Unknown OS

diff --git a/coregrind/m_main.c b/coregrind/m_main.c
index 9773b4767ebc6bff5296eb7245e2ec2649f14046..a4bb850a545531d13a54837c31fa03d8697306fd 100644 (file)
--- a/coregrind/m_main.c
+++ b/coregrind/m_main.c
@@ -977,7 +977,7 @@ static void setup_file_descriptors(void)
 
    if (show)
       VG_(printf)("fd limits: host, before: cur %lu max %lu\n", 
-                  rl.rlim_cur, rl.rlim_max);
+                  (UWord)rl.rlim_cur, (UWord)rl.rlim_max);
 
 #  if defined(VGP_ppc32_aix5) || defined(VGP_ppc64_aix5)
    /* I don't know why this kludge is needed; however if rl.rlim_cur
@@ -1005,7 +1005,7 @@ static void setup_file_descriptors(void)
 
    if (show) {
       VG_(printf)("fd limits: host,  after: cur %lu max %lu\n",
-                  rl.rlim_cur, rl.rlim_max);
+                  (UWord)rl.rlim_cur, (UWord)rl.rlim_max);
       VG_(printf)("fd limits: guest       : cur %u max %u\n",
                   VG_(fd_soft_limit), VG_(fd_hard_limit));
    }

diff --git a/coregrind/m_sigframe/sigframe-ppc32-aix5.c b/coregrind/m_sigframe/sigframe-ppc32-aix5.c
index 2cad8bf3df1b509cfaf138ebc8569ab09b52f686..37b037e37dc5f702643e8fb38d1c355c3cf5bf1d 100644 (file)
--- a/coregrind/m_sigframe/sigframe-ppc32-aix5.c
+++ b/coregrind/m_sigframe/sigframe-ppc32-aix5.c
@@ -181,8 +181,8 @@ void VG_(sigframe_create) ( ThreadId tid,
             (Addr)&frame->tramp, sizeof(frame->tramp));
 
    if (0) {
-      VG_(printf)("pushed signal frame for sig %d; R1 now = %p, "
-                  "next %%CIA = %p, status=%d\n", 
+      VG_(printf)("pushed signal frame for sig %d; R1 now = %#lx, "
+                  "next %%CIA = %#x, status=%d\n", 
                   sigNo,
                  sp, tst->arch.vex.guest_CIA, tst->status);
       VG_(printf)("trampoline is at %p\n",  &frame->tramp[0]);
@@ -219,7 +219,7 @@ void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
 
    if (VG_(clo_trace_signals))
       VG_(message)(Vg_DebugMsg,
-                   "vg_pop_signal_frame (thread %d): valid magic; CIA=%p",
+                   "vg_pop_signal_frame (thread %d): valid magic; CIA=%#x",
                    tid, tst->arch.vex.guest_CIA);
 
    VG_TRACK( die_mem_stack_signal, 

diff --git a/coregrind/m_sigframe/sigframe-ppc64-aix5.c b/coregrind/m_sigframe/sigframe-ppc64-aix5.c
index 610993ea8f2cac44369f1492f449c4cf7b681922..757a7aa8ce385c1a9ffaf3e01e7e23d641d17d28 100644 (file)
--- a/coregrind/m_sigframe/sigframe-ppc64-aix5.c
+++ b/coregrind/m_sigframe/sigframe-ppc64-aix5.c
@@ -181,8 +181,8 @@ void VG_(sigframe_create) ( ThreadId tid,
             (Addr)&frame->tramp, sizeof(frame->tramp));
 
    if (0) {
-      VG_(printf)("pushed signal frame for sig %d; R1 now = %p, "
-                  "next %%CIA = %p, status=%d\n", 
+      VG_(printf)("pushed signal frame for sig %d; R1 now = %#lx, "
+                  "next %%CIA = %#llx, status=%d\n", 
                   sigNo,
                  sp, tst->arch.vex.guest_CIA, tst->status);
       VG_(printf)("trampoline is at %p\n",  &frame->tramp[0]);
@@ -253,7 +253,7 @@ void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
 
    if (VG_(clo_trace_signals))
       VG_(message)(Vg_DebugMsg,
-                   "vg_pop_signal_frame (thread %d): valid magic; CIA=%p",
+                   "vg_pop_signal_frame (thread %d): valid magic; CIA=%#llx",
                    tid, tst->arch.vex.guest_CIA);
 
    VG_TRACK( die_mem_stack_signal, 

diff --git a/coregrind/m_signals.c b/coregrind/m_signals.c
index 3e8049229c1b935fa7c49be5ef2b4f627ed0c416..370c59a1bed3a19a44a7d92106e21a65d815590e 100644 (file)
--- a/coregrind/m_signals.c
+++ b/coregrind/m_signals.c
@@ -661,9 +661,9 @@ static void handle_SCSS_change ( Bool force_update )
             "setting ksig %d to: hdlr %p, flags 0x%lx, "
             "mask(63..0) 0x%lx 0x%lx",
             sig, ksa.ksa_handler,
-            ksa.sa_flags,
-            ksa.sa_mask.sig[1], 
-            ksa.sa_mask.sig[0] 
+            (UWord)ksa.sa_flags,
+            (UWord)ksa.sa_mask.sig[1], 
+            (UWord)ksa.sa_mask.sig[0] 
          );
 
       res = VG_(sigaction)( sig, &ksa, &ksa_old );
@@ -884,13 +884,15 @@ const Char *format_sigset ( const vki_sigset_t* set )
 
    for (w = _VKI_NSIG_WORDS - 1; w >= 0; w--)
    {
-#if _VKI_NSIG_BPW == 32
-      VG_(sprintf)(buf + VG_(strlen)(buf), "%08lx", set ? set->sig[w] : 0);
-#elif _VKI_NSIG_BPW == 64
-      VG_(sprintf)(buf + VG_(strlen)(buf), "%16lx", set ? set->sig[w] : 0);
-#else
-#error "Unsupported value for _VKI_NSIG_BPW"
-#endif
+#     if _VKI_NSIG_BPW == 32
+      VG_(sprintf)(buf + VG_(strlen)(buf), "%08llx",
+                   set ? (ULong)set->sig[w] : 0);
+#     elif _VKI_NSIG_BPW == 64
+      VG_(sprintf)(buf + VG_(strlen)(buf), "%16llx",
+                   set ? (ULong)set->sig[w] : 0);
+#     else
+#       error "Unsupported value for _VKI_NSIG_BPW"
+#     endif
    }
 
    return buf;
@@ -1982,7 +1984,7 @@ void pp_ksigaction ( struct vki_sigaction* sa )
 #              if !defined(VGP_ppc32_aix5) && !defined(VGP_ppc64_aix5)
                   sa->sa_restorer
 #              else
-                  0
+                  (void*)0
 #              endif
               );
    VG_(printf)("pp_ksigaction: { ");

diff --git a/coregrind/m_syswrap/syswrap-aix5.c b/coregrind/m_syswrap/syswrap-aix5.c
index 328f13f2c7c1b90b64260f9efaf006c130d29bcf..a3307355d5acdb656610c4eeb99c6237a4ce823b 100644 (file)
--- a/coregrind/m_syswrap/syswrap-aix5.c
+++ b/coregrind/m_syswrap/syswrap-aix5.c
@@ -184,7 +184,7 @@ Bool ML_(aix5_force_thread_into_pthread_exit)( ThreadId tid )
                                    &ent, &toc);
    if (found) {
       if (0) 
-         VG_(printf)("THREAD CANCELED, new cia,toc = %p,%p\n", ent, toc);
+         VG_(printf)("THREAD CANCELED, new cia,toc = %#lx,%#lx\n", ent, toc);
       tst->arch.vex.guest_CIA  = ent;
       tst->arch.vex.guest_GPR2 = toc;
       tst->arch.vex.guest_GPR3 = (Word)(-1); /* == PTHREAD_CANCELED */
@@ -383,7 +383,7 @@ void ML_(aix5debugstuff_show_tstate) ( Addr tsA, HChar* who )
       if ((i == _NGPRS-1) || ((i % step) == step-1 && i > 0)) 
          VG_(printf)("\n");
    }
-   VG_(printf)("  [iar] %p %s\n", ts->mst.iar, 
+   VG_(printf)("  [iar] %#llx %s\n", (ULong)ts->mst.iar, 
                ML_(aix5debugstuff_pc_to_fnname)(ts->mst.iar));
 
    VG_(printf)("  errnop_addr      %p\n", ts->errnop_addr);
@@ -416,7 +416,7 @@ void ML_(aix5debugstuff_show_tstate) ( Addr tsA, HChar* who )
       HChar* s = ML_(aix5debugstuff_pc_to_fnname)( (Addr)p[i] );
       if (0==VG_(strcmp)(s,"???"))
          continue;
-      VG_(printf)("  [%d] %p %s\n", i, p[i], s);
+      VG_(printf)("  [%d] %x %s\n", i, p[i], s);
    }
    VG_(printf)("}\n");
 }
@@ -445,7 +445,7 @@ void ML_(aix5debugstuff_show_tstate) ( Addr tsA, HChar* who )
 
 PRE(sys___libc_sbrk)
 {
-   PRINT("__libc_sbrk (BOGUS HANDLER)( %p )",ARG1);
+   PRINT("__libc_sbrk (BOGUS HANDLER)( %#lx )",ARG1);
    PRE_REG_READ1(long, "__libc_sbrk", long, arg1);
    /* After a zero sbrk, disallow aspacem from doing sbrk, since libc
       might rely on the value returned by this syscall. */
@@ -473,7 +473,7 @@ POST(sys___libc_sbrk)
 
 PRE(sys___msleep)
 {
-   PRINT("__msleep (BOGUS HANDLER) ( %p )", ARG1);
+   PRINT("__msleep (BOGUS HANDLER) ( %#lx )", ARG1);
    PRE_REG_READ1(long, "msleep", void*, arg1);
 }
 
@@ -481,7 +481,7 @@ PRE(sys___msleep)
 
 PRE(sys__clock_settime)
 {
-   PRINT("_clock_settime (UNDOCUMENTED) ( %d, %p )", ARG1, ARG2);
+   PRINT("_clock_settime (UNDOCUMENTED) ( %ld, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(int, "_clock_settime", int, arg1, int, arg2);
 }
 
@@ -489,7 +489,7 @@ PRE(sys__exit)
 {
    ThreadState* tst;
    /* simple; just make this thread exit */
-   PRINT("_exit( %d )", ARG1);
+   PRINT("_exit( %ld )", ARG1);
    PRE_REG_READ1(void, "exit", int, exitcode);
 
    tst = VG_(get_ThreadState)(tid);
@@ -528,7 +528,7 @@ PRE(sys__getpriority)
 PRE(sys__nsleep)
 {
    *flags |= SfMayBlock;
-   PRINT("_nsleep( %p, %p )", ARG1, ARG2);
+   PRINT("_nsleep( %#lx, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(void, "_nsleep", struct timestruc_t*, arg1,
                                   struct timestruc_t*, arg2);
    /* In 64-bit mode, struct ends in 4 padding bytes.  Hence: */
@@ -558,7 +558,7 @@ PRE(sys__poll)
    UInt i;
    struct pollfd* ufds = (struct pollfd *)ARG1;
    *flags |= SfMayBlock;
-   PRINT("_poll ( %p, %ld, %ld )\n", ARG1,ARG2,ARG3);
+   PRINT("_poll ( %#lx, %ld, %ld )\n", ARG1,ARG2,ARG3);
    PRE_REG_READ3(long, "_poll",
                  struct pollfd *, ufds, unsigned int, nfds, long, timeout);
 
@@ -586,7 +586,7 @@ PRE(sys__select)
    UInt nfds, nmqids;
    *flags |= SfMayBlock;
    /* XXX: copy of generic; I don't know if this is right or not. */
-   PRINT("_select ( %ld, %p, %p, %p, %p )", ARG1,ARG2,ARG3,ARG4,ARG5);
+   PRINT("_select ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
    PRE_REG_READ5(long, "_select",
                  int, n, struct sellist *, readfds, 
                          struct sellist *, writefds,
@@ -618,7 +618,7 @@ PRE(sys__select)
 PRE(sys__sem_wait)
 {
    *flags |= SfMayBlock;
-   PRINT("_sem_wait (BOGUS HANDLER) ( %p, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("_sem_wait (BOGUS HANDLER) ( %#lx, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "_sem_wait", void*, arg1, void*, arg2, long, arg3 );
    /* Not sure what the two pointer args are.  Hence no proper handler.*/
 }
@@ -636,7 +636,7 @@ PRE(sys__setsid)
 
 PRE(sys__sigaction) /* COL, more or less */
 {
-   PRINT("_sigaction ( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("_sigaction ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "_sigaction",
                  int, signum, const struct sigaction *, act,
                  struct sigaction *, oldact);
@@ -678,14 +678,14 @@ PRE(sys__thread_setsched)
 
 PRE(sys_access)
 {
-   PRINT("access ( %p(%s), %ld )", ARG1,ARG1, ARG2);
+   PRINT("access ( %#lx(%s), %ld )", ARG1,(Char*)ARG1, ARG2);
    PRE_REG_READ2(int, "access", char*, pathname, int, mode);
    PRE_MEM_RASCIIZ( "access(pathname)", ARG1 );
 }
 
 PRE(sys_accessx)
 {
-   PRINT("accessx ( %p(%s), %ld, %ld )", ARG1,ARG1, ARG2, ARG3);
+   PRINT("accessx ( %#lx(%s), %ld, %ld )", ARG1,(Char*)ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "accessx", char*, pathname, int, mode, int, who);
    PRE_MEM_RASCIIZ( "accessx(pathname)", ARG1 );
 }
@@ -693,7 +693,7 @@ PRE(sys_accessx)
 PRE(sys_appgetrlimit)
 {
    /* Note: assumes kernel struct == libc struct */
-   PRINT("appgetrlimit ( %ld, %p )", ARG1, ARG2);
+   PRINT("appgetrlimit ( %ld, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(int, "appgetrlimit", int, arg1, struct rlimit*, arg2);
    PRE_MEM_WRITE( "appgetrlimit(buf)", ARG2, sizeof(struct rlimit) );
 }
@@ -705,7 +705,7 @@ POST(sys_appgetrlimit)
 PRE(sys_appgetrusage)
 {
    /* Note: assumes kernel struct == libc struct */
-   PRINT("appgetrusage ( %d, %p )", ARG1, ARG2);
+   PRINT("appgetrusage ( %ld, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(int, "appgetrusage", int, arg1, struct rusage*, arg2);
    PRE_MEM_WRITE( "appgetrusage(buf)", ARG2, sizeof(struct rusage) );
 }
@@ -732,7 +732,7 @@ PRE(sys_appulimit)
 
 PRE(sys_bind)
 {
-   PRINT("bind ( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("bind ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "bind", int, socket, 
                               void*, address, int, addresslen);
    /* Hmm.  This isn't really right - see pre_mem_read_sockaddr. */
@@ -741,21 +741,21 @@ PRE(sys_bind)
 
 PRE(sys_chdir)
 {
-  PRINT("chdir ( %p(%s) )", ARG1,ARG1);
+  PRINT("chdir ( %#lx(%s) )", ARG1,(Char*)ARG1);
   PRE_REG_READ1(long, "chdir", const char *, path);
   PRE_MEM_RASCIIZ( "chdir(path)", ARG1 );
 }
 
 PRE(sys_chmod)
 {
-   PRINT("chmod ( %p(%s), 0x%lx )", ARG1,ARG1, ARG2 );
+   PRINT("chmod ( %#lx(%s), 0x%lx )", ARG1,(Char*)ARG1, ARG2 );
    PRE_REG_READ2(int, "chmod", char*, path, int, mode);
    PRE_MEM_RASCIIZ( "chmod(path)", ARG1 );
 }
 
 PRE(sys_chown)
 {
-   PRINT("chown ( %p(%s), %ld, %ld )", ARG1,ARG1, ARG2, ARG3 );
+   PRINT("chown ( %#lx(%s), %ld, %ld )", ARG1,(Char*)ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "chown", char*, path, int, owner, int, group);
    PRE_MEM_RASCIIZ( "chown(path)", ARG1 );
 }
@@ -776,7 +776,7 @@ PRE(sys_connext)
    /* Although /usr/include/net/proto_uipc.h does mention it.
       Args are apparently (int, caddr_t, int).  I suspect the
       first arg is a fd and the third a flags value. */
-   PRINT("connext (UNDOCUMENTED)( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("connext (UNDOCUMENTED)( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "connext", int, arg1, caddr_t*, arg2, int, arg3);
 }
 
@@ -831,7 +831,7 @@ PRE(sys_execve)
    Int          i, j, tot_args;
    SysRes       res;
 
-   PRINT("sys_execve ( %p(%s), %p, %p )", ARG1, ARG1, ARG2, ARG3);
+   PRINT("sys_execve ( %#lx(%s), %#lx, %#lx )", ARG1, (Char*)ARG1, ARG2, ARG3);
    PRE_REG_READ3(vki_off_t, "execve",
                  char *, filename, char **, argv, char **, envp);
    PRE_MEM_RASCIIZ( "execve(filename)", ARG1 );
@@ -1040,8 +1040,8 @@ PRE(sys_execve)
       too much of a mess to continue, so we have to abort. */
   hosed:
    vg_assert(FAILURE);
-   VG_(message)(Vg_UserMsg, "execve(%p(%s), %p, %p) failed, errno %d",
-                ARG1, ARG1, ARG2, ARG3, ERR);
+   VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx) failed, errno %ld",
+                ARG1, (Char*)ARG1, ARG2, ARG3, ERR);
    VG_(message)(Vg_UserMsg, "EXEC FAILED: I can't recover from "
                             "execve() failing, so I'm dying.");
    VG_(message)(Vg_UserMsg, "Add more stringent tests in PRE(sys_execve), "
@@ -1051,8 +1051,8 @@ PRE(sys_execve)
 
 PRE(sys_finfo)
 {
-   PRINT("finfo ( %p(%s), %ld, %p, %ld )",
-          ARG1,ARG1, ARG2, ARG3, ARG4);
+   PRINT("finfo ( %#lx(%s), %ld, %#lx, %ld )",
+          ARG1,(Char*)ARG1, ARG2, ARG3, ARG4);
    PRE_REG_READ4(int, "finfo", 
                       char*, Path1, int, cmd, void*, buffer, int, length);
    PRE_MEM_RASCIIZ( "finfo(Path1)", ARG1 );
@@ -1065,7 +1065,7 @@ POST(sys_finfo)
 
 PRE(sys_fstatfs)
 {
-   PRINT("sys_fstatfs ( %ld, %p )", ARG1, ARG2);
+   PRINT("sys_fstatfs ( %ld, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(UWord, "fstatfs", UWord, fd, struct statfs *, buf);
    PRE_MEM_WRITE( "fstatfs(buf)", ARG2, sizeof(struct statfs) );
 }
@@ -1076,7 +1076,7 @@ POST(sys_fstatfs)
 
 PRE(sys_fstatx)
 {
-   PRINT("fstatx ( %ld, %p, %ld, %ld )", ARG1, ARG2, ARG3, ARG4 );
+   PRINT("fstatx ( %ld, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4 );
    PRE_REG_READ4(Word, "fstatx", UWord, fd, void*, buf,
                                  UWord, len, UWord, cmd);
    PRE_MEM_WRITE( "fstatx(buf)", ARG2, ARG3 );
@@ -1097,7 +1097,7 @@ PRE(sys_getdirent)
    *flags |= SfMayBlock;
    /* this is pretty much like 'read':
       getdirent(fd, buffer, nbytes) -> # actually read */
-   PRINT("getdirent ( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("getdirent ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(Word, "getdirent", UWord, fd, UChar*, buf, UWord, count);
    PRE_MEM_WRITE( "getdirent(buf)", ARG2, ARG3 );
 }
@@ -1113,7 +1113,7 @@ PRE(sys_getdirent64)
    *flags |= SfMayBlock;
    /* this is pretty much like 'read':
       getdirent(fd, buffer, nbytes) -> # actually read */
-   PRINT("getdirent64 ( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("getdirent64 ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(Word, "getdirent64", UWord, fd, UChar*, buf, UWord, count);
    PRE_MEM_WRITE( "getdirent64(buf)", ARG2, ARG3 );
 }
@@ -1125,7 +1125,7 @@ POST(sys_getdirent64)
 
 PRE(sys_getdomainname)
 {
-   PRINT("getdomainname ( %p, %ld )", ARG1, ARG2 );
+   PRINT("getdomainname ( %#lx, %ld )", ARG1, ARG2 );
    PRE_MEM_WRITE( "getdomainname(buf)", ARG1, ARG2 );
 }
 POST(sys_getdomainname)
@@ -1135,13 +1135,13 @@ POST(sys_getdomainname)
 
 PRE(sys_getgidx)
 {
-   PRINT("getgidx ( %d )", ARG1);
+   PRINT("getgidx ( %ld )", ARG1);
    PRE_REG_READ1(UInt, "getgidx", long, arg1);
 }
 
 PRE(sys_getgroups)
 {
-   PRINT("getgroups ( %d, %p )", ARG1, ARG2);
+   PRINT("getgroups ( %ld, %#lx )", ARG1, ARG2);
    PRE_REG_READ2(long, "getgroups", int, size, gid_t *, list);
    if (ARG1 > 0)
       PRE_MEM_WRITE( "getgroups(list)", ARG2, ARG1 * sizeof(gid_t) );
@@ -1155,7 +1155,7 @@ POST(sys_getgroups)
 
 PRE(sys_gethostname)
 {
-   PRINT("gethostname ( %p, %ld )", ARG1, ARG2);
+   PRINT("gethostname ( %#lx, %ld )", ARG1, ARG2);
    PRE_MEM_WRITE( "gethostname(buf)", ARG1, ARG2 );
 }
 POST(sys_gethostname)
@@ -1165,7 +1165,7 @@ POST(sys_gethostname)
 
 PRE(sys_getpriv)
 {
-   PRINT("getpriv (UNDOCUMENTED)(%ld, %p, %ld)", ARG1, ARG2, ARG3);
+   PRINT("getpriv (UNDOCUMENTED)(%ld, %#lx, %ld)", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "getpriv", int, arg1, void*, arg2, int, arg3);
    PRE_MEM_WRITE( "getpriv(arg2)", ARG2, 8 );
 }
@@ -1177,7 +1177,7 @@ POST(sys_getpriv)
 
 PRE(sys_getprocs)
 {
-   PRINT("getprocs ( %p, %ld, %p, %ld, %p, %ld )",
+   PRINT("getprocs ( %#lx, %ld, %#lx, %ld, %#lx, %ld )",
          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
    PRE_REG_READ6(int, "getprocs", 
                  void*, processbuffer, long, processize, 
@@ -1203,13 +1203,13 @@ POST(sys_getprocs)
 
 PRE(sys_getrpid)
 {
-   PRINT("getrpid ( %d, %ld, %ld )", ARG1, ARG2, ARG3);
+   PRINT("getrpid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "getrpid", long, arg1, long, arg2, long, arg3);
 }
 
 PRE(sys_getsockopt)
 {
-   PRINT("getsockopt ( %ld, %ld, %ld, %p, %p )", 
+   PRINT("getsockopt ( %ld, %ld, %ld, %#lx, %#lx )", 
          ARG1, ARG2, ARG3, ARG4, ARG5);
    PRE_REG_READ5(int, "getsockopt", int, socket, int, level, 
                                     int, optionname, 
@@ -1241,7 +1241,7 @@ PRE(sys_getuidx)
 
 PRE(sys_incinterval)
 {
-   PRINT("incinterval ( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("incinterval ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "incinterval", int, timerid, 
                       struct itimerstruc_t*, value,
                       struct itimerstruc_t*, ovalue);
@@ -1289,7 +1289,7 @@ PRE(sys_kfcntl)
       case F_GETLK64:
       case F_SETLK64:
       case F_SETLKW64:
-         PRINT("kfcntl[ARG3=='lock'] ( %ld, %ld, %p )", ARG1,ARG2,ARG3);
+         PRINT("kfcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
          PRE_REG_READ3(long, "fcntl",
                        unsigned int, fd, unsigned int, cmd,
                        struct flock64 *, lock);
@@ -1346,7 +1346,7 @@ PRE(sys_kfork) /* COPY OF GENERIC */
    else 
    if (SUCCESS && RES > 0) {
       /* parent */
-      PRINT("   fork: process %d created child %d\n", VG_(getpid)(), RES);
+      PRINT("   fork: process %d created child %lu\n", VG_(getpid)(), RES);
 
       /* restore signal mask */
       VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
@@ -1373,7 +1373,7 @@ PRE(sys_kill)
 PRE(sys_kioctl)
 {
    *flags |= SfMayBlock;
-   PRINT("kioctl ( %ld, %p, %p, %p )", ARG1, ARG2, ARG3, ARG4);
+   PRINT("kioctl ( %ld, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
    PRE_REG_READ4(Word, "ioctl", Word, fd, 
                                 Word, command, Word, arg, Word, ext);
    switch (ARG2 /* request */) {
@@ -1423,7 +1423,7 @@ PRE(sys_kioctl)
             if (moans > 0 && !VG_(clo_xml)) {
                moans--;
                VG_(message)(Vg_UserMsg, 
-                            "Warning: noted but unhandled ioctl 0x%x"
+                            "Warning: noted but unhandled ioctl 0x%lx"
                             " with no size/direction hints",
                             ARG2); 
                VG_(message)(Vg_UserMsg, 
@@ -1509,7 +1509,7 @@ POST(sys_kioctl)
 
 PRE(sys_klseek)
 {
-   PRINT("klseek ( %ld, %ld, %ld, %p )", ARG1, ARG2, ARG3, ARG4);
+   PRINT("klseek ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4);
    PRE_REG_READ4(long, "klseek", 
                  long, fd, long, offset, long, whence, void*, arg4);
    /* XXX: looks like 4th arg is a pointer to something.  Is it
@@ -1524,8 +1524,8 @@ PRE(sys_knlist)
 PRE(sys_kpread)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_kpread ( %d, %p, %llu, %lld )",
-         ARG1, ARG2, (ULong)ARG3, ARG4);
+   PRINT("sys_kpread ( %ld, %#lx, %llu, %lld )",
+         ARG1, ARG2, (ULong)ARG3, (ULong)ARG4);
    PRE_REG_READ4(ssize_t, "kpread",
                  unsigned int, fd, char *, buf,
                  vki_size_t, count, long, offset);
@@ -1542,7 +1542,7 @@ POST(sys_kpread)
 PRE(sys_kread)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_read ( %ld, %p, %llu )", ARG1, ARG2, (ULong)ARG3);
+   PRINT("sys_read ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
    PRE_REG_READ3(ssize_t, "read",
                  unsigned int, fd, char *, buf, vki_size_t, count);
    //zz   if (!ML_(fd_allowed)(ARG1, "read", tid, False))
@@ -1562,7 +1562,7 @@ PRE(sys_kreadv)
    struct vki_iovec * vec;
    *flags |= SfMayBlock;
    /* ssize_t readvx ( int fd, struct iovec*, int iovCount, int extension ) */
-   PRINT("kreadv ( %ld, %p, %ld, %p )", ARG1, ARG2, ARG3, ARG4);
+   PRINT("kreadv ( %ld, %#lx, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4);
    PRE_REG_READ4(ssize_t, "kreadv",
                  unsigned long, fd, const struct iovec *, vector,
                  unsigned long, iovCount, unsigned long, extension);
@@ -1606,7 +1606,7 @@ PRE(sys_kthread_ctl)
 
 PRE(sys_ktruncate)
 {
-   PRINT("ktruncate( %p(%s), %lx, %lx )", ARG1,ARG1, ARG2, ARG3 );
+   PRINT("ktruncate( %#lx(%s), %lx, %lx )", ARG1,(Char*)ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "ktruncate", char*, path, long, arg2, long, arg3 );
    PRE_MEM_RASCIIZ( "ktruncate(path)", ARG1 );
 }
@@ -1616,7 +1616,7 @@ PRE(sys_kwaitpid)
    /* Note: args 1 and 2 (status, pid) opposite way round
       from generic handler */
    *flags |= SfMayBlock;
-   PRINT("kwaitpid ( %p, %ld, %ld, %p, %p )", ARG1,ARG2,ARG3,ARG4,ARG5);
+   PRINT("kwaitpid ( %#lx, %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
    PRE_REG_READ3(long, "waitpid", 
                  unsigned int *, status, int, pid, int, options);
 
@@ -1633,7 +1633,7 @@ PRE(sys_kwrite)
 {
    //zz   Bool ok;
    *flags |= SfMayBlock;
-   PRINT("sys_kwrite ( %ld, %p, %llu )", ARG1, ARG2, (ULong)ARG3);
+   PRINT("sys_kwrite ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
    PRE_REG_READ3(ssize_t, "kwrite",
                  unsigned int, fd, const char *, buf, vki_size_t, count);
    /* check to see if it is allowed.  If not, try for an exemption from
@@ -1660,7 +1660,7 @@ PRE(sys_listen)
 
 PRE(sys_loadbind)
 {
-   PRINT("loadbind( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("loadbind( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "loadbind", int, flag,
                       void*, ExportPointer, void*, ImportPointer);
 }
@@ -1668,7 +1668,7 @@ PRE(sys_loadbind)
 PRE(sys_loadquery)
 {
    /* loadquery ( int flags, void* buffer, unsigned int bufferlength ) */
-   PRINT("loadquery ( %p, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("loadquery ( %#lx, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_MEM_WRITE( "loadquery(buf)", ARG2, ARG3 );
 }
 POST(sys_loadquery)
@@ -1685,14 +1685,14 @@ PRE(sys_lseek)
 
 PRE(sys_mkdir)
 {
-   PRINT("mkdir (%p(%s), %p)", ARG1,ARG1, ARG2);
+   PRINT("mkdir (%#lx(%s), %#lx)", ARG1,(Char*)ARG1, ARG2);
    PRE_REG_READ2(int, "mkdir", char*, path, int, mode);
    PRE_MEM_RASCIIZ( "mkdir(path)", ARG1 );
 }
 
 PRE(sys_mmap)
 {
-   PRINT("mmap ( %p, %ld, %p, %p, %ld, %ld )",
+   PRINT("mmap ( %#lx, %ld, %#lx, %#lx, %ld, %ld )",
          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
    PRE_REG_READ6(void*, "mmap", void*, addr, int, len, 
                         int, prot, int, flags, int, fd, int, off);
@@ -1716,7 +1716,7 @@ POST(sys_mmap)
 
 PRE(sys_mntctl)
 {
-   PRINT("mntctl ( %ld, %ld, %p )", ARG1, ARG2, ARG3 );
+   PRINT("mntctl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3 );
    PRE_REG_READ3(long, "mntctl", long, command, long, size, char*, buffer);
    PRE_MEM_WRITE( "mntctl(buffer)", ARG3, ARG2 );
 }
@@ -1737,7 +1737,7 @@ POST(sys_mntctl)
 
 PRE(sys_mprotect)
 {
-   PRINT("mprotect (BOGUS HANDLER)( %p, %ld, %p )", ARG1, ARG2, ARG3);
+   PRINT("mprotect (BOGUS HANDLER)( %#lx, %ld, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "mprotect", void*, addr, long, len, long, prot);
 }
 POST(sys_mprotect)
@@ -1754,7 +1754,7 @@ POST(sys_mprotect)
 
 PRE(sys_munmap)
 {
-   PRINT("munmap ( %p, %ld )", ARG1, ARG2);
+   PRINT("munmap ( %#lx, %ld )", ARG1, ARG2);
    PRE_REG_READ2(int, "munmap", void*, addr, long, len);
 }
 POST(sys_munmap)
@@ -1771,7 +1771,7 @@ POST(sys_munmap)
 
 PRE(sys_naccept)
 {
-   PRINT("naccept (%ld, %p, %p)", ARG1, ARG2, ARG3);
+   PRINT("naccept (%ld, %#lx, %#lx)", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "naccept", int, socket, char*, addr, int*, addrlen);
    PRE_MEM_READ( "naccept(addrlen)", ARG3, sizeof(UInt) );
    PRE_MEM_WRITE( "naccept(addr)", ARG2, *(UInt*)ARG3 );
@@ -1784,7 +1784,7 @@ POST(sys_naccept)
 
 PRE(sys_ngetpeername)
 {
-   PRINT("ngetpeername ( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("ngetpeername ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "ngetpeername", int, fd, char*, name, int*, namelen);
    PRE_MEM_READ( "ngetpeername(namelen)", ARG3, sizeof(UInt) );
    PRE_MEM_WRITE( "ngetpeername(name)", ARG2, *(UInt*)ARG3 );
@@ -1797,7 +1797,7 @@ POST(sys_ngetpeername)
 
 PRE(sys_ngetsockname)
 {
-   PRINT("ngetsockname ( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("ngetsockname ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "ngetsockname", int, fd, char*, name, int*, namelen);
    PRE_MEM_READ( "ngetsockname(namelen)", ARG3, sizeof(UInt) );
    PRE_MEM_WRITE( "ngetsockname(name)", ARG2, *(UInt*)ARG3 );
@@ -1811,7 +1811,7 @@ POST(sys_ngetsockname)
 PRE(sys_nrecvfrom)
 {
    *flags |= SfMayBlock;
-   PRINT("nrecvfrom ( %ld, %p, %ld, %ld, %p, %p )",
+   PRINT("nrecvfrom ( %ld, %#lx, %ld, %ld, %#lx, %#lx )",
          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
    PRE_REG_READ6(ssize_t, "nrecvfrom",
                  int, s, void*, buf, size_t, len, int, flags,
@@ -1834,14 +1834,14 @@ POST(sys_nrecvfrom)
 PRE(sys_nrecvmsg)
 {
    *flags |= SfMayBlock;
-   PRINT("nrecvmsg(BOGUS HANDLER)( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("nrecvmsg(BOGUS HANDLER)( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "nrecvmsg", long, arg1, void*, arg2, long, arg3);
 }
 
 PRE(sys_nsendmsg)
 {
    *flags |= SfMayBlock;
-   PRINT("nsendmsg(BOGUS HANDLER)( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("nsendmsg(BOGUS HANDLER)( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
 }
 
 PRE(sys_open) /* XXX CoG */
@@ -1851,12 +1851,12 @@ PRE(sys_open) /* XXX CoG */
 
    if (ARG2 & VKI_O_CREAT) {
       // 3-arg version
-      PRINT("sys_open ( %p(%s), %p, %ld )",ARG1,ARG1,ARG2,ARG3);
+      PRINT("sys_open ( %#lx(%s), %#lx, %ld )",ARG1,(Char*)ARG1,ARG2,ARG3);
       PRE_REG_READ3(long, "open",
                     const char *, filename, int, flags, int, mode);
    } else {
       // 2-arg version
-      PRINT("sys_open ( %p(%s), %p )",ARG1,ARG1,ARG2);
+      PRINT("sys_open ( %#lx(%s), %#lx )",ARG1,(Char*)ARG1,ARG2);
       PRE_REG_READ2(long, "open",
                     const char *, filename, int, flags);
    }
@@ -1898,7 +1898,7 @@ POST(sys_open)
 
 PRE(sys_pipe)
 {
-   PRINT("sys_pipe ( %p )", ARG1);
+   PRINT("sys_pipe ( %#lx )", ARG1);
    PRE_REG_READ1(int, "pipe", int *, filedes);
    PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) );
 }
@@ -1928,7 +1928,7 @@ PRE(sys_privcheck)
 
 PRE(sys_readlink)
 {
-   PRINT("readlink ( 0x%x(%s),0x%x,%ld )", ARG1,ARG1, ARG2, ARG3);
+   PRINT("readlink ( 0x%lx(%s),0x%lx,%ld )", ARG1,(Char*)ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "readlink",
                  const char *, path, char *, buf, int, bufsiz);
    PRE_MEM_RASCIIZ( "readlink(path)", ARG1 );
@@ -1942,7 +1942,7 @@ POST(sys_readlink)
 PRE(sys_recv)
 {
    *flags |= SfMayBlock;
-   PRINT("recv ( %ld, %p, %ld, %ld )",
+   PRINT("recv ( %ld, %#lx, %ld, %ld )",
          ARG1, ARG2, ARG3, ARG4);
    PRE_REG_READ4(int, "recv", int, fd, void*, buf, int, len, int, flags);
    PRE_MEM_WRITE( "recv(buf)", ARG2, ARG3);
@@ -1956,7 +1956,7 @@ POST(sys_recv)
 PRE(sys_rename)
 {
    *flags |= SfMayBlock;
-   PRINT( "rename ( %p(%s), %p(%s) )", ARG1,ARG1, ARG2,ARG2 );
+   PRINT( "rename ( %#lx(%s), %#lx(%s) )", ARG1,(Char*)ARG1, ARG2,(Char*)ARG2 );
    PRE_REG_READ2(int, "rename", char*, frompath, char*, topath);
    PRE_MEM_RASCIIZ( "rename(frompath)", ARG1 );
    PRE_MEM_RASCIIZ( "rename(topath)", ARG2 );
@@ -1964,7 +1964,7 @@ PRE(sys_rename)
 
 PRE(sys_sbrk)
 {
-   PRINT("sbrk (BOGUS HANDLER)( %p )", ARG1);
+   PRINT("sbrk (BOGUS HANDLER)( %#lx )", ARG1);
    PRE_REG_READ1(long, "sbrk", long, arg1);
    /* After a zero sbrk, disallow aspacem from doing sbrk, since libc
       might rely on the value returned by this syscall. */
@@ -1996,14 +1996,14 @@ PRE(sys_sched_get_priority_max)
 
 PRE(sys_sem_destroy)
 {
-   PRINT("sem_destroy ( %p )", ARG1);
+   PRINT("sem_destroy ( %#lx )", ARG1);
    PRE_REG_READ1(int, "sem_destroy", sem_t*, sem);
    PRE_MEM_READ( "sem_destroy(sem)", ARG1, sizeof(sem_t) );
 }
 
 PRE(sys_sem_init)
 {
-   PRINT("sem_init ( %p, %ld, %ld )", ARG1, ARG2, ARG3);
+   PRINT("sem_init ( %#lx, %ld, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "sem_init", sem_t*, sem, int, pshared, int, value);
    PRE_MEM_WRITE( "sem_init(sem)", ARG1, sizeof(sem_t) );
 }
@@ -2014,7 +2014,7 @@ POST(sys_sem_init)
 
 PRE(sys_sem_post)
 {
-   PRINT("sem_post ( %p )", ARG1);
+   PRINT("sem_post ( %#lx )", ARG1);
    PRE_REG_READ1(int, "sem_post", sem_t*, sem);
    PRE_MEM_READ("sem_post(sem)", ARG1, sizeof(sem_t));
 }
@@ -2026,7 +2026,7 @@ POST(sys_sem_post)
 PRE(sys_send)
 {
    *flags |= SfMayBlock;
-   PRINT("send (BOGUS HANDLER)( %ld, %p, %ld, %ld )", 
+   PRINT("send (BOGUS HANDLER)( %ld, %#lx, %ld, %ld )", 
          ARG1, ARG2, ARG3, ARG4);
 }
 
@@ -2038,7 +2038,7 @@ PRE(sys_setgid)
 
 PRE(sys_setsockopt)
 {
-   PRINT("setsockopt ( %ld, %ld, %ld, %p, %ld )", 
+   PRINT("setsockopt ( %ld, %ld, %ld, %#lx, %ld )", 
          ARG1,ARG2,ARG3,ARG4,ARG5 );
    PRE_REG_READ5(long, "setsockopt", 
                  long, socket, long, level, long, optionname, 
@@ -2060,7 +2060,7 @@ static UWord get_shm_size ( Word shmid )
    vg_assert(__NR_AIX5_shmctl != __NR_AIX5_UNKNOWN);
    res = VG_(do_syscall3)(__NR_AIX5_shmctl, shmid, IPC_STAT, (UWord)&buf);
    if (0) 
-      VG_(printf)("XXX: shm_size(%ld) = %d %d\n", shmid, res.res, res.err);
+      VG_(printf)("XXX: shm_size(%ld) = %ld %ld\n", shmid, res.res, res.err);
    if (res.isError) {
       if (0)
          VG_(printf)("XXX: shm_size(shmid = %ld): FAILED\n", shmid);
@@ -2090,7 +2090,7 @@ PRE(sys_shmat)
 {
    UWord segmentSize;
    /* void* shmat ( int shmid, const void* shmaddr, int flags ) */
-   PRINT("shmat (%ld, %p, %p)", ARG1, ARG2, ARG3);
+   PRINT("shmat (%ld, %#lx, %#lx)", ARG1, ARG2, ARG3);
    PRE_REG_READ3(void*, "shmat", int, shmid, void*, shmaddr, int, flags);
    segmentSize = get_shm_size( ARG1 );
    if (0) VG_(printf)("shmat: seg size = %lu\n", segmentSize);
@@ -2122,7 +2122,7 @@ POST(sys_shmat)
 
 PRE(sys_shmctl)
 {
-   PRINT("shmctl ( %ld, %ld, %p )", ARG1, ARG2, ARG3 );
+   PRINT("shmctl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "shmctl", int, shmid, int, command, void*, buffer);
    if (ARG3)
       PRE_MEM_WRITE( "shmctl(buffer)", ARG3, sizeof(struct shmid_ds) );
@@ -2135,7 +2135,7 @@ POST(sys_shmctl)
 
 PRE(sys_shmdt)
 {
-   PRINT("shmdt ( %p )", ARG1);
+   PRINT("shmdt ( %#lx )", ARG1);
    PRE_REG_READ1(long, "shmdt", void*, address);
 }
 POST(sys_shmdt)
@@ -2177,7 +2177,7 @@ PRE(sys_sigcleanup)
 
 PRE(sys_sigprocmask)
 {
-   PRINT("sigprocmask ( %ld, %p, %p )", ARG1, ARG2, ARG3);
+   PRINT("sigprocmask ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(long, "sigprocmask", 
                  int, how, vki_sigset_t *, set, vki_sigset_t *, oldset);
    if (ARG2 != 0)
@@ -2208,7 +2208,7 @@ PRE(sys_socket)
 
 PRE(sys_statfs)
 {
-   PRINT("sys_statfs ( %p(%s), %p )",ARG1,ARG1,ARG2);
+   PRINT("sys_statfs ( %#lx(%s), %#lx )",ARG1,(Char*)ARG1,ARG2);
    PRE_REG_READ2(long, "statfs", const char *, path, struct statfs *, buf);
    PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
    PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct statfs) );
@@ -2220,7 +2220,7 @@ POST(sys_statfs)
 
 PRE(sys_statx)
 {
-   PRINT("statx ( %p(%s), %p, %ld, %ld )", ARG1,ARG1,ARG2,ARG3,ARG4);
+   PRINT("statx ( %#lx(%s), %#lx, %ld, %ld )", ARG1,(Char*)ARG1,ARG2,ARG3,ARG4);
    PRE_MEM_RASCIIZ( "statx(file_name)", ARG1 );
    PRE_REG_READ4(Word, "statx", UWord, fd, void*, buf,
                                 UWord, len, UWord, cmd);
@@ -2238,7 +2238,7 @@ PRE(sys_symlink)
 
 PRE(sys_sys_parm)
 {
-   PRINT("sys_parm (%ld, %ld, %p)", ARG1, ARG2, ARG3);
+   PRINT("sys_parm (%ld, %ld, %#lx)", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "sys_parm", int, cmd, int, cmdflag, 
                       struct vario*, parmp);
    /* this is a bit of a kludge, but if parmp has uninitialised areas
@@ -2255,7 +2255,7 @@ POST(sys_sys_parm)
 
 PRE(sys_sysconfig)
 {
-   PRINT("sysconfig ( %ld, %p, %ld )", ARG1, ARG2, ARG3);
+   PRINT("sysconfig ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
    PRE_REG_READ3(int, "sysconfig", int, cmd, void*, parmp, int, parmlen);
    /* It may be that the area is read sometimes as well as written,
       but for the same reasons as sys_parm, just check addressibility,
@@ -2301,7 +2301,7 @@ PRE(sys_thread_init)
 {
    *flags |= SfMayBlock;
    PRE_REG_READ2(long, "thread_init", long, arg1, long, arg2);
-   PRINT("thread_init (BOGUS HANDLER) ( %p, %p )", ARG1, ARG2);
+   PRINT("thread_init (BOGUS HANDLER) ( %#lx, %#lx )", ARG1, ARG2);
 }
 
 PRE(sys_thread_kill)
@@ -2345,7 +2345,7 @@ PRE(sys_thread_setmystate)
       I assume: first is new state, if not NULL.  
       Second is place to write the previous state, if not NULL.
       (in the style of sigaction) */
-   PRINT("thread_setmystate (BOGUS HANDLER) ( %p, %p )",
+   PRINT("thread_setmystate (BOGUS HANDLER) ( %#lx, %#lx )",
          ARG1, ARG2 );
    PRE_REG_READ2(long, "thread_setmystate", 
                        struct tstate *, newstate, 
@@ -2386,7 +2386,7 @@ PRE(sys_thread_setmystate_fast)
    UWord how = ARG1;
    /* args: ?? */
    PRINT("thread_setmystate_fast (BOGUS HANDLER)"
-         "(%p,%p(%s),%p(%s))", 
+         "(%#lx,%#lx(%s),%#lx(%s))", 
          ARG1,
          ARG2, ML_(aix5debugstuff_pc_to_fnname)(ARG2),
          ARG3, ML_(aix5debugstuff_pc_to_fnname)(ARG3)
@@ -2439,7 +2439,7 @@ PRE(sys_thread_terminate_unlock)
 {
    ThreadState* tst;
    /* simple; just make this thread exit */
-   PRINT("thread_terminate_unlock( %p )", ARG1);
+   PRINT("thread_terminate_unlock( %#lx )", ARG1);
    PRE_REG_READ1(void, "thread_terminate_unlock", void*, exitcode);
    tst = VG_(get_ThreadState)(tid);
    /* Drop the lock we were holding, since we're not really going to
@@ -2456,27 +2456,27 @@ PRE(sys_thread_terminate_unlock)
 PRE(sys_thread_tsleep)
 {
    *flags |= SfMayBlock;
-   PRINT("thread_tsleep (BOGUS HANDLER)( %ld, %p, %p, %p )", 
+   PRINT("thread_tsleep (BOGUS HANDLER)( %ld, %#lx, %#lx, %#lx )", 
          ARG1, ARG2, ARG3, ARG4 );
 }
 
 PRE(sys_thread_tsleep_event)
 {
    *flags |= SfMayBlock;
-   PRINT("thread_tsleep_event (UNDOCUMENTED)( %p, %p, %ld, %p )", 
+   PRINT("thread_tsleep_event (UNDOCUMENTED)( %#lx, %#lx, %ld, %#lx )", 
          ARG1, ARG2, ARG3, ARG4 );
 }
 
 PRE(sys_thread_twakeup)
 {
    *flags |= SfMayBlock;
-   PRINT("thread_twakeup (BOGUS HANDLER)( tid=%ld, val=%p )", ARG1, ARG2 );
+   PRINT("thread_twakeup (BOGUS HANDLER)( tid=%ld, val=%#lx )", ARG1, ARG2 );
 }
 
 PRE(sys_thread_twakeup_event)
 {
    *flags |= SfMayBlock;
-   PRINT("thread_twakeup_event (BOGUS HANDLER)( %p, %ld, %ld )", 
+   PRINT("thread_twakeup_event (BOGUS HANDLER)( %#lx, %ld, %ld )", 
          ARG1, ARG2, ARG3 );
 }
 
@@ -2500,7 +2500,7 @@ PRE(sys_thread_waitlock_)
 
 PRE(sys_times)
 {
-   PRINT("times ( %p )", ARG1);
+   PRINT("times ( %#lx )", ARG1);
    PRE_REG_READ1(long, "times", struct tms *, buffer);
    PRE_MEM_WRITE("times(buf)", ARG1, sizeof(struct tms) );
 }
@@ -2521,14 +2521,14 @@ PRE(sys_uname)
 
 PRE(sys_unlink)
 {
-   PRINT("unlink ( %p(%s) )", ARG1);
+   PRINT("unlink ( %#lx(%s) )", ARG1, (Char*)ARG1 );
    PRE_REG_READ1(int, "unlink", char*, path);
    PRE_MEM_RASCIIZ( "unlink(path)", ARG1 );
 }
 
 PRE(sys_utimes)
 {
-   PRINT("utimes ( %p(%s), %p )", ARG1, ARG2);
+   PRINT("utimes ( %#lx(%s), %#lx )", ARG1,(Char*)ARG1, ARG2);
    PRE_REG_READ2(int, "utimes", char*, path, struct timeval*, times);
    PRE_MEM_RASCIIZ( "utimes(path)", ARG1 );
    PRE_MEM_READ( "utimes(times)", ARG2, 2 * sizeof(struct vki_timeval) );
@@ -2536,7 +2536,7 @@ PRE(sys_utimes)
 
 PRE(sys_vmgetinfo)
 {
-   PRINT("vmgetinfo ( %p, %ld, %ld )", ARG1, ARG2, ARG3 );
+   PRINT("vmgetinfo ( %#lx, %ld, %ld )", ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "vmgetinfo", void*, out, int, command, int, arg);
    /* It looks like libc's vmgetinfo just hands stuff through to the
       syscall.  The man page says that the interpretation of ARG3(arg)

diff --git a/coregrind/m_syswrap/syswrap-main.c b/coregrind/m_syswrap/syswrap-main.c
index 9eea1e2faa3ef1944f9184edb1696cab55070fc9..ec2e7a2a436c0a47f5e86d57b391932d1fc6a324 100644 (file)
--- a/coregrind/m_syswrap/syswrap-main.c
+++ b/coregrind/m_syswrap/syswrap-main.c
@@ -1220,7 +1220,7 @@ void ML_(fixup_guest_state_to_restart_syscall) ( ThreadArchState* arch )
       if (p[0] != 0x44 || p[1] != 0x0 || p[2] != 0x0 || p[3] != 0x02)
          VG_(message)(Vg_DebugMsg,
                       "?! restarting over syscall at %#lx %02x %02x %02x %02x\n",
-                      arch->vex.guest_CIA, p[0], p[1], p[2], p[3]);
+                      (UWord)arch->vex.guest_CIA, p[0], p[1], p[2], p[3]);
 
       vg_assert(p[0] == 0x44 && p[1] == 0x0 && p[2] == 0x0 && p[3] == 0x2);
    }

diff --git a/coregrind/m_syswrap/syswrap-ppc32-aix5.c b/coregrind/m_syswrap/syswrap-ppc32-aix5.c
index 81e810d1e99cc6a0f3435a1ea64443ef5d30b95a..0835ced1d137a35eb22163fcc4e997c2b6163b0e 100644 (file)
--- a/coregrind/m_syswrap/syswrap-ppc32-aix5.c
+++ b/coregrind/m_syswrap/syswrap-ppc32-aix5.c
@@ -350,9 +350,9 @@ PRE(sys___loadx)
 {
    *flags |= SfMayBlock;
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_LOAD) {
-      PRINT("__loadx(0x%x(DL_LOAD),0x%x,%d,0x%x(%s),0x%x(%s))",
+      PRINT("__loadx(0x%lx(DL_LOAD),0x%lx,%ld,0x%lx(%s),0x%lx(%s))",
             ARG1,ARG2,ARG3,
-            ARG4,ARG4,
+            ARG4,(HChar*)ARG4,
             ARG5, (ARG5 ? (HChar*)ARG5 : "nil") );
       /* It would appear that (ARG2, ARG3) describe a buffer
          which is written into by the kernel on success. */
@@ -360,7 +360,7 @@ PRE(sys___loadx)
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_POSTLOADQ) {
-      PRINT("__loadx(0x%x(DL_POSTLOADQ),0x%x,%d,0x%x)",
+      PRINT("__loadx(0x%lx(DL_POSTLOADQ),0x%lx,%ld,0x%lx)",
             ARG1,ARG2,ARG3,ARG4);
     /* It would appear that (ARG2, ARG3) describe a buffer                      
         which is written into by the kernel on success. */
@@ -368,40 +368,40 @@ PRE(sys___loadx)
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_GLOBALSYM) {
-      PRINT("__loadx(0x%x(DL_GLOBALSYM),0x%x(%s),0x%x,0x%x,0x%x)",
-            ARG1, ARG2,ARG2,
+      PRINT("__loadx(0x%lx(DL_GLOBALSYM),0x%lx(%s),0x%lx,0x%lx,0x%lx)",
+            ARG1, ARG2,(Char*)ARG2,
             ARG3, ARG4, ARG5);
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_EXITQ) {
-      PRINT("__loadx(0x%x(DL_EXITQ),0x%x,%d)", ARG1, ARG2, ARG3);
+      PRINT("__loadx(0x%lx(DL_EXITQ),0x%lx,%ld)", ARG1, ARG2, ARG3);
       PRE_MEM_WRITE("__loadx(DL_EXITQ)(ARG2,ARG3)", ARG2, ARG3);
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_EXECQ) {
-      PRINT("__loadx(0x%x(DL_EXECQ),0x%x,%d)", ARG1, ARG2, ARG3);
+      PRINT("__loadx(0x%lx(DL_EXECQ),0x%lx,%ld)", ARG1, ARG2, ARG3);
       PRE_MEM_WRITE("__loadx(DL_EXECQ)(ARG2,ARG3)", ARG2, ARG3);
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_GETSYM) {
-      PRINT("__loadx(0x%x(DL_GETSYM),0x%x(%s),%d,0x%x)", 
-            ARG1, ARG2,ARG2, ARG3, ARG4);
+      PRINT("__loadx(0x%lx(DL_GETSYM),0x%lx(%s),%ld,0x%lx)", 
+            ARG1, ARG2,(Char*)ARG2, ARG3, ARG4);
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == VKI_DL_PREUNLOADQ) {
-      PRINT("__loadx(0x%x(DL_PREUNLOADQ),0x%x,%d,0x%x)", 
+      PRINT("__loadx(0x%lx(DL_PREUNLOADQ),0x%lx,%ld,0x%lx)", 
             ARG1,ARG2,ARG3,ARG4);
       PRE_MEM_WRITE("__loadx(DL_PREUNLOADQ)(ARG2,ARG3)", ARG2, ARG3);
    }
    else
    if ((ARG1 & VKI_DL_FUNCTION_MASK) == 0x0D000000) {
-      PRINT("__loadx(0x%x(UNDOCUMENTED),0x%x,0x%xd,0x%x)", 
+      PRINT("__loadx(0x%lx(UNDOCUMENTED),0x%lx,0x%lx,0x%lx)", 
             ARG1,ARG2,ARG3,ARG4);
       /* This doesn't appear to have any args, from the examples I've
          seen. */
    }
    else {
-      PRINT("__loadx (BOGUS HANDLER) (0x%x, ..)", ARG1);
+      PRINT("__loadx (BOGUS HANDLER) (0x%lx, ..)", ARG1);
    }
 }
 POST(sys___loadx)
@@ -444,7 +444,7 @@ POST(sys___loadx)
 
 PRE(sys___unload)
 {
-   PRINT("__unload (UNDOCUMENTED) ( %p )", ARG1);
+   PRINT("__unload (UNDOCUMENTED) ( %#lx )", ARG1);
 }
 POST(sys___unload)
 {
@@ -457,7 +457,7 @@ PRE(sys__clock_gettime)
 {
    /* Seems like ARG3 points at a destination buffer? */
    /* _clock_gettime (UNDOCUMENTED) ( 0, 0xA, 0x2FF21808 ) */
-   PRINT("_clock_gettime (UNDOCUMENTED) ( %d, %p, %p )", ARG1, ARG2, ARG3 );
+   PRINT("_clock_gettime (UNDOCUMENTED) ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "_clock_gettime", int, arg1, int, arg2, void*, arg3);
    PRE_MEM_WRITE( "_clock_gettime(dst)", ARG3, sizeof(struct timespec) );
 }
@@ -474,7 +474,7 @@ PRE(sys_thread_setmymask_fast)
       mask, we act like sigprocmask(SIG_SETMASK, set, NULL) and don't
       hand this to the kernel.  Layout verified 30 July 06. */
    vki_sigset_t set;
-   PRINT("thread_setmymask_fast (BOGUS HANDLER)( %08x %08x )", ARG1,ARG2 );
+   PRINT("thread_setmymask_fast (BOGUS HANDLER)( %08lx %08lx )", ARG1,ARG2 );
    vg_assert(sizeof(vki_sigset_t) == 8);
    set.sig[0] = ARG1; /* sigs 1-32 */
    set.sig[1] = ARG2; /* sigs 32-64 */

diff --git a/coregrind/m_syswrap/syswrap-ppc64-aix5.c b/coregrind/m_syswrap/syswrap-ppc64-aix5.c
index 5a3b258aa89c87b4dc605b642191b470e65352f9..f5074bb3bdbf60ceb0a27111783b3474c2c86879 100644 (file)
--- a/coregrind/m_syswrap/syswrap-ppc64-aix5.c
+++ b/coregrind/m_syswrap/syswrap-ppc64-aix5.c
@@ -350,7 +350,7 @@ PRE(sys__clock_gettime)
 {
    /* Seems like ARG2 points at a destination buffer? */
    /* _clock_gettime (UNDOCUMENTED) ( 0, 0xA, 0x2FF21808 ) */
-   PRINT("_clock_gettime (UNDOCUMENTED) ( %d, %p, %p )", ARG1, ARG2, ARG3 );
+   PRINT("_clock_gettime (UNDOCUMENTED) ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3 );
    PRE_REG_READ3(int, "_clock_gettime", int, arg1, int, arg2, void*, arg3);
    PRE_MEM_WRITE( "_clock_gettime(dst)", ARG2, sizeof(struct timespec) );
 }
@@ -367,14 +367,14 @@ PRE(sys__fp_fpscrx64_)
 
 PRE(sys_kload)
 {
-   PRINT("kload (UNDOCUMENTED)( %p(%s), %ld, %ld )", 
-         ARG1,ARG1, ARG2, ARG3 );
+   PRINT("kload (UNDOCUMENTED)( %#lx(%s), %ld, %ld )", 
+         ARG1,(Char*)ARG1, ARG2, ARG3 );
    PRE_REG_READ3(void*, "kload", char*, name, long, arg2, char*, arg3);
 }
 POST(sys_kload)
 {
    vg_assert(SUCCESS);
-   if (0) VG_(printf)("kload result = %p\n", RES);
+   if (0) VG_(printf)("kload result = %#lx\n", RES);
    if (RES)
       POST_MEM_WRITE( RES, 64 );
    ML_(aix5_rescan_procmap_after_load_or_unload)();
@@ -382,7 +382,7 @@ POST(sys_kload)
 
 PRE(sys_kunload64)
 {
-   PRINT("kunload64 (UNDOCUMENTED)( %p, %ld, %ld, %p )", 
+   PRINT("kunload64 (UNDOCUMENTED)( %#lx, %ld, %ld, %#lx )", 
          ARG1, ARG2, ARG3, ARG4 );
    PRE_REG_READ4(long, "kunload64",
                  void*, arg1, long, arg2, long, arg3, void*, arg4);