0N/A

0N/A#include "precompiled.hpp"

0N/A#include "classfile/classLoader.hpp"

0N/A#include "classfile/javaAssertions.hpp"

0N/A#include "classfile/javaClasses.hpp"

0N/A#include "classfile/symbolTable.hpp"

0N/A#include "classfile/systemDictionary.hpp"

0N/A#include "classfile/vmSymbols.hpp"

0N/A#include "gc_interface/collectedHeap.inline.hpp"

0N/A#include "memory/oopFactory.hpp"

0N/A#include "memory/universe.inline.hpp"

0N/A#include "oops/fieldStreams.hpp"

0N/A#include "oops/instanceKlass.hpp"

0N/A#include "oops/objArrayKlass.hpp"

0N/A#include "oops/methodOop.hpp"

0N/A#include "prims/jvm.h"

0N/A#include "prims/jvm_misc.hpp"

0N/A#include "prims/jvmtiExport.hpp"

0N/A#include "prims/jvmtiThreadState.hpp"

0N/A#include "prims/nativeLookup.hpp"

0N/A#include "prims/privilegedStack.hpp"

0N/A#include "runtime/arguments.hpp"

0N/A#include "runtime/dtraceJSDT.hpp"

0N/A#include "runtime/handles.inline.hpp"

0N/A#include "runtime/init.hpp"

0N/A#include "runtime/interfaceSupport.hpp"

0N/A#include "runtime/java.hpp"

0N/A#include "runtime/javaCalls.hpp"

0N/A#include "runtime/jfieldIDWorkaround.hpp"

0N/A#include "runtime/os.hpp"

0N/A#include "runtime/perfData.hpp"

0N/A#include "runtime/reflection.hpp"

0N/A#include "runtime/vframe.hpp"

0N/A#include "runtime/vm_operations.hpp"

4063N/A#include "services/attachListener.hpp"

0N/A#include "services/management.hpp"

4063N/A#include "services/threadService.hpp"

0N/A#include "utilities/copy.hpp"

0N/A#include "utilities/defaultStream.hpp"

0N/A#include "utilities/dtrace.hpp"

0N/A#include "utilities/events.hpp"

0N/A#include "utilities/histogram.hpp"

4063N/A#include "utilities/top.hpp"

0N/A#include "utilities/utf8.hpp"

0N/A#ifdef TARGET_OS_FAMILY_linux

0N/A# include "jvm_linux.h"

0N/A#endif

0N/A#ifdef TARGET_OS_FAMILY_solaris

0N/A# include "jvm_solaris.h"

0N/A#endif

0N/A#ifdef TARGET_OS_FAMILY_windows

0N/A# include "jvm_windows.h"

0N/A#endif

0N/A#ifdef TARGET_OS_FAMILY_bsd

0N/A# include "jvm_bsd.h"

0N/A#endif

0N/A

0N/A#include <errno.h>

0N/A

0N/A#ifndef USDT2

0N/AHS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__begin, long long);

0N/AHS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__end, int);

0N/AHS_DTRACE_PROBE_DECL0(hotspot, thread__yield);

0N/A#endif /* !USDT2 */

0N/A

0N/A

0N/Astatic void trace_class_resolution_impl(klassOop to_class, TRAPS) {

0N/A ResourceMark rm;

0N/A int line_number = -1;

0N/A const char * source_file = NULL;

0N/A const char * trace = "explicit";

0N/A klassOop caller = NULL;

0N/A JavaThread* jthread = JavaThread::current();

0N/A if (jthread->has_last_Java_frame()) {

0N/A vframeStream vfst(jthread);

0N/A

0N/A // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames

0N/A TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);

0N/A klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);

0N/A TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);

0N/A klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);

0N/A

0N/A methodOop last_caller = NULL;

0N/A

0N/A while (!vfst.at_end()) {

0N/A methodOop m = vfst.method();

0N/A if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&

0N/A !vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) &&

0N/A !vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) {

0N/A break;

0N/A }

0N/A last_caller = m;

0N/A vfst.next();

0N/A }

0N/A // if this is called from Class.forName0 and that is called from Class.forName,

0N/A // then print the caller of Class.forName. If this is Class.loadClass, then print

0N/A // that caller, otherwise keep quiet since this should be picked up elsewhere.

0N/A bool found_it = false;

0N/A if (!vfst.at_end() &&

0N/A instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

0N/A vfst.method()->name() == vmSymbols::forName0_name()) {

0N/A vfst.next();

0N/A if (!vfst.at_end() &&

0N/A instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

0N/A vfst.method()->name() == vmSymbols::forName_name()) {

0N/A vfst.next();

0N/A found_it = true;

}

} else if (last_caller != NULL &&

instanceKlass::cast(last_caller->method_holder())->name() ==

vmSymbols::java_lang_ClassLoader() &&

(last_caller->name() == vmSymbols::loadClassInternal_name() ||

last_caller->name() == vmSymbols::loadClass_name())) {

found_it = true;

} else if (!vfst.at_end()) {

if (vfst.method()->is_native()) {

// JNI call

found_it = true;

}

}

if (found_it && !vfst.at_end()) {

// found the caller

caller = vfst.method()->method_holder();

line_number = vfst.method()->line_number_from_bci(vfst.bci());

if (line_number == -1) {

// show method name if it's a native method

trace = vfst.method()->name_and_sig_as_C_string();

}

Symbol* s = instanceKlass::cast(caller)->source_file_name();

if (s != NULL) {

source_file = s->as_C_string();

}

}

}

if (caller != NULL) {

if (to_class != caller) {

const char * from = Klass::cast(caller)->external_name();

const char * to = Klass::cast(to_class)->external_name();

// print in a single call to reduce interleaving between threads

if (source_file != NULL) {

tty->print("RESOLVE %s %s %s:%d (%s)\n", from, to, source_file, line_number, trace);

} else {

tty->print("RESOLVE %s %s (%s)\n", from, to, trace);

}

}

}

}

void trace_class_resolution(klassOop to_class) {

EXCEPTION_MARK;

trace_class_resolution_impl(to_class, THREAD);

if (HAS_PENDING_EXCEPTION) {

CLEAR_PENDING_EXCEPTION;

}

}

#ifdef ASSERT

class JVMTraceWrapper : public StackObj {

public:

JVMTraceWrapper(const char* format, ...) {

if (TraceJVMCalls) {

va_list ap;

va_start(ap, format);

tty->print("JVM ");

tty->vprint_cr(format, ap);

va_end(ap);

}

}

};

Histogram* JVMHistogram;

volatile jint JVMHistogram_lock = 0;

class JVMHistogramElement : public HistogramElement {

public:

JVMHistogramElement(const char* name);

};

JVMHistogramElement::JVMHistogramElement(const char* elementName) {

_name = elementName;

uintx count = 0;

while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) {

while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) {

count +=1;

if ( (WarnOnStalledSpinLock > 0)

&& (count % WarnOnStalledSpinLock == 0)) {

warning("JVMHistogram_lock seems to be stalled");

}

}

}

if(JVMHistogram == NULL)

JVMHistogram = new Histogram("JVM Call Counts",100);

JVMHistogram->add_element(this);

Atomic::dec(&JVMHistogram_lock);

}

#define JVMCountWrapper(arg) \

static JVMHistogramElement* e = new JVMHistogramElement(arg); \

if (e != NULL) e->increment_count(); // Due to bug in VC++, we need a NULL check here eventhough it should never happen!

#define JVMWrapper(arg1) JVMCountWrapper(arg1); JVMTraceWrapper(arg1)

#define JVMWrapper2(arg1, arg2) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2)

#define JVMWrapper3(arg1, arg2, arg3) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3)

#define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4)

#else

#define JVMWrapper(arg1)

#define JVMWrapper2(arg1, arg2)

#define JVMWrapper3(arg1, arg2, arg3)

#define JVMWrapper4(arg1, arg2, arg3, arg4)

#endif

JVM_LEAF(jint, JVM_GetInterfaceVersion())

return JVM_INTERFACE_VERSION;

JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))

JVMWrapper("JVM_CurrentTimeMillis");

return os::javaTimeMillis();

JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))

JVMWrapper("JVM_NanoTime");

return os::javaTimeNanos();

JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

jobject dst, jint dst_pos, jint length))

JVMWrapper("JVM_ArrayCopy");

// Check if we have null pointers

if (src == NULL || dst == NULL) {

THROW(vmSymbols::java_lang_NullPointerException());

}

arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));

arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));

assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");

assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");

// Do copy

Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread);

static void set_property(Handle props, const char* key, const char* value, TRAPS) {

JavaValue r(T_OBJECT);

// public synchronized Object put(Object key, Object value);

HandleMark hm(THREAD);

Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK);

Handle value_str = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);

JavaCalls::call_virtual(&r,

props,

KlassHandle(THREAD, SystemDictionary::Properties_klass()),

vmSymbols::put_name(),

vmSymbols::object_object_object_signature(),

key_str,

value_str,

THREAD);

}

#define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));

JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties))

JVMWrapper("JVM_InitProperties");

ResourceMark rm;

Handle props(THREAD, JNIHandles::resolve_non_null(properties));

// System property list includes both user set via -D option and

// jvm system specific properties.

for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) {

PUTPROP(props, p->key(), p->value());

}

// Convert the -XX:MaxDirectMemorySize= command line flag

// to the sun.nio.MaxDirectMemorySize property.

// Do this after setting user properties to prevent people

// from setting the value with a -D option, as requested.

{

if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) {

PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1");

} else {

char as_chars[256];

jio_snprintf(as_chars, sizeof(as_chars), UINTX_FORMAT, MaxDirectMemorySize);

PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars);

}

}

// JVM monitoring and management support

// Add the sun.management.compiler property for the compiler's name

{

#undef CSIZE

#if defined(_LP64) || defined(_WIN64)

#define CSIZE "64-Bit "

#else

#define CSIZE

#endif // 64bit

#ifdef TIERED

const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";

#else

#if defined(COMPILER1)

const char* compiler_name = "HotSpot " CSIZE "Client Compiler";

#elif defined(COMPILER2)

const char* compiler_name = "HotSpot " CSIZE "Server Compiler";

#else

const char* compiler_name = "";

#endif // compilers

#endif // TIERED

if (*compiler_name != '\0' &&

(Arguments::mode() != Arguments::_int)) {

PUTPROP(props, "sun.management.compiler", compiler_name);

}

}

return properties;

extern volatile jint vm_created;

JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))

if (vm_created != 0 && (code == 0)) {

// The VM is about to exit. We call back into Java to check whether finalizers should be run

Universe::run_finalizers_on_exit();

}

before_exit(thread);

vm_exit(code);

JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

before_exit(thread);

vm_exit(code);

JVM_LEAF(void, JVM_OnExit(void (*func)(void)))

register_on_exit_function(func);

JVM_ENTRY_NO_ENV(void, JVM_GC(void))

JVMWrapper("JVM_GC");

if (!DisableExplicitGC) {

Universe::heap()->collect(GCCause::_java_lang_system_gc);

}

JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

JVMWrapper("JVM_MaxObjectInspectionAge");

return Universe::heap()->millis_since_last_gc();

JVM_LEAF(void, JVM_TraceInstructions(jboolean on))

if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");

JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))

if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");

static inline jlong convert_size_t_to_jlong(size_t val) {

// In the 64-bit vm, a size_t can overflow a jlong (which is signed).

NOT_LP64 (return (jlong)val;)

LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)

}

JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

JVMWrapper("JVM_TotalMemory");

size_t n = Universe::heap()->capacity();

return convert_size_t_to_jlong(n);

JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

JVMWrapper("JVM_FreeMemory");

CollectedHeap* ch = Universe::heap();

size_t n;

{

MutexLocker x(Heap_lock);

n = ch->capacity() - ch->used();

}

return convert_size_t_to_jlong(n);

JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

JVMWrapper("JVM_MaxMemory");

size_t n = Universe::heap()->max_capacity();

return convert_size_t_to_jlong(n);

JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

JVMWrapper("JVM_ActiveProcessorCount");

return os::active_processor_count();

JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))

JVMWrapper("JVM_FillInStackTrace");

Handle exception(thread, JNIHandles::resolve_non_null(receiver));

java_lang_Throwable::fill_in_stack_trace(exception);

JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable))

JVMWrapper("JVM_PrintStackTrace");

// Note: This is no longer used in Merlin, but we still support it for compatibility.

oop exception = JNIHandles::resolve_non_null(receiver);

oop stream = JNIHandles::resolve_non_null(printable);

java_lang_Throwable::print_stack_trace(exception, stream);

JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable))

JVMWrapper("JVM_GetStackTraceDepth");

oop exception = JNIHandles::resolve(throwable);

return java_lang_Throwable::get_stack_trace_depth(exception, THREAD);

JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index))

JVMWrapper("JVM_GetStackTraceElement");

JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC

oop exception = JNIHandles::resolve(throwable);

oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL);

return JNIHandles::make_local(env, element);

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))

JVMWrapper("JVM_IHashCode");

// as implemented in the classic virtual machine; return 0 if object is NULL

return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;

JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))

JVMWrapper("JVM_MonitorWait");

Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");

JavaThreadInObjectWaitState jtiows(thread, ms != 0);

if (JvmtiExport::should_post_monitor_wait()) {

JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);

}

ObjectSynchronizer::wait(obj, ms, CHECK);

JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

JVMWrapper("JVM_MonitorNotify");

Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object");

ObjectSynchronizer::notify(obj, CHECK);

JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))

JVMWrapper("JVM_MonitorNotifyAll");

Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object");

ObjectSynchronizer::notifyall(obj, CHECK);

JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))

JVMWrapper("JVM_Clone");

Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

const KlassHandle klass (THREAD, obj->klass());

JvmtiVMObjectAllocEventCollector oam;

#ifdef ASSERT

// Just checking that the cloneable flag is set correct

if (obj->is_javaArray()) {

guarantee(klass->is_cloneable(), "all arrays are cloneable");

} else {

guarantee(obj->is_instance(), "should be instanceOop");

bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());

guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");

}

#endif

// Check if class of obj supports the Cloneable interface.

// All arrays are considered to be cloneable (See JLS 20.1.5)

if (!klass->is_cloneable()) {

ResourceMark rm(THREAD);

THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());

}

// Make shallow object copy

const int size = obj->size();

oop new_obj = NULL;

if (obj->is_javaArray()) {

const int length = ((arrayOop)obj())->length();

new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);

} else {

new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);

}

// 4839641 (4840070): We must do an oop-atomic copy, because if another thread

// is modifying a reference field in the clonee, a non-oop-atomic copy might

// be suspended in the middle of copying the pointer and end up with parts

// of two different pointers in the field. Subsequent dereferences will crash.

// 4846409: an oop-copy of objects with long or double fields or arrays of same

// won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead

// of oops. We know objects are aligned on a minimum of an jlong boundary.

// The same is true of StubRoutines::object_copy and the various oop_copy

// variants, and of the code generated by the inline_native_clone intrinsic.

assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");

Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,

(size_t)align_object_size(size) / HeapWordsPerLong);

// Clear the header

new_obj->init_mark();

// Store check (mark entire object and let gc sort it out)

BarrierSet* bs = Universe::heap()->barrier_set();

assert(bs->has_write_region_opt(), "Barrier set does not have write_region");

bs->write_region(MemRegion((HeapWord*)new_obj, size));

// Caution: this involves a java upcall, so the clone should be

// "gc-robust" by this stage.

if (klass->has_finalizer()) {

assert(obj->is_instance(), "should be instanceOop");

new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);

}

return JNIHandles::make_local(env, oop(new_obj));

JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls))

if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported");

JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls))

if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported");

return JNI_FALSE;

JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls))

if (PrintJVMWarnings) warning("JVM_CompileClass not supported");

return JNI_FALSE;

JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname))

if (PrintJVMWarnings) warning("JVM_CompileClasses not supported");

return JNI_FALSE;

JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg))

if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported");

return NULL;

JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls))

if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported");

JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls))

if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported");

JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len))

JVMWrapper("JVM_GetLastErrorString");

return (jint)os::lasterror(buf, len);

JVM_LEAF(char*, JVM_NativePath(char* path))

JVMWrapper2("JVM_NativePath (%s)", path);

return os::native_path(path);

JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))

JVMWrapper("JVM_GetCallerClass");

klassOop k = thread->security_get_caller_class(depth);

return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))

JVMWrapper("JVM_FindPrimitiveClass");

oop mirror = NULL;

BasicType t = name2type(utf);

if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {

mirror = Universe::java_mirror(t);

}

if (mirror == NULL) {

THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);

} else {

return (jclass) JNIHandles::make_local(env, mirror);

}

JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls))

JVMWrapper("JVM_ResolveClass");

if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented");

JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,

const char* name))

JVMWrapper2("JVM_FindClassFromBootLoader %s", name);

// Java libraries should ensure that name is never null...

if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

// It's impossible to create this class; the name cannot fit

// into the constant pool.

return NULL;

}

TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

klassOop k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);

if (k == NULL) {

return NULL;

}

if (TraceClassResolution) {

trace_class_resolution(k);

}

return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

JVM_ENTRY(jclass, JVM_FindClassFromClassLoader(JNIEnv* env, const char* name,

jboolean init, jobject loader,

jboolean throwError))

JVMWrapper3("JVM_FindClassFromClassLoader %s throw %s", name,

throwError ? "error" : "exception");

// Java libraries should ensure that name is never null...

if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

// It's impossible to create this class; the name cannot fit

// into the constant pool.

if (throwError) {

THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

} else {

THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name);

}

}

TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

Handle h_loader(THREAD, JNIHandles::resolve(loader));

jclass result = find_class_from_class_loader(env, h_name, init, h_loader,

Handle(), throwError, THREAD);

if (TraceClassResolution && result != NULL) {

trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));

}

return result;

JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,

jboolean init, jclass from))

JVMWrapper2("JVM_FindClassFromClass %s", name);

if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

// It's impossible to create this class; the name cannot fit

// into the constant pool.

THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

}

TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

oop from_class_oop = JNIHandles::resolve(from);

klassOop from_class = (from_class_oop == NULL)

? (klassOop)NULL

: java_lang_Class::as_klassOop(from_class_oop);

oop class_loader = NULL;

oop protection_domain = NULL;

if (from_class != NULL) {

class_loader = Klass::cast(from_class)->class_loader();

protection_domain = Klass::cast(from_class)->protection_domain();

}

Handle h_loader(THREAD, class_loader);

Handle h_prot (THREAD, protection_domain);

jclass result = find_class_from_class_loader(env, h_name, init, h_loader,

h_prot, true, thread);

if (TraceClassResolution && result != NULL) {

// this function is generally only used for class loading during verification.

ResourceMark rm;

oop from_mirror = JNIHandles::resolve_non_null(from);

klassOop from_class = java_lang_Class::as_klassOop(from_mirror);

const char * from_name = Klass::cast(from_class)->external_name();

oop mirror = JNIHandles::resolve_non_null(result);

klassOop to_class = java_lang_Class::as_klassOop(mirror);

const char * to = Klass::cast(to_class)->external_name();

tty->print("RESOLVE %s %s (verification)\n", from_name, to);

}

return result;

static void is_lock_held_by_thread(Handle loader, PerfCounter* counter, TRAPS) {

if (loader.is_null()) {

return;

}

// check whether the current caller thread holds the lock or not.

// If not, increment the corresponding counter

if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader) !=

ObjectSynchronizer::owner_self) {

counter->inc();

}

}

static jclass jvm_define_class_common(JNIEnv *env, const char *name,

jobject loader, const jbyte *buf,

jsize len, jobject pd, const char *source,

jboolean verify, TRAPS) {

if (source == NULL) source = "__JVM_DefineClass__";

assert(THREAD->is_Java_thread(), "must be a JavaThread");

JavaThread* jt = (JavaThread*) THREAD;

PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(),

ClassLoader::perf_define_appclass_selftime(),

ClassLoader::perf_define_appclasses(),

jt->get_thread_stat()->perf_recursion_counts_addr(),

jt->get_thread_stat()->perf_timers_addr(),

PerfClassTraceTime::DEFINE_CLASS);

if (UsePerfData) {

ClassLoader::perf_app_classfile_bytes_read()->inc(len);

}

// Since exceptions can be thrown, class initialization can take place

// if name is NULL no check for class name in .class stream has to be made.

TempNewSymbol class_name = NULL;

if (name != NULL) {

const int str_len = (int)strlen(name);

if (str_len > Symbol::max_length()) {

// It's impossible to create this class; the name cannot fit

// into the constant pool.

THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

}

class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL);

}

ResourceMark rm(THREAD);

ClassFileStream st((u1*) buf, len, (char *)source);

Handle class_loader (THREAD, JNIHandles::resolve(loader));

if (UsePerfData) {

is_lock_held_by_thread(class_loader,

ClassLoader::sync_JVMDefineClassLockFreeCounter(),

THREAD);

}

Handle protection_domain (THREAD, JNIHandles::resolve(pd));

klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,

protection_domain, &st,

verify != 0,

CHECK_NULL);

if (TraceClassResolution && k != NULL) {

trace_class_resolution(k);

}

return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

}

JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))

JVMWrapper2("JVM_DefineClass %s", name);

return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD);

JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))

JVMWrapper2("JVM_DefineClassWithSource %s", name);

return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD);

JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name,

jobject loader, const jbyte *buf,

jsize len, jobject pd,

const char *source, jboolean verify))

JVMWrapper2("JVM_DefineClassWithSourceCond %s", name);

return jvm_define_class_common(env, name, loader, buf, len, pd, source, verify, THREAD);

JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))

JVMWrapper("JVM_FindLoadedClass");

ResourceMark rm(THREAD);

Handle h_name (THREAD, JNIHandles::resolve_non_null(name));

Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL);

const char* str = java_lang_String::as_utf8_string(string());

// Sanity check, don't expect null

if (str == NULL) return NULL;

const int str_len = (int)strlen(str);

if (str_len > Symbol::max_length()) {

// It's impossible to create this class; the name cannot fit

// into the constant pool.

return NULL;

}

TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL);

// Security Note:

// The Java level wrapper will perform the necessary security check allowing

// us to pass the NULL as the initiating class loader.

Handle h_loader(THREAD, JNIHandles::resolve(loader));

if (UsePerfData) {

is_lock_held_by_thread(h_loader,

ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),

THREAD);

}

klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name,

h_loader,

Handle(),

CHECK_NULL);

return (k == NULL) ? NULL :

(jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

JVM_ENTRY(jstring, JVM_GetClassName(JNIEnv *env, jclass cls))

assert (cls != NULL, "illegal class");

JVMWrapper("JVM_GetClassName");

JvmtiVMObjectAllocEventCollector oam;

ResourceMark rm(THREAD);

const char* name;

if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {

name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls)));

} else {

// Consider caching interned string in Klass

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

assert(k->is_klass(), "just checking");

name = Klass::cast(k)->external_name();

}

oop result = StringTable::intern((char*) name, CHECK_NULL);

return (jstring) JNIHandles::make_local(env, result);

JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetClassInterfaces");

JvmtiVMObjectAllocEventCollector oam;

oop mirror = JNIHandles::resolve_non_null(cls);

// Special handling for primitive objects

if (java_lang_Class::is_primitive(mirror)) {

// Primitive objects does not have any interfaces

objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);

return (jobjectArray) JNIHandles::make_local(env, r);

}

KlassHandle klass(thread, java_lang_Class::as_klassOop(mirror));

// Figure size of result array

int size;

if (klass->oop_is_instance()) {

size = instanceKlass::cast(klass())->local_interfaces()->length();

} else {

assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass");

size = 2;

}

// Allocate result array

objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL);

objArrayHandle result (THREAD, r);

// Fill in result

if (klass->oop_is_instance()) {

// Regular instance klass, fill in all local interfaces

for (int index = 0; index < size; index++) {

klassOop k = klassOop(instanceKlass::cast(klass())->local_interfaces()->obj_at(index));

result->obj_at_put(index, Klass::cast(k)->java_mirror());

}

} else {

// All arrays implement java.lang.Cloneable and java.io.Serializable

result->obj_at_put(0, Klass::cast(SystemDictionary::Cloneable_klass())->java_mirror());

result->obj_at_put(1, Klass::cast(SystemDictionary::Serializable_klass())->java_mirror());

}

return (jobjectArray) JNIHandles::make_local(env, result());

JVM_ENTRY(jobject, JVM_GetClassLoader(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetClassLoader");

if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {

return NULL;

}

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

oop loader = Klass::cast(k)->class_loader();

return JNIHandles::make_local(env, loader);

JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))

JVMWrapper("JVM_IsInterface");

oop mirror = JNIHandles::resolve_non_null(cls);

if (java_lang_Class::is_primitive(mirror)) {

return JNI_FALSE;

}

klassOop k = java_lang_Class::as_klassOop(mirror);

jboolean result = Klass::cast(k)->is_interface();

assert(!result || Klass::cast(k)->oop_is_instance(),

"all interfaces are instance types");

// The compiler intrinsic for isInterface tests the

// Klass::_access_flags bits in the same way.

return result;

JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetClassSigners");

JvmtiVMObjectAllocEventCollector oam;

if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {

// There are no signers for primitive types

return NULL;

}

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

objArrayOop signers = NULL;

if (Klass::cast(k)->oop_is_instance()) {

signers = instanceKlass::cast(k)->signers();

}

// If there are no signers set in the class, or if the class

// is an array, return NULL.

if (signers == NULL) return NULL;

// copy of the signers array

klassOop element = objArrayKlass::cast(signers->klass())->element_klass();

objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);

for (int index = 0; index < signers->length(); index++) {

signers_copy->obj_at_put(index, signers->obj_at(index));

}

// return the copy

return (jobjectArray) JNIHandles::make_local(env, signers_copy);

JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))

JVMWrapper("JVM_SetClassSigners");

if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {

// This call is ignored for primitive types and arrays.

// Signers are only set once, ClassLoader.java, and thus shouldn't

// be called with an array. Only the bootstrap loader creates arrays.

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

if (Klass::cast(k)->oop_is_instance()) {

instanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));

}

}

JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetProtectionDomain");

if (JNIHandles::resolve(cls) == NULL) {

THROW_(vmSymbols::java_lang_NullPointerException(), NULL);

}

if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {

// Primitive types does not have a protection domain.

return NULL;

}

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain());

JVM_ENTRY(void, JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain))

JVMWrapper("JVM_SetProtectionDomain");

if (JNIHandles::resolve(cls) == NULL) {

THROW(vmSymbols::java_lang_NullPointerException());

}

if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {

// Call is ignored for primitive types

klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

// cls won't be an array, as this called only from ClassLoader.defineClass

if (Klass::cast(k)->oop_is_instance()) {

oop pd = JNIHandles::resolve(protection_domain);

assert(pd == NULL || pd->is_oop(), "just checking");

instanceKlass::cast(k)->set_protection_domain(pd);

}

}

JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException))

JVMWrapper("JVM_DoPrivileged");

if (action == NULL) {

THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), "Null action");

}

// Stack allocated list of privileged stack elements

PrivilegedElement pi;

// Check that action object understands "Object run()"

Handle object (THREAD, JNIHandles::resolve(action));

// get run() method

methodOop m_oop = Klass::cast(object->klass())->uncached_lookup_method(

vmSymbols::run_method_name(),

vmSymbols::void_object_signature());

methodHandle m (THREAD, m_oop);

if (m.is_null() || !m->is_method() || !methodOop(m())->is_public() || methodOop(m())->is_static()) {

THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method");

}

// Compute the frame initiating the do privileged operation and setup the privileged stack

vframeStream vfst(thread);

vfst.security_get_caller_frame(1);

if (!vfst.at_end()) {

pi.initialize(&vfst, JNIHandles::resolve(context), thread->privileged_stack_top(), CHECK_NULL);

thread->set_privileged_stack_top(&pi);

}

// invoke the Object run() in the action object. We cannot use call_interface here, since the static type

// is not really known - it is either java.security.PrivilegedAction or java.security.PrivilegedExceptionAction

Handle pending_exception;

JavaValue result(T_OBJECT);

JavaCallArguments args(object);

JavaCalls::call(&result, m, &args, THREAD);

// done with action, remove ourselves from the list

if (!vfst.at_end()) {

assert(thread->privileged_stack_top() != NULL && thread->privileged_stack_top() == &pi, "wrong top element");

thread->set_privileged_stack_top(thread->privileged_stack_top()->next());

}

if (HAS_PENDING_EXCEPTION) {

pending_exception = Handle(THREAD, PENDING_EXCEPTION);

CLEAR_PENDING_EXCEPTION;

if ( pending_exception->is_a(SystemDictionary::Exception_klass()) &&

!pending_exception->is_a(SystemDictionary::RuntimeException_klass())) {

// Throw a java.security.PrivilegedActionException(Exception e) exception

JavaCallArguments args(pending_exception);

THROW_ARG_0(vmSymbols::java_security_PrivilegedActionException(),

vmSymbols::exception_void_signature(),

&args);

}

}

if (pending_exception.not_null()) THROW_OOP_0(pending_exception());

return JNIHandles::make_local(env, (oop) result.get_jobject());

JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetInheritedAccessControlContext");

oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj());

return JNIHandles::make_local(env, result);

class RegisterArrayForGC {

private:

JavaThread *_thread;

public:

RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) {

_thread = thread;

_thread->register_array_for_gc(array);

}

~RegisterArrayForGC() {

_thread->register_array_for_gc(NULL);

}

};

JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls))

JVMWrapper("JVM_GetStackAccessControlContext");

if (!UsePrivilegedStack) return NULL;

ResourceMark rm(THREAD);

GrowableArray<oop>* local_array = new GrowableArray<oop>(12);

JvmtiVMObjectAllocEventCollector oam;

// count the protection domains on the execution stack. We collapse

// duplicate consecutive protection domains into a single one, as

// well as stopping when we hit a privileged frame.

// Use vframeStream to iterate through Java frames

vframeStream vfst(thread);

oop previous_protection_domain = NULL;

Handle privileged_context(thread, NULL);

bool is_privileged = false;

oop protection_domain = NULL;