Lines Matching refs:to
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 = Klass::cast(to_class)->external_name();
196 // print in a single call to reduce interleaving between threads
198 tty->print("RESOLVE %s %s %s:%d (%s)\n", from, to, source_file, line_number, trace);
200 tty->print("RESOLVE %s %s (%s)\n", from, to, trace);
214 // Wrapper to trace JVM functions
247 warning("JVMHistogram_lock seems to be stalled");
261 if (e != NULL) e->increment_count(); // Due to bug in VC++, we need a NULL check here eventhough it should never happen!
346 // to the sun.nio.MaxDirectMemorySize property.
347 // Do this after setting user properties to prevent people
397 // The VM is about to exit. We call back into Java to check whether finalizers should be run
526 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");
538 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object");
546 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object");
569 // All arrays are considered to be cloneable (See JLS 20.1.5)
617 // JITs would need extensive changes to work with HotSpot. The JIT-related JVM
716 // unexpectedly at runtime, it is safest for the launcher to dlopen a
719 // signature to change from _JVM_FindClassFromClassLoader@20 to
724 // to the JDK, and is not intended to be a public API.
732 // It's impossible to create this class; the name cannot fit
756 // It's impossible to create this class; the name cannot fit
780 // It's impossible to create this class; the name cannot fit
809 const char * to = Klass::cast(to_class)->external_name();
810 tty->print("RESOLVE %s %s (verification)\n", from_name, to);
852 // if name is NULL no check for class name in .class stream has to be made.
857 // It's impossible to create this class; the name cannot fit
921 // It's impossible to create this class; the name cannot fit
929 // us to pass the NULL as the initiating class loader.
1122 // this context to revert to older behavior.
1287 // Use vframeStream to iterate through Java frames
1300 // check the privileged frames to see if we have a match
1383 // ofClass is a reference to a java_lang_Class object. The mirror object
1415 // Check to see if the name matches the class we're looking for
1416 // before attempting to find the class.
1449 // ofClass is a reference to a java_lang_Class object.
1489 // Check to see if the name matches the class we're looking for
1490 // before attempting to find the class.
1518 // the system could allow a spoof of an inner class to gain access rights.
1564 // field is a handle to a java.lang.reflect.Field object
1628 // method is a handle to a java.lang.reflect.Method object
1637 // method is a handle to a java.lang.reflect.Method object
1646 // method is a handle to a java.lang.reflect.Method object
1673 // 4496456 We need to filter out java.lang.Throwable.backtrace
1921 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
1973 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
2145 // RedefineClasses support: bug 6214132 caused verification to fail.
2151 // Please, refer to the description in the jvmtiThreadSate.hpp.
2166 // (length is determined by call to JVM_GetClassCPEntriesCount)
2209 // array klasses, so a direct cast to instanceKlass is safe.
2349 * All of these JVM_GetCP-xxx methods are used by the old verifier to
2353 * that nothing it calls tries to use the cpCache instead of the raw
2533 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2668 // Try to make this function as atomic as possible.
2672 // Make an unused local variable to avoid warning from gcc 4.x compiler.
2681 // In most of the JVM Thread support functions we need to be sure to lock the Threads_lock
2682 // to prevent the target thread from exiting after we have a pointer to the C++ Thread or
2683 // OSThread objects. The exception to this rule is when the target object is the thread
2686 // rather silly to do operations on yourself, like resuming yourself or asking whether
2687 // you are alive. While these can still happen, they are not subject to deadlocks if
2689 // instance), and are very unlikely. Because IsAlive needs to be fast and its
2690 // implementation is local to this file, we always lock Threads_lock for that one.
2710 // due to rank ordering issues. Example: we might need to grab the
2721 // Since JDK 5 the java.lang.Thread threadStatus is used to prevent
2725 // (with its JavaThread set) and the update to its threadStatus, so we
2726 // have to check for this
2730 // We could also check the stillborn flag to see if this thread was already stopped, but
2743 // JavaThread due to lack of memory. Check for this situation and throw
2744 // an exception if necessary. Eventually we may want to change this so
2762 // No one should hold a reference to the 'native_thread'.
2767 "unable to create new native thread");
2770 "unable to create new native thread");
2777 // JVM_Stop is implemented using a VM_Operation, so threads are forced to safepoints
2779 // but is thought to be reliable and simple. In the case, where the receiver is the
2800 // Enques a VM_Operation to stop all threads and then deliver the exception...
2808 // We could read the threadStatus to determine which case it is
2850 // It would be nice to have the following assertion in all the
2851 // time, but it is possible for a racing resume request to have
2865 // We need to *always* get the threads lock here, since this operation cannot be allowed during
2866 // a safepoint. The safepoint code relies on suspending a thread to examine its state. If other
2921 // And set new thread state to SLEEPING.
2936 // It appears that in certain GUI contexts, it may be beneficial to do a short sleep
2964 // to properly restore the thread state. That's likely wrong.
3000 // We need to re-resolve the java_thread, since a GC might have happened during the
3008 // IllegalThreadStateException. We defer to throw that exception until
3009 // Threads_lock is released since loading exception class has to leave VM.
3010 // The correct way to test a thread is actually suspended is
3032 // Consider: A better way to implement JVM_Interrupt() is to acquire
3033 // Threads_lock to resolve the jthread into a Thread pointer, fetch
3036 // outside the critical section. Threads_lock is hot so we want to minimize
3037 // the hold-time. A cleaner interface would be to decompose interrupt into
3049 // We need to re-resolve the java_thread, since a GC might have happened during the
3064 // We need to re-resolve the java_thread, since a GC might have happened during the
3105 // we don't set the name of an attached thread to avoid stepping
3186 // Collect linked list of (handles to) method holders
3209 // Fill in mirrors corresponding to method holders
3344 // Make sure klass is initialized, since we are about to instantiate one of them.
3360 // Only allow calls to a public no-arg constructor.
3361 // This path corresponds to creating an Externalizable object.
3366 // subclass 'curr_klass' does not have access to no-arg constructor of 'initcb'
3421 // Load a class relative to the most recent class on the stack with a non-null
3432 // Class name argument is not guaranteed to be in internal format
3439 // It's impossible to create this class; the name cannot fit
3512 value.i = 0; // to initialize value before getting used in CHECK
3529 value.i = 0; // to initialize value before getting used in CHECK
3670 JVM_LEAF(jint, JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen))
3673 return os::sendto(fd, buf, (size_t)len, (uint)flags, to, (socklen_t)tolen);
3722 // platform encoding scheme, we need to pass
3723 // Exceptions::unsafe_to_utf8 to the new_exception method
3778 // The lock routine below calls lock_without_safepoint_check in order to get a raw lock
4104 // us to pass the NULL as the initiating class loader.
4372 // to the Java thread state that the JDK supports.
4435 // to the Java thread state that the JDK supports.
4556 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat