From ee6104254324ccb8728cca74b866c5b26d481cfc Mon Sep 17 00:00:00 2001 From: hboehm Date: Sun, 1 Mar 2009 00:20:14 +0000 Subject: [PATCH] 2009-02-28 Hans Boehm (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 * os_dep.c: Define GC_GWW_BUF_LEN more intelligently. Add FIXME comment. --- ChangeLog | 11 ++++++++ allchblk.c | 4 +-- backgraph.c | 4 +-- dbg_mlc.c | 7 +++-- dyn_load.c | 4 +-- finalize.c | 8 +++--- include/private/gc_pmark.h | 17 ++++++++----- malloc.c | 2 +- mark.c | 52 +++++++++++++++++++++----------------- os_dep.c | 17 ++++++++----- pthread_stop_world.c | 4 +-- pthread_support.c | 7 ++--- reclaim.c | 11 ++++---- thread_local_alloc.c | 3 ++- 14 files changed, 89 insertions(+), 62 deletions(-) diff --git a/ChangeLog b/ChangeLog index 6684b574..5fb8b053 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2009-02-28 Hans Boehm (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 + * os_dep.c: Define GC_GWW_BUF_LEN more intelligently. Add FIXME + comment. + 2009-02-28 Hans Boehm (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 82822ed3..694e9dec 100644 --- 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 233400a2..0ca05194 100644 --- 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 1758635c..70137d4c 100644 --- 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(", appr. sz = %ld)\n", - (GC_size((ptr_t)ohdr) - DEBUG_BYTES)); + GC_err_printf(", 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 5c3842c4..459d17ef 100644 --- 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 402f783f..bc41ffed 100644 --- 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 e8930828..b0dd2089 100644 --- 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 33297608..7d214af3 100644 --- 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 b636c057..5bd43b82 100644 --- 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 e0538fbf..5b57ea23 100644 --- 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 c077736d..36c24dde 100644 --- 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 dff43e3d..0a3e336f 100644 --- 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 30e97dea..fd4521de 100644 --- 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 85865722..71ba9775 100644 --- 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; } -- 2.50.1