vm/prims/jvm.cpp

16  * 2 along with this work; if not, write to the Free Software Foundation,
100           // Object address to be held directly in mirror & not visible to GC
106           // Boom! mirror may point to JUNK instead of the intended object
117   The solution is to keep the oop declaration BELOW the ctor or function
118   call that might cause a GC, do another resolve to reassign the oop, or
195       const char * to = to_class->external_name();
196       // print in a single call to reduce interleaving between threads
198         log_debug(class, resolve)("%s %s %s:%d (%s)", from, to, source_file, line_number, trace);
200         log_debug(class, resolve)("%s %s (%s)", from, to, trace);
214 // Wrapper to trace JVM functions
234           warning("JVMHistogram_lock seems to be stalled");
248       if (e != NULL) e->increment_count();  // Due to bug in VC++, we need a NULL check here eventhough it should never happen!
278 // java.lang.System, but we choose to keep it here so that it stays next
279 // to JVM_CurrentTimeMillis and JVM_NanoTime
291   // We're going to verify that the result can fit in a long.
293   // and 'offset_secs' to be such that:
295   // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3)
302   // exception value indicating that the offset given to us is
303   // too far from range of the current time - leading to too big
304   // a nano adjustment. The caller is expected to recover by
369   // to the sun.nio.MaxDirectMemorySize property.
370   // Do this after setting user properties to prevent people
598     // been added to the wait queue so the current thread cannot be
639   // All arrays are considered to be cloneable (See JLS 20.1.5)
703   // temporarily for existing code to use until a replacement API is defined.
764 // FindClassFromBootLoader is exported to the launcher for windows.
771     // It's impossible to create this class;  the name cannot fit
795     // It's impossible to create this class;  the name cannot fit
809   // manager to avoid the performance cost of getting the calling class.
833     // It's impossible to create this class;  the name cannot fit
867     const char * to = to_class->external_name();
868     log_debug(class, resolve)("%s %s (verification)", from_name, to);
909   // if name is NULL no check for class name in .class stream has to be made.
914       // It's impossible to create this class;  the name cannot fit
975     // It's impossible to create this class;  the name cannot fit
983   //   us to pass the NULL as the initiating class loader.
997     // If the class is not already loaded, try to see if it's in the shared
1179     // this context to revert to older behavior.
1306     // JVMTI internal flag reset is needed in order to report PrivilegedActionException
1359   // Use vframeStream to iterate through Java frames
1372     // check the privileged frames to see if we have a match
1447   // ofClass is a reference to a java_lang_Class object. The mirror object
1479       // Check to see if the name matches the class we're looking for
1480       // before attempting to find the class.
1513   // ofClass is a reference to a java_lang_Class object.
1634   return m;  // caller has to deal with NULL in product mode
1661   // method is a handle to a java.lang.reflect.Method object
1698   // method is a handle to a java.lang.reflect.Method object
1706     // parameter data.  Return null to indicate this to the reflection
1711     // Otherwise, we return something up to reflection, even if it is
1984     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2036     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
2229   // If returned tag values are not from the JVM spec, e.g. tags from 100 to 105,
2230   // they are changed to the corresponding tags from the JVM spec, so that java code in
2280 // RedefineClasses support: bug 6214132 caused verification to fail.
2286 // Please, refer to the description in the jvmtiThreadSate.hpp.
2301   // (length is determined by call to JVM_GetClassCPEntriesCount)
2337 // array klasses, so a direct cast to InstanceKlass is safe.
2486  * All of these JVM_GetCP-xxx methods are used by the old verifier to
2490  * that nothing it calls tries to use the cpCache instead of the raw
2669   // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2745   // Try to make this function as atomic as possible.
2749     // Make an unused local variable to avoid warning from gcc 4.x compiler.
2758 // In most of the JVM Thread support functions we need to be sure to lock the Threads_lock
2759 // to prevent the target thread from exiting after we have a pointer to the C++ Thread or
2760 // OSThread objects.  The exception to this rule is when the target object is the thread
2763 // rather silly to do operations on yourself, like resuming yourself or asking whether
2764 // you are alive.  While these can still happen, they are not subject to deadlocks if
2766 // instance), and are very unlikely.  Because IsAlive needs to be fast and its
2767 // implementation is local to this file, we always lock Threads_lock for that one.
2787   // due to rank ordering issues. Example:  we might need to grab the
2798     // Since JDK 5 the java.lang.Thread threadStatus is used to prevent
2802     // (with its JavaThread set) and the update to its threadStatus, so we
2803     // have to check for this
2807       // We could also check the stillborn flag to see if this thread was already stopped, but
2822       // JavaThread due to lack of memory. Check for this situation and throw
2823       // an exception if necessary. Eventually we may want to change this so
2841     // No one should hold a reference to the 'native_thread'.
2856 // JVM_Stop is implemented using a VM_Operation, so threads are forced to safepoints
2858 // but is thought to be reliable and simple. In the case, where the receiver is the
2879       // Enques a VM_Operation to stop all threads and then deliver the exception...
2887     // We could read the threadStatus to determine which case it is
2929     // It would be nice to have the following assertion in all the
2930     // time, but it is possible for a racing resume request to have
2944   // We need to *always* get the threads lock here, since this operation cannot be allowed during
2945   // a safepoint. The safepoint code relies on suspending a thread to examine its state. If other
2990   // And set new thread state to SLEEPING.
3013         // to properly restore the thread state.  That's likely wrong.
3044     // We need to re-resolve the java_thread, since a GC might have happened during the
3052       // IllegalThreadStateException. We defer to throw that exception until
3053       // Threads_lock is released since loading exception class has to leave VM.
3054       // The correct way to test a thread is actually suspended is
3076 // Consider: A better way to implement JVM_Interrupt() is to acquire
3077 // Threads_lock to resolve the jthread into a Thread pointer, fetch
3080 // outside the critical section.  Threads_lock is hot so we want to minimize
3081 // the hold-time.  A cleaner interface would be to decompose interrupt into
3093   // We need to re-resolve the java_thread, since a GC might have happened during the
3108   // We need to re-resolve the java_thread, since a GC might have happened during the
3149     // we don't set the name of an attached thread to avoid stepping
3246   // Fill in mirrors corresponding to method holders
3431   value.i = 0; // to initialize value before getting used in CHECK
3448   value.i = 0; // to initialize value before getting used in CHECK
3504     // platform encoding scheme, we need to pass
3505     // Exceptions::unsafe_to_utf8 to the new_exception method
3552 // The lock routine below calls lock_without_safepoint_check in order to get a raw lock
3594   //   us to pass the NULL as the initiating class loader.  The VM is responsible for
3595   //   the checkPackageAccess relative to the initiating class loader via the
3786   // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat
3792 // Returns an array of java.lang.String objects containing the input arguments to the VM.