2009-02-28 Hans Boehm <Hans.Boehm@hp.com> (Mostly Ivan Maidansky)

	* allchblk.c, backgraph.c, dbg_mlc.c, dyn_load.c,
	finalize.c, include/private/gc_pmark.h, malloc.c, mark.c,
	os_dep.c, pthread_stop_world.c, pthread_support.c, reclaim.c,
	thread_local_alloc.c.
	* misc.s: Refine comment.

2009-02-28  Hans Boehm <Hans.Boehm@hp.com>
	* os_dep.c: Define GC_GWW_BUF_LEN more intelligently.  Add FIXME
	comment.

diff --git a/ChangeLog b/ChangeLog
index 6684b57433abe7a519abf36c7faeed783c7580d6..5fb8b053684ab3de3ebae42137e8fad47a81eea1 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2009-02-28  Hans Boehm <Hans.Boehm@hp.com> (Mostly Ivan Maidansky)
+       * allchblk.c, backgraph.c, dbg_mlc.c, dyn_load.c,
+       finalize.c, include/private/gc_pmark.h, malloc.c, mark.c,
+       os_dep.c, pthread_stop_world.c, pthread_support.c, reclaim.c,
+       thread_local_alloc.c.
+       * misc.s: Refine comment.
+
+2009-02-28  Hans Boehm <Hans.Boehm@hp.com>
+       * os_dep.c: Define GC_GWW_BUF_LEN more intelligently.  Add FIXME
+       comment.
+
 2009-02-28  Hans Boehm <Hans.Boehm@hp.com> (With input from Ivan Maidansky)
        * win32_threads.c (GC_push_stack_for): Yet another attempt
        at the stack_min finding logic.  Try to clean up the existing code

diff --git a/allchblk.c b/allchblk.c
index 82822ed311623a366741833a444c22ffdacfb131..694e9dec4a84e8769b3ef9e2c015548512038330 100644 (file)
--- a/allchblk.c
+++ b/allchblk.c
@@ -117,7 +117,7 @@ void GC_print_hblkfreelist(void)
                              (unsigned long)i);
 #     else
         if (0 != h) GC_printf("Free list %lu (Total size %lu):\n",
-                             i, (unsigned long)GC_free_bytes[i]);
+                             (long)i, (unsigned long)GC_free_bytes[i]);
 #     endif
       while (h != 0) {
         hhdr = HDR(h);
@@ -183,7 +183,7 @@ void GC_dump_regions(void)
            hhdr = HDR(p);
            GC_printf("\t%p ", p);
            if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
-               GC_printf("Missing header!!(%d)\n", hhdr);
+               GC_printf("Missing header!!(%p)\n", hhdr);
                p += HBLKSIZE;
                continue;
            }

diff --git a/backgraph.c b/backgraph.c
index 233400a2f0a1e35e9c0451678848b20d470432b6..0ca051948f14cb3c5bf923eada3d88318556e141 100644 (file)
--- a/backgraph.c
+++ b/backgraph.c
@@ -378,7 +378,7 @@ static word backwards_height(ptr_t p)
     word this_height;
     if (GC_is_marked(q) && !(FLAG_MANY & (word)GET_OH_BG_PTR(p))) {
       if (GC_print_stats)
-         GC_log_printf("Found bogus pointer from 0x%lx to 0x%lx\n", q, p);
+         GC_log_printf("Found bogus pointer from %p to %p\n", q, p);
        /* Reachable object "points to" unreachable one.                */
        /* Could be caused by our lax treatment of GC descriptors.      */
       this_height = 1;
@@ -468,7 +468,7 @@ void GC_print_back_graph_stats(void)
     GC_print_heap_obj(GC_deepest_obj);
   }
   if (GC_print_stats) {
-    GC_log_printf("Needed max total of %ld back-edge structs\n",
+    GC_log_printf("Needed max total of %d back-edge structs\n",
                  GC_n_back_edge_structs);
   }
   GC_apply_to_each_object(reset_back_edge);

diff --git a/dbg_mlc.c b/dbg_mlc.c
index 1758635c78e5c374dcfe6a2a2baad547579fe128..70137d4c1ad75a1303e9ef2b500c783a2efffa56 100644 (file)
--- a/dbg_mlc.c
+++ b/dbg_mlc.c
@@ -193,8 +193,7 @@ GC_bool GC_has_other_debug_info(ptr_t p)
        GC_err_printf("No debug info in object: Can't find reference\n");
        goto out;
       }
-      GC_err_printf("Reachable via %d levels of pointers from ",
-                (unsigned long)i);
+      GC_err_printf("Reachable via %d levels of pointers from ", i);
       switch(source) {
        case GC_REFD_FROM_ROOT:
          GC_err_printf("root at %p\n\n", base);
@@ -417,8 +416,8 @@ STATIC void GC_print_smashed_obj(ptr_t p, ptr_t clobbered_addr)
     GC_err_printf("%p in or near object at %p(", clobbered_addr, p);
     if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz))
         || ohdr -> oh_string == 0) {
-        GC_err_printf("<smashed>, appr. sz = %ld)\n",
-                      (GC_size((ptr_t)ohdr) - DEBUG_BYTES));
+        GC_err_printf("<smashed>, appr. sz = %lu)\n",
+                     (unsigned long)(GC_size((ptr_t)ohdr) - DEBUG_BYTES));
     } else {
         if ((word)(ohdr -> oh_string) < HBLKSIZE) {
             GC_err_puts("(smashed string)");

diff --git a/dyn_load.c b/dyn_load.c
index 5c3842c4e98d29e8e395f205d3af191804874fb7..459d17ef58ab400889e7476de97c916d8f8d0c5a 100644 (file)
--- a/dyn_load.c
+++ b/dyn_load.c
@@ -594,7 +594,7 @@ void GC_register_dynamic_libraries(void)
 #   endif /* SOLARISDL */
 
     if (fd < 0) {
-      sprintf(buf, "/proc/%d", getpid());
+      sprintf(buf, "/proc/%ld", (long)getpid());
        /* The above generates a lint complaint, since pid_t varies.    */
        /* It's unclear how to improve this.                            */
       fd = open(buf, O_RDONLY);
@@ -613,7 +613,7 @@ void GC_register_dynamic_libraries(void)
                                                (current_sz * sizeof(prmap_t)));
     }
     if (ioctl(fd, PIOCMAP, addr_map) < 0) {
-        GC_err_printf("fd = %d, errno = %d, needed_sz = %d, addr_map = 0x%X\n",
+        GC_err_printf("fd = %d, errno = %d, needed_sz = %d, addr_map = %p\n",
                         fd, errno, needed_sz, addr_map);
        ABORT("/proc PIOCMAP ioctl failed");
     };

diff --git a/finalize.c b/finalize.c
index 402f783f949351d50d2906c28c45429f1361f38a..bc41ffed966a5a1cfe03c9c9f508ef627fcb6fda 100644 (file)
--- a/finalize.c
+++ b/finalize.c
@@ -167,7 +167,7 @@ GC_API int GC_CALL GC_general_register_disappearing_link(void * * link,
                      &log_dl_table_size);
        if (GC_print_stats) {
            GC_log_printf("Grew dl table to %u entries\n",
-                     (1 << log_dl_table_size));
+                     (1 << (unsigned)log_dl_table_size));
        }
     }
     index = HASH2(link, log_dl_table_size);
@@ -325,7 +325,7 @@ STATIC void GC_register_finalizer_inner(void * obj,
                      &log_fo_table_size);
        if (GC_print_stats) {
            GC_log_printf("Grew fo table to %u entries\n",
-                         (1 << log_fo_table_size));
+                         (1 << (unsigned)log_fo_table_size));
        }
     }
     /* in the THREADS case signals are disabled and we hold allocation */
@@ -861,10 +861,10 @@ GC_API void * GC_CALL GC_call_with_alloc_lock(GC_fn_type fn,
 void GC_print_finalization_stats(void)
 {
     struct finalizable_object *fo = GC_finalize_now;
-    size_t ready = 0;
+    unsigned ready = 0;
 
     GC_printf("%u finalization table entries; %u disappearing links\n",
-              GC_fo_entries, GC_dl_entries);
+              (unsigned)GC_fo_entries, (unsigned)GC_dl_entries);
     for (; 0 != fo; fo = fo_next(fo)) ++ready;
     GC_printf("%u objects are eligible for immediate finalization\n", ready);
 }

diff --git a/include/private/gc_pmark.h b/include/private/gc_pmark.h
index e8930828b4ffb6abe4255b5619e4f329ced34841..b0dd208911472d7cf138a1ea1aefe48ea0ec1ee1 100644 (file)
--- a/include/private/gc_pmark.h
+++ b/include/private/gc_pmark.h
@@ -296,11 +296,13 @@ exit_label: ; \
     } \
     GC_ASSERT(hhdr == GC_find_header(base)); \
     GC_ASSERT(gran_displ % BYTES_TO_GRANULES(hhdr -> hb_sz) == 0); \
-    TRACE(source, GC_log_printf("GC:%d: passed validity tests\n",GC_gc_no)); \
+    TRACE(source, GC_log_printf("GC:%u: passed validity tests\n", \
+                               (unsigned)GC_gc_no)); \
     SET_MARK_BIT_EXIT_IF_SET(hhdr, gran_displ, exit_label); \
-    TRACE(source, GC_log_printf("GC:%d: previously unmarked\n",GC_gc_no)); \
+    TRACE(source, GC_log_printf("GC:%u: previously unmarked\n", \
+                               (unsigned)GC_gc_no)); \
     TRACE_TARGET(base, \
-       GC_log_printf("GC:%d: marking %p from %p instead\n", GC_gc_no, \
+       GC_log_printf("GC:%u: marking %p from %p instead\n", (unsigned)GC_gc_no, \
                      base, source)); \
     INCR_MARKS(hhdr); \
     GC_STORE_BACK_PTR((ptr_t)source, base); \
@@ -352,11 +354,14 @@ exit_label: ; \
     /* May get here for pointer to start of block not at       */ \
     /* beginning of object.  If so, it's valid, and we're fine. */ \
     GC_ASSERT(high_prod >= 0 && high_prod <= HBLK_OBJS(hhdr -> hb_sz)); \
-    TRACE(source, GC_log_printf("GC:%d: passed validity tests\n",GC_gc_no)); \
+    TRACE(source, GC_log_printf("GC:%u: passed validity tests\n", \
+                               (unsigned)GC_gc_no)); \
     SET_MARK_BIT_EXIT_IF_SET(hhdr, high_prod, exit_label); \
-    TRACE(source, GC_log_printf("GC:%d: previously unmarked\n",GC_gc_no)); \
+    TRACE(source, GC_log_printf("GC:%u: previously unmarked\n", \
+                               (unsigned)GC_gc_no)); \
     TRACE_TARGET(base, \
-       GC_log_printf("GC:%d: marking %p from %p instead\n", GC_gc_no, \
+       GC_log_printf("GC:%u: marking %p from %p instead\n",
+                     (unsigned)GC_gc_no, \
                      base, source)); \
     INCR_MARKS(hhdr); \
     GC_STORE_BACK_PTR((ptr_t)source, base); \

diff --git a/malloc.c b/malloc.c
index 3329760834141ef4c09c732a64bc61842467b3f6..7d214af34c671ede112bf11c54c33bf7d3717db8 100644 (file)
--- a/malloc.c
+++ b/malloc.c
@@ -401,7 +401,7 @@ GC_API void GC_CALL GC_free(void * p)
     if (p == 0) return;
        /* Required by ANSI.  It's not my fault ...     */
 #   ifdef LOG_ALLOCS
-      GC_err_printf("GC_free(%p): %d\n", p, GC_gc_no);
+      GC_err_printf("GC_free(%p): %lu\n", p, (unsigned long)GC_gc_no);
 #   endif
     h = HBLKPTR(p);
     hhdr = HDR(h);

diff --git a/mark.c b/mark.c
index b636c05798c222e09cd5a86a5c2974ed8d8aaaa4..5bd43b828a34c5686452a18aa51d77f42e6ed788 100644 (file)
--- a/mark.c
+++ b/mark.c
@@ -320,8 +320,8 @@ static void alloc_mark_stack(size_t);
                scan_ptr = GC_push_next_marked_dirty(scan_ptr);
                if (scan_ptr == 0) {
                    if (GC_print_stats) {
-                       GC_log_printf("Marked from %u dirty pages\n",
-                                     GC_n_rescuing_pages);
+                       GC_log_printf("Marked from %lu dirty pages\n",
+                                     (unsigned long)GC_n_rescuing_pages);
                    }
                    GC_push_roots(FALSE, cold_gc_frame);
                    GC_objects_are_marked = TRUE;
@@ -580,7 +580,7 @@ mse * GC_signal_mark_stack_overflow(mse *msp)
     GC_mark_stack_too_small = TRUE;
     if (GC_print_stats) {
        GC_log_printf("Mark stack overflow; current size = %lu entries\n",
-                     GC_mark_stack_size);
+                     (unsigned long)GC_mark_stack_size);
     }
     return(msp - GC_MARK_STACK_DISCARDS);
 }
@@ -642,8 +642,9 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
 #        ifdef ENABLE_TRACE
            if (GC_trace_addr >= current_p
                && GC_trace_addr < current_p + descr) {
-               GC_log_printf("GC:%d Large section; start %p len %lu\n",
-                             GC_gc_no, current_p, (unsigned long) descr);
+               GC_log_printf("GC:%u Large section; start %p len %lu\n",
+                             (unsigned)GC_gc_no, current_p,
+                             (unsigned long) descr);
            }
 #        endif /* ENABLE_TRACE */
 #        ifdef PARALLEL_MARK
@@ -659,8 +660,9 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
 #            ifdef ENABLE_TRACE
                if (GC_trace_addr >= current_p
                    && GC_trace_addr < current_p + descr) {
-                   GC_log_printf("GC:%d splitting (parallel) %p at %p\n",
-                                 GC_gc_no, current_p, current_p + new_size);
+                   GC_log_printf("GC:%u splitting (parallel) %p at %p\n",
+                                 (unsigned)GC_gc_no, current_p,
+                                 current_p + new_size);
                }
 #            endif /* ENABLE_TRACE */
              current_p += new_size;
@@ -675,8 +677,8 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
 #        ifdef ENABLE_TRACE
            if (GC_trace_addr >= current_p
                && GC_trace_addr < current_p + descr) {
-               GC_log_printf("GC:%d splitting %p at %p\n",
-                             GC_gc_no, current_p, limit);
+               GC_log_printf("GC:%u splitting %p at %p\n",
+                             (unsigned)GC_gc_no, current_p, limit);
            }
 #        endif /* ENABLE_TRACE */
           /* Make sure that pointers overlapping the two ranges are    */
@@ -688,8 +690,9 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
 #        ifdef ENABLE_TRACE
            if (GC_trace_addr >= current_p
                && GC_trace_addr < current_p + WORDS_TO_BYTES(WORDSZ-2)) {
-               GC_log_printf("GC:%d Tracing from %p bitmap descr %lu\n",
-                             GC_gc_no, current_p, (unsigned long) descr);
+               GC_log_printf("GC:%u Tracing from %p bitmap descr %lu\n",
+                             (unsigned)GC_gc_no, current_p,
+                             (unsigned long) descr);
            }
 #        endif /* ENABLE_TRACE */
           descr &= ~GC_DS_TAGS;
@@ -702,8 +705,9 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
                PREFETCH((ptr_t)current);
 #               ifdef ENABLE_TRACE
                  if (GC_trace_addr == current_p) {
-                   GC_log_printf("GC:%d Considering(3) %p -> %p\n",
-                                 GC_gc_no, current_p, (ptr_t) current);
+                   GC_log_printf("GC:%u Considering(3) %p -> %p\n",
+                                 (unsigned)GC_gc_no, current_p,
+                                 (ptr_t) current);
                  }
 #               endif /* ENABLE_TRACE */
                 PUSH_CONTENTS((ptr_t)current, mark_stack_top,
@@ -720,8 +724,9 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
            if (GC_trace_addr >= current_p
                && GC_base(current_p) != 0
                && GC_base(current_p) == GC_base(GC_trace_addr)) {
-               GC_log_printf("GC:%d Tracing from %p proc descr %lu\n",
-                             GC_gc_no, current_p, (unsigned long) descr);
+               GC_log_printf("GC:%u Tracing from %p proc descr %lu\n",
+                             (unsigned)GC_gc_no, current_p,
+                             (unsigned long) descr);
            }
 #        endif /* ENABLE_TRACE */
           credit -= GC_PROC_BYTES;
@@ -769,8 +774,8 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
 #   ifdef ENABLE_TRACE
        if (GC_trace_addr >= current_p
            && GC_trace_addr < limit) {
-           GC_log_printf("GC:%d Tracing from %p len %lu\n",
-                         GC_gc_no, current_p, (unsigned long) descr);
+           GC_log_printf("GC:%u Tracing from %p len %lu\n",
+                         (int)GC_gc_no, current_p, (unsigned long) descr);
        }
 #   endif /* ENABLE_TRACE */
     /* The simple case in which we're scanning a range.        */
@@ -826,8 +831,8 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
          PREFETCH((ptr_t)current);
 #         ifdef ENABLE_TRACE
            if (GC_trace_addr == current_p) {
-               GC_log_printf("GC:%d Considering(1) %p -> %p\n",
-                             GC_gc_no, current_p, (ptr_t) current);
+               GC_log_printf("GC:%u Considering(1) %p -> %p\n",
+                             (unsigned)GC_gc_no, current_p, (ptr_t) current);
            }
 #         endif /* ENABLE_TRACE */
           PUSH_CONTENTS((ptr_t)current, mark_stack_top,
@@ -842,8 +847,8 @@ mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
        /* validity test.                                               */
 #       ifdef ENABLE_TRACE
            if (GC_trace_addr == current_p) {
-               GC_log_printf("GC:%d Considering(2) %p -> %p\n",
-                             GC_gc_no, current_p, (ptr_t) deferred);
+               GC_log_printf("GC:%u Considering(2) %p -> %p\n",
+                             (unsigned)GC_gc_no, current_p, (ptr_t) deferred);
            }
 #       endif /* ENABLE_TRACE */
         PUSH_CONTENTS((ptr_t)deferred, mark_stack_top,
@@ -1455,8 +1460,9 @@ void GC_print_trace(word gc_no, GC_bool lock)
        if (i < 0) i = TRACE_ENTRIES-1;
        p = GC_trace_buf + i;
        if (p -> gc_no < gc_no || p -> kind == 0) return;
-       printf("Trace:%s (gc:%d,bytes:%d) 0x%X, 0x%X\n",
-               p -> kind, p -> gc_no, p -> bytes_allocd,
+       printf("Trace:%s (gc:%u,bytes:%lu) 0x%X, 0x%X\n",
+               p -> kind, (unsigned)p -> gc_no,
+               (unsigned long)p -> bytes_allocd,
                (p -> arg1) ^ 0x80000000, (p -> arg2) ^ 0x80000000);
     }
     printf("Trace incomplete\n");

diff --git a/os_dep.c b/os_dep.c
index e0538fbf46c907a42099a16431c7d8d5a1fb2827..5b57ea23f292b6d912b3d3bb972ac271f4b4212e 100644 (file)
--- a/os_dep.c
+++ b/os_dep.c
@@ -265,8 +265,9 @@ char * GC_get_maps(void)
            close(f);
 #          ifdef THREADS
              if (maps_size > old_maps_size) {
-               GC_err_printf("Old maps size = %d, new maps size = %d\n",
-                             old_maps_size, maps_size);
+               GC_err_printf("Old maps size = %lu, new maps size = %lu\n",
+                             (unsigned long)old_maps_size,
+                             (unsigned long)maps_size);
                ABORT("Unexpected asynchronous /proc/self/maps growth: "
                      "Unregistered thread?");
              }
@@ -2228,7 +2229,9 @@ STATIC void GC_or_pages(page_hash_table pht1, page_hash_table pht2)
 
 #ifdef GWW_VDB
 
-# define GC_GWW_BUF_LEN 1024
+# define GC_GWW_BUF_LEN (MAXHINCR * HBLKSIZE / 4096 /* X86 page size */)
+  /* Still susceptible to overflow, if there are very large allocations, */
+  /* and everything is dirty.                                           */
   static PVOID gww_buf[GC_GWW_BUF_LEN];
 
 # ifdef MPROTECT_VDB
@@ -2315,6 +2318,9 @@ STATIC void GC_or_pages(page_hash_table pht1, page_hash_table pht2)
           }
         }
       } while (count == GC_GWW_BUF_LEN);
+      /* FIXME: It's unclear from Microsoft's documentation if this loop  */
+      /* is useful.  We suspect the call just fails if the buffer fills          */
+      /* up.  But that should still be handled correctly.                */
     }
 
     GC_or_pages(GC_written_pages, GC_grungy_pages);
@@ -2527,8 +2533,7 @@ void GC_remove_protection(struct hblk *h, word nblocks, GC_bool is_ptrfree)
 #   define PROTECT(addr, len) \
          if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
                              &protect_junk)) { \
-           DWORD last_error = GetLastError(); \
-           GC_printf("Last error code: %lx\n", last_error); \
+           GC_printf("Last error code: %lx\n", (long)GetLastError()); \
            ABORT("VirtualProtect failed"); \
          }
 #   define UNPROTECT(addr, len) \
@@ -3171,7 +3176,7 @@ void GC_dirty_init(void)
                      (unsigned long)
                                (GC_bytes_allocd + GC_bytes_allocd_before_gc));
     }
-    sprintf(buf, "/proc/%d", getpid());
+    sprintf(buf, "/proc/%ld", (long)getpid());
     fd = open(buf, O_RDONLY);
     if (fd < 0) {
        ABORT("/proc open failed");

diff --git a/pthread_stop_world.c b/pthread_stop_world.c
index c077736de5b8ef0f90410c758ca8c8bb1468177c..36c24ddece60ded8042f2d694a313063290ee66d 100644 (file)
--- a/pthread_stop_world.c
+++ b/pthread_stop_world.c
@@ -296,7 +296,7 @@ void GC_push_all_stacks(void)
 #      endif
 #      ifdef IA64
 #         if DEBUG_THREADS
-            GC_printf("Reg stack for thread 0x%x = [%lx,%lx)\n",
+            GC_printf("Reg stack for thread 0x%x = [%p,%p)\n",
                      (unsigned)p -> id, bs_lo, bs_hi);
 #        endif
           if (THREAD_EQUAL(p -> id, me)) {
@@ -310,7 +310,7 @@ void GC_push_all_stacks(void)
       }
     }
     if (GC_print_stats == VERBOSE) {
-       GC_log_printf("Pushed %d thread stacks\n", nthreads);
+       GC_log_printf("Pushed %d thread stacks\n", (int)nthreads);
     }
     if (!found_me && !GC_in_thread_creation)
       ABORT("Collecting from unknown thread.");

diff --git a/pthread_support.c b/pthread_support.c
index dff43e3d80c844d3a8ee6d0c905fe5fc0c1e8ee6..0a3e336fa12b67e73cf3c1696b881f6bb49c4e0b 100644 (file)
--- a/pthread_support.c
+++ b/pthread_support.c
@@ -298,7 +298,8 @@ void * GC_mark_thread(void * id)
        my_mark_no = GC_mark_no;
     }
 #   ifdef DEBUG_THREADS
-       GC_printf("Starting mark helper for mark number %lu\n", my_mark_no);
+       GC_printf("Starting mark helper for mark number %lu\n",
+               (unsigned long)my_mark_no);
 #   endif
     GC_help_marker(my_mark_no);
   }
@@ -1061,7 +1062,7 @@ STATIC void * GC_CALLBACK GC_inner_start_routine(struct GC_stack_base *sb,
 #   ifdef DEBUG_THREADS
         GC_printf("Starting thread 0x%x\n", (unsigned)my_pthread);
         GC_printf("pid = %ld\n", (long) getpid());
-        GC_printf("sp = 0x%lx\n", (long) &arg);
+        GC_printf("sp = %p\n", &arg);
 #   endif
     LOCK();
     me = GC_register_my_thread_inner(sb, my_pthread);
@@ -1069,7 +1070,7 @@ STATIC void * GC_CALLBACK GC_inner_start_routine(struct GC_stack_base *sb,
     UNLOCK();
     start = si -> start_routine;
 #   ifdef DEBUG_THREADS
-       GC_printf("start_routine = %p\n", (void *)start);
+       GC_printf("start_routine = %p\n", (void *)(signed_word)start);
 #   endif
     start_arg = si -> arg;
     sem_post(&(si -> registered));     /* Last action on si.   */

diff --git a/reclaim.c b/reclaim.c
index 30e97deae2ffa0c86d1b70e3303626e64a978171..fd4521de411547d29acfb70dd10e93c9248de084 100644 (file)
--- a/reclaim.c
+++ b/reclaim.c
@@ -403,12 +403,11 @@ STATIC void GC_print_block_descr(struct hblk *h,
     unsigned n_marks = GC_n_set_marks(hhdr);
     
     if (hhdr -> hb_n_marks != n_marks) {
-      GC_printf("(%u:%u,%u!=%u)", hhdr -> hb_obj_kind,
-                                 bytes,
-                                 hhdr -> hb_n_marks, n_marks);
+      GC_printf("(%u:%u,%u!=%u)", hhdr -> hb_obj_kind, (unsigned)bytes,
+                                 (unsigned)hhdr -> hb_n_marks, n_marks);
     } else {
       GC_printf("(%u:%u,%u)", hhdr -> hb_obj_kind,
-                             bytes, n_marks);
+                             (unsigned)bytes, n_marks);
     }
     bytes += HBLKSIZE-1;
     bytes &= ~(HBLKSIZE-1);
@@ -442,10 +441,10 @@ void GC_print_free_list(int kind, size_t sz_in_granules)
     while (flh){
         struct hblk *block = HBLKPTR(flh);
         if (block != lastBlock){
-            GC_printf("\nIn heap block at 0x%x:\n\t", block);
+            GC_printf("\nIn heap block at %p:\n\t", block);
             lastBlock = block;
         }
-        GC_printf("%d: 0x%x;", ++n, flh);
+        GC_printf("%d: %p;", ++n, flh);
         flh = obj_link(flh);
     }
 }

diff --git a/thread_local_alloc.c b/thread_local_alloc.c
index 85865722b09b971923bb0b8960162d322c761b48..71ba97757c3bb832821d0cd259755393360062fe 100644 (file)
--- a/thread_local_alloc.c
+++ b/thread_local_alloc.c
@@ -176,7 +176,8 @@ GC_API void * GC_CALL GC_malloc(size_t bytes)
     GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, DIRECT_GRANULES,
                         NORMAL, GC_core_malloc(bytes), obj_link(result)=0);
 #   ifdef LOG_ALLOCS
-      GC_err_printf("GC_malloc(%d) = %p : %d\n", bytes, result, GC_gc_no);
+      GC_err_printf("GC_malloc(%u) = %p : %u\n",
+                       (unsigned)bytes, result, (unsigned)GC_gc_no);
 #   endif
     return result;
 }