1 /*

     2  * Copyright 1997-2007 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 class ThreadSafepointState;

    26 class ThreadProfiler;

    27 

    28 class JvmtiThreadState;

    29 class JvmtiGetLoadedClassesClosure;

    30 class ThreadStatistics;

    31 class ConcurrentLocksDump;

    32 class ParkEvent ;

    33 

    34 class ciEnv;

    35 class CompileThread;

    36 class CompileLog;

    37 class CompileTask;

    38 class CompileQueue;

    39 class CompilerCounters;

    40 class vframeArray;

    41 

    42 class DeoptResourceMark;

    43 class jvmtiDeferredLocalVariableSet;

    44 

    45 class GCTaskQueue;

    46 class ThreadClosure;

    47 class IdealGraphPrinter;

    48 

    49 // Class hierarchy

    50 // - Thread

    51 //   - VMThread

    52 //   - JavaThread

    53 //   - WatcherThread

    54 

    55 class Thread: public ThreadShadow {

    56   friend class VMStructs;

    57  private:

    58   // Exception handling

    59   // (Note: _pending_exception and friends are in ThreadShadow)

    60   //oop       _pending_exception;                // pending exception for current thread

    61   // const char* _exception_file;                   // file information for exception (debugging only)

    62   // int         _exception_line;                   // line information for exception (debugging only)

    63 

    64   // Support for forcing alignment of thread objects for biased locking

    65   void*       _real_malloc_address;

    66  public:

    67   void* operator new(size_t size);

    68   void  operator delete(void* p);

    69  private:

    70 

    71   // ***************************************************************

    72   // Suspend and resume support

    73   // ***************************************************************

    74   //

    75   // VM suspend/resume no longer exists - it was once used for various

    76   // things including safepoints but was deprecated and finally removed

    77   // in Java 7. Because VM suspension was considered "internal" Java-level

    78   // suspension was considered "external", and this legacy naming scheme

    79   // remains.

    80   //

    81   // External suspend/resume requests come from JVM_SuspendThread,

    82   // JVM_ResumeThread, JVMTI SuspendThread, and finally JVMTI

    83   // ResumeThread. External

    84   // suspend requests cause _external_suspend to be set and external

    85   // resume requests cause _external_suspend to be cleared.

    86   // External suspend requests do not nest on top of other external

    87   // suspend requests. The higher level APIs reject suspend requests

    88   // for already suspended threads.

    89   //

    90   // The external_suspend

    91   // flag is checked by has_special_runtime_exit_condition() and java thread

    92   // will self-suspend when handle_special_runtime_exit_condition() is

    93   // called. Most uses of the _thread_blocked state in JavaThreads are

    94   // considered the same as being externally suspended; if the blocking

    95   // condition lifts, the JavaThread will self-suspend. Other places

    96   // where VM checks for external_suspend include:

    97   //   + mutex granting (do not enter monitors when thread is suspended)

    98   //   + state transitions from _thread_in_native

    99   //

   100   // In general, java_suspend() does not wait for an external suspend

   101   // request to complete. When it returns, the only guarantee is that

   102   // the _external_suspend field is true.

   103   //

   104   // wait_for_ext_suspend_completion() is used to wait for an external

   105   // suspend request to complete. External suspend requests are usually

   106   // followed by some other interface call that requires the thread to

   107   // be quiescent, e.g., GetCallTrace(). By moving the "wait time" into

   108   // the interface that requires quiescence, we give the JavaThread a

   109   // chance to self-suspend before we need it to be quiescent. This

   110   // improves overall suspend/query performance.

   111   //

   112   // _suspend_flags controls the behavior of java_ suspend/resume.

   113   // It must be set under the protection of SR_lock. Read from the flag is

   114   // OK without SR_lock as long as the value is only used as a hint.

   115   // (e.g., check _external_suspend first without lock and then recheck

   116   // inside SR_lock and finish the suspension)

   117   //

   118   // _suspend_flags is also overloaded for other "special conditions" so

   119   // that a single check indicates whether any special action is needed

   120   // eg. for async exceptions.

   121   // -------------------------------------------------------------------

   122   // Notes:

   123   // 1. The suspend/resume logic no longer uses ThreadState in OSThread

   124   // but we still update its value to keep other part of the system (mainly

   125   // JVMTI) happy. ThreadState is legacy code (see notes in

   126   // osThread.hpp).

   127   //

   128   // 2. It would be more natural if set_external_suspend() is private and

   129   // part of java_suspend(), but that probably would affect the suspend/query

   130   // performance. Need more investigation on this.

   131   //

   132 

   133   // suspend/resume lock: used for self-suspend

   134   Monitor*    _SR_lock;

   135 

   136  protected:

   137   enum SuspendFlags {

   138     // NOTE: avoid using the sign-bit as cc generates different test code

   139     //       when the sign-bit is used, and sometimes incorrectly - see CR 6398077

   140 

   141     _external_suspend       = 0x20000000U, // thread is asked to self suspend

   142     _ext_suspended          = 0x40000000U, // thread has self-suspended

   143     _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt

   144 

   145     _has_async_exception    = 0x00000001U  // there is a pending async exception

   146   };

   147 

   148   // various suspension related flags - atomically updated

   149   // overloaded for async exception checking in check_special_condition_for_native_trans.

   150   volatile uint32_t _suspend_flags;

   151 

   152  private:

   153   int _num_nested_signal;

   154 

   155  public:

   156   void enter_signal_handler() { _num_nested_signal++; }

   157   void leave_signal_handler() { _num_nested_signal--; }

   158   bool is_inside_signal_handler() const  { return _num_nested_signal > 0; }

   159 

   160  private:

   161   // Debug tracing

   162   static void trace(const char* msg, const Thread* const thread) PRODUCT_RETURN;

   163 

   164   // Active_handles points to a block of handles

   165   JNIHandleBlock* _active_handles;

   166 

   167   // One-element thread local free list

   168   JNIHandleBlock* _free_handle_block;

   169 

   170   // Point to the last handle mark

   171   HandleMark* _last_handle_mark;

   172 

   173   // The parity of the last strong_roots iteration in which this thread was

   174   // claimed as a task.

   175   jint _oops_do_parity;

   176 

   177   public:

   178    void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }

   179     HandleMark* last_handle_mark() const          { return _last_handle_mark; }

   180   private:

   181 

   182   // debug support for checking if code does allow safepoints or not

   183   // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on

   184   // mutex, or blocking on an object synchronizer (Java locking).

   185   // If !allow_safepoint(), then an assertion failure will happen in any of the above cases

   186   // If !allow_allocation(), then an assertion failure will happen during allocation

   187   // (Hence, !allow_safepoint() => !allow_allocation()).

   188   //

   189   // The two classes No_Safepoint_Verifier and No_Allocation_Verifier are used to set these counters.

   190   //

   191   NOT_PRODUCT(int _allow_safepoint_count;)       // If 0, thread allow a safepoint to happen

   192   debug_only (int _allow_allocation_count;)      // If 0, the thread is allowed to allocate oops.

   193 

   194   // Record when GC is locked out via the GC_locker mechanism

   195   CHECK_UNHANDLED_OOPS_ONLY(int _gc_locked_out_count;)

   196 

   197   friend class No_Alloc_Verifier;

   198   friend class No_Safepoint_Verifier;

   199   friend class Pause_No_Safepoint_Verifier;

   200   friend class ThreadLocalStorage;

   201   friend class GC_locker;

   202 

   203   // In order for all threads to be able to use fast locking, we need to know the highest stack

   204   // address of where a lock is on the stack (stacks normally grow towards lower addresses). This

   205   // variable is initially set to NULL, indicating no locks are used by the thread. During the thread's

   206   // execution, it will be set whenever locking can happen, i.e., when we call out to Java code or use

   207   // an ObjectLocker. The value is never decreased, hence, it will over the lifetime of a thread

   208   // approximate the real stackbase.

   209   address _highest_lock;                         // Highest stack address where a JavaLock exist

   210 

   211   ThreadLocalAllocBuffer _tlab;                  // Thread-local eden

   212 

   213   int   _vm_operation_started_count;             // VM_Operation support

   214   int   _vm_operation_completed_count;           // VM_Operation support

   215 

   216   ObjectMonitor* _current_pending_monitor;       // ObjectMonitor this thread

   217                                                  // is waiting to lock

   218   bool _current_pending_monitor_is_from_java;    // locking is from Java code

   219 

   220   // ObjectMonitor on which this thread called Object.wait()

   221   ObjectMonitor* _current_waiting_monitor;

   222 

   223   // Private thread-local objectmonitor list - a simple cache organized as a SLL.

   224  public:

   225   ObjectMonitor * omFreeList ;

   226   int omFreeCount ;                             // length of omFreeList

   227   int omFreeProvision ;                         // reload chunk size

   228 

   229  public:

   230   enum {

   231     is_definitely_current_thread = true

   232   };

   233 

   234   // Constructor

   235   Thread();

   236   virtual ~Thread();

   237 

   238   // initializtion

   239   void initialize_thread_local_storage();

   240 

   241   // thread entry point

   242   virtual void run();

   243 

   244   // Testers

   245   virtual bool is_VM_thread()       const            { return false; }

   246   virtual bool is_Java_thread()     const            { return false; }

   247   // Remove this ifdef when C1 is ported to the compiler interface.

   248   virtual bool is_Compiler_thread() const            { return false; }

   249   virtual bool is_hidden_from_external_view() const  { return false; }

   250   virtual bool is_jvmti_agent_thread() const         { return false; }

   251   // True iff the thread can perform GC operations at a safepoint.

   252   // Generally will be true only of VM thread and parallel GC WorkGang

   253   // threads.

   254   virtual bool is_GC_task_thread() const             { return false; }

   255   virtual bool is_Watcher_thread() const             { return false; }

   256   virtual bool is_ConcurrentGC_thread() const        { return false; }

   257 

   258   virtual char* name() const { return (char*)"Unknown thread"; }

   259 

   260   // Returns the current thread

   261   static inline Thread* current();

   262 

   263   // Common thread operations

   264   static void set_priority(Thread* thread, ThreadPriority priority);

   265   static ThreadPriority get_priority(const Thread* const thread);

   266   static void start(Thread* thread);

   267   static void interrupt(Thread* thr);

   268   static bool is_interrupted(Thread* thr, bool clear_interrupted);

   269 

   270   Monitor* SR_lock() const                       { return _SR_lock; }

   271 

   272   bool has_async_exception() const { return (_suspend_flags & _has_async_exception) != 0; }

   273 

   274   void set_suspend_flag(SuspendFlags f) {

   275     assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");

   276     uint32_t flags;

   277     do {

   278       flags = _suspend_flags;

   279     }

   280     while (Atomic::cmpxchg((jint)(flags | f),

   281                            (volatile jint*)&_suspend_flags,

   282                            (jint)flags) != (jint)flags);

   283   }

   284   void clear_suspend_flag(SuspendFlags f) {

   285     assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");

   286     uint32_t flags;

   287     do {

   288       flags = _suspend_flags;

   289     }

   290     while (Atomic::cmpxchg((jint)(flags & ~f),

   291                            (volatile jint*)&_suspend_flags,

   292                            (jint)flags) != (jint)flags);

   293   }

   294 

   295   void set_has_async_exception() {

   296     set_suspend_flag(_has_async_exception);

   297   }

   298   void clear_has_async_exception() {

   299     clear_suspend_flag(_has_async_exception);

   300   }

   301 

   302   // Support for Unhandled Oop detection

   303 #ifdef CHECK_UNHANDLED_OOPS

   304  private:

   305   UnhandledOops *_unhandled_oops;

   306  public:

   307   UnhandledOops* unhandled_oops()               { return _unhandled_oops; }

   308   // Mark oop safe for gc.  It may be stack allocated but won't move.

   309   void allow_unhandled_oop(oop *op)              {

   310     if (CheckUnhandledOops) unhandled_oops()->allow_unhandled_oop(op);

   311   }

   312   // Clear oops at safepoint so crashes point to unhandled oop violator

   313   void clear_unhandled_oops()                   {

   314     if (CheckUnhandledOops) unhandled_oops()->clear_unhandled_oops();

   315   }

   316   bool is_gc_locked_out() { return _gc_locked_out_count > 0; }

   317 #endif // CHECK_UNHANDLED_OOPS

   318 

   319  public:

   320   // Installs a pending exception to be inserted later

   321   static void send_async_exception(oop thread_oop, oop java_throwable);

   322 

   323   // Resource area

   324   ResourceArea* resource_area() const            { return _resource_area; }

   325   void set_resource_area(ResourceArea* area)     { _resource_area = area; }

   326 

   327   OSThread* osthread() const                     { return _osthread;   }

   328   void set_osthread(OSThread* thread)            { _osthread = thread; }

   329 

   330   // JNI handle support

   331   JNIHandleBlock* active_handles() const         { return _active_handles; }

   332   void set_active_handles(JNIHandleBlock* block) { _active_handles = block; }

   333   JNIHandleBlock* free_handle_block() const      { return _free_handle_block; }

   334   void set_free_handle_block(JNIHandleBlock* block) { _free_handle_block = block; }

   335 

   336   // Internal handle support

   337   HandleArea* handle_area() const                { return _handle_area; }

   338   void set_handle_area(HandleArea* area)         { _handle_area = area; }

   339 

   340   // Thread-Local Allocation Buffer (TLAB) support

   341   ThreadLocalAllocBuffer& tlab()                 { return _tlab; }

   342   void initialize_tlab() {

   343     if (UseTLAB) {

   344       tlab().initialize();

   345     }

   346   }

   347 

   348   // VM operation support

   349   int vm_operation_ticket()                      { return ++_vm_operation_started_count; }

   350   int vm_operation_completed_count()             { return _vm_operation_completed_count; }

   351   void increment_vm_operation_completed_count()  { _vm_operation_completed_count++; }

   352 

   353   // For tracking the heavyweight monitor the thread is pending on.

   354   ObjectMonitor* current_pending_monitor() {

   355     return _current_pending_monitor;

   356   }

   357   void set_current_pending_monitor(ObjectMonitor* monitor) {

   358     _current_pending_monitor = monitor;

   359   }

   360   void set_current_pending_monitor_is_from_java(bool from_java) {

   361     _current_pending_monitor_is_from_java = from_java;

   362   }

   363   bool current_pending_monitor_is_from_java() {

   364     return _current_pending_monitor_is_from_java;

   365   }

   366 

   367   // For tracking the ObjectMonitor on which this thread called Object.wait()

   368   ObjectMonitor* current_waiting_monitor() {

   369     return _current_waiting_monitor;

   370   }

   371   void set_current_waiting_monitor(ObjectMonitor* monitor) {

   372     _current_waiting_monitor = monitor;

   373   }

   374 

   375   // GC support

   376   // Apply "f->do_oop" to all root oops in "this".

   377   void oops_do(OopClosure* f);

   378 

   379   // Handles the parallel case for the method below.

   380 private:

   381   bool claim_oops_do_par_case(int collection_parity);

   382 public:

   383   // Requires that "collection_parity" is that of the current strong roots

   384   // iteration.  If "is_par" is false, sets the parity of "this" to

   385   // "collection_parity", and returns "true".  If "is_par" is true,

   386   // uses an atomic instruction to set the current threads parity to

   387   // "collection_parity", if it is not already.  Returns "true" iff the

   388   // calling thread does the update, this indicates that the calling thread

   389   // has claimed the thread's stack as a root groop in the current

   390   // collection.

   391   bool claim_oops_do(bool is_par, int collection_parity) {

   392     if (!is_par) {

   393       _oops_do_parity = collection_parity;

   394       return true;

   395     } else {

   396       return claim_oops_do_par_case(collection_parity);

   397     }

   398   }

   399 

   400   // Sweeper support

   401   void nmethods_do();

   402 

   403   // Fast-locking support

   404   address highest_lock() const                   { return _highest_lock; }

   405   void update_highest_lock(address base)         { if (base > _highest_lock) _highest_lock = base; }

   406 

   407   // Tells if adr belong to this thread. This is used

   408   // for checking if a lock is owned by the running thread.

   409   // Warning: the method can only be used on the running thread

   410   // Fast lock support uses these methods

   411   virtual bool lock_is_in_stack(address adr) const;

   412   virtual bool is_lock_owned(address adr) const;

   413 

   414   // Check if address is in the stack of the thread (not just for locks).

   415   bool is_in_stack(address adr) const;

   416 

   417   // Sets this thread as starting thread. Returns failure if thread

   418   // creation fails due to lack of memory, too many threads etc.

   419   bool set_as_starting_thread();

   420 

   421  protected:

   422   // OS data associated with the thread

   423   OSThread* _osthread;  // Platform-specific thread information

   424 

   425   // Thread local resource area for temporary allocation within the VM

   426   ResourceArea* _resource_area;

   427 

   428   // Thread local handle area for allocation of handles within the VM

   429   HandleArea* _handle_area;

   430 

   431   // Support for stack overflow handling, get_thread, etc.

   432   address          _stack_base;

   433   size_t           _stack_size;

   434   uintptr_t        _self_raw_id;      // used by get_thread (mutable)

   435   int              _lgrp_id;

   436 

   437  public:

   438   // Stack overflow support

   439   address stack_base() const           { assert(_stack_base != NULL,"Sanity check"); return _stack_base; }

   440 

   441   void    set_stack_base(address base) { _stack_base = base; }

   442   size_t  stack_size() const           { return _stack_size; }

   443   void    set_stack_size(size_t size)  { _stack_size = size; }

   444   void    record_stack_base_and_size();

   445 

   446   int     lgrp_id() const                 { return _lgrp_id; }

   447   void    set_lgrp_id(int value)          { _lgrp_id = value; }

   448 

   449   // Printing

   450   void print_on(outputStream* st) const;

   451   void print() const { print_on(tty); }

   452   virtual void print_on_error(outputStream* st, char* buf, int buflen) const;

   453 

   454   // Debug-only code

   455 

   456 #ifdef ASSERT

   457  private:

   458   // Deadlock detection support for Mutex locks. List of locks own by thread.

   459   Monitor *_owned_locks;

   460   // Mutex::set_owner_implementation is the only place where _owned_locks is modified,

   461   // thus the friendship

   462   friend class Mutex;

   463   friend class Monitor;

   464 

   465  public:

   466   void print_owned_locks_on(outputStream* st) const;

   467   void print_owned_locks() const                 { print_owned_locks_on(tty);    }

   468   Monitor * owned_locks() const                  { return _owned_locks;          }

   469   bool owns_locks() const                        { return owned_locks() != NULL; }

   470   bool owns_locks_but_compiled_lock() const;

   471 

   472   // Deadlock detection

   473   bool allow_allocation()                        { return _allow_allocation_count == 0; }

   474 #endif

   475 

   476   void check_for_valid_safepoint_state(bool potential_vm_operation) PRODUCT_RETURN;

   477 

   478  private:

   479   volatile int _jvmti_env_iteration_count;

   480 

   481  public:

   482   void entering_jvmti_env_iteration()            { ++_jvmti_env_iteration_count; }

   483   void leaving_jvmti_env_iteration()             { --_jvmti_env_iteration_count; }

   484   bool is_inside_jvmti_env_iteration()           { return _jvmti_env_iteration_count > 0; }

   485 

   486   // Code generation

   487   static ByteSize exception_file_offset()        { return byte_offset_of(Thread, _exception_file   ); }

   488   static ByteSize exception_line_offset()        { return byte_offset_of(Thread, _exception_line   ); }

   489   static ByteSize active_handles_offset()        { return byte_offset_of(Thread, _active_handles   ); }

   490 

   491   static ByteSize stack_base_offset()            { return byte_offset_of(Thread, _stack_base ); }

   492   static ByteSize stack_size_offset()            { return byte_offset_of(Thread, _stack_size ); }

   493   static ByteSize omFreeList_offset()            { return byte_offset_of(Thread, omFreeList); }

   494 

   495 #define TLAB_FIELD_OFFSET(name) \

   496   static ByteSize tlab_##name##_offset()            { return byte_offset_of(Thread, _tlab) + ThreadLocalAllocBuffer::name##_offset(); }

   497 

   498   TLAB_FIELD_OFFSET(start)

   499   TLAB_FIELD_OFFSET(end)

   500   TLAB_FIELD_OFFSET(top)

   501   TLAB_FIELD_OFFSET(pf_top)

   502   TLAB_FIELD_OFFSET(size)                   // desired_size

   503   TLAB_FIELD_OFFSET(refill_waste_limit)

   504   TLAB_FIELD_OFFSET(number_of_refills)

   505   TLAB_FIELD_OFFSET(fast_refill_waste)

   506   TLAB_FIELD_OFFSET(slow_allocations)

   507 

   508 #undef TLAB_FIELD_OFFSET

   509 

   510  public:

   511   volatile intptr_t _Stalled ;

   512   volatile int _TypeTag ;

   513   ParkEvent * _ParkEvent ;                     // for synchronized()

   514   ParkEvent * _SleepEvent ;                    // for Thread.sleep

   515   ParkEvent * _MutexEvent ;                    // for native internal Mutex/Monitor

   516   ParkEvent * _MuxEvent ;                      // for low-level muxAcquire-muxRelease

   517   int NativeSyncRecursion ;                    // diagnostic

   518 

   519   volatile int _OnTrap ;                       // Resume-at IP delta

   520   jint _hashStateW ;                           // Marsaglia Shift-XOR thread-local RNG

   521   jint _hashStateX ;                           // thread-specific hashCode generator state

   522   jint _hashStateY ;

   523   jint _hashStateZ ;

   524   void * _schedctl ;

   525 

   526   intptr_t _ScratchA, _ScratchB ;              // Scratch locations for fast-path sync code

   527   static ByteSize ScratchA_offset()            { return byte_offset_of(Thread, _ScratchA ); }

   528   static ByteSize ScratchB_offset()            { return byte_offset_of(Thread, _ScratchB ); }

   529 

   530   volatile jint rng [4] ;                      // RNG for spin loop

   531 

   532   // Low-level leaf-lock primitives used to implement synchronization

   533   // and native monitor-mutex infrastructure.

   534   // Not for general synchronization use.

   535   static void SpinAcquire (volatile int * Lock, const char * Name) ;

   536   static void SpinRelease (volatile int * Lock) ;

   537   static void muxAcquire  (volatile intptr_t * Lock, const char * Name) ;

   538   static void muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) ;

   539   static void muxRelease  (volatile intptr_t * Lock) ;

   540 

   541 };

   542 

   543 // Inline implementation of Thread::current()

   544 // Thread::current is "hot" it's called > 128K times in the 1st 500 msecs of

   545 // startup.

   546 // ThreadLocalStorage::thread is warm -- it's called > 16K times in the same

   547 // period.   This is inlined in thread_<os_family>.inline.hpp.

   548 

   549 inline Thread* Thread::current() {

   550 #ifdef ASSERT

   551 // This function is very high traffic. Define PARANOID to enable expensive

   552 // asserts.

   553 #ifdef PARANOID

   554   // Signal handler should call ThreadLocalStorage::get_thread_slow()

   555   Thread* t = ThreadLocalStorage::get_thread_slow();

   556   assert(t != NULL && !t->is_inside_signal_handler(),

   557          "Don't use Thread::current() inside signal handler");

   558 #endif

   559 #endif

   560   Thread* thread = ThreadLocalStorage::thread();

   561   assert(thread != NULL, "just checking");

   562   return thread;

   563 }

   564 

   565 // Name support for threads.  non-JavaThread subclasses with multiple

   566 // uniquely named instances should derive from this.

   567 class NamedThread: public Thread {

   568   friend class VMStructs;

   569   enum {

   570     max_name_len = 64

   571   };

   572  private:

   573   char* _name;

   574  public:

   575   NamedThread();

   576   ~NamedThread();

   577   // May only be called once per thread.

   578   void set_name(const char* format, ...);

   579   virtual char* name() const { return _name == NULL ? (char*)"Unknown Thread" : _name; }

   580 };

   581 

   582 // Worker threads are named and have an id of an assigned work.

   583 class WorkerThread: public NamedThread {

   584 private:

   585   uint _id;

   586 public:

   587   WorkerThread() : _id(0) { }

   588   void set_id(uint work_id) { _id = work_id; }

   589   uint id() const { return _id; }

   590 };

   591 

   592 // A single WatcherThread is used for simulating timer interrupts.

   593 class WatcherThread: public Thread {

   594   friend class VMStructs;

   595  public:

   596   virtual void run();

   597 

   598  private:

   599   static WatcherThread* _watcher_thread;

   600 

   601   static bool _should_terminate;

   602  public:

   603   enum SomeConstants {

   604     delay_interval = 10                          // interrupt delay in milliseconds

   605   };

   606 

   607   // Constructor

   608   WatcherThread();

   609 

   610   // Tester

   611   bool is_Watcher_thread() const                 { return true; }

   612 

   613   // Printing

   614   char* name() const { return (char*)"VM Periodic Task Thread"; }

   615   void print_on(outputStream* st) const;

   616   void print() const { print_on(tty); }

   617 

   618   // Returns the single instance of WatcherThread

   619   static WatcherThread* watcher_thread()         { return _watcher_thread; }

   620 

   621   // Create and start the single instance of WatcherThread, or stop it on shutdown

   622   static void start();

   623   static void stop();

   624 };

   625 

   626 

   627 class CompilerThread;

   628 

   629 typedef void (*ThreadFunction)(JavaThread*, TRAPS);

   630 

   631 class JavaThread: public Thread {

   632   friend class VMStructs;

   633  private:

   634   JavaThread*    _next;                          // The next thread in the Threads list

   635   oop            _threadObj;                     // The Java level thread object

   636 

   637 #ifdef ASSERT

   638  private:

   639   int _java_call_counter;

   640 

   641  public:

   642   int  java_call_counter()                       { return _java_call_counter; }

   643   void inc_java_call_counter()                   { _java_call_counter++; }

   644   void dec_java_call_counter() {

   645     assert(_java_call_counter > 0, "Invalid nesting of JavaCallWrapper");

   646     _java_call_counter--;

   647   }

   648  private:  // restore original namespace restriction

   649 #endif  // ifdef ASSERT

   650 

   651 #ifndef PRODUCT

   652  public:

   653   enum {

   654     jump_ring_buffer_size = 16

   655   };

   656  private:  // restore original namespace restriction

   657 #endif

   658 

   659   JavaFrameAnchor _anchor;                       // Encapsulation of current java frame and it state

   660 

   661   ThreadFunction _entry_point;

   662 

   663   JNIEnv        _jni_environment;

   664 

   665   // Deopt support

   666   DeoptResourceMark*  _deopt_mark;               // Holds special ResourceMark for deoptimization

   667 

   668   intptr_t*      _must_deopt_id;                 // id of frame that needs to be deopted once we

   669                                                  // transition out of native

   670 

   671   vframeArray*  _vframe_array_head;              // Holds the heap of the active vframeArrays

   672   vframeArray*  _vframe_array_last;              // Holds last vFrameArray we popped

   673   // Because deoptimization is lazy we must save jvmti requests to set locals

   674   // in compiled frames until we deoptimize and we have an interpreter frame.

   675   // This holds the pointer to array (yeah like there might be more than one) of

   676   // description of compiled vframes that have locals that need to be updated.

   677   GrowableArray<jvmtiDeferredLocalVariableSet*>* _deferred_locals_updates;

   678 

   679   // Handshake value for fixing 6243940. We need a place for the i2c

   680   // adapter to store the callee methodOop. This value is NEVER live

   681   // across a gc point so it does NOT have to be gc'd

   682   // The handshake is open ended since we can't be certain that it will

   683   // be NULLed. This is because we rarely ever see the race and end up

   684   // in handle_wrong_method which is the backend of the handshake. See

   685   // code in i2c adapters and handle_wrong_method.

   686 

   687   methodOop     _callee_target;

   688 

   689   // Oop results of VM runtime calls

   690   oop           _vm_result;                      // Used to pass back an oop result into Java code, GC-preserved

   691   oop           _vm_result_2;                    // Used to pass back an oop result into Java code, GC-preserved

   692 

   693   MonitorChunk* _monitor_chunks;                 // Contains the off stack monitors

   694                                                  // allocated during deoptimization

   695                                                  // and by JNI_MonitorEnter/Exit

   696 

   697   // Async. requests support

   698   enum AsyncRequests {

   699     _no_async_condition = 0,

   700     _async_exception,

   701     _async_unsafe_access_error

   702   };

   703   AsyncRequests _special_runtime_exit_condition; // Enum indicating pending async. request

   704   oop           _pending_async_exception;

   705 

   706   // Safepoint support

   707  public:                                         // Expose _thread_state for SafeFetchInt()

   708   volatile JavaThreadState _thread_state;

   709  private:

   710   ThreadSafepointState *_safepoint_state;        // Holds information about a thread during a safepoint

   711   address               _saved_exception_pc;     // Saved pc of instruction where last implicit exception happened

   712 

   713   // JavaThread termination support

   714   enum TerminatedTypes {

   715     _not_terminated = 0xDEAD - 2,

   716     _thread_exiting,                             // JavaThread::exit() has been called for this thread

   717     _thread_terminated,                          // JavaThread is removed from thread list

   718     _vm_exited                                   // JavaThread is still executing native code, but VM is terminated

   719                                                  // only VM_Exit can set _vm_exited

   720   };

   721 

   722   // In general a JavaThread's _terminated field transitions as follows:

   723   //

   724   //   _not_terminated => _thread_exiting => _thread_terminated

   725   //

   726   // _vm_exited is a special value to cover the case of a JavaThread

   727   // executing native code after the VM itself is terminated.

   728   TerminatedTypes       _terminated;

   729   // suspend/resume support

   730   volatile bool         _suspend_equivalent;     // Suspend equivalent condition

   731   jint                  _in_deopt_handler;       // count of deoptimization

   732                                                  // handlers thread is in

   733   volatile bool         _doing_unsafe_access;    // Thread may fault due to unsafe access

   734   bool                  _do_not_unlock_if_synchronized; // Do not unlock the receiver of a synchronized method (since it was

   735                                                  // never locked) when throwing an exception. Used by interpreter only.

   736 

   737   //  Flag to mark a JNI thread in the process of attaching - See CR 6404306

   738   //  This flag is never set true other than at construction, and in that case

   739   //  is shortly thereafter set false

   740   volatile bool _is_attaching;

   741 

   742  public:

   743   // State of the stack guard pages for this thread.

   744   enum StackGuardState {

   745     stack_guard_unused,         // not needed

   746     stack_guard_yellow_disabled,// disabled (temporarily) after stack overflow

   747     stack_guard_enabled         // enabled

   748   };

   749 

   750  private:

   751 

   752   StackGuardState        _stack_guard_state;

   753 

   754   // Compiler exception handling (NOTE: The _exception_oop is *NOT* the same as _pending_exception. It is

   755   // used to temp. parsing values into and out of the runtime system during exception handling for compiled

   756   // code)

   757   volatile oop     _exception_oop;               // Exception thrown in compiled code

   758   volatile address _exception_pc;                // PC where exception happened

   759   volatile address _exception_handler_pc;        // PC for handler of exception

   760   volatile int     _exception_stack_size;        // Size of frame where exception happened

   761 

   762   // support for compilation

   763   bool    _is_compiling;                         // is true if a compilation is active inthis thread (one compilation per thread possible)

   764 

   765   // support for JNI critical regions

   766   jint    _jni_active_critical;                  // count of entries into JNI critical region

   767 

   768   // For deadlock detection.

   769   int _depth_first_number;

   770 

   771   // JVMTI PopFrame support

   772   // This is set to popframe_pending to signal that top Java frame should be popped immediately

   773   int _popframe_condition;

   774 

   775 #ifndef PRODUCT

   776   int _jmp_ring_index;

   777   struct {

   778       // We use intptr_t instead of address so debugger doesn't try and display strings

   779       intptr_t _target;

   780       intptr_t _instruction;

   781       const char*  _file;

   782       int _line;

   783   }   _jmp_ring[ jump_ring_buffer_size ];

   784 #endif /* PRODUCT */

   785 

   786   friend class VMThread;

   787   friend class ThreadWaitTransition;

   788   friend class VM_Exit;

   789 

   790   void initialize();                             // Initialized the instance variables

   791 

   792  public:

   793   // Constructor

   794   JavaThread(bool is_attaching = false); // for main thread and JNI attached threads

   795   JavaThread(ThreadFunction entry_point, size_t stack_size = 0);

   796   ~JavaThread();

   797 

   798 #ifdef ASSERT

   799   // verify this JavaThread hasn't be published in the Threads::list yet

   800   void verify_not_published();

   801 #endif

   802 

   803   //JNI functiontable getter/setter for JVMTI jni function table interception API.

   804   void set_jni_functions(struct JNINativeInterface_* functionTable) {

   805     _jni_environment.functions = functionTable;

   806   }

   807   struct JNINativeInterface_* get_jni_functions() {

   808     return (struct JNINativeInterface_ *)_jni_environment.functions;

   809   }

   810 

   811   // Executes Shutdown.shutdown()

   812   void invoke_shutdown_hooks();

   813 

   814   // Cleanup on thread exit

   815   enum ExitType {

   816     normal_exit,

   817     jni_detach

   818   };

   819   void exit(bool destroy_vm, ExitType exit_type = normal_exit);

   820 

   821   void cleanup_failed_attach_current_thread();

   822 

   823   // Testers

   824   virtual bool is_Java_thread() const            { return true;  }

   825 

   826   // compilation

   827   void set_is_compiling(bool f)                  { _is_compiling = f; }

   828   bool is_compiling() const                      { return _is_compiling; }

   829 

   830   // Thread chain operations

   831   JavaThread* next() const                       { return _next; }

   832   void set_next(JavaThread* p)                   { _next = p; }

   833 

   834   // Thread oop. threadObj() can be NULL for initial JavaThread

   835   // (or for threads attached via JNI)

   836   oop threadObj() const                          { return _threadObj; }

   837   void set_threadObj(oop p)                      { _threadObj = p; }

   838 

   839   ThreadPriority java_priority() const;          // Read from threadObj()

   840 

   841   // Prepare thread and add to priority queue.  If a priority is

   842   // not specified, use the priority of the thread object. Threads_lock

   843   // must be held while this function is called.

   844   void prepare(jobject jni_thread, ThreadPriority prio=NoPriority);

   845 

   846   void set_saved_exception_pc(address pc)        { _saved_exception_pc = pc; }

   847   address saved_exception_pc()                   { return _saved_exception_pc; }

   848 

   849 

   850   ThreadFunction entry_point() const             { return _entry_point; }

   851 

   852   // Allocates a new Java level thread object for this thread. thread_name may be NULL.

   853   void allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS);

   854 

   855   // Last frame anchor routines

   856 

   857   JavaFrameAnchor* frame_anchor(void)                { return &_anchor; }

   858 

   859   // last_Java_sp

   860   bool has_last_Java_frame() const                   { return _anchor.has_last_Java_frame(); }

   861   intptr_t* last_Java_sp() const                     { return _anchor.last_Java_sp(); }

   862 

   863   // last_Java_pc

   864 

   865   address last_Java_pc(void)                         { return _anchor.last_Java_pc(); }

   866 

   867   // Safepoint support

   868   JavaThreadState thread_state() const           { return _thread_state; }

   869   void set_thread_state(JavaThreadState s)       { _thread_state=s;      }

   870   ThreadSafepointState *safepoint_state() const  { return _safepoint_state;  }

   871   void set_safepoint_state(ThreadSafepointState *state) { _safepoint_state = state; }

   872   bool is_at_poll_safepoint()                    { return _safepoint_state->is_at_poll_safepoint(); }

   873 

   874   // thread has called JavaThread::exit() or is terminated

   875   bool is_exiting()                              { return _terminated == _thread_exiting || is_terminated(); }

   876   // thread is terminated (no longer on the threads list); we compare

   877   // against the two non-terminated values so that a freed JavaThread

   878   // will also be considered terminated.

   879   bool is_terminated()                           { return _terminated != _not_terminated && _terminated != _thread_exiting; }

   880   void set_terminated(TerminatedTypes t)         { _terminated = t; }

   881   // special for Threads::remove() which is static:

   882   void set_terminated_value()                    { _terminated = _thread_terminated; }

   883   void block_if_vm_exited();

   884 

   885   bool doing_unsafe_access()                     { return _doing_unsafe_access; }

   886   void set_doing_unsafe_access(bool val)         { _doing_unsafe_access = val; }

   887 

   888   bool do_not_unlock_if_synchronized()             { return _do_not_unlock_if_synchronized; }

   889   void set_do_not_unlock_if_synchronized(bool val) { _do_not_unlock_if_synchronized = val; }

   890 

   891 

   892   // Suspend/resume support for JavaThread

   893 

   894  private:

   895   void set_ext_suspended()       { set_suspend_flag (_ext_suspended);  }

   896   void clear_ext_suspended()     { clear_suspend_flag(_ext_suspended); }

   897 

   898  public:

   899   void java_suspend();

   900   void java_resume();

   901   int  java_suspend_self();

   902 

   903   void check_and_wait_while_suspended() {

   904     assert(JavaThread::current() == this, "sanity check");

   905 

   906     bool do_self_suspend;

   907     do {

   908       // were we externally suspended while we were waiting?

   909       do_self_suspend = handle_special_suspend_equivalent_condition();

   910       if (do_self_suspend) {

   911         // don't surprise the thread that suspended us by returning

   912         java_suspend_self();

   913         set_suspend_equivalent();

   914       }

   915     } while (do_self_suspend);

   916   }

   917   static void check_safepoint_and_suspend_for_native_trans(JavaThread *thread);

   918   // Check for async exception in addition to safepoint and suspend request.

   919   static void check_special_condition_for_native_trans(JavaThread *thread);

   920 

   921   bool is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits);

   922   bool is_ext_suspend_completed_with_lock(uint32_t *bits) {

   923     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);

   924     // Warning: is_ext_suspend_completed() may temporarily drop the

   925     // SR_lock to allow the thread to reach a stable thread state if

   926     // it is currently in a transient thread state.

   927     return is_ext_suspend_completed(false /*!called_by_wait */,

   928                                     SuspendRetryDelay, bits);

   929   }

   930 

   931   // We cannot allow wait_for_ext_suspend_completion() to run forever or

   932   // we could hang. SuspendRetryCount and SuspendRetryDelay are normally

   933   // passed as the count and delay parameters. Experiments with specific

   934   // calls to wait_for_ext_suspend_completion() can be done by passing

   935   // other values in the code. Experiments with all calls can be done

   936   // via the appropriate -XX options.

   937   bool wait_for_ext_suspend_completion(int count, int delay, uint32_t *bits);

   938 

   939   void set_external_suspend()     { set_suspend_flag  (_external_suspend); }

   940   void clear_external_suspend()   { clear_suspend_flag(_external_suspend); }

   941 

   942   void set_deopt_suspend()        { set_suspend_flag  (_deopt_suspend); }

   943   void clear_deopt_suspend()      { clear_suspend_flag(_deopt_suspend); }

   944   bool is_deopt_suspend()         { return (_suspend_flags & _deopt_suspend) != 0; }

   945 

   946   bool is_external_suspend() const {

   947     return (_suspend_flags & _external_suspend) != 0;

   948   }

   949   // Whenever a thread transitions from native to vm/java it must suspend

   950   // if external|deopt suspend is present.

   951   bool is_suspend_after_native() const {

   952     return (_suspend_flags & (_external_suspend | _deopt_suspend) ) != 0;

   953   }

   954 

   955   // external suspend request is completed

   956   bool is_ext_suspended() const {

   957     return (_suspend_flags & _ext_suspended) != 0;

   958   }

   959 

   960   // legacy method that checked for either external suspension or vm suspension

   961   bool is_any_suspended() const {

   962     return is_ext_suspended();

   963   }

   964 

   965   bool is_external_suspend_with_lock() const {

   966     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);

   967     return is_external_suspend();

   968   }

   969 

   970   // Special method to handle a pending external suspend request

   971   // when a suspend equivalent condition lifts.

   972   bool handle_special_suspend_equivalent_condition() {

   973     assert(is_suspend_equivalent(),

   974       "should only be called in a suspend equivalence condition");

   975     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);

   976     bool ret = is_external_suspend();

   977     if (!ret) {

   978       // not about to self-suspend so clear suspend equivalence

   979       clear_suspend_equivalent();

   980     }

   981     // implied else:

   982     // We have a pending external suspend request so we leave the

   983     // suspend_equivalent flag set until java_suspend_self() sets

   984     // the ext_suspended flag and clears the suspend_equivalent

   985     // flag. This insures that wait_for_ext_suspend_completion()

   986     // will return consistent values.

   987     return ret;

   988   }

   989 

   990   bool is_any_suspended_with_lock() const {

   991     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);

   992     return is_any_suspended();

   993   }

   994   // utility methods to see if we are doing some kind of suspension

   995   bool is_being_ext_suspended() const            {

   996     MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);

   997     return is_ext_suspended() || is_external_suspend();

   998   }

   999 

  1000   bool is_suspend_equivalent() const             { return _suspend_equivalent; }

  1001 

  1002   void set_suspend_equivalent()                  { _suspend_equivalent = true; };

  1003   void clear_suspend_equivalent()                { _suspend_equivalent = false; };

  1004 

  1005   // Thread.stop support

  1006   void send_thread_stop(oop throwable);

  1007   AsyncRequests clear_special_runtime_exit_condition() {

  1008     AsyncRequests x = _special_runtime_exit_condition;

  1009     _special_runtime_exit_condition = _no_async_condition;

  1010     return x;

  1011   }

  1012 

  1013   // Are any async conditions present?

  1014   bool has_async_condition() { return (_special_runtime_exit_condition != _no_async_condition); }

  1015 

  1016   void check_and_handle_async_exceptions(bool check_unsafe_error = true);

  1017 

  1018   // these next two are also used for self-suspension and async exception support

  1019   void handle_special_runtime_exit_condition(bool check_asyncs = true);

  1020 

  1021   // Return true if JavaThread has an asynchronous condition or

  1022   // if external suspension is requested.

  1023   bool has_special_runtime_exit_condition() {

  1024     // We call is_external_suspend() last since external suspend should

  1025     // be less common. Because we don't use is_external_suspend_with_lock

  1026     // it is possible that we won't see an asynchronous external suspend

  1027     // request that has just gotten started, i.e., SR_lock grabbed but

  1028     // _external_suspend field change either not made yet or not visible

  1029     // yet. However, this is okay because the request is asynchronous and

  1030     // we will see the new flag value the next time through. It's also

  1031     // possible that the external suspend request is dropped after

  1032     // we have checked is_external_suspend(), we will recheck its value

  1033     // under SR_lock in java_suspend_self().

  1034     return (_special_runtime_exit_condition != _no_async_condition) ||

  1035             is_external_suspend() || is_deopt_suspend();

  1036   }

  1037 

  1038   void set_pending_unsafe_access_error()          { _special_runtime_exit_condition = _async_unsafe_access_error; }

  1039 

  1040   void set_pending_async_exception(oop e) {

  1041     _pending_async_exception = e;

  1042     _special_runtime_exit_condition = _async_exception;

  1043     set_has_async_exception();

  1044   }

  1045 

  1046   // Fast-locking support

  1047   bool is_lock_owned(address adr) const;

  1048 

  1049   // Accessors for vframe array top

  1050   // The linked list of vframe arrays are sorted on sp. This means when we

  1051   // unpack the head must contain the vframe array to unpack.

  1052   void set_vframe_array_head(vframeArray* value) { _vframe_array_head = value; }

  1053   vframeArray* vframe_array_head() const         { return _vframe_array_head;  }

  1054 

  1055   // Side structure for defering update of java frame locals until deopt occurs

  1056   GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred_locals() const { return _deferred_locals_updates; }

  1057   void set_deferred_locals(GrowableArray<jvmtiDeferredLocalVariableSet *>* vf) { _deferred_locals_updates = vf; }

  1058 

  1059   // These only really exist to make debugging deopt problems simpler

  1060 

  1061   void set_vframe_array_last(vframeArray* value) { _vframe_array_last = value; }

  1062   vframeArray* vframe_array_last() const         { return _vframe_array_last;  }

  1063 

  1064   // The special resourceMark used during deoptimization

  1065 

  1066   void set_deopt_mark(DeoptResourceMark* value)  { _deopt_mark = value; }

  1067   DeoptResourceMark* deopt_mark(void)            { return _deopt_mark; }

  1068 

  1069   intptr_t* must_deopt_id()                      { return _must_deopt_id; }

  1070   void     set_must_deopt_id(intptr_t* id)       { _must_deopt_id = id; }

  1071   void     clear_must_deopt_id()                 { _must_deopt_id = NULL; }

  1072 

  1073   methodOop  callee_target() const               { return _callee_target; }

  1074   void set_callee_target  (methodOop x)          { _callee_target   = x; }

  1075 

  1076   // Oop results of vm runtime calls

  1077   oop  vm_result() const                         { return _vm_result; }

  1078   void set_vm_result  (oop x)                    { _vm_result   = x; }

  1079 

  1080   oop  vm_result_2() const                       { return _vm_result_2; }

  1081   void set_vm_result_2  (oop x)                  { _vm_result_2   = x; }

  1082 

  1083   // Exception handling for compiled methods

  1084   oop      exception_oop() const                 { return _exception_oop; }

  1085   int      exception_stack_size() const          { return _exception_stack_size; }

  1086   address  exception_pc() const                  { return _exception_pc; }

  1087   address  exception_handler_pc() const          { return _exception_handler_pc; }

  1088 

  1089   void set_exception_oop(oop o)                  { _exception_oop = o; }

  1090   void set_exception_pc(address a)               { _exception_pc = a; }

  1091   void set_exception_handler_pc(address a)       { _exception_handler_pc = a; }

  1092   void set_exception_stack_size(int size)        { _exception_stack_size = size; }

  1093 

  1094   // Stack overflow support

  1095   inline size_t stack_available(address cur_sp);

  1096   address stack_yellow_zone_base()

  1097     { return (address)(stack_base() - (stack_size() - (stack_red_zone_size() + stack_yellow_zone_size()))); }

  1098   size_t  stack_yellow_zone_size()

  1099     { return StackYellowPages * os::vm_page_size(); }

  1100   address stack_red_zone_base()

  1101     { return (address)(stack_base() - (stack_size() - stack_red_zone_size())); }

  1102   size_t stack_red_zone_size()

  1103     { return StackRedPages * os::vm_page_size(); }

  1104   bool in_stack_yellow_zone(address a)

  1105     { return (a <= stack_yellow_zone_base()) && (a >= stack_red_zone_base()); }

  1106   bool in_stack_red_zone(address a)

  1107     { return (a <= stack_red_zone_base()) && (a >= (address)((intptr_t)stack_base() - stack_size())); }

  1108 

  1109   void create_stack_guard_pages();

  1110   void remove_stack_guard_pages();

  1111 

  1112   void enable_stack_yellow_zone();

  1113   void disable_stack_yellow_zone();

  1114   void enable_stack_red_zone();

  1115   void disable_stack_red_zone();

  1116 

  1117   inline bool stack_yellow_zone_disabled();

  1118   inline bool stack_yellow_zone_enabled();

  1119 

  1120   // Attempt to reguard the stack after a stack overflow may have occurred.

  1121   // Returns true if (a) guard pages are not needed on this thread, (b) the

  1122   // pages are already guarded, or (c) the pages were successfully reguarded.

  1123   // Returns false if there is not enough stack space to reguard the pages, in

  1124   // which case the caller should unwind a frame and try again.  The argument

  1125   // should be the caller's (approximate) sp.

  1126   bool reguard_stack(address cur_sp);

  1127   // Similar to above but see if current stackpoint is out of the guard area

  1128   // and reguard if possible.

  1129   bool reguard_stack(void);

  1130 

  1131   // Misc. accessors/mutators

  1132   void set_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = true; }

  1133   void clr_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = false; }

  1134   bool do_not_unlock(void)                       { return _do_not_unlock_if_synchronized; }

  1135