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

equal deleted inserted replaced

-:77349b58b4c0
+:68fa8b6c4340
 #endif
 #if INCLUDE_RTM_OPT
 #include "runtime/rtmLocking.hpp"
 #endif
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 #ifdef DTRACE_ENABLED
 // Only bother with this argument setup if dtrace is available
 #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START
 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
 "JavaThread alignment code overflowed allocated storage");
 if (TraceBiasedLocking) {
 if (aligned_addr != real_malloc_addr) {
 tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
-real_malloc_addr, aligned_addr);
+p2i(real_malloc_addr), p2i(aligned_addr));
 }
 }
 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
 return aligned_addr;
 } else {
 if (osthread() != NULL) {
 int os_prio;
 if (os::get_native_priority(this, &os_prio) == OS_OK) {
 st->print("os_prio=%d ", os_prio);
 }
-st->print("tid=" INTPTR_FORMAT " ", this);
+st->print("tid=" INTPTR_FORMAT " ", p2i(this));
 ext().print_on(st);
 osthread()->print_on(st);
 }
 debug_only(if (WizardMode) print_owned_locks_on(st);)
 }
 else if (is_Watcher_thread())       st->print("WatcherThread");
 else if (is_ConcurrentGC_thread())  st->print("ConcurrentGCThread");
 else                                st->print("Thread");
 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
-_stack_base - _stack_size, _stack_base);
+p2i(_stack_base - _stack_size), p2i(_stack_base));
 if (osthread()) {
 st->print(" [id=%d]", osthread()->thread_id());
 }
 }
 // We cannot call Exceptions::_throw(...) here because we cannot block
 set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
 if (TraceExceptions) {
 ResourceMark rm;
-tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
+tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", p2i(this));
 if (has_last_Java_frame()) {
 frame f = last_frame();
-tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
+tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", p2i(f.pc()), p2i(f.sp()));
 }
 tty->print_cr(" of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
 }
 _pending_async_exception = NULL;
 clear_has_async_exception();
 StackFrameStream fst(this, UseBiasedLocking);
 for (; !fst.is_done(); fst.next()) {
 if (fst.current()->should_be_deoptimized()) {
 if (LogCompilation && xtty != NULL) {
 nmethod* nm = fst.current()->cb()->as_nmethod_or_null();
-xtty->elem("deoptimized thread='" UINTX_FORMAT "' compile_id='%d'",
+xtty->elem("deoptimized thread='%s' compile_id='%d'",
 this->name(), nm != NULL ? nm->compile_id() : -1);
 }
 Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
 }
 st->print("%s", _get_thread_state_name(_thread_state));
 if (osthread()) {
 st->print(", id=%d", osthread()->thread_id());
 }
 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")",
-_stack_base - _stack_size, _stack_base);
+p2i(_stack_base - _stack_size), p2i(_stack_base));
 st->print("]");
 return;
 }
 // Verification
 class PrintAndVerifyOopClosure: public OopClosure {
 protected:
 template <class T> inline void do_oop_work(T* p) {
 oop obj = oopDesc::load_decode_heap_oop(p);
 if (obj == NULL) return;
-tty->print(INTPTR_FORMAT ": ", p);
+tty->print(INTPTR_FORMAT ": ", p2i(p));
 if (obj->is_oop_or_null()) {
 if (obj->is_objArray()) {
-tty->print_cr("valid objArray: " INTPTR_FORMAT, (oopDesc*) obj);
+tty->print_cr("valid objArray: " INTPTR_FORMAT, p2i(obj));
 } else {
 obj->print();
 }
 } else {
-tty->print_cr("invalid oop: " INTPTR_FORMAT, (oopDesc*) obj);
+tty->print_cr("invalid oop: " INTPTR_FORMAT, p2i(obj));
 }
 tty->cr();
 }
 public:
 virtual void do_oop(oop* p) { do_oop_work(p); }
 }
 ThreadService::add_thread(p, daemon);
 // Possible GC point.
-Events::log(p, "Thread added: " INTPTR_FORMAT, p);
+Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
 }
 void Threads::remove(JavaThread* p) {
 // Extra scope needed for Thread_lock, so we can check
 // that we do not remove thread without safepoint code notice
 // of this thread since it is removed from the queue.
 p->set_terminated_value();
 } // unlock Threads_lock
 // Since Events::log uses a lock, we grab it outside the Threads_lock
-Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
+Events::log(p, "Thread exited: " INTPTR_FORMAT, p2i(p));
 }
 // Threads_lock must be held when this is called (or must be called during a safepoint)
 bool Threads::includes(JavaThread* p) {
 assert(Threads_lock->is_locked(), "sanity check");
 bool is_current = (current == thread);
 found_current = found_current || is_current;
 st->print("%s", is_current ? "=>" : "  ");
-st->print(PTR_FORMAT, thread);
+st->print(PTR_FORMAT, p2i(thread));
 st->print(" ");
 thread->print_on_error(st, buf, buflen);
 st->cr();
 }
 st->cr();
 if (VMThread::vm_thread()) {
 bool is_current = (current == VMThread::vm_thread());
 found_current = found_current || is_current;
 st->print("%s", current == VMThread::vm_thread() ? "=>" : "  ");
-st->print(PTR_FORMAT, VMThread::vm_thread());
+st->print(PTR_FORMAT, p2i(VMThread::vm_thread()));
 st->print(" ");
 VMThread::vm_thread()->print_on_error(st, buf, buflen);
 st->cr();
 }
 WatcherThread* wt = WatcherThread::watcher_thread();
 if (wt != NULL) {
 bool is_current = (current == wt);
 found_current = found_current || is_current;
 st->print("%s", is_current ? "=>" : "  ");
-st->print(PTR_FORMAT, wt);
+st->print(PTR_FORMAT, p2i(wt));
 st->print(" ");
 wt->print_on_error(st, buf, buflen);
 st->cr();
 }
 if (!found_current) {
 st->cr();
-st->print("=>" PTR_FORMAT " (exited) ", current);
+st->print("=>" PTR_FORMAT " (exited) ", p2i(current));
 current->print_on_error(st, buf, buflen);
 st->cr();
 }
 }

changeset 33148	68fa8b6c4340
parent 33107	77bf0d2069a3
child 33208	5ec6ffa63c57
child 33198	b37ad9fbf681