src/share/vm/runtime/thread.cpp
author ysr
Fri Oct 16 02:05:46 2009 -0700 (3 weeks ago)
changeset 1027 39b01ab7035a
parent 99746b819ba120b
permissions -rw-r--r--
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
6889757: G1: enable card mark elision for initializing writes from compiled code (ReduceInitialCardMarks)
Summary: Defer the (compiler-elided) card-mark upon a slow-path allocation until after the store and before the next subsequent safepoint; G1 now answers yes to can_elide_tlab_write_barriers().
Reviewed-by: jcoomes, kvn, never
        1 /*
        2  * Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
        3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
        4  *
        5  * This code is free software; you can redistribute it and/or modify it
        6  * under the terms of the GNU General Public License version 2 only, as
        7  * published by the Free Software Foundation.
        8  *
        9  * This code is distributed in the hope that it will be useful, but WITHOUT
       10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
       12  * version 2 for more details (a copy is included in the LICENSE file that
       13  * accompanied this code).
       14  *
       15  * You should have received a copy of the GNU General Public License version
       16  * 2 along with this work; if not, write to the Free Software Foundation,
       17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
       18  *
       19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
       20  * CA 95054 USA or visit www.sun.com if you need additional information or
       21  * have any questions.
       22  *
       23  */
       24 
       25 # include "incls/_precompiled.incl"
       26 # include "incls/_thread.cpp.incl"
       27 
       28 #ifdef DTRACE_ENABLED
       29 
       30 // Only bother with this argument setup if dtrace is available
       31 
       32 HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);
       33 HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);
       34 HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,
       35   intptr_t, intptr_t, bool);
       36 HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
       37   intptr_t, intptr_t, bool);
       38 
       39 #define DTRACE_THREAD_PROBE(probe, javathread)                             \
       40   {                                                                        \
       41     ResourceMark rm(this);                                                 \
       42     int len = 0;                                                           \
       43     const char* name = (javathread)->get_thread_name();                    \
       44     len = strlen(name);                                                    \
       45     HS_DTRACE_PROBE5(hotspot, thread__##probe,                             \
       46       name, len,                                                           \
       47       java_lang_Thread::thread_id((javathread)->threadObj()),              \
       48       (javathread)->osthread()->thread_id(),                               \
       49       java_lang_Thread::is_daemon((javathread)->threadObj()));             \
       50   }
       51 
       52 #else //  ndef DTRACE_ENABLED
       53 
       54 #define DTRACE_THREAD_PROBE(probe, javathread)
       55 
       56 #endif // ndef DTRACE_ENABLED
       57 
       58 // Class hierarchy
       59 // - Thread
       60 //   - VMThread
       61 //   - WatcherThread
       62 //   - ConcurrentMarkSweepThread
       63 //   - JavaThread
       64 //     - CompilerThread
       65 
       66 // ======= Thread ========
       67 
       68 // Support for forcing alignment of thread objects for biased locking
       69 void* Thread::operator new(size_t size) {
       70   if (UseBiasedLocking) {
       71     const int alignment = markOopDesc::biased_lock_alignment;
       72     size_t aligned_size = size + (alignment - sizeof(intptr_t));
       73     void* real_malloc_addr = CHeapObj::operator new(aligned_size);
       74     void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
       75     assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
       76            ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
       77            "JavaThread alignment code overflowed allocated storage");
       78     if (TraceBiasedLocking) {
       79       if (aligned_addr != real_malloc_addr)
       80         tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
       81                       real_malloc_addr, aligned_addr);
       82     }
       83     ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
       84     return aligned_addr;
       85   } else {
       86     return CHeapObj::operator new(size);
       87   }
       88 }
       89 
       90 void Thread::operator delete(void* p) {
       91   if (UseBiasedLocking) {
       92     void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
       93     CHeapObj::operator delete(real_malloc_addr);
       94   } else {
       95     CHeapObj::operator delete(p);
       96   }
       97 }
       98 
       99 
      100 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,
      101 // JavaThread
      102 
      103 
      104 Thread::Thread() {
      105   // stack
      106   _stack_base   = NULL;
      107   _stack_size   = 0;
      108   _self_raw_id  = 0;
      109   _lgrp_id      = -1;
      110   _osthread     = NULL;
      111 
      112   // allocated data structures
      113   set_resource_area(new ResourceArea());
      114   set_handle_area(new HandleArea(NULL));
      115   set_active_handles(NULL);
      116   set_free_handle_block(NULL);
      117   set_last_handle_mark(NULL);
      118   set_osthread(NULL);
      119 
      120   // This initial value ==> never claimed.
      121   _oops_do_parity = 0;
      122 
      123   // the handle mark links itself to last_handle_mark
      124   new HandleMark(this);
      125 
      126   // plain initialization
      127   debug_only(_owned_locks = NULL;)
      128   debug_only(_allow_allocation_count = 0;)
      129   NOT_PRODUCT(_allow_safepoint_count = 0;)
      130   NOT_PRODUCT(_skip_gcalot = false;)
      131   CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
      132   _jvmti_env_iteration_count = 0;
      133   _vm_operation_started_count = 0;
      134   _vm_operation_completed_count = 0;
      135   _current_pending_monitor = NULL;
      136   _current_pending_monitor_is_from_java = true;
      137   _current_waiting_monitor = NULL;
      138   _num_nested_signal = 0;
      139   omFreeList = NULL ;
      140   omFreeCount = 0 ;
      141   omFreeProvision = 32 ;
      142 
      143   _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);
      144   _suspend_flags = 0;
      145 
      146   // thread-specific hashCode stream generator state - Marsaglia shift-xor form
      147   _hashStateX = os::random() ;
      148   _hashStateY = 842502087 ;
      149   _hashStateZ = 0x8767 ;    // (int)(3579807591LL & 0xffff) ;
      150   _hashStateW = 273326509 ;
      151 
      152   _OnTrap   = 0 ;
      153   _schedctl = NULL ;
      154   _Stalled  = 0 ;
      155   _TypeTag  = 0x2BAD ;
      156 
      157   // Many of the following fields are effectively final - immutable
      158   // Note that nascent threads can't use the Native Monitor-Mutex
      159   // construct until the _MutexEvent is initialized ...
      160   // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents
      161   // we might instead use a stack of ParkEvents that we could provision on-demand.
      162   // The stack would act as a cache to avoid calls to ParkEvent::Allocate()
      163   // and ::Release()
      164   _ParkEvent   = ParkEvent::Allocate (this) ;
      165   _SleepEvent  = ParkEvent::Allocate (this) ;
      166   _MutexEvent  = ParkEvent::Allocate (this) ;
      167   _MuxEvent    = ParkEvent::Allocate (this) ;
      168 
      169 #ifdef CHECK_UNHANDLED_OOPS
      170   if (CheckUnhandledOops) {
      171     _unhandled_oops = new UnhandledOops(this);
      172   }
      173 #endif // CHECK_UNHANDLED_OOPS
      174 #ifdef ASSERT
      175   if (UseBiasedLocking) {
      176     assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
      177     assert(this == _real_malloc_address ||
      178            this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
      179            "bug in forced alignment of thread objects");
      180   }
      181 #endif /* ASSERT */
      182 }
      183 
      184 void Thread::initialize_thread_local_storage() {
      185   // Note: Make sure this method only calls
      186   // non-blocking operations. Otherwise, it might not work
      187   // with the thread-startup/safepoint interaction.
      188 
      189   // During Java thread startup, safepoint code should allow this
      190   // method to complete because it may need to allocate memory to
      191   // store information for the new thread.
      192 
      193   // initialize structure dependent on thread local storage
      194   ThreadLocalStorage::set_thread(this);
      195 
      196   // set up any platform-specific state.
      197   os::initialize_thread();
      198 
      199 }
      200 
      201 void Thread::record_stack_base_and_size() {
      202   set_stack_base(os::current_stack_base());
      203   set_stack_size(os::current_stack_size());
      204 }
      205 
      206 
      207 Thread::~Thread() {
      208   // Reclaim the objectmonitors from the omFreeList of the moribund thread.
      209   ObjectSynchronizer::omFlush (this) ;
      210 
      211   // deallocate data structures
      212   delete resource_area();
      213   // since the handle marks are using the handle area, we have to deallocated the root
      214   // handle mark before deallocating the thread's handle area,
      215   assert(last_handle_mark() != NULL, "check we have an element");
      216   delete last_handle_mark();
      217   assert(last_handle_mark() == NULL, "check we have reached the end");
      218 
      219   // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
      220   // We NULL out the fields for good hygiene.
      221   ParkEvent::Release (_ParkEvent)   ; _ParkEvent   = NULL ;
      222   ParkEvent::Release (_SleepEvent)  ; _SleepEvent  = NULL ;
      223   ParkEvent::Release (_MutexEvent)  ; _MutexEvent  = NULL ;
      224   ParkEvent::Release (_MuxEvent)    ; _MuxEvent    = NULL ;
      225 
      226   delete handle_area();
      227 
      228   // osthread() can be NULL, if creation of thread failed.
      229   if (osthread() != NULL) os::free_thread(osthread());
      230 
      231   delete _SR_lock;
      232 
      233   // clear thread local storage if the Thread is deleting itself
      234   if (this == Thread::current()) {
      235     ThreadLocalStorage::set_thread(NULL);
      236   } else {
      237     // In the case where we're not the current thread, invalidate all the
      238     // caches in case some code tries to get the current thread or the
      239     // thread that was destroyed, and gets stale information.
      240     ThreadLocalStorage::invalidate_all();
      241   }
      242   CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)
      243 }
      244 
      245 // NOTE: dummy function for assertion purpose.
      246 void Thread::run() {
      247   ShouldNotReachHere();
      248 }
      249 
      250 #ifdef ASSERT
      251 // Private method to check for dangling thread pointer
      252 void check_for_dangling_thread_pointer(Thread *thread) {
      253  assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
      254          "possibility of dangling Thread pointer");
      255 }
      256 #endif
      257 
      258 
      259 #ifndef PRODUCT
      260 // Tracing method for basic thread operations
      261 void Thread::trace(const char* msg, const Thread* const thread) {
      262   if (!TraceThreadEvents) return;
      263   ResourceMark rm;
      264   ThreadCritical tc;
      265   const char *name = "non-Java thread";
      266   int prio = -1;
      267   if (thread->is_Java_thread()
      268       && !thread->is_Compiler_thread()) {
      269     // The Threads_lock must be held to get information about
      270     // this thread but may not be in some situations when
      271     // tracing  thread events.
      272     bool release_Threads_lock = false;
      273     if (!Threads_lock->owned_by_self()) {
      274       Threads_lock->lock();
      275       release_Threads_lock = true;
      276     }
      277     JavaThread* jt = (JavaThread *)thread;
      278     name = (char *)jt->get_thread_name();
      279     oop thread_oop = jt->threadObj();
      280     if (thread_oop != NULL) {
      281       prio = java_lang_Thread::priority(thread_oop);
      282     }
      283     if (release_Threads_lock) {
      284       Threads_lock->unlock();
      285     }
      286   }
      287   tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);
      288 }
      289 #endif
      290 
      291 
      292 ThreadPriority Thread::get_priority(const Thread* const thread) {
      293   trace("get priority", thread);
      294   ThreadPriority priority;
      295   // Can return an error!
      296   (void)os::get_priority(thread, priority);
      297   assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");
      298   return priority;
      299 }
      300 
      301 void Thread::set_priority(Thread* thread, ThreadPriority priority) {
      302   trace("set priority", thread);
      303   debug_only(check_for_dangling_thread_pointer(thread);)
      304   // Can return an error!
      305   (void)os::set_priority(thread, priority);
      306 }
      307 
      308 
      309 void Thread::start(Thread* thread) {
      310   trace("start", thread);
      311   // Start is different from resume in that its safety is guaranteed by context or
      312   // being called from a Java method synchronized on the Thread object.
      313   if (!DisableStartThread) {
      314     if (thread->is_Java_thread()) {
      315       // Initialize the thread state to RUNNABLE before starting this thread.
      316       // Can not set it after the thread started because we do not know the
      317       // exact thread state at that time. It could be in MONITOR_WAIT or
      318       // in SLEEPING or some other state.
      319       java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
      320                                           java_lang_Thread::RUNNABLE);
      321     }
      322     os::start_thread(thread);
      323   }
      324 }
      325 
      326 // Enqueue a VM_Operation to do the job for us - sometime later
      327 void Thread::send_async_exception(oop java_thread, oop java_throwable) {
      328   VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);
      329   VMThread::execute(vm_stop);
      330 }
      331 
      332 
      333 //
      334 // Check if an external suspend request has completed (or has been
      335 // cancelled). Returns true if the thread is externally suspended and
      336 // false otherwise.
      337 //
      338 // The bits parameter returns information about the code path through
      339 // the routine. Useful for debugging:
      340 //
      341 // set in is_ext_suspend_completed():
      342 // 0x00000001 - routine was entered
      343 // 0x00000010 - routine return false at end
      344 // 0x00000100 - thread exited (return false)
      345 // 0x00000200 - suspend request cancelled (return false)
      346 // 0x00000400 - thread suspended (return true)
      347 // 0x00001000 - thread is in a suspend equivalent state (return true)
      348 // 0x00002000 - thread is native and walkable (return true)
      349 // 0x00004000 - thread is native_trans and walkable (needed retry)
      350 //
      351 // set in wait_for_ext_suspend_completion():
      352 // 0x00010000 - routine was entered
      353 // 0x00020000 - suspend request cancelled before loop (return false)
      354 // 0x00040000 - thread suspended before loop (return true)
      355 // 0x00080000 - suspend request cancelled in loop (return false)
      356 // 0x00100000 - thread suspended in loop (return true)
      357 // 0x00200000 - suspend not completed during retry loop (return false)
      358 //
      359 
      360 // Helper class for tracing suspend wait debug bits.
      361 //
      362 // 0x00000100 indicates that the target thread exited before it could
      363 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and
      364 // 0x00080000 each indicate a cancelled suspend request so they don't
      365 // count as wait failures either.
      366 #define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)
      367 
      368 class TraceSuspendDebugBits : public StackObj {
      369  private:
      370   JavaThread * jt;
      371   bool         is_wait;
      372   bool         called_by_wait;  // meaningful when !is_wait
      373   uint32_t *   bits;
      374 
      375  public:
      376   TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,
      377                         uint32_t *_bits) {
      378     jt             = _jt;
      379     is_wait        = _is_wait;
      380     called_by_wait = _called_by_wait;
      381     bits           = _bits;
      382   }
      383 
      384   ~TraceSuspendDebugBits() {
      385     if (!is_wait) {
      386 #if 1
      387       // By default, don't trace bits for is_ext_suspend_completed() calls.
      388       // That trace is very chatty.
      389       return;
      390 #else
      391       if (!called_by_wait) {
      392         // If tracing for is_ext_suspend_completed() is enabled, then only
      393         // trace calls to it from wait_for_ext_suspend_completion()
      394         return;
      395       }
      396 #endif
      397     }
      398 
      399     if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {
      400       if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {
      401         MutexLocker ml(Threads_lock);  // needed for get_thread_name()
      402         ResourceMark rm;
      403 
      404         tty->print_cr(
      405             "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",
      406             jt->get_thread_name(), *bits);
      407 
      408         guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");
      409       }
      410     }
      411   }
      412 };
      413 #undef DEBUG_FALSE_BITS
      414 
      415 
      416 bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) {
      417   TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits);
      418 
      419   bool did_trans_retry = false;  // only do thread_in_native_trans retry once
      420   bool do_trans_retry;           // flag to force the retry
      421 
      422   *bits |= 0x00000001;
      423 
      424   do {
      425     do_trans_retry = false;
      426 
      427     if (is_exiting()) {
      428       // Thread is in the process of exiting. This is always checked
      429       // first to reduce the risk of dereferencing a freed JavaThread.
      430       *bits |= 0x00000100;
      431       return false;
      432     }
      433 
      434     if (!is_external_suspend()) {
      435       // Suspend request is cancelled. This is always checked before
      436       // is_ext_suspended() to reduce the risk of a rogue resume
      437       // confusing the thread that made the suspend request.
      438       *bits |= 0x00000200;
      439       return false;
      440     }
      441 
      442     if (is_ext_suspended()) {
      443       // thread is suspended
      444       *bits |= 0x00000400;
      445       return true;
      446     }
      447 
      448     // Now that we no longer do hard suspends of threads running
      449     // native code, the target thread can be changing thread state
      450     // while we are in this routine:
      451     //
      452     //   _thread_in_native -> _thread_in_native_trans -> _thread_blocked
      453     //
      454     // We save a copy of the thread state as observed at this moment
      455     // and make our decision about suspend completeness based on the
      456     // copy. This closes the race where the thread state is seen as
      457     // _thread_in_native_trans in the if-thread_blocked check, but is
      458     // seen as _thread_blocked in if-thread_in_native_trans check.
      459     JavaThreadState save_state = thread_state();
      460 
      461     if (save_state == _thread_blocked && is_suspend_equivalent()) {
      462       // If the thread's state is _thread_blocked and this blocking
      463       // condition is known to be equivalent to a suspend, then we can
      464       // consider the thread to be externally suspended. This means that
      465       // the code that sets _thread_blocked has been modified to do
      466       // self-suspension if the blocking condition releases. We also
      467       // used to check for CONDVAR_WAIT here, but that is now covered by
      468       // the _thread_blocked with self-suspension check.
      469       //
      470       // Return true since we wouldn't be here unless there was still an
      471       // external suspend request.
      472       *bits |= 0x00001000;
      473       return true;
      474     } else if (save_state == _thread_in_native && frame_anchor()->walkable()) {
      475       // Threads running native code will self-suspend on native==>VM/Java
      476       // transitions. If its stack is walkable (should always be the case
      477       // unless this function is called before the actual java_suspend()
      478       // call), then the wait is done.
      479       *bits |= 0x00002000;
      480       return true;
      481     } else if (!called_by_wait && !did_trans_retry &&
      482                save_state == _thread_in_native_trans &&
      483                frame_anchor()->walkable()) {
      484       // The thread is transitioning from thread_in_native to another
      485       // thread state. check_safepoint_and_suspend_for_native_trans()
      486       // will force the thread to self-suspend. If it hasn't gotten
      487       // there yet we may have caught the thread in-between the native
      488       // code check above and the self-suspend. Lucky us. If we were
      489       // called by wait_for_ext_suspend_completion(), then it
      490       // will be doing the retries so we don't have to.
      491       //
      492       // Since we use the saved thread state in the if-statement above,
      493       // there is a chance that the thread has already transitioned to
      494       // _thread_blocked by the time we get here. In that case, we will
      495       // make a single unnecessary pass through the logic below. This
      496       // doesn't hurt anything since we still do the trans retry.
      497 
      498       *bits |= 0x00004000;
      499 
      500       // Once the thread leaves thread_in_native_trans for another
      501       // thread state, we break out of this retry loop. We shouldn't
      502       // need this flag to prevent us from getting back here, but
      503       // sometimes paranoia is good.
      504       did_trans_retry = true;
      505 
      506       // We wait for the thread to transition to a more usable state.
      507       for (int i = 1; i <= SuspendRetryCount; i++) {
      508         // We used to do an "os::yield_all(i)" call here with the intention
      509         // that yielding would increase on each retry. However, the parameter
      510         // is ignored on Linux which means the yield didn't scale up. Waiting
      511         // on the SR_lock below provides a much more predictable scale up for
      512         // the delay. It also provides a simple/direct point to check for any
      513         // safepoint requests from the VMThread
      514 
      515         // temporarily drops SR_lock while doing wait with safepoint check
      516         // (if we're a JavaThread - the WatcherThread can also call this)
      517         // and increase delay with each retry
      518         SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
      519 
      520         // check the actual thread state instead of what we saved above
      521         if (thread_state() != _thread_in_native_trans) {
      522           // the thread has transitioned to another thread state so
      523           // try all the checks (except this one) one more time.
      524           do_trans_retry = true;
      525           break;
      526         }
      527       } // end retry loop
      528 
      529 
      530     }
      531   } while (do_trans_retry);
      532 
      533   *bits |= 0x00000010;
      534   return false;
      535 }
      536 
      537 //
      538 // Wait for an external suspend request to complete (or be cancelled).
      539 // Returns true if the thread is externally suspended and false otherwise.
      540 //
      541 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
      542        uint32_t *bits) {
      543   TraceSuspendDebugBits tsdb(this, true /* is_wait */,
      544                              false /* !called_by_wait */, bits);
      545 
      546   // local flag copies to minimize SR_lock hold time
      547   bool is_suspended;
      548   bool pending;
      549   uint32_t reset_bits;
      550 
      551   // set a marker so is_ext_suspend_completed() knows we are the caller
      552   *bits |= 0x00010000;
      553 
      554   // We use reset_bits to reinitialize the bits value at the top of
      555   // each retry loop. This allows the caller to make use of any
      556   // unused bits for their own marking purposes.
      557   reset_bits = *bits;
      558 
      559   {
      560     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
      561     is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
      562                                             delay, bits);
      563     pending = is_external_suspend();
      564   }
      565   // must release SR_lock to allow suspension to complete
      566 
      567   if (!pending) {
      568     // A cancelled suspend request is the only false return from
      569     // is_ext_suspend_completed() that keeps us from entering the
      570     // retry loop.
      571     *bits |= 0x00020000;
      572     return false;
      573   }
      574 
      575   if (is_suspended) {
      576     *bits |= 0x00040000;
      577     return true;
      578   }
      579 
      580   for (int i = 1; i <= retries; i++) {
      581     *bits = reset_bits;  // reinit to only track last retry
      582 
      583     // We used to do an "os::yield_all(i)" call here with the intention
      584     // that yielding would increase on each retry. However, the parameter
      585     // is ignored on Linux which means the yield didn't scale up. Waiting
      586     // on the SR_lock below provides a much more predictable scale up for
      587     // the delay. It also provides a simple/direct point to check for any
      588     // safepoint requests from the VMThread
      589 
      590     {
      591       MutexLocker ml(SR_lock());
      592       // wait with safepoint check (if we're a JavaThread - the WatcherThread
      593       // can also call this)  and increase delay with each retry
      594       SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
      595 
      596       is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
      597                                               delay, bits);
      598 
      599       // It is possible for the external suspend request to be cancelled
      600       // (by a resume) before the actual suspend operation is completed.
      601       // Refresh our local copy to see if we still need to wait.
      602       pending = is_external_suspend();
      603     }
      604 
      605     if (!pending) {
      606       // A cancelled suspend request is the only false return from
      607       // is_ext_suspend_completed() that keeps us from staying in the
      608       // retry loop.
      609       *bits |= 0x00080000;
      610       return false;
      611     }
      612 
      613     if (is_suspended) {
      614       *bits |= 0x00100000;
      615       return true;
      616     }
      617   } // end retry loop
      618 
      619   // thread did not suspend after all our retries
      620   *bits |= 0x00200000;
      621   return false;
      622 }
      623 
      624 #ifndef PRODUCT
      625 void JavaThread::record_jump(address target, address instr, const char* file, int line) {
      626 
      627   // This should not need to be atomic as the only way for simultaneous
      628   // updates is via interrupts. Even then this should be rare or non-existant
      629   // and we don't care that much anyway.
      630 
      631   int index = _jmp_ring_index;
      632   _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
      633   _jmp_ring[index]._target = (intptr_t) target;
      634   _jmp_ring[index]._instruction = (intptr_t) instr;
      635   _jmp_ring[index]._file = file;
      636   _jmp_ring[index]._line = line;
      637 }
      638 #endif /* PRODUCT */
      639 
      640 // Called by flat profiler
      641 // Callers have already called wait_for_ext_suspend_completion
      642 // The assertion for that is currently too complex to put here:
      643 bool JavaThread::profile_last_Java_frame(frame* _fr) {
      644   bool gotframe = false;
      645   // self suspension saves needed state.
      646   if (has_last_Java_frame() && _anchor.walkable()) {
      647      *_fr = pd_last_frame();
      648      gotframe = true;
      649   }
      650   return gotframe;
      651 }
      652 
      653 void Thread::interrupt(Thread* thread) {
      654   trace("interrupt", thread);
      655   debug_only(check_for_dangling_thread_pointer(thread);)
      656   os::interrupt(thread);
      657 }
      658 
      659 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
      660   trace("is_interrupted", thread);
      661   debug_only(check_for_dangling_thread_pointer(thread);)
      662   // Note:  If clear_interrupted==false, this simply fetches and
      663   // returns the value of the field osthread()->interrupted().
      664   return os::is_interrupted(thread, clear_interrupted);
      665 }
      666 
      667 
      668 // GC Support
      669 bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
      670   jint thread_parity = _oops_do_parity;
      671   if (thread_parity != strong_roots_parity) {
      672     jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
      673     if (res == thread_parity) return true;
      674     else {
      675       guarantee(res == strong_roots_parity, "Or else what?");
      676       assert(SharedHeap::heap()->n_par_threads() > 0,
      677              "Should only fail when parallel.");
      678       return false;
      679     }
      680   }
      681   assert(SharedHeap::heap()->n_par_threads() > 0,
      682          "Should only fail when parallel.");
      683   return false;
      684 }
      685 
      686 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
      687   active_handles()->oops_do(f);
      688   // Do oop for ThreadShadow
      689   f->do_oop((oop*)&_pending_exception);
      690   handle_area()->oops_do(f);
      691 }
      692 
      693 void Thread::nmethods_do(CodeBlobClosure* cf) {
      694   // no nmethods in a generic thread...
      695 }
      696 
      697 void Thread::print_on(outputStream* st) const {
      698   // get_priority assumes osthread initialized
      699   if (osthread() != NULL) {
      700     st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this);
      701     osthread()->print_on(st);
      702   }
      703   debug_only(if (WizardMode) print_owned_locks_on(st);)
      704 }
      705 
      706 // Thread::print_on_error() is called by fatal error handler. Don't use
      707 // any lock or allocate memory.
      708 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
      709   if      (is_VM_thread())                  st->print("VMThread");
      710   else if (is_Compiler_thread())            st->print("CompilerThread");
      711   else if (is_Java_thread())                st->print("JavaThread");
      712   else if (is_GC_task_thread())             st->print("GCTaskThread");
      713   else if (is_Watcher_thread())             st->print("WatcherThread");
      714   else if (is_ConcurrentGC_thread())        st->print("ConcurrentGCThread");
      715   else st->print("Thread");
      716 
      717   st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
      718             _stack_base - _stack_size, _stack_base);
      719 
      720   if (osthread()) {
      721     st->print(" [id=%d]", osthread()->thread_id());
      722   }
      723 }
      724 
      725 #ifdef ASSERT
      726 void Thread::print_owned_locks_on(outputStream* st) const {
      727   Monitor *cur = _owned_locks;
      728   if (cur == NULL) {
      729     st->print(" (no locks) ");
      730   } else {
      731     st->print_cr(" Locks owned:");
      732     while(cur) {
      733       cur->print_on(st);
      734       cur = cur->next();
      735     }
      736   }
      737 }
      738 
      739 static int ref_use_count  = 0;
      740 
      741 bool Thread::owns_locks_but_compiled_lock() const {
      742   for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
      743     if (cur != Compile_lock) return true;
      744   }
      745   return false;
      746 }
      747 
      748 
      749 #endif
      750 
      751 #ifndef PRODUCT
      752 
      753 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
      754 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
      755 // no threads which allow_vm_block's are held
      756 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
      757     // Check if current thread is allowed to block at a safepoint
      758     if (!(_allow_safepoint_count == 0))
      759       fatal("Possible safepoint reached by thread that does not allow it");
      760     if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
      761       fatal("LEAF method calling lock?");
      762     }
      763 
      764 #ifdef ASSERT
      765     if (potential_vm_operation && is_Java_thread()
      766         && !Universe::is_bootstrapping()) {
      767       // Make sure we do not hold any locks that the VM thread also uses.
      768       // This could potentially lead to deadlocks
      769       for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
      770         // Threads_lock is special, since the safepoint synchronization will not start before this is
      771         // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
      772         // since it is used to transfer control between JavaThreads and the VMThread
      773         // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
      774         if ( (cur->allow_vm_block() &&
      775               cur != Threads_lock &&
      776               cur != Compile_lock &&               // Temporary: should not be necessary when we get spearate compilation
      777               cur != VMOperationRequest_lock &&
      778               cur != VMOperationQueue_lock) ||
      779               cur->rank() == Mutex::special) {
      780           warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
      781         }
      782       }
      783     }
      784 
      785     if (GCALotAtAllSafepoints) {
      786       // We could enter a safepoint here and thus have a gc
      787       InterfaceSupport::check_gc_alot();
      788     }
      789 #endif
      790 }
      791 #endif
      792 
      793 bool Thread::is_in_stack(address adr) const {
      794   assert(Thread::current() == this, "is_in_stack can only be called from current thread");
      795   address end = os::current_stack_pointer();
      796   if (stack_base() >= adr && adr >= end) return true;
      797 
      798   return false;
      799 }
      800 
      801 
      802 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter
      803 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being
      804 // used for compilation in the future. If that change is made, the need for these methods
      805 // should be revisited, and they should be removed if possible.
      806 
      807 bool Thread::is_lock_owned(address adr) const {
      808   return (_stack_base >= adr && adr >= (_stack_base - _stack_size));
      809 }
      810 
      811 bool Thread::set_as_starting_thread() {
      812  // NOTE: this must be called inside the main thread.
      813   return os::create_main_thread((JavaThread*)this);
      814 }
      815 
      816 static void initialize_class(symbolHandle class_name, TRAPS) {
      817   klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
      818   instanceKlass::cast(klass)->initialize(CHECK);
      819 }
      820 
      821 
      822 // Creates the initial ThreadGroup
      823 static Handle create_initial_thread_group(TRAPS) {
      824   klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH);
      825   instanceKlassHandle klass (THREAD, k);
      826 
      827   Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
      828   {
      829     JavaValue result(T_VOID);
      830     JavaCalls::call_special(&result,
      831                             system_instance,
      832                             klass,
      833                             vmSymbolHandles::object_initializer_name(),
      834                             vmSymbolHandles::void_method_signature(),
      835                             CHECK_NH);
      836   }
      837   Universe::set_system_thread_group(system_instance());
      838 
      839   Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
      840   {
      841     JavaValue result(T_VOID);
      842     Handle string = java_lang_String::create_from_str("main", CHECK_NH);
      843     JavaCalls::call_special(&result,
      844                             main_instance,
      845                             klass,
      846                             vmSymbolHandles::object_initializer_name(),
      847                             vmSymbolHandles::threadgroup_string_void_signature(),
      848                             system_instance,
      849                             string,
      850                             CHECK_NH);
      851   }
      852   return main_instance;
      853 }
      854 
      855 // Creates the initial Thread
      856 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
      857   klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL);
      858   instanceKlassHandle klass (THREAD, k);
      859   instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
      860 
      861   java_lang_Thread::set_thread(thread_oop(), thread);
      862   java_lang_Thread::set_priority(thread_oop(), NormPriority);
      863   thread->set_threadObj(thread_oop());
      864 
      865   Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
      866 
      867   JavaValue result(T_VOID);
      868   JavaCalls::call_special(&result, thread_oop,
      869                                    klass,
      870                                    vmSymbolHandles::object_initializer_name(),
      871                                    vmSymbolHandles::threadgroup_string_void_signature(),
      872                                    thread_group,
      873                                    string,
      874                                    CHECK_NULL);
      875   return thread_oop();
      876 }
      877 
      878 static void call_initializeSystemClass(TRAPS) {
      879   klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
      880   instanceKlassHandle klass (THREAD, k);
      881 
      882   JavaValue result(T_VOID);
      883   JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(),
      884                                          vmSymbolHandles::void_method_signature(), CHECK);
      885 }
      886 
      887 static void reset_vm_info_property(TRAPS) {
      888   // the vm info string
      889   ResourceMark rm(THREAD);
      890   const char *vm_info = VM_Version::vm_info_string();
      891 
      892   // java.lang.System class
      893   klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
      894   instanceKlassHandle klass (THREAD, k);
      895 
      896   // setProperty arguments
      897   Handle key_str    = java_lang_String::create_from_str("java.vm.info", CHECK);
      898   Handle value_str  = java_lang_String::create_from_str(vm_info, CHECK);
      899 
      900   // return value
      901   JavaValue r(T_OBJECT);
      902 
      903   // public static String setProperty(String key, String value);
      904   JavaCalls::call_static(&r,
      905                          klass,
      906                          vmSymbolHandles::setProperty_name(),
      907                          vmSymbolHandles::string_string_string_signature(),
      908                          key_str,
      909                          value_str,
      910                          CHECK);
      911 }
      912 
      913 
      914 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
      915   assert(thread_group.not_null(), "thread group should be specified");
      916   assert(threadObj() == NULL, "should only create Java thread object once");
      917 
      918   klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK);
      919   instanceKlassHandle klass (THREAD, k);
      920   instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
      921 
      922   java_lang_Thread::set_thread(thread_oop(), this);
      923   java_lang_Thread::set_priority(thread_oop(), NormPriority);
      924   set_threadObj(thread_oop());
      925 
      926   JavaValue result(T_VOID);
      927   if (thread_name != NULL) {
      928     Handle name = java_lang_String::create_from_str(thread_name, CHECK);
      929     // Thread gets assigned specified name and null target
      930     JavaCalls::call_special(&result,
      931                             thread_oop,
      932                             klass,
      933                             vmSymbolHandles::object_initializer_name(),
      934                             vmSymbolHandles::threadgroup_string_void_signature(),
      935                             thread_group, // Argument 1
      936                             name,         // Argument 2
      937                             THREAD);
      938   } else {
      939     // Thread gets assigned name "Thread-nnn" and null target
      940     // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
      941     JavaCalls::call_special(&result,
      942                             thread_oop,
      943                             klass,
      944                             vmSymbolHandles::object_initializer_name(),
      945                             vmSymbolHandles::threadgroup_runnable_void_signature(),
      946                             thread_group, // Argument 1
      947                             Handle(),     // Argument 2
      948                             THREAD);
      949   }
      950 
      951 
      952   if (daemon) {
      953       java_lang_Thread::set_daemon(thread_oop());
      954   }
      955 
      956   if (HAS_PENDING_EXCEPTION) {
      957     return;
      958   }
      959 
      960   KlassHandle group(this, SystemDictionary::threadGroup_klass());
      961   Handle threadObj(this, this->threadObj());
      962 
      963   JavaCalls::call_special(&result,
      964                          thread_group,
      965                          group,
      966                          vmSymbolHandles::add_method_name(),
      967                          vmSymbolHandles::thread_void_signature(),
      968                          threadObj,          // Arg 1
      969                          THREAD);
      970 
      971 
      972 }
      973 
      974 // NamedThread --  non-JavaThread subclasses with multiple
      975 // uniquely named instances should derive from this.
      976 NamedThread::NamedThread() : Thread() {
      977   _name = NULL;
      978 }
      979 
      980 NamedThread::~NamedThread() {
      981   if (_name != NULL) {
      982     FREE_C_HEAP_ARRAY(char, _name);
      983     _name = NULL;
      984   }
      985 }
      986 
      987 void NamedThread::set_name(const char* format, ...) {
      988   guarantee(_name == NULL, "Only get to set name once.");
      989   _name = NEW_C_HEAP_ARRAY(char, max_name_len);
      990   guarantee(_name != NULL, "alloc failure");
      991   va_list ap;
      992   va_start(ap, format);
      993   jio_vsnprintf(_name, max_name_len, format, ap);
      994   va_end(ap);
      995 }
      996 
      997 // ======= WatcherThread ========
      998 
      999 // The watcher thread exists to simulate timer interrupts.  It should
     1000 // be replaced by an abstraction over whatever native support for
     1001 // timer interrupts exists on the platform.
     1002 
     1003 WatcherThread* WatcherThread::_watcher_thread   = NULL;
     1004 bool           WatcherThread::_should_terminate = false;
     1005 
     1006 WatcherThread::WatcherThread() : Thread() {
     1007   assert(watcher_thread() == NULL, "we can only allocate one WatcherThread");
     1008   if (os::create_thread(this, os::watcher_thread)) {
     1009     _watcher_thread = this;
     1010 
     1011     // Set the watcher thread to the highest OS priority which should not be
     1012     // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY
     1013     // is created. The only normal thread using this priority is the reference
     1014     // handler thread, which runs for very short intervals only.
     1015     // If the VMThread's priority is not lower than the WatcherThread profiling
     1016     // will be inaccurate.
     1017     os::set_priority(this, MaxPriority);
     1018     if (!DisableStartThread) {
     1019       os::start_thread(this);
     1020     }
     1021   }
     1022 }
     1023 
     1024 void WatcherThread::run() {
     1025   assert(this == watcher_thread(), "just checking");
     1026 
     1027   this->record_stack_base_and_size();
     1028   this->initialize_thread_local_storage();
     1029   this->set_active_handles(JNIHandleBlock::allocate_block());
     1030   while(!_should_terminate) {
     1031     assert(watcher_thread() == Thread::current(),  "thread consistency check");
     1032     assert(watcher_thread() == this,  "thread consistency check");
     1033 
     1034     // Calculate how long it'll be until the next PeriodicTask work
     1035     // should be done, and sleep that amount of time.
     1036     const size_t time_to_wait = PeriodicTask::time_to_wait();
     1037     os::sleep(this, time_to_wait, false);
     1038 
     1039     if (is_error_reported()) {
     1040       // A fatal error has happened, the error handler(VMError::report_and_die)
     1041       // should abort JVM after creating an error log file. However in some
     1042       // rare cases, the error handler itself might deadlock. Here we try to
     1043       // kill JVM if the fatal error handler fails to abort in 2 minutes.
     1044       //
     1045       // This code is in WatcherThread because WatcherThread wakes up
     1046       // periodically so the fatal error handler doesn't need to do anything;
     1047       // also because the WatcherThread is less likely to crash than other
     1048       // threads.
     1049 
     1050       for (;;) {
     1051         if (!ShowMessageBoxOnError
     1052          && (OnError == NULL || OnError[0] == '\0')
     1053          && Arguments::abort_hook() == NULL) {
     1054              os::sleep(this, 2 * 60 * 1000, false);
     1055              fdStream err(defaultStream::output_fd());
     1056              err.print_raw_cr("# [ timer expired, abort... ]");
     1057              // skip atexit/vm_exit/vm_abort hooks
     1058              os::die();
     1059         }
     1060 
     1061         // Wake up 5 seconds later, the fatal handler may reset OnError or
     1062         // ShowMessageBoxOnError when it is ready to abort.
     1063         os::sleep(this, 5 * 1000, false);
     1064       }
     1065     }
     1066 
     1067     PeriodicTask::real_time_tick(time_to_wait);
     1068 
     1069     // If we have no more tasks left due to dynamic disenrollment,
     1070     // shut down the thread since we don't currently support dynamic enrollment
     1071     if (PeriodicTask::num_tasks() == 0) {
     1072       _should_terminate = true;
     1073     }
     1074   }
     1075 
     1076   // Signal that it is terminated
     1077   {
     1078     MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
     1079     _watcher_thread = NULL;
     1080     Terminator_lock->notify();
     1081   }
     1082 
     1083   // Thread destructor usually does this..
     1084   ThreadLocalStorage::set_thread(NULL);
     1085 }
     1086 
     1087 void WatcherThread::start() {
     1088   if (watcher_thread() == NULL) {
     1089     _should_terminate = false;
     1090     // Create the single instance of WatcherThread
     1091     new WatcherThread();
     1092   }
     1093 }
     1094 
     1095 void WatcherThread::stop() {
     1096   // it is ok to take late safepoints here, if needed
     1097   MutexLocker mu(Terminator_lock);
     1098   _should_terminate = true;
     1099   while(watcher_thread() != NULL) {
     1100     // This wait should make safepoint checks, wait without a timeout,
     1101     // and wait as a suspend-equivalent condition.
     1102     //
     1103     // Note: If the FlatProfiler is running, then this thread is waiting
     1104     // for the WatcherThread to terminate and the WatcherThread, via the
     1105     // FlatProfiler task, is waiting for the external suspend request on
     1106     // this thread to complete. wait_for_ext_suspend_completion() will
     1107     // eventually timeout, but that takes time. Making this wait a
     1108     // suspend-equivalent condition solves that timeout problem.
     1109     //
     1110     Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
     1111                           Mutex::_as_suspend_equivalent_flag);
     1112   }
     1113 }
     1114 
     1115 void WatcherThread::print_on(outputStream* st) const {
     1116   st->print("\"%s\" ", name());
     1117   Thread::print_on(st);
     1118   st->cr();
     1119 }
     1120 
     1121 // ======= JavaThread ========
     1122 
     1123 // A JavaThread is a normal Java thread
     1124 
     1125 void JavaThread::initialize() {
     1126   // Initialize fields
     1127 
     1128   // Set the claimed par_id to -1 (ie not claiming any par_ids)
     1129   set_claimed_par_id(-1);
     1130 
     1131   set_saved_exception_pc(NULL);
     1132   set_threadObj(NULL);
     1133   _anchor.clear();
     1134   set_entry_point(NULL);
     1135   set_jni_functions(jni_functions());
     1136   set_callee_target(NULL);
     1137   set_vm_result(NULL);
     1138   set_vm_result_2(NULL);
     1139   set_vframe_array_head(NULL);
     1140   set_vframe_array_last(NULL);
     1141   set_deferred_locals(NULL);
     1142   set_deopt_mark(NULL);
     1143   clear_must_deopt_id();
     1144   set_monitor_chunks(NULL);
     1145   set_next(NULL);
     1146   set_thread_state(_thread_new);
     1147   _terminated = _not_terminated;
     1148   _privileged_stack_top = NULL;
     1149   _array_for_gc = NULL;
     1150   _suspend_equivalent = false;
     1151   _in_deopt_handler = 0;
     1152   _doing_unsafe_access = false;
     1153   _stack_guard_state = stack_guard_unused;
     1154   _exception_oop = NULL;
     1155   _exception_pc  = 0;
     1156   _exception_handler_pc = 0;
     1157   _exception_stack_size = 0;
     1158   _jvmti_thread_state= NULL;
     1159   _jvmti_get_loaded_classes_closure = NULL;
     1160   _interp_only_mode    = 0;
     1161   _special_runtime_exit_condition = _no_async_condition;
     1162   _pending_async_exception = NULL;
     1163   _is_compiling = false;
     1164   _thread_stat = NULL;
     1165   _thread_stat = new ThreadStatistics();
     1166   _blocked_on_compilation = false;
     1167   _jni_active_critical = 0;
     1168   _do_not_unlock_if_synchronized = false;
     1169   _cached_monitor_info = NULL;
     1170   _parker = Parker::Allocate(this) ;
     1171 
     1172 #ifndef PRODUCT
     1173   _jmp_ring_index = 0;
     1174   for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) {
     1175     record_jump(NULL, NULL, NULL, 0);
     1176   }
     1177 #endif /* PRODUCT */
     1178 
     1179   set_thread_profiler(NULL);
     1180   if (FlatProfiler::is_active()) {
     1181     // This is where we would decide to either give each thread it's own profiler
     1182     // or use one global one from FlatProfiler,
     1183     // or up to some count of the number of profiled threads, etc.
     1184     ThreadProfiler* pp = new ThreadProfiler();
     1185     pp->engage();
     1186     set_thread_profiler(pp);
     1187   }
     1188 
     1189   // Setup safepoint state info for this thread
     1190   ThreadSafepointState::create(this);
     1191 
     1192   debug_only(_java_call_counter = 0);
     1193 
     1194   // JVMTI PopFrame support
     1195   _popframe_condition = popframe_inactive;
     1196   _popframe_preserved_args = NULL;
     1197   _popframe_preserved_args_size = 0;
     1198 
     1199   pd_initialize();
     1200 }
     1201 
     1202 #ifndef SERIALGC
     1203 SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
     1204 DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
     1205 #endif // !SERIALGC
     1206 
     1207 JavaThread::JavaThread(bool is_attaching) :
     1208   Thread()
     1209 #ifndef SERIALGC
     1210   , _satb_mark_queue(&_satb_mark_queue_set),
     1211   _dirty_card_queue(&_dirty_card_queue_set)
     1212 #endif // !SERIALGC
     1213 {
     1214   initialize();
     1215   _is_attaching = is_attaching;
     1216   assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor");
     1217 }
     1218 
     1219 bool JavaThread::reguard_stack(address cur_sp) {
     1220   if (_stack_guard_state != stack_guard_yellow_disabled) {
     1221     return true; // Stack already guarded or guard pages not needed.
     1222   }
     1223 
     1224   if (register_stack_overflow()) {
     1225     // For those architectures which have separate register and
     1226     // memory stacks, we must check the register stack to see if
     1227     // it has overflowed.
     1228     return false;
     1229   }
     1230 
     1231   // Java code never executes within the yellow zone: the latter is only
     1232   // there to provoke an exception during stack banging.  If java code
     1233   // is executing there, either StackShadowPages should be larger, or
     1234   // some exception code in c1, c2 or the interpreter isn't unwinding
     1235   // when it should.
     1236   guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages");
     1237 
     1238   enable_stack_yellow_zone();
     1239   return true;
     1240 }
     1241 
     1242 bool JavaThread::reguard_stack(void) {
     1243   return reguard_stack(os::current_stack_pointer());
     1244 }
     1245 
     1246 
     1247 void JavaThread::block_if_vm_exited() {
     1248   if (_terminated == _vm_exited) {
     1249     // _vm_exited is set at safepoint, and Threads_lock is never released
     1250     // we will block here forever
     1251     Threads_lock->lock_without_safepoint_check();
     1252     ShouldNotReachHere();
     1253   }
     1254 }
     1255 
     1256 
     1257 // Remove this ifdef when C1 is ported to the compiler interface.
     1258 static void compiler_thread_entry(JavaThread* thread, TRAPS);
     1259 
     1260 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
     1261   Thread()
     1262 #ifndef SERIALGC
     1263   , _satb_mark_queue(&_satb_mark_queue_set),
     1264   _dirty_card_queue(&_dirty_card_queue_set)
     1265 #endif // !SERIALGC
     1266 {
     1267   if (TraceThreadEvents) {
     1268     tty->print_cr("creating thread %p", this);
     1269   }
     1270   initialize();
     1271   _is_attaching = false;
     1272   set_entry_point(entry_point);
     1273   // Create the native thread itself.
     1274   // %note runtime_23
     1275   os::ThreadType thr_type = os::java_thread;
     1276   thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
     1277                                                      os::java_thread;
     1278   os::create_thread(this, thr_type, stack_sz);
     1279 
     1280   // The _osthread may be NULL here because we ran out of memory (too many threads active).
     1281   // We need to throw and OutOfMemoryError - however we cannot do this here because the caller
     1282   // may hold a lock and all locks must be unlocked before throwing the exception (throwing
     1283   // the exception consists of creating the exception object & initializing it, initialization
     1284   // will leave the VM via a JavaCall and then all locks must be unlocked).
     1285   //
     1286   // The thread is still suspended when we reach here. Thread must be explicit started
     1287   // by creator! Furthermore, the thread must also explicitly be added to the Threads list
     1288   // by calling Threads:add. The reason why this is not done here, is because the thread
     1289   // object must be fully initialized (take a look at JVM_Start)
     1290 }
     1291 
     1292 JavaThread::~JavaThread() {
     1293   if (TraceThreadEvents) {
     1294       tty->print_cr("terminate thread %p", this);
     1295   }
     1296 
     1297   // JSR166 -- return the parker to the free list
     1298   Parker::Release(_parker);
     1299   _parker = NULL ;
     1300 
     1301   // Free any remaining  previous UnrollBlock
     1302   vframeArray* old_array = vframe_array_last();
     1303 
     1304   if (old_array != NULL) {
     1305     Deoptimization::UnrollBlock* old_info = old_array->unroll_block();
     1306     old_array->set_unroll_block(NULL);
     1307     delete old_info;
     1308     delete old_array;
     1309   }
     1310 
     1311   GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals();
     1312   if (deferred != NULL) {
     1313     // This can only happen if thread is destroyed before deoptimization occurs.
     1314     assert(deferred->length() != 0, "empty array!");
     1315     do {
     1316       jvmtiDeferredLocalVariableSet* dlv = deferred->at(0);
     1317       deferred->remove_at(0);
     1318       // individual jvmtiDeferredLocalVariableSet are CHeapObj's
     1319       delete dlv;
     1320     } while (deferred->length() != 0);
     1321     delete deferred;
     1322   }
     1323 
     1324   // All Java related clean up happens in exit
     1325   ThreadSafepointState::destroy(this);
     1326   if (_thread_profiler != NULL) delete _thread_profiler;
     1327   if (_thread_stat != NULL) delete _thread_stat;
     1328 }
     1329 
     1330 
     1331 // The first routine called by a new Java thread
     1332 void JavaThread::run() {
     1333   // initialize thread-local alloc buffer related fields
     1334   this->initialize_tlab();
     1335 
     1336   // used to test validitity of stack trace backs
     1337   this->record_base_of_stack_pointer();
     1338 
     1339   // Record real stack base and size.
     1340   this->record_stack_base_and_size();
     1341 
     1342   // Initialize thread local storage; set before calling MutexLocker
     1343   this->initialize_thread_local_storage();
     1344 
     1345   this->create_stack_guard_pages();
     1346 
     1347   // Thread is now sufficient initialized to be handled by the safepoint code as being
     1348   // in the VM. Change thread state from _thread_new to _thread_in_vm
     1349   ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
     1350 
     1351   assert(JavaThread::current() == this, "sanity check");
     1352   assert(!Thread::current()->owns_locks(), "sanity check");
     1353 
     1354   DTRACE_THREAD_PROBE(start, this);
     1355 
     1356   // This operation might block. We call that after all safepoint checks for a new thread has
     1357   // been completed.
     1358   this->set_active_handles(JNIHandleBlock::allocate_block());
     1359 
     1360   if (JvmtiExport::should_post_thread_life()) {
     1361     JvmtiExport::post_thread_start(this);
     1362   }
     1363 
     1364   // We call another function to do the rest so we are sure that the stack addresses used
     1365   // from there will be lower than the stack base just computed
     1366   thread_main_inner();
     1367 
     1368   // Note, thread is no longer valid at this point!
     1369 }
     1370 
     1371 
     1372 void JavaThread::thread_main_inner() {
     1373   assert(JavaThread::current() == this, "sanity check");
     1374   assert(this->threadObj() != NULL, "just checking");
     1375 
     1376   // Execute thread entry point. If this thread is being asked to restart,
     1377   // or has been stopped before starting, do not reexecute entry point.
     1378   // Note: Due to JVM_StopThread we can have pending exceptions already!
     1379   if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) {
     1380     // enter the thread's entry point only if we have no pending exceptions
     1381     HandleMark hm(this);
     1382     this->entry_point()(this, this);
     1383   }
     1384 
     1385   DTRACE_THREAD_PROBE(stop, this);
     1386 
     1387   this->exit(false);
     1388   delete this;
     1389 }
     1390 
     1391 
     1392 static void ensure_join(JavaThread* thread) {
     1393   // We do not need to grap the Threads_lock, since we are operating on ourself.
     1394   Handle threadObj(thread, thread->threadObj());
     1395   assert(threadObj.not_null(), "java thread object must exist");
     1396   ObjectLocker lock(threadObj, thread);
     1397   // Ignore pending exception (ThreadDeath), since we are exiting anyway
     1398   thread->clear_pending_exception();
     1399   // It is of profound importance that we set the stillborn bit and reset the thread object,
     1400   // before we do the notify. Since, changing these two variable will make JVM_IsAlive return
     1401   // false. So in case another thread is doing a join on this thread , it will detect that the thread
     1402   // is dead when it gets notified.
     1403   java_lang_Thread::set_stillborn(threadObj());
     1404   // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
     1405   java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
     1406   java_lang_Thread::set_thread(threadObj(), NULL);
     1407   lock.notify_all(thread);
     1408   // Ignore pending exception (ThreadDeath), since we are exiting anyway
     1409   thread->clear_pending_exception();
     1410 }
     1411 
     1412 
     1413 // For any new cleanup additions, please check to see if they need to be applied to
     1414 // cleanup_failed_attach_current_thread as well.
     1415 void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
     1416   assert(this == JavaThread::current(),  "thread consistency check");
     1417   if (!InitializeJavaLangSystem) return;
     1418 
     1419   HandleMark hm(this);
     1420   Handle uncaught_exception(this, this->pending_exception());
     1421   this->clear_pending_exception();
     1422   Handle threadObj(this, this->threadObj());
     1423   assert(threadObj.not_null(), "Java thread object should be created");
     1424 
     1425   if (get_thread_profiler() != NULL) {
     1426     get_thread_profiler()->disengage();
     1427     ResourceMark rm;
     1428     get_thread_profiler()->print(get_thread_name());
     1429   }
     1430 
     1431 
     1432   // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place
     1433   {
     1434     EXCEPTION_MARK;
     1435 
     1436     CLEAR_PENDING_EXCEPTION;
     1437   }
     1438   // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This
     1439   // has to be fixed by a runtime query method
     1440   if (!destroy_vm || JDK_Version::is_jdk12x_version()) {
     1441     // JSR-166: change call from from ThreadGroup.uncaughtException to
     1442     // java.lang.Thread.dispatchUncaughtException
     1443     if (uncaught_exception.not_null()) {
     1444       Handle group(this, java_lang_Thread::threadGroup(threadObj()));
     1445       Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT",
     1446         (address)uncaught_exception(), (address)threadObj(), (address)group());
     1447       {
     1448         EXCEPTION_MARK;
     1449         // Check if the method Thread.dispatchUncaughtException() exists. If so
     1450         // call it.  Otherwise we have an older library without the JSR-166 changes,
     1451         // so call ThreadGroup.uncaughtException()
     1452         KlassHandle recvrKlass(THREAD, threadObj->klass());
     1453         CallInfo callinfo;
     1454         KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
     1455         LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass,
     1456                                            vmSymbolHandles::dispatchUncaughtException_name(),
     1457                                            vmSymbolHandles::throwable_void_signature(),
     1458                                            KlassHandle(), false, false, THREAD);
     1459         CLEAR_PENDING_EXCEPTION;
     1460         methodHandle method = callinfo.selected_method();
     1461         if (method.not_null()) {
     1462           JavaValue result(T_VOID);
     1463           JavaCalls::call_virtual(&result,
     1464                                   threadObj, thread_klass,
     1465                                   vmSymbolHandles::dispatchUncaughtException_name(),
     1466                                   vmSymbolHandles::throwable_void_signature(),
     1467                                   uncaught_exception,
     1468                                   THREAD);
     1469         } else {
     1470           KlassHandle thread_group(THREAD, SystemDictionary::threadGroup_klass());
     1471           JavaValue result(T_VOID);
     1472           JavaCalls::call_virtual(&result,
     1473                                   group, thread_group,
     1474                                   vmSymbolHandles::uncaughtException_name(),
     1475                                   vmSymbolHandles::thread_throwable_void_signature(),
     1476                                   threadObj,           // Arg 1
     1477                                   uncaught_exception,  // Arg 2
     1478                                   THREAD);
     1479         }
     1480         CLEAR_PENDING_EXCEPTION;
     1481       }
     1482     }
     1483 
     1484     // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
     1485     // the execution of the method. If that is not enough, then we don't really care. Thread.stop
     1486     // is deprecated anyhow.
     1487     { int count = 3;
     1488       while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
     1489         EXCEPTION_MARK;
     1490         JavaValue result(T_VOID);
     1491         KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
     1492         JavaCalls::call_virtual(&result,
     1493                               threadObj, thread_klass,
     1494                               vmSymbolHandles::exit_method_name(),
     1495                               vmSymbolHandles::void_method_signature(),
     1496                               THREAD);
     1497         CLEAR_PENDING_EXCEPTION;
     1498       }
     1499     }
     1500 
     1501     // notify JVMTI
     1502     if (JvmtiExport::should_post_thread_life()) {
     1503       JvmtiExport::post_thread_end(this);
     1504     }
     1505 
     1506     // We have notified the agents that we are exiting, before we go on,
     1507     // we must check for a pending external suspend request and honor it
     1508     // in order to not surprise the thread that made the suspend request.
     1509     while (true) {
     1510       {
     1511         MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
     1512         if (!is_external_suspend()) {
     1513           set_terminated(_thread_exiting);
     1514           ThreadService::current_thread_exiting(this);
     1515           break;
     1516         }
     1517         // Implied else:
     1518         // Things get a little tricky here. We have a pending external
     1519         // suspend request, but we are holding the SR_lock so we
     1520         // can't just self-suspend. So we temporarily drop the lock
     1521         // and then self-suspend.
     1522       }
     1523 
     1524       ThreadBlockInVM tbivm(this);
     1525       java_suspend_self();
     1526 
     1527       // We're done with this suspend request, but we have to loop around
     1528       // and check again. Eventually we will get SR_lock without a pending
     1529       // external suspend request and will be able to mark ourselves as
     1530       // exiting.
     1531     }
     1532     // no more external suspends are allowed at this point
     1533   } else {
     1534     // before_exit() has already posted JVMTI THREAD_END events
     1535   }
     1536 
     1537   // Notify waiters on thread object. This has to be done after exit() is called
     1538   // on the thread (if the thread is the last thread in a daemon ThreadGroup the
     1539   // group should have the destroyed bit set before waiters are notified).
     1540   ensure_join(this);
     1541   assert(!this->has_pending_exception(), "ensure_join should have cleared");
     1542 
     1543   // 6282335 JNI DetachCurrentThread spec states that all Java monitors
     1544   // held by this thread must be released.  A detach operation must only
     1545   // get here if there are no Java frames on the stack.  Therefore, any
     1546   // owned monitors at this point MUST be JNI-acquired monitors which are
     1547   // pre-inflated and in the monitor cache.
     1548   //
     1549   // ensure_join() ignores IllegalThreadStateExceptions, and so does this.
     1550   if (exit_type == jni_detach && JNIDetachReleasesMonitors) {
     1551     assert(!this->has_last_Java_frame(), "detaching with Java frames?");
     1552     ObjectSynchronizer::release_monitors_owned_by_thread(this);
     1553     assert(!this->has_pending_exception(), "release_monitors should have cleared");
     1554   }
     1555 
     1556   // These things needs to be done while we are still a Java Thread. Make sure that thread
     1557   // is in a consistent state, in case GC happens
     1558   assert(_privileged_stack_top == NULL, "must be NULL when we get here");
     1559 
     1560   if (active_handles() != NULL) {
     1561     JNIHandleBlock* block = active_handles();
     1562     set_active_handles(NULL);
     1563     JNIHandleBlock::release_block(block);
     1564   }
     1565 
     1566   if (free_handle_block() != NULL) {
     1567     JNIHandleBlock* block = free_handle_block();
     1568     set_free_handle_block(NULL);
     1569     JNIHandleBlock::release_block(block);
     1570   }
     1571 
     1572   // These have to be removed while this is still a valid thread.
     1573   remove_stack_guard_pages();
     1574 
     1575   if (UseTLAB) {
     1576     tlab().make_parsable(true);  // retire TLAB
     1577   }
     1578 
     1579   if (jvmti_thread_state() != NULL) {
     1580     JvmtiExport::cleanup_thread(this);
     1581   }
     1582 
     1583 #ifndef SERIALGC
     1584   // We must flush G1-related buffers before removing a thread from
     1585   // the list of active threads.
     1586   if (UseG1GC) {
     1587     flush_barrier_queues();
     1588   }
     1589 #endif
     1590 
     1591   // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
     1592   Threads::remove(this);
     1593 }
     1594 
     1595 #ifndef SERIALGC
     1596 // Flush G1-related queues.
     1597 void JavaThread::flush_barrier_queues() {
     1598   satb_mark_queue().flush();
     1599   dirty_card_queue().flush();
     1600 }
     1601 #endif
     1602 
     1603 void JavaThread::cleanup_failed_attach_current_thread() {
     1604   if (get_thread_profiler() != NULL) {
     1605     get_thread_profiler()->disengage();
     1606     ResourceMark rm;
     1607     get_thread_profiler()->print(get_thread_name());
     1608   }
     1609 
     1610   if (active_handles() != NULL) {
     1611     JNIHandleBlock* block = active_handles();
     1612     set_active_handles(NULL);
     1613     JNIHandleBlock::release_block(block);
     1614   }
     1615 
     1616   if (free_handle_block() != NULL) {
     1617     JNIHandleBlock* block = free_handle_block();
     1618     set_free_handle_block(NULL);
     1619     JNIHandleBlock::release_block(block);
     1620   }
     1621 
     1622   if (UseTLAB) {
     1623     tlab().make_parsable(true);  // retire TLAB, if any
     1624   }
     1625 
     1626 #ifndef SERIALGC
     1627   if (UseG1GC) {
     1628     flush_barrier_queues();
     1629   }
     1630 #endif
     1631 
     1632   Threads::remove(this);
     1633   delete this;
     1634 }
     1635 
     1636 
     1637 
     1638 
     1639 JavaThread* JavaThread::active() {
     1640   Thread* thread = ThreadLocalStorage::thread();
     1641   assert(thread != NULL, "just checking");
     1642   if (thread->is_Java_thread()) {
     1643     return (JavaThread*) thread;
     1644   } else {
     1645     assert(thread->is_VM_thread(), "this must be a vm thread");
     1646     VM_Operation* op = ((VMThread*) thread)->vm_operation();
     1647     JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread();
     1648     assert(ret->is_Java_thread(), "must be a Java thread");
     1649     return ret;
     1650   }
     1651 }
     1652 
     1653 bool JavaThread::is_lock_owned(address adr) const {
     1654   if (Thread::is_lock_owned(adr)) return true;
     1655 
     1656   for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
     1657     if (chunk->contains(adr)) return true;
     1658   }
     1659 
     1660   return false;
     1661 }
     1662 
     1663 
     1664 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) {
     1665   chunk->set_next(monitor_chunks());
     1666   set_monitor_chunks(chunk);
     1667 }
     1668 
     1669 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) {
     1670   guarantee(monitor_chunks() != NULL, "must be non empty");
     1671   if (monitor_chunks() == chunk) {
     1672     set_monitor_chunks(chunk->next());
     1673   } else {
     1674     MonitorChunk* prev = monitor_chunks();
     1675     while (prev->next() != chunk) prev = prev->next();
     1676     prev->set_next(chunk->next());
     1677   }
     1678 }
     1679 
     1680 // JVM support.
     1681 
     1682 // Note: this function shouldn't block if it's called in
     1683 // _thread_in_native_trans state (such as from
     1684 // check_special_condition_for_native_trans()).
     1685 void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) {
     1686 
     1687   if (has_last_Java_frame() && has_async_condition()) {
     1688     // If we are at a polling page safepoint (not a poll return)
     1689     // then we must defer async exception because live registers
     1690     // will be clobbered by the exception path. Poll return is
     1691     // ok because the call we a returning from already collides
     1692     // with exception handling registers and so there is no issue.
     1693     // (The exception handling path kills call result registers but
     1694     //  this is ok since the exception kills the result anyway).
     1695 
     1696     if (is_at_poll_safepoint()) {
     1697       // if the code we are returning to has deoptimized we must defer
     1698       // the exception otherwise live registers get clobbered on the
     1699       // exception path before deoptimization is able to retrieve them.
     1700       //
     1701       RegisterMap map(this, false);
     1702       frame caller_fr = last_frame().sender(&map);
     1703       assert(caller_fr.is_compiled_frame(), "what?");
     1704       if (caller_fr.is_deoptimized_frame()) {
     1705         if (TraceExceptions) {
     1706           ResourceMark rm;
     1707           tty->print_cr("deferred async exception at compiled safepoint");
     1708         }
     1709         return;
     1710       }
     1711     }
     1712   }
     1713 
     1714   JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition();
     1715   if (condition == _no_async_condition) {
     1716     // Conditions have changed since has_special_runtime_exit_condition()
     1717     // was called:
     1718     // - if we were here only because of an external suspend request,
     1719     //   then that was taken care of above (or cancelled) so we are done
     1720     // - if we were here because of another async request, then it has
     1721     //   been cleared between the has_special_runtime_exit_condition()
     1722     //   and now so again we are done
     1723     return;
     1724   }
     1725 
     1726   // Check for pending async. exception
     1727   if (_pending_async_exception != NULL) {
     1728     // Only overwrite an already pending exception, if it is not a threadDeath.
     1729     if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::threaddeath_klass())) {
     1730 
     1731       // We cannot call Exceptions::_throw(...) here because we cannot block
     1732       set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
     1733 
     1734       if (TraceExceptions) {
     1735         ResourceMark rm;
     1736         tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
     1737         if (has_last_Java_frame() ) {
     1738           frame f = last_frame();
     1739           tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
     1740         }
     1741         tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
     1742       }
     1743       _pending_async_exception = NULL;
     1744       clear_has_async_exception();
     1745     }
     1746   }
     1747 
     1748   if (check_unsafe_error &&
     1749       condition == _async_unsafe_access_error && !has_pending_exception()) {
     1750     condition = _no_async_condition;  // done
     1751     switch (thread_state()) {
     1752     case _thread_in_vm:
     1753       {
     1754         JavaThread* THREAD = this;
     1755         THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
     1756       }
     1757     case _thread_in_native:
     1758       {
     1759         ThreadInVMfromNative tiv(this);
     1760         JavaThread* THREAD = this;
     1761         THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
     1762       }
     1763     case _thread_in_Java:
     1764       {
     1765         ThreadInVMfromJava tiv(this);
     1766         JavaThread* THREAD = this;
     1767         THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code");
     1768       }
     1769     default:
     1770       ShouldNotReachHere();
     1771     }
     1772   }
     1773 
     1774   assert(condition == _no_async_condition || has_pending_exception() ||
     1775          (!check_unsafe_error && condition == _async_unsafe_access_error),
     1776          "must have handled the async condition, if no exception");
     1777 }
     1778 
     1779 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) {
     1780   //
     1781   // Check for pending external suspend. Internal suspend requests do
     1782   // not use handle_special_runtime_exit_condition().
     1783   // If JNIEnv proxies are allowed, don't self-suspend if the target
     1784   // thread is not the current thread. In older versions of jdbx, jdbx
     1785   // threads could call into the VM with another thread's JNIEnv so we
     1786   // can be here operating on behalf of a suspended thread (4432884).
     1787   bool do_self_suspend = is_external_suspend_with_lock();
     1788   if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) {
     1789     //
     1790     // Because thread is external suspended the safepoint code will count
     1791     // thread as at a safepoint. This can be odd because we can be here
     1792     // as _thread_in_Java which would normally transition to _thread_blocked
     1793     // at a safepoint. We would like to mark the thread as _thread_blocked
     1794     // before calling java_suspend_self like all other callers of it but
     1795     // we must then observe proper safepoint protocol. (We can't leave
     1796     // _thread_blocked with a safepoint in progress). However we can be
     1797     // here as _thread_in_native_trans so we can't use a normal transition
     1798     // constructor/destructor pair because they assert on that type of
     1799     // transition. We could do something like:
     1800     //
     1801     // JavaThreadState state = thread_state();
     1802     // set_thread_state(_thread_in_vm);
     1803     // {
     1804     //   ThreadBlockInVM tbivm(this);
     1805     //   java_suspend_self()
     1806     // }
     1807     // set_thread_state(_thread_in_vm_trans);
     1808     // if (safepoint) block;
     1809     // set_thread_state(state);
     1810     //
     1811     // but that is pretty messy. Instead we just go with the way the
     1812     // code has worked before and note that this is the only path to
     1813     // java_suspend_self that doesn't put the thread in _thread_blocked
     1814     // mode.
     1815 
     1816     frame_anchor()->make_walkable(this);
     1817     java_suspend_self();
     1818 
     1819     // We might be here for reasons in addition to the self-suspend request
     1820     // so check for other async requests.
     1821   }
     1822 
     1823   if (check_asyncs) {
     1824     check_and_handle_async_exceptions();
     1825   }
     1826 }
     1827 
     1828 void JavaThread::send_thread_stop(oop java_throwable)  {
     1829   assert(Thread::current()->is_VM_thread(), "should be in the vm thread");
     1830   assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code");
     1831   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
     1832 
     1833   // Do not throw asynchronous exceptions against the compiler thread
     1834   // (the compiler thread should not be a Java thread -- fix in 1.4.2)
     1835   if (is_Compiler_thread()) return;
     1836 
     1837   // This is a change from JDK 1.1, but JDK 1.2 will also do it:
     1838   if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) {
     1839     java_lang_Thread::set_stillborn(threadObj());
     1840   }
     1841 
     1842   {
     1843     // Actually throw the Throwable against the target Thread - however
     1844     // only if there is no thread death exception installed already.
     1845     if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::threaddeath_klass())) {
     1846       // If the topmost frame is a runtime stub, then we are calling into
     1847       // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..)
     1848       // must deoptimize the caller before continuing, as the compiled  exception handler table
     1849       // may not be valid
     1850       if (has_last_Java_frame()) {
     1851         frame f = last_frame();
     1852         if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) {
     1853           // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
     1854           RegisterMap reg_map(this, UseBiasedLocking);
     1855           frame compiled_frame = f.sender(&reg_map);
     1856           if (compiled_frame.can_be_deoptimized()) {
     1857             Deoptimization::deoptimize(this, compiled_frame, &reg_map);
     1858           }
     1859         }
     1860       }
     1861 
     1862       // Set async. pending exception in thread.
     1863       set_pending_async_exception(java_throwable);
     1864 
     1865       if (TraceExceptions) {
     1866        ResourceMark rm;
     1867        tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
     1868       }
     1869       // for AbortVMOnException flag
     1870       NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name()));
     1871     }
     1872   }
     1873 
     1874 
     1875   // Interrupt thread so it will wake up from a potential wait()
     1876   Thread::interrupt(this);
     1877 }
     1878 
     1879 // External suspension mechanism.
     1880 //
     1881 // Tell the VM to suspend a thread when ever it knows that it does not hold on
     1882 // to any VM_locks and it is at a transition
     1883 // Self-suspension will happen on the transition out of the vm.
     1884 // Catch "this" coming in from JNIEnv pointers when the thread has been freed
     1885 //
     1886 // Guarantees on return:
     1887 //   + Target thread will not execute any new bytecode (that's why we need to
     1888 //     force a safepoint)
     1889 //   + Target thread will not enter any new monitors
     1890 //
     1891 void JavaThread::java_suspend() {
     1892   { MutexLocker mu(Threads_lock);
     1893     if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) {
     1894        return;
     1895     }
     1896   }
     1897 
     1898   { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
     1899     if (!is_external_suspend()) {
     1900       // a racing resume has cancelled us; bail out now
     1901       return;
     1902     }
     1903 
     1904     // suspend is done
     1905     uint32_t debug_bits = 0;
     1906     // Warning: is_ext_suspend_completed() may temporarily drop the
     1907     // SR_lock to allow the thread to reach a stable thread state if
     1908     // it is currently in a transient thread state.
     1909     if (is_ext_suspend_completed(false /* !called_by_wait */,
     1910                                  SuspendRetryDelay, &debug_bits) ) {
     1911       return;
     1912     }
     1913   }
     1914 
     1915   VM_ForceSafepoint vm_suspend;
     1916   VMThread::execute(&vm_suspend);
     1917 }
     1918 
     1919 // Part II of external suspension.
     1920 // A JavaThread self suspends when it detects a pending external suspend
     1921 // request. This is usually on transitions. It is also done in places
     1922 // where continuing to the next transition would surprise the caller,
     1923 // e.g., monitor entry.
     1924 //
     1925 // Returns the number of times that the thread self-suspended.
     1926 //
     1927 // Note: DO NOT call java_suspend_self() when you just want to block current
     1928 //       thread. java_suspend_self() is the second stage of cooperative
     1929 //       suspension for external suspend requests and should only be used
     1930 //       to complete an external suspend request.
     1931 //
     1932 int JavaThread::java_suspend_self() {
     1933   int ret = 0;
     1934 
     1935   // we are in the process of exiting so don't suspend
     1936   if (is_exiting()) {
     1937      clear_external_suspend();
     1938      return ret;
     1939   }
     1940 
     1941   assert(_anchor.walkable() ||
     1942     (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()),
     1943     "must have walkable stack");
     1944 
     1945   MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
     1946 
     1947   assert(!this->is_ext_suspended(),
     1948     "a thread trying to self-suspend should not already be suspended");
     1949 
     1950   if (this->is_suspend_equivalent()) {
     1951     // If we are self-suspending as a result of the lifting of a
     1952     // suspend equivalent condition, then the suspend_equivalent
     1953     // flag is not cleared until we set the ext_suspended flag so
     1954     // that wait_for_ext_suspend_completion() returns consistent
     1955     // results.
     1956     this->clear_suspend_equivalent();
     1957   }
     1958 
     1959   // A racing resume may have cancelled us before we grabbed SR_lock
     1960   // above. Or another external suspend request could be waiting for us
     1961   // by the time we return from SR_lock()->wait(). The thread
     1962   // that requested the suspension may already be trying to walk our
     1963   // stack and if we return now, we can change the stack out from under
     1964   // it. This would be a "bad thing (TM)" and cause the stack walker
     1965   // to crash. We stay self-suspended until there are no more pending
     1966   // external suspend requests.
     1967   while (is_external_suspend()) {
     1968     ret++;
     1969     this->set_ext_suspended();
     1970 
     1971     // _ext_suspended flag is cleared by java_resume()
     1972     while (is_ext_suspended()) {
     1973       this->SR_lock()->wait(Mutex::_no_safepoint_check_flag);
     1974     }
     1975   }
     1976 
     1977   return ret;
     1978 }
     1979 
     1980 #ifdef ASSERT
     1981 // verify the JavaThread has not yet been published in the Threads::list, and
     1982 // hence doesn't need protection from concurrent access at this stage
     1983 void JavaThread::verify_not_published() {
     1984   if (!Threads_lock->owned_by_self()) {
     1985    MutexLockerEx ml(Threads_lock,  Mutex::_no_safepoint_check_flag);
     1986    assert( !Threads::includes(this),
     1987            "java thread shouldn't have been published yet!");
     1988   }
     1989   else {
     1990    assert( !Threads::includes(this),
     1991            "java thread shouldn't have been published yet!");
     1992   }
     1993 }
     1994 #endif
     1995 
     1996 // Slow path when the native==>VM/Java barriers detect a safepoint is in
     1997 // progress or when _suspend_flags is non-zero.
     1998 // Current thread needs to self-suspend if there is a suspend request and/or
     1999 // block if a safepoint is in progress.
     2000 // Async exception ISN'T checked.
     2001 // Note only the ThreadInVMfromNative transition can call this function
     2002 // directly and when thread state is _thread_in_native_trans
     2003 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) {
     2004   assert(thread->thread_state() == _thread_in_native_trans, "wrong state");
     2005 
     2006   JavaThread *curJT = JavaThread::current();
     2007   bool do_self_suspend = thread->is_external_suspend();
     2008 
     2009   assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
     2010 
     2011   // If JNIEnv proxies are allowed, don't self-suspend if the target
     2012   // thread is not the current thread. In older versions of jdbx, jdbx
     2013   // threads could call into the VM with another thread's JNIEnv so we
     2014   // can be here operating on behalf of a suspended thread (4432884).
     2015   if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) {
     2016     JavaThreadState state = thread->thread_state();
     2017 
     2018     // We mark this thread_blocked state as a suspend-equivalent so
     2019     // that a caller to is_ext_suspend_completed() won't be confused.
     2020     // The suspend-equivalent state is cleared by java_suspend_self().
     2021     thread->set_suspend_equivalent();
     2022 
     2023     // If the safepoint code sees the _thread_in_native_trans state, it will
     2024     // wait until the thread changes to other thread state. There is no
     2025     // guarantee on how soon we can obtain the SR_lock and complete the
     2026     // self-suspend request. It would be a bad idea to let safepoint wait for
     2027     // too long. Temporarily change the state to _thread_blocked to
     2028     // let the VM thread know that this thread is ready for GC. The problem
     2029     // of changing thread state is that safepoint could happen just after
     2030     // java_suspend_self() returns after being resumed, and VM thread will
     2031     // see the _thread_blocked state. We must check for safepoint
     2032     // after restoring the state and make sure we won't leave while a safepoint
     2033     // is in progress.
     2034     thread->set_thread_state(_thread_blocked);
     2035     thread->java_suspend_self();
     2036     thread->set_thread_state(state);
     2037     // Make sure new state is seen by VM thread
     2038     if (os::is_MP()) {
     2039       if (UseMembar) {
     2040         // Force a fence between the write above and read below
     2041         OrderAccess::fence();
     2042       } else {
     2043         // Must use this rather than serialization page in particular on Windows
     2044         InterfaceSupport::serialize_memory(thread);
     2045       }
     2046     }
     2047   }
     2048 
     2049   if (SafepointSynchronize::do_call_back()) {
     2050     // If we are safepointing, then block the caller which may not be
     2051     // the same as the target thread (see above).
     2052     SafepointSynchronize::block(curJT);
     2053   }
     2054 
     2055   if (thread->is_deopt_suspend()) {
     2056     thread->clear_deopt_suspend();
     2057     RegisterMap map(thread, false);
     2058     frame f = thread->last_frame();
     2059     while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) {
     2060       f = f.sender(&map);
     2061     }
     2062     if (f.id() == thread->must_deopt_id()) {
     2063       thread->clear_must_deopt_id();
     2064       // Since we know we're safe to deopt the current state is a safe state
     2065       f.deoptimize(thread, true);
     2066     } else {
     2067       fatal("missed deoptimization!");
     2068     }
     2069   }
     2070 }
     2071 
     2072 // Slow path when the native==>VM/Java barriers detect a safepoint is in
     2073 // progress or when _suspend_flags is non-zero.
     2074 // Current thread needs to self-suspend if there is a suspend request and/or
     2075 // block if a safepoint is in progress.
     2076 // Also check for pending async exception (not including unsafe access error).
     2077 // Note only the native==>VM/Java barriers can call this function and when
     2078 // thread state is _thread_in_native_trans.
     2079 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) {
     2080   check_safepoint_and_suspend_for_native_trans(thread);
     2081 
     2082   if (thread->has_async_exception()) {
     2083     // We are in _thread_in_native_trans state, don't handle unsafe
     2084     // access error since that may block.
     2085     thread->check_and_handle_async_exceptions(false);
     2086   }
     2087 }
     2088 
     2089 // We need to guarantee the Threads_lock here, since resumes are not
     2090 // allowed during safepoint synchronization
     2091 // Can only resume from an external suspension
     2092 void JavaThread::java_resume() {
     2093   assert_locked_or_safepoint(Threads_lock);
     2094 
     2095   // Sanity check: thread is gone, has started exiting or the thread
     2096   // was not externally suspended.
     2097   if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) {
     2098     return;
     2099   }
     2100 
     2101   MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
     2102 
     2103   clear_external_suspend();
     2104 
     2105   if (is_ext_suspended()) {
     2106     clear_ext_suspended();
     2107     SR_lock()->notify_all();
     2108   }
     2109 }
     2110 
     2111 void JavaThread::create_stack_guard_pages() {
     2112   if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return;
     2113   address low_addr = stack_base() - stack_size();
     2114   size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
     2115 
     2116   int allocate = os::allocate_stack_guard_pages();
     2117   // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len);
     2118 
     2119   if (allocate && !os::commit_memory((char *) low_addr, len)) {
     2120     warning("Attempt to allocate stack guard pages failed.");
     2121     return;
     2122   }
     2123 
     2124   if (os::guard_memory((char *) low_addr, len)) {
     2125     _stack_guard_state = stack_guard_enabled;
     2126   } else {
     2127     warning("Attempt to protect stack guard pages failed.");
     2128     if (os::uncommit_memory((char *) low_addr, len)) {
     2129       warning("Attempt to deallocate stack guard pages failed.");
     2130     }
     2131   }
     2132 }
     2133 
     2134 void JavaThread::remove_stack_guard_pages() {
     2135   if (_stack_guard_state == stack_guard_unused) return;
     2136   address low_addr = stack_base() - stack_size();
     2137   size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
     2138 
     2139   if (os::allocate_stack_guard_pages()) {
     2140     if (os::uncommit_memory((char *) low_addr, len)) {
     2141       _stack_guard_state = stack_guard_unused;
     2142     } else {
     2143       warning("Attempt to deallocate stack guard pages failed.");
     2144     }
     2145   } else {
     2146     if (_stack_guard_state == stack_guard_unused) return;
     2147     if (os::unguard_memory((char *) low_addr, len)) {
     2148       _stack_guard_state = stack_guard_unused;
     2149     } else {
     2150         warning("Attempt to unprotect stack guard pages failed.");
     2151     }
     2152   }
     2153 }
     2154 
     2155 void JavaThread::enable_stack_yellow_zone() {
     2156   assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
     2157   assert(_stack_guard_state != stack_guard_enabled, "already enabled");
     2158 
     2159   // The base notation is from the stacks point of view, growing downward.
     2160   // We need to adjust it to work correctly with guard_memory()
     2161   address base = stack_yellow_zone_base() - stack_yellow_zone_size();
     2162 
     2163   guarantee(base < stack_base(),"Error calculating stack yellow zone");
     2164   guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone");
     2165 
     2166   if (os::guard_memory((char *) base, stack_yellow_zone_size())) {
     2167     _stack_guard_state = stack_guard_enabled;
     2168   } else {
     2169     warning("Attempt to guard stack yellow zone failed.");
     2170   }
     2171   enable_register_stack_guard();
     2172 }
     2173 
     2174 void JavaThread::disable_stack_yellow_zone() {
     2175   assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
     2176   assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled");
     2177 
     2178   // Simply return if called for a thread that does not use guard pages.
     2179   if (_stack_guard_state == stack_guard_unused) return;
     2180 
     2181   // The base notation is from the stacks point of view, growing downward.
     2182   // We need to adjust it to work correctly with guard_memory()
     2183   address base = stack_yellow_zone_base() - stack_yellow_zone_size();
     2184 
     2185   if (os::unguard_memory((char *)base, stack_yellow_zone_size())) {
     2186     _stack_guard_state = stack_guard_yellow_disabled;
     2187   } else {
     2188     warning("Attempt to unguard stack yellow zone failed.");
     2189   }
     2190   disable_register_stack_guard();
     2191 }
     2192 
     2193 void JavaThread::enable_stack_red_zone() {
     2194   // The base notation is from the stacks point of view, growing downward.
     2195   // We need to adjust it to work correctly with guard_memory()
     2196   assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
     2197   address base = stack_red_zone_base() - stack_red_zone_size();
     2198 
     2199   guarantee(base < stack_base(),"Error calculating stack red zone");
     2200   guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone");
     2201 
     2202   if(!os::guard_memory((char *) base, stack_red_zone_size())) {
     2203     warning("Attempt to guard stack red zone failed.");
     2204   }
     2205 }
     2206 
     2207 void JavaThread::disable_stack_red_zone() {
     2208   // The base notation is from the stacks point of view, growing downward.
     2209   // We need to adjust it to work correctly with guard_memory()
     2210   assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
     2211   address base = stack_red_zone_base() - stack_red_zone_size();
     2212   if (!os::unguard_memory((char *)base, stack_red_zone_size())) {
     2213     warning("Attempt to unguard stack red zone failed.");
     2214   }
     2215 }
     2216 
     2217 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) {
     2218   // ignore is there is no stack
     2219   if (!has_last_Java_frame()) return;
     2220   // traverse the stack frames. Starts from top frame.
     2221   for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
     2222     frame* fr = fst.current();
     2223     f(fr, fst.register_map());
     2224   }
     2225 }
     2226 
     2227 
     2228 #ifndef PRODUCT
     2229 // Deoptimization
     2230 // Function for testing deoptimization
     2231 void JavaThread::deoptimize() {
     2232   // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
     2233   StackFrameStream fst(this, UseBiasedLocking);
     2234   bool deopt = false;           // Dump stack only if a deopt actually happens.
     2235   bool only_at = strlen(DeoptimizeOnlyAt) > 0;
     2236   // Iterate over all frames in the thread and deoptimize
     2237   for(; !fst.is_done(); fst.next()) {
     2238     if(fst.current()->can_be_deoptimized()) {
     2239 
     2240       if (only_at) {
     2241         // Deoptimize only at particular bcis.  DeoptimizeOnlyAt
     2242         // consists of comma or carriage return separated numbers so
     2243         // search for the current bci in that string.
     2244         address pc = fst.current()->pc();
     2245         nmethod* nm =  (nmethod*) fst.current()->cb();
     2246         ScopeDesc* sd = nm->scope_desc_at( pc);
     2247         char buffer[8];
     2248         jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci());
     2249         size_t len = strlen(buffer);
     2250         const char * found = strstr(DeoptimizeOnlyAt, buffer);
     2251         while (found != NULL) {
     2252           if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') &&
     2253               (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) {
     2254             // Check that the bci found is bracketed by terminators.
     2255             break;
     2256           }
     2257           found = strstr(found + 1, buffer);
     2258         }
     2259         if (!found) {
     2260           continue;
     2261         }
     2262       }
     2263 
     2264       if (DebugDeoptimization && !deopt) {
     2265         deopt = true; // One-time only print before deopt
     2266         tty->print_cr("[BEFORE Deoptimization]");
     2267         trace_frames();
     2268         trace_stack();
     2269       }
     2270       Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
     2271     }
     2272   }
     2273 
     2274   if (DebugDeoptimization && deopt) {
     2275     tty->print_cr("[AFTER Deoptimization]");
     2276     trace_frames();
     2277   }
     2278 }
     2279 
     2280 
     2281 // Make zombies
     2282 void JavaThread::make_zombies() {
     2283   for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
     2284     if (fst.current()->can_be_deoptimized()) {
     2285       // it is a Java nmethod
     2286       nmethod* nm = CodeCache::find_nmethod(fst.current()->pc());
     2287       nm->make_not_entrant();
     2288     }
     2289   }
     2290 }
     2291 #endif // PRODUCT
     2292 
     2293 
     2294 void JavaThread::deoptimized_wrt_marked_nmethods() {
     2295   if (!has_last_Java_frame()) return;
     2296   // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
     2297   StackFrameStream fst(this, UseBiasedLocking);
     2298   for(; !fst.is_done(); fst.next()) {
     2299     if (fst.current()->should_be_deoptimized()) {
     2300       Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
     2301     }
     2302   }
     2303 }
     2304 
     2305 
     2306 // GC support
     2307 static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); }
     2308 
     2309 void JavaThread::gc_epilogue() {
     2310   frames_do(frame_gc_epilogue);
     2311 }
     2312 
     2313 
     2314 static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); }
     2315 
     2316 void JavaThread::gc_prologue() {
     2317   frames_do(frame_gc_prologue);
     2318 }
     2319 
     2320 
     2321 void JavaThread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
     2322   // Flush deferred store-barriers, if any, associated with
     2323   // initializing stores done by this JavaThread in the current epoch.
     2324   Universe::heap()->flush_deferred_store_barrier(this);
     2325 
     2326   // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
     2327   // since there may be more than one thread using each ThreadProfiler.
     2328 
     2329   // Traverse the GCHandles
     2330   Thread::oops_do(f, cf);
     2331 
     2332   assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
     2333           (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
     2334 
     2335   if (has_last_Java_frame()) {
     2336 
     2337     // Traverse the privileged stack
     2338     if (_privileged_stack_top != NULL) {
     2339       _privileged_stack_top->oops_do(f);
     2340     }
     2341 
     2342     // traverse the registered growable array
     2343     if (_array_for_gc != NULL) {
     2344       for (int index = 0; index < _array_for_gc->length(); index++) {
     2345         f->do_oop(_array_for_gc->adr_at(index));
     2346       }
     2347     }
     2348 
     2349     // Traverse the monitor chunks
     2350     for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
     2351       chunk->oops_do(f);
     2352     }
     2353 
     2354     // Traverse the execution stack
     2355     for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
     2356       fst.current()->oops_do(f, cf, fst.register_map());
     2357     }
     2358   }
     2359 
     2360   // callee_target is never live across a gc point so NULL it here should
     2361   // it still contain a methdOop.
     2362 
     2363   set_callee_target(NULL);
     2364 
     2365   assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!");
     2366   // If we have deferred set_locals there might be oops waiting to be
     2367   // written
     2368   GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals();
     2369   if (list != NULL) {
     2370     for (int i = 0; i < list->length(); i++) {
     2371       list->at(i)->oops_do(f);
     2372     }
     2373   }
     2374 
     2375   // Traverse instance variables at the end since the GC may be moving things
     2376   // around using this function
     2377   f->do_oop((oop*) &_threadObj);
     2378   f->do_oop((oop*) &_vm_result);
     2379   f->do_oop((oop*) &_vm_result_2);
     2380   f->do_oop((oop*) &_exception_oop);
     2381   f->do_oop((oop*) &_pending_async_exception);
     2382 
     2383   if (jvmti_thread_state() != NULL) {
     2384     jvmti_thread_state()->oops_do(f);
     2385   }
     2386 }
     2387 
     2388 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
     2389   Thread::nmethods_do(cf);  // (super method is a no-op)
     2390 
     2391   assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
     2392           (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
     2393 
     2394   if (has_last_Java_frame()) {
     2395     // Traverse the execution stack
     2396     for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
     2397       fst.current()->nmethods_do(cf);
     2398     }
     2399   }
     2400 }
     2401 
     2402 // Printing
     2403 const char* _get_thread_state_name(JavaThreadState _thread_state) {
     2404   switch (_thread_state) {
     2405   case _thread_uninitialized:     return "_thread_uninitialized";
     2406   case _thread_new:               return "_thread_new";
     2407   case _thread_new_trans:         return "_thread_new_trans";
     2408   case _thread_in_native:         return "_thread_in_native";
     2409   case _thread_in_native_trans:   return "_thread_in_native_trans";
     2410   case _thread_in_vm:             return "_thread_in_vm";
     2411   case _thread_in_vm_trans:       return "_thread_in_vm_trans";
     2412   case _thread_in_Java:           return "_thread_in_Java";
     2413   case _thread_in_Java_trans:     return "_thread_in_Java_trans";
     2414   case _thread_blocked:           return "_thread_blocked";
     2415   case _thread_blocked_trans:     return "_thread_blocked_trans";
     2416   default:                        return "unknown thread state";
     2417   }
     2418 }
     2419 
     2420 #ifndef PRODUCT
     2421 void JavaThread::print_thread_state_on(outputStream *st) const {
     2422   st->print_cr("   JavaThread state: %s", _get_thread_state_name(_thread_state));
     2423 };
     2424 void JavaThread::print_thread_state() const {
     2425   print_thread_state_on(tty);
     2426 };
     2427 #endif // PRODUCT
     2428 
     2429 // Called by Threads::print() for VM_PrintThreads operation
     2430 void JavaThread::print_on(outputStream *st) const {
     2431   st->print("\"%s\" ", get_thread_name());
     2432   oop thread_oop = threadObj();
     2433   if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop))  st->print("daemon ");
     2434   Thread::print_on(st);
     2435   // print guess for valid stack memory region (assume 4K pages); helps lock debugging
     2436   st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12));
     2437   if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) {
     2438     st->print_cr("   java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
     2439   }
     2440 #ifndef PRODUCT
     2441   print_thread_state_on(st);
     2442   _safepoint_state->print_on(st);
     2443 #endif // PRODUCT
     2444 }
     2445 
     2446 // Called by fatal error handler. The difference between this and
     2447 // JavaThread::print() is that we can't grab lock or allocate memory.
     2448 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const {
     2449   st->print("JavaThread \"%s\"",  get_thread_name_string(buf, buflen));
     2450   oop thread_obj = threadObj();
     2451   if (thread_obj != NULL) {
     2452      if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon");
     2453   }
     2454   st->print(" [");
     2455   st->print("%s", _get_thread_state_name(_thread_state));
     2456   if (osthread()) {
     2457     st->print(", id=%d", osthread()->thread_id());
     2458   }
     2459   st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")",
     2460             _stack_base - _stack_size, _stack_base);
     2461   st->print("]");
     2462   return;
     2463 }
     2464 
     2465 // Verification
     2466 
     2467 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); }
     2468 
     2469 void JavaThread::verify() {
     2470   // Verify oops in the thread.
     2471   oops_do(&VerifyOopClosure::verify_oop, NULL);
     2472 
     2473   // Verify the stack frames.
     2474   frames_do(frame_verify);
     2475 }
     2476 
     2477 // CR 6300358 (sub-CR 2137150)
     2478 // Most callers of this method assume that it can't return NULL but a
     2479 // thread may not have a name whilst it is in the process of attaching to
     2480 // the VM - see CR 6412693, and there are places where a JavaThread can be
     2481 // seen prior to having it's threadObj set (eg JNI attaching threads and
     2482 // if vm exit occurs during initialization). These cases can all be accounted
     2483 // for such that this method never returns NULL.
     2484 const char* JavaThread::get_thread_name() const {
     2485 #ifdef ASSERT
     2486   // early safepoints can hit while current thread does not yet have TLS
     2487   if (!SafepointSynchronize::is_at_safepoint()) {
     2488     Thread *cur = Thread::current();
     2489     if (!(cur->is_Java_thread() && cur == this)) {
     2490       // Current JavaThreads are allowed to get their own name without
     2491       // the Threads_lock.
     2492       assert_locked_or_safepoint(Threads_lock);
     2493     }
     2494   }
     2495 #endif // ASSERT
     2496     return get_thread_name_string();
     2497 }
     2498 
     2499 // Returns a non-NULL representation of this thread's name, or a suitable
     2500 // descriptive string if there is no set name
     2501 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const {
     2502   const char* name_str;
     2503   oop thread_obj = threadObj();
     2504   if (thread_obj != NULL) {
     2505     typeArrayOop name = java_lang_Thread::name(thread_obj);
     2506     if (name != NULL) {
     2507       if (buf == NULL) {
     2508         name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
     2509       }
     2510       else {
     2511         name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen);
     2512       }
     2513     }
     2514     else if (is_attaching()) { // workaround for 6412693 - see 6404306
     2515       name_str = "<no-name - thread is attaching>";
     2516     }
     2517     else {
     2518       name_str = Thread::name();
     2519     }
     2520   }
     2521   else {
     2522     name_str = Thread::name();
     2523   }
     2524   assert(name_str != NULL, "unexpected NULL thread name");
     2525   return name_str;
     2526 }
     2527 
     2528 
     2529 const char* JavaThread::get_threadgroup_name() const {
     2530   debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
     2531   oop thread_obj = threadObj();
     2532   if (thread_obj != NULL) {
     2533     oop thread_group = java_lang_Thread::threadGroup(thread_obj);
     2534     if (thread_group != NULL) {
     2535       typeArrayOop name = java_lang_ThreadGroup::name(thread_group);
     2536       // ThreadGroup.name can be null
     2537       if (name != NULL) {
     2538         const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
     2539         return str;
     2540       }
     2541     }
     2542   }
     2543   return NULL;
     2544 }
     2545 
     2546 const char* JavaThread::get_parent_name() const {
     2547   debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
     2548   oop thread_obj = threadObj();
     2549   if (thread_obj != NULL) {
     2550     oop thread_group = java_lang_Thread::threadGroup(thread_obj);
     2551     if (thread_group != NULL) {
     2552       oop parent = java_lang_ThreadGroup::parent(thread_group);
     2553       if (parent != NULL) {
     2554         typeArrayOop name = java_lang_ThreadGroup::name(parent);
     2555         // ThreadGroup.name can be null
     2556         if (name != NULL) {
     2557           const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
     2558           return str;
     2559         }
     2560       }
     2561     }
     2562   }
     2563   return NULL;
     2564 }
     2565 
     2566 ThreadPriority JavaThread::java_priority() const {
     2567   oop thr_oop = threadObj();
     2568   if (thr_oop == NULL) return NormPriority; // Bootstrapping
     2569   ThreadPriority priority = java_lang_Thread::priority(thr_oop);
     2570   assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
     2571   return priority;
     2572 }
     2573 
     2574 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) {
     2575 
     2576   assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
     2577   // Link Java Thread object <-> C++ Thread
     2578 
     2579   // Get the C++ thread object (an oop) from the JNI handle (a jthread)
     2580   // and put it into a new Handle.  The Handle "thread_oop" can then
     2581   // be used to pass the C++ thread object to other methods.
     2582 
     2583   // Set the Java level thread object (jthread) field of the
     2584   // new thread (a JavaThread *) to C++ thread object using the
     2585   // "thread_oop" handle.
     2586 
     2587   // Set the thread field (a JavaThread *) of the
     2588   // oop representing the java_lang_Thread to the new thread (a JavaThread *).
     2589 
     2590   Handle thread_oop(Thread::current(),
     2591                     JNIHandles::resolve_non_null(jni_thread));
     2592   assert(instanceKlass::cast(thread_oop->klass())->is_linked(),
     2593     "must be initialized");
     2594   set_threadObj(thread_oop());
     2595   java_lang_Thread::set_thread(thread_oop(), this);
     2596 
     2597   if (prio == NoPriority) {
     2598     prio = java_lang_Thread::priority(thread_oop());
     2599     assert(prio != NoPriority, "A valid priority should be present");
     2600   }
     2601 
     2602   // Push the Java priority down to the native thread; needs Threads_lock
     2603   Thread::set_priority(this, prio);
     2604 
     2605   // Add the new thread to the Threads list and set it in motion.
     2606   // We must have threads lock in order to call Threads::add.
     2607   // It is crucial that we do not block before the thread is
     2608   // added to the Threads list for if a GC happens, then the java_thread oop
     2609   // will not be visited by GC.
     2610   Threads::add(this);
     2611 }
     2612 
     2613 oop JavaThread::current_park_blocker() {
     2614   // Support for JSR-166 locks
     2615   oop thread_oop = threadObj();
     2616   if (thread_oop != NULL &&
     2617       JDK_Version::current().supports_thread_park_blocker()) {
     2618     return java_lang_Thread::park_blocker(thread_oop);
     2619   }
     2620   return NULL;
     2621 }
     2622 
     2623 
     2624 void JavaThread::print_stack_on(outputStream* st) {
     2625   if (!has_last_Java_frame()) return;
     2626   ResourceMark rm;
     2627   HandleMark   hm;
     2628 
     2629   RegisterMap reg_map(this);
     2630   vframe* start_vf = last_java_vframe(&reg_map);
     2631   int count = 0;
     2632   for (vframe* f = start_vf; f; f = f->sender() ) {
     2633     if (f->is_java_frame()) {
     2634       javaVFrame* jvf = javaVFrame::cast(f);
     2635       java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci());
     2636 
     2637       // Print out lock information
     2638       if (JavaMonitorsInStackTrace) {
     2639         jvf->print_lock_info_on(st, count);
     2640       }
     2641     } else {
     2642       // Ignore non-Java frames
     2643     }
     2644 
     2645     // Bail-out case for too deep stacks
     2646     count++;
     2647     if (MaxJavaStackTraceDepth == count) return;
     2648   }
     2649 }
     2650 
     2651 
     2652 // JVMTI PopFrame support
     2653 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) {
     2654   assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments");
     2655   if (in_bytes(size_in_bytes) != 0) {
     2656     _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes));
     2657     _popframe_preserved_args_size = in_bytes(size_in_bytes);
     2658     Copy::conjoint_bytes(start, _popframe_preserved_args, _popframe_preserved_args_size);
     2659   }
     2660 }
     2661 
     2662 void* JavaThread::popframe_preserved_args() {
     2663   return _popframe_preserved_args;
     2664 }
     2665 
     2666 ByteSize JavaThread::popframe_preserved_args_size() {
     2667   return in_ByteSize(_popframe_preserved_args_size);
     2668 }
     2669 
     2670 WordSize JavaThread::popframe_preserved_args_size_in_words() {
     2671   int sz = in_bytes(popframe_preserved_args_size());
     2672   assert(sz % wordSize == 0, "argument size must be multiple of wordSize");
     2673   return in_WordSize(sz / wordSize);
     2674 }
     2675 
     2676 void JavaThread::popframe_free_preserved_args() {
     2677   assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice");
     2678   FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args);
     2679   _popframe_preserved_args = NULL;
     2680   _popframe_preserved_args_size = 0;
     2681 }
     2682 
     2683 #ifndef PRODUCT
     2684 
     2685 void JavaThread::trace_frames() {
     2686   tty->print_cr("[Describe stack]");
     2687   int frame_no = 1;
     2688   for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
     2689     tty->print("  %d. ", frame_no++);
     2690     fst.current()->print_value_on(tty,this);
     2691     tty->cr();
     2692   }
     2693 }
     2694 
     2695 
     2696 void JavaThread::trace_stack_from(vframe* start_vf) {
     2697   ResourceMark rm;
     2698   int vframe_no = 1;
     2699   for (vframe* f = start_vf; f; f = f->sender() ) {
     2700     if (f->is_java_frame()) {
     2701       javaVFrame::cast(f)->print_activation(vframe_no++);
     2702     } else {
     2703       f->print();
     2704     }
     2705     if (vframe_no > StackPrintLimit) {
     2706       tty->print_cr("...<more frames>...");
     2707       return;
     2708     }
     2709   }
     2710 }
     2711 
     2712 
     2713 void JavaThread::trace_stack() {
     2714   if (!has_last_Java_frame()) return;
     2715   ResourceMark rm;
     2716   HandleMark   hm;
     2717   RegisterMap reg_map(this);
     2718   trace_stack_from(last_java_vframe(&reg_map));
     2719 }
     2720 
     2721 
     2722 #endif // PRODUCT
     2723 
     2724 
     2725 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) {
     2726   assert(reg_map != NULL, "a map must be given");
     2727   frame f = last_frame();
     2728   for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) {
     2729     if (vf->is_java_frame()) return javaVFrame::cast(vf);
     2730   }
     2731   return NULL;
     2732 }
     2733 
     2734 
     2735 klassOop JavaThread::security_get_caller_class(int depth) {
     2736   vframeStream vfst(this);
     2737   vfst.security_get_caller_frame(depth);
     2738   if (!vfst.at_end()) {
     2739     return vfst.method()->method_holder();
     2740   }
     2741   return NULL;
     2742 }
     2743 
     2744 static void compiler_thread_entry(JavaThread* thread, TRAPS) {
     2745   assert(thread->is_Compiler_thread(), "must be compiler thread");
     2746   CompileBroker::compiler_thread_loop();
     2747 }
     2748 
     2749 // Create a CompilerThread
     2750 CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters)
     2751 : JavaThread(&compiler_thread_entry) {
     2752   _env   = NULL;
     2753   _log   = NULL;
     2754   _task  = NULL;
     2755   _queue = queue;
     2756   _counters = counters;
     2757 
     2758 #ifndef PRODUCT
     2759   _ideal_graph_printer = NULL;
     2760 #endif
     2761 }
     2762 
     2763 
     2764 // ======= Threads ========
     2765 
     2766 // The Threads class links together all active threads, and provides
     2767 // operations over all threads.  It is protected by its own Mutex
     2768 // lock, which is also used in other contexts to protect thread
     2769 // operations from having the thread being operated on from exiting
     2770 // and going away unexpectedly (e.g., safepoint synchronization)
     2771 
     2772 JavaThread* Threads::_thread_list = NULL;
     2773 int         Threads::_number_of_threads = 0;
     2774 int         Threads::_number_of_non_daemon_threads = 0;
     2775 int         Threads::_return_code = 0;
     2776 size_t      JavaThread::_stack_size_at_create = 0;
     2777 
     2778 // All JavaThreads
     2779 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next())
     2780 
     2781 void os_stream();
     2782 
     2783 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system)
     2784 void Threads::threads_do(ThreadClosure* tc) {
     2785   assert_locked_or_safepoint(Threads_lock);
     2786   // ALL_JAVA_THREADS iterates through all JavaThreads
     2787   ALL_JAVA_THREADS(p) {
     2788     tc->do_thread(p);
     2789   }
     2790   // Someday we could have a table or list of all non-JavaThreads.
     2791   // For now, just manually iterate through them.
     2792   tc->do_thread(VMThread::vm_thread());
     2793   Universe::heap()->gc_threads_do(tc);
     2794   WatcherThread *wt = WatcherThread::watcher_thread();
     2795   // Strictly speaking, the following NULL check isn't sufficient to make sure
     2796   // the data for WatcherThread is still valid upon being examined. However,
     2797   // considering that WatchThread terminates when the VM is on the way to
     2798   // exit at safepoint, the chance of the above is extremely small. The right
     2799   // way to prevent termination of WatcherThread would be to acquire
     2800   // Terminator_lock, but we can't do that without violating the lock rank
     2801   // checking in some cases.
     2802   if (wt != NULL)
     2803     tc->do_thread(wt);
     2804 
     2805   // If CompilerThreads ever become non-JavaThreads, add them here
     2806 }
     2807 
     2808 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
     2809 
     2810   extern void JDK_Version_init();
     2811 
     2812   // Check version
     2813   if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
     2814 
     2815   // Initialize the output stream module
     2816   ostream_init();
     2817 
     2818   // Process java launcher properties.
     2819   Arguments::process_sun_java_launcher_properties(args);
     2820 
     2821   // Initialize the os module before using TLS
     2822   os::init();
     2823 
     2824   // Initialize system properties.
     2825   Arguments::init_system_properties();
     2826 
     2827   // So that JDK version can be used as a discrimintor when parsing arguments
     2828   JDK_Version_init();
     2829 
     2830   // Parse arguments
     2831   jint parse_result = Arguments::parse(args);
     2832   if (parse_result != JNI_OK) return parse_result;
     2833 
     2834   if (PauseAtStartup) {
     2835     os::pause();
     2836   }
     2837 
     2838   HS_DTRACE_PROBE(hotspot, vm__init__begin);
     2839 
     2840   // Record VM creation timing statistics
     2841   TraceVmCreationTime create_vm_timer;
     2842   create_vm_timer.start();
     2843 
     2844   // Timing (must come after argument parsing)
     2845   TraceTime timer("Create VM", TraceStartupTime);
     2846 
     2847   // Initialize the os module after parsing the args
     2848   jint os_init_2_result = os::init_2();
     2849   if (os_init_2_result != JNI_OK) return os_init_2_result;
     2850 
     2851   // Initialize output stream logging
     2852   ostream_init_log();
     2853 
     2854   // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
     2855   // Must be before create_vm_init_agents()
     2856   if (Arguments::init_libraries_at_startup()) {
     2857     convert_vm_init_libraries_to_agents();
     2858   }
     2859 
     2860   // Launch -agentlib/-agentpath and converted -Xrun agents
     2861   if (Arguments::init_agents_at_startup()) {
     2862     create_vm_init_agents();
     2863   }
     2864 
     2865   // Initialize Threads state
     2866   _thread_list = NULL;
     2867   _number_of_threads = 0;
     2868   _number_of_non_daemon_threads = 0;
     2869 
     2870   // Initialize TLS
     2871   ThreadLocalStorage::init();
     2872 
     2873   // Initialize global data structures and create system classes in heap
     2874   vm_init_globals();
     2875 
     2876   // Attach the main thread to this os thread
     2877   JavaThread* main_thread = new JavaThread();
     2878   main_thread->set_thread_state(_thread_in_vm);
     2879   // must do this before set_active_handles and initialize_thread_local_storage
     2880   // Note: on solaris initialize_thread_local_storage() will (indirectly)
     2881   // change the stack size recorded here to one based on the java thread
     2882   // stacksize. This adjusted size is what is used to figure the placement
     2883   // of the guard pages.
     2884   main_thread->record_stack_base_and_size();
     2885   main_thread->initialize_thread_local_storage();
     2886 
     2887   main_thread->set_active_handles(JNIHandleBlock::allocate_block());
     2888 
     2889   if (!main_thread->set_as_starting_thread()) {
     2890     vm_shutdown_during_initialization(
     2891       "Failed necessary internal allocation. Out of swap space");
     2892     delete main_thread;
     2893     *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
     2894     return JNI_ENOMEM;
     2895   }
     2896 
     2897   // Enable guard page *after* os::create_main_thread(), otherwise it would
     2898   // crash Linux VM, see notes in os_linux.cpp.
     2899   main_thread->create_stack_guard_pages();
     2900 
     2901   // Initialize Java-Leve synchronization subsystem
     2902   ObjectSynchronizer::Initialize() ;
     2903 
     2904   // Initialize global modules
     2905   jint status = init_globals();
     2906   if (status != JNI_OK) {
     2907     delete main_thread;
     2908     *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
     2909     return status;
     2910   }
     2911 
     2912   HandleMark hm;
     2913 
     2914   { MutexLocker mu(Threads_lock);
     2915     Threads::add(main_thread);
     2916   }
     2917 
     2918   // Any JVMTI raw monitors entered in onload will transition into
     2919   // real raw monitor. VM is setup enough here for raw monitor enter.
     2920   JvmtiExport::transition_pending_onload_raw_monitors();
     2921 
     2922   if (VerifyBeforeGC &&
     2923       Universe::heap()->total_collections() >= VerifyGCStartAt) {
     2924     Universe::heap()->prepare_for_verify();
     2925     Universe::verify();   // make sure we're starting with a clean slate
     2926   }
     2927 
     2928   // Create the VMThread
     2929   { TraceTime timer("Start VMThread", TraceStartupTime);
     2930     VMThread::create();
     2931     Thread* vmthread = VMThread::vm_thread();
     2932 
     2933     if (!os::create_thread(vmthread, os::vm_thread))
     2934       vm_exit_during_initialization("Cannot create VM thread. Out of system resources.");
     2935 
     2936     // Wait for the VM thread to become ready, and VMThread::run to initialize
     2937     // Monitors can have spurious returns, must always check another state flag
     2938     {
     2939       MutexLocker ml(Notify_lock);
     2940       os::start_thread(vmthread);
     2941       while (vmthread->active_handles() == NULL) {
     2942         Notify_lock->wait();
     2943       }
     2944     }
     2945   }
     2946 
     2947   assert (Universe::is_fully_initialized(), "not initialized");
     2948   EXCEPTION_MARK;
     2949 
     2950   // At this point, the Universe is initialized, but we have not executed
     2951   // any byte code.  Now is a good time (the only time) to dump out the
     2952   // internal state of the JVM for sharing.
     2953 
     2954   if (DumpSharedSpaces) {
     2955     Universe::heap()->preload_and_dump(CHECK_0);
     2956     ShouldNotReachHere();
     2957   }
     2958 
     2959   // Always call even when there are not JVMTI environments yet, since environments
     2960   // may be attached late and JVMTI must track phases of VM execution
     2961   JvmtiExport::enter_start_phase();
     2962 
     2963   // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents.
     2964   JvmtiExport::post_vm_start();
     2965 
     2966   {
     2967     TraceTime timer("Initialize java.lang classes", TraceStartupTime);
     2968 
     2969     if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
     2970       create_vm_init_libraries();
     2971     }
     2972 
     2973     if (InitializeJavaLangString) {
     2974       initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0);
     2975     } else {
     2976       warning("java.lang.String not initialized");
     2977     }
     2978 
     2979     if (AggressiveOpts) {
     2980       {
     2981         // Forcibly initialize java/util/HashMap and mutate the private
     2982         // static final "frontCacheEnabled" field before we start creating instances
     2983 #ifdef ASSERT
     2984         klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
     2985         assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
     2986 #endif
     2987         klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
     2988         KlassHandle k = KlassHandle(THREAD, k_o);
     2989         guarantee(k.not_null(), "Must find java/util/HashMap");
     2990         instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
     2991         ik->initialize(CHECK_0);
     2992         fieldDescriptor fd;
     2993         // Possible we might not find this field; if so, don't break
     2994         if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
     2995           k()->bool_field_put(fd.offset(), true);
     2996         }
     2997       }
     2998 
     2999       if (UseStringCache) {
     3000         // Forcibly initialize java/lang/StringValue and mutate the private
     3001         // static final "stringCacheEnabled" field before we start creating instances
     3002         klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
     3003         // Possible that StringValue isn't present: if so, silently don't break
     3004         if (k_o != NULL) {
     3005           KlassHandle k = KlassHandle(THREAD, k_o);
     3006           instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
     3007           ik->initialize(CHECK_0);
     3008           fieldDescriptor fd;
     3009           // Possible we might not find this field: if so, silently don't break
     3010           if (ik->find_local_field(vmSymbols::stringCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
     3011             k()->bool_field_put(fd.offset(), true);
     3012           }
     3013         }
     3014       }
     3015     }
     3016 
     3017     // Initialize java_lang.System (needed before creating the thread)
     3018     if (InitializeJavaLangSystem) {
     3019       initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0);
     3020       initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0);
     3021       Handle thread_group = create_initial_thread_group(CHECK_0);
     3022       Universe::set_main_thread_group(thread_group());
     3023       initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0);
     3024       oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0);
     3025       main_thread->set_threadObj(thread_object);
     3026       // Set thread status to running since main thread has
     3027       // been started and running.
     3028       java_lang_Thread::set_thread_status(thread_object,
     3029                                           java_lang_Thread::RUNNABLE);
     3030 
     3031       // The VM preresolve methods to these classes. Make sure that get initialized
     3032       initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0);
     3033       initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(),  CHECK_0);
     3034       // The VM creates & returns objects of this class. Make sure it's initialized.
     3035       initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0);
     3036       call_initializeSystemClass(CHECK_0);
     3037     } else {
     3038       warning("java.lang.System not initialized");
     3039     }
     3040 
     3041     // an instance of OutOfMemory exception has been allocated earlier
     3042     if (InitializeJavaLangExceptionsErrors) {
     3043       initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0);
     3044       initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0);
     3045       initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0);
     3046       initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0);
     3047       initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0);
     3048       initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0);
     3049       initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0);
     3050     } else {
     3051       warning("java.lang.OutOfMemoryError has not been initialized");
     3052       warning("java.lang.NullPointerException has not been initialized");
     3053       warning("java.lang.ClassCastException has not been initialized");
     3054       warning("java.lang.ArrayStoreException has not been initialized");
     3055       warning("java.lang.ArithmeticException has not been initialized");
     3056       warning("java.lang.StackOverflowError has not been initialized");
     3057     }
     3058   }
     3059 
     3060   // See        : bugid 4211085.
     3061   // Background : the static initializer of java.lang.Compiler tries to read
     3062   //              property"java.compiler" and read & write property "java.vm.info".
     3063   //              When a security manager is installed through the command line
     3064   //              option "-Djava.security.manager", the above properties are not
     3065   //              readable and the static initializer for java.lang.Compiler fails
     3066   //              resulting in a NoClassDefFoundError.  This can happen in any
     3067   //              user code which calls methods in java.lang.Compiler.
     3068   // Hack :       the hack is to pre-load and initialize this class, so that only
     3069   //              system domains are on the stack when the properties are read.
     3070   //              Currently even the AWT code has calls to methods in java.lang.Compiler.
     3071   //              On the classic VM, java.lang.Compiler is loaded very early to load the JIT.
     3072   // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
     3073   //              read and write"java.vm.info" in the default policy file. See bugid 4211383
     3074   //              Once that is done, we should remove this hack.
     3075   initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0);
     3076 
     3077   // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to
     3078   // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot
     3079   // compiler does not get loaded through java.lang.Compiler).  "java -version" with the
     3080   // hotspot vm says "nojit" all the time which is confusing.  So, we reset it here.
     3081   // This should also be taken out as soon as 4211383 gets fixed.
     3082   reset_vm_info_property(CHECK_0);
     3083 
     3084   quicken_jni_functions();
     3085 
     3086   // Set flag that basic i