jdk-sandbox: comparison hotspot/src/share/vm/runtime/os.cpp

equal deleted inserted replaced

-:77349b58b4c0
+:68fa8b6c4340
 #include "utilities/defaultStream.hpp"
 #include "utilities/events.hpp"
 # include <signal.h>
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 OSThread*         os::_starting_thread    = NULL;
 address           os::_polling_page       = NULL;
 volatile int32_t* os::_mem_serialize_page = NULL;
 uintptr_t         os::_serialize_page_mask = 0;
 long              os::_rand_seed          = 1;
 // Wrap memory with guard
 GuardedMemory guarded(ptr, size + nmt_header_size);
 ptr = guarded.get_user_ptr();
 #endif
 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
-tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
+tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, p2i(ptr));
 breakpoint();
 }
 debug_only(if (paranoid) verify_memory(ptr));
 if (PrintMalloc && tty != NULL) {
-tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
+tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, p2i(ptr));
 }
 // we do not track guard memory
 return MemTracker::record_malloc((address)ptr, size, memflags, stack, level);
 }
 #else
 if (memblock == NULL) {
 return os::malloc(size, memflags, stack);
 }
 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
-tty->print_cr("os::realloc caught " PTR_FORMAT, memblock);
+tty->print_cr("os::realloc caught " PTR_FORMAT, p2i(memblock));
 breakpoint();
 }
 // NMT support
 void* membase = MemTracker::malloc_base(memblock);
 verify_memory(membase);
 return NULL;
 }
 // always move the block
 void* ptr = os::malloc(size, memflags, stack);
 if (PrintMalloc && tty != NULL) {
-tty->print_cr("os::realloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);
+tty->print_cr("os::realloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, p2i(memblock), p2i(ptr));
 }
 // Copy to new memory if malloc didn't fail
 if ( ptr != NULL ) {
 GuardedMemory guarded(MemTracker::malloc_base(memblock));
 // Guard's user data contains NMT header
 size_t memblock_size = guarded.get_user_size() - MemTracker::malloc_header_size(memblock);
 memcpy(ptr, memblock, MIN2(size, memblock_size));
 if (paranoid) verify_memory(MemTracker::malloc_base(ptr));
 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
-tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
+tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, p2i(ptr));
 breakpoint();
 }
 os::free(memblock);
 }
 return ptr;
 void  os::free(void *memblock) {
 NOT_PRODUCT(inc_stat_counter(&num_frees, 1));
 #ifdef ASSERT
 if (memblock == NULL) return;
 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
-if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock);
+if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, p2i(memblock));
 breakpoint();
 }
 void* membase = MemTracker::record_free(memblock);
 verify_memory(membase);
 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
 case 8: cols_per_line = 2;  break;
 default: return;
 }
 address p = start;
-st->print(PTR_FORMAT ":   ", start);
+st->print(PTR_FORMAT ":   ", p2i(start));
 while (p < end) {
 switch (unitsize) {
 case 1: st->print("%02x", *(u1*)p); break;
 case 2: st->print("%04x", *(u2*)p); break;
 case 4: st->print("%08x", *(u4*)p); break;
 p += unitsize;
 cols++;
 if (cols >= cols_per_line && p < end) {
 cols = 0;
 st->cr();
-st->print(PTR_FORMAT ":   ", p);
+st->print(PTR_FORMAT ":   ", p2i(p));
 } else {
 st->print(" ");
 }
 }
 st->cr();
 get_summary_cpu_info(buf, buflen);
 st->print("%s, ", buf);
 size_t mem = physical_memory()/G;
 if (mem == 0) {  // for low memory systems
 mem = physical_memory()/M;
-st->print("%d cores, %dM, ", processor_count(), mem);
+st->print("%d cores, " SIZE_FORMAT "M, ", processor_count(), mem);
 } else {
-st->print("%d cores, %dG, ", processor_count(), mem);
+st->print("%d cores, " SIZE_FORMAT "G, ", processor_count(), mem);
 }
 get_summary_os_info(buf, buflen);
 st->print_raw(buf);
 st->cr();
 }
 if (b != NULL) {
 if (b->is_buffer_blob()) {
 // the interpreter is generated into a buffer blob
 InterpreterCodelet* i = Interpreter::codelet_containing(addr);
 if (i != NULL) {
-st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", addr, (int)(addr - i->code_begin()));
+st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", p2i(addr), (int)(addr - i->code_begin()));
 i->print_on(st);
 return;
 }
 if (Interpreter::contains(addr)) {
 st->print_cr(INTPTR_FORMAT " is pointing into interpreter code"
-" (not bytecode specific)", addr);
+" (not bytecode specific)", p2i(addr));
 return;
 }
 //
 if (AdapterHandlerLibrary::contains(b)) {
-st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", addr, (int)(addr - b->code_begin()));
+st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", p2i(addr), (int)(addr - b->code_begin()));
 AdapterHandlerLibrary::print_handler_on(st, b);
 }
 // the stubroutines are generated into a buffer blob
 StubCodeDesc* d = StubCodeDesc::desc_for(addr);
 if (d != NULL) {
-st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", addr, (int)(addr - d->begin()));
+st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", p2i(addr), (int)(addr - d->begin()));
 d->print_on(st);
 st->cr();
 return;
 }
 if (StubRoutines::contains(addr)) {
-st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) "
+st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) stub routine", p2i(addr));
-"stub routine", addr);
 return;
 }
 // the InlineCacheBuffer is using stubs generated into a buffer blob
 if (InlineCacheBuffer::contains(addr)) {
-st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", addr);
+st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", p2i(addr));
 return;
 }
 VtableStub* v = VtableStubs::stub_containing(addr);
 if (v != NULL) {
-st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", addr, (int)(addr - v->entry_point()));
+st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", p2i(addr), (int)(addr - v->entry_point()));
 v->print_on(st);
 st->cr();
 return;
 }
 }
 nmethod* nm = b->as_nmethod_or_null();
 if (nm != NULL) {
 ResourceMark rm;
 st->print(INTPTR_FORMAT " is at entry_point+%d in (nmethod*)" INTPTR_FORMAT,
-addr, (int)(addr - nm->entry_point()), nm);
+p2i(addr), (int)(addr - nm->entry_point()), p2i(nm));
 if (verbose) {
 st->print(" for ");
 nm->method()->print_value_on(st);
 }
 st->cr();
 nm->print_nmethod(verbose);
 return;
 }
-st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", addr, (int)(addr - b->code_begin()));
+st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", p2i(addr), (int)(addr - b->code_begin()));
 b->print_on(st);
 return;
 }
 if (Universe::heap()->is_in(addr)) {
 p = (HeapWord*) addr;
 print = true;
 }
 if (print) {
 if (p == (HeapWord*) addr) {
-st->print_cr(INTPTR_FORMAT " is an oop", addr);
+st->print_cr(INTPTR_FORMAT " is an oop", p2i(addr));
 } else {
-st->print_cr(INTPTR_FORMAT " is pointing into object: " INTPTR_FORMAT, addr, p);
+st->print_cr(INTPTR_FORMAT " is pointing into object: " INTPTR_FORMAT, p2i(addr), p2i(p));
 }
 oop(p)->print_on(st);
 return;
 }
 } else {
 if (Universe::heap()->is_in_reserved(addr)) {
 st->print_cr(INTPTR_FORMAT " is an unallocated location "
-"in the heap", addr);
+"in the heap", p2i(addr));
 return;
 }
 }
 if (JNIHandles::is_global_handle((jobject) addr)) {
-st->print_cr(INTPTR_FORMAT " is a global jni handle", addr);
+st->print_cr(INTPTR_FORMAT " is a global jni handle", p2i(addr));
 return;
 }
 if (JNIHandles::is_weak_global_handle((jobject) addr)) {
-st->print_cr(INTPTR_FORMAT " is a weak global jni handle", addr);
+st->print_cr(INTPTR_FORMAT " is a weak global jni handle", p2i(addr));
 return;
 }
 #ifndef PRODUCT
 // we don't keep the block list in product mode
 if (JNIHandleBlock::any_contains((jobject) addr)) {
-st->print_cr(INTPTR_FORMAT " is a local jni handle", addr);
+st->print_cr(INTPTR_FORMAT " is a local jni handle", p2i(addr));
 return;
 }
 #endif
 for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
 // Check for privilege stack
 if (thread->privileged_stack_top() != NULL &&
 thread->privileged_stack_top()->contains(addr)) {
 st->print_cr(INTPTR_FORMAT " is pointing into the privilege stack "
-"for thread: " INTPTR_FORMAT, addr, thread);
+"for thread: " INTPTR_FORMAT, p2i(addr), p2i(thread));
 if (verbose) thread->print_on(st);
 return;
 }
 // If the addr is a java thread print information about that.
 if (addr == (address)thread) {
 if (verbose) {
 thread->print_on(st);
 } else {
-st->print_cr(INTPTR_FORMAT " is a thread", addr);
+st->print_cr(INTPTR_FORMAT " is a thread", p2i(addr));
 }
 return;
 }
 // If the addr is in the stack region for this thread then report that
 // and print thread info
 if (thread->stack_base() >= addr &&
 addr > (thread->stack_base() - thread->stack_size())) {
 st->print_cr(INTPTR_FORMAT " is pointing into the stack for thread: "
-INTPTR_FORMAT, addr, thread);
+INTPTR_FORMAT, p2i(addr), p2i(thread));
 if (verbose) thread->print_on(st);
 return;
 }
 }
 if (Method::has_method_vptr((const void*)addr)) {
 ((Method*)addr)->print_value_on(st);
 st->cr();
 } else {
 // Use addr->print() from the debugger instead (not here)
-st->print_cr(INTPTR_FORMAT " is pointing into metadata", addr);
+st->print_cr(INTPTR_FORMAT " is pointing into metadata", p2i(addr));
 }
 return;
 }
 // Try an OS specific find
 if (os::find(addr, st)) {
 return;
 }
-st->print_cr(INTPTR_FORMAT " is an unknown value", addr);
+st->print_cr(INTPTR_FORMAT " is an unknown value", p2i(addr));
 }
 // Looks like all platforms except IA64 can use the same function to check
 // if C stack is walkable beyond current frame. The check for fp() is not
 // necessary on Sparc, but it's harmless.
 if (TracePageSizes) {
 tty->print_cr("%s:  min=" SIZE_FORMAT " max=" SIZE_FORMAT
 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT
 " size=" SIZE_FORMAT,
 str, region_min_size, region_max_size,
-page_size, base, size);
+page_size, p2i(base), size);
 }
 }
 #endif  // #ifndef PRODUCT
 // This is the working definition of a server class machine:

changeset 33148	68fa8b6c4340
parent 33105	294e48b4f704
child 33593	60764a78fa5c