< prev index next >
src/hotspot/share/prims/jvm.cpp
Print this page
@@ -1,5 +1,6 @@
+
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -139,11 +140,11 @@
ResourceMark rm;
int line_number = -1;
const char * source_file = NULL;
const char * trace = "explicit";
InstanceKlass* caller = NULL;
- JavaThread* jthread = JavaThread::current();
+ JavaThread* jthread = (JavaThread*) THREAD;
if (jthread->has_last_Java_frame()) {
vframeStream vfst(jthread);
// scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames
TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController");
@@ -445,11 +446,11 @@
result_h->obj_at_put(ndx * 2 + 1, value_str());
ndx++;
}
}
- return (jobjectArray) JNIHandles::make_local(env, result_h());
+ return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
JVM_END
/*
* Return the temporary directory that the VM uses for the attach
@@ -462,11 +463,11 @@
JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
JVMWrapper("JVM_GetTemporaryDirectory");
HandleMark hm(THREAD);
const char* temp_dir = os::get_temp_directory();
Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, h());
+ return (jstring) JNIHandles::make_local(THREAD, h());
JVM_END
// java.lang.Runtime /////////////////////////////////////////////////////////////////////////
@@ -566,11 +567,11 @@
stringStream ss;
bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci);
if (ok) {
oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, result);
+ return (jstring) JNIHandles::make_local(THREAD, result);
} else {
return NULL;
}
JVM_END
@@ -620,11 +621,11 @@
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", NULL);
}
oop result = StackWalk::walk(stackStream_h, mode, skip_frames, frame_count,
start_index, frames_array_h, CHECK_NULL);
- return JNIHandles::make_local(env, result);
+ return JNIHandles::make_local(THREAD, result);
JVM_END
JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jlong mode, jlong anchor,
jint frame_count, jint start_index,
@@ -736,11 +737,11 @@
assert(obj->is_instance(), "should be instanceOop");
new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
new_obj = Handle(THREAD, new_obj_oop);
}
- return JNIHandles::make_local(env, new_obj());
+ return JNIHandles::make_local(THREAD, new_obj());
JVM_END
// java.io.File ///////////////////////////////////////////////////////////////
JVM_LEAF(char*, JVM_NativePath(char* path))
@@ -782,11 +783,11 @@
}
break;
default:
if (!m->is_ignored_by_security_stack_walk()) {
// We have reached the desired frame; return the holder class.
- return (jclass) JNIHandles::make_local(env, m->method_holder()->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, m->method_holder()->java_mirror());
}
break;
}
}
return NULL;
@@ -801,11 +802,11 @@
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);
+ return (jclass) JNIHandles::make_local(THREAD, mirror);
}
JVM_END
// Returns a class loaded by the bootstrap class loader; or null
@@ -830,11 +831,11 @@
}
if (log_is_enabled(Debug, class, resolve)) {
trace_class_resolution(k);
}
- return (jclass) JNIHandles::make_local(env, k->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
JVM_END
// Find a class with this name in this loader, using the caller's protection domain.
JVM_ENTRY(jclass, JVM_FindClassFromCaller(JNIEnv* env, const char* name,
jboolean init, jobject loader,
@@ -918,11 +919,11 @@
counter->inc();
}
}
// common code for JVM_DefineClass() and JVM_DefineClassWithSource()
-static jclass jvm_define_class_common(JNIEnv *env, const char *name,
+static jclass jvm_define_class_common(const char *name,
jobject loader, const jbyte *buf,
jsize len, jobject pd, const char *source,
TRAPS) {
if (source == NULL) source = "__JVM_DefineClass__";
@@ -962,11 +963,11 @@
if (log_is_enabled(Debug, class, resolve) && k != NULL) {
trace_class_resolution(k);
}
- return (jclass) JNIHandles::make_local(env, k->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
}
enum {
NESTMATE = java_lang_invoke_MemberName::MN_NESTMATE_CLASS,
HIDDEN_CLASS = java_lang_invoke_MemberName::MN_HIDDEN_CLASS,
@@ -976,11 +977,11 @@
/*
* Define a class with the specified flags that indicates if it's a nestmate,
* hidden, or strongly referenced from class loader.
*/
-static jclass jvm_lookup_define_class(JNIEnv *env, jclass lookup, const char *name,
+static jclass jvm_lookup_define_class(jclass lookup, const char *name,
const jbyte *buf, jsize len, jobject pd,
jboolean init, int flags, jobject classData, TRAPS) {
assert(THREAD->is_Java_thread(), "must be a JavaThread");
JavaThread* jt = (JavaThread*) THREAD;
ResourceMark rm(THREAD);
@@ -1097,17 +1098,17 @@
ik->initialize(CHECK_NULL);
} else {
ik->link_class(CHECK_NULL);
}
- return (jclass) JNIHandles::make_local(env, defined_k->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, defined_k->java_mirror());
}
JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
JVMWrapper("JVM_DefineClass");
- return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD);
+ return jvm_define_class_common(name, loader, buf, len, pd, NULL, THREAD);
JVM_END
/*
* Define a class with the specified lookup class.
* lookup: Lookup class
@@ -1127,17 +1128,17 @@
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
}
assert(buf != NULL, "buf must not be NULL");
- return jvm_lookup_define_class(env, lookup, name, buf, len, pd, initialize, flags, classData, THREAD);
+ return jvm_lookup_define_class(lookup, name, buf, len, pd, initialize, flags, classData, THREAD);
JVM_END
JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
JVMWrapper("JVM_DefineClassWithSource");
- return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD);
+ return jvm_define_class_common(name, loader, buf, len, pd, source, THREAD);
JVM_END
JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
JVMWrapper("JVM_FindLoadedClass");
ResourceMark rm(THREAD);
@@ -1185,11 +1186,11 @@
// archive for the current classloader (h_loader).
k = SystemDictionaryShared::find_or_load_shared_class(klass_name, h_loader, CHECK_NULL);
}
#endif
return (k == NULL) ? NULL :
- (jclass) JNIHandles::make_local(env, k->java_mirror());
+ (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
JVM_END
// Module support //////////////////////////////////////////////////////////////////////////////
JVM_ENTRY(void, JVM_DefineModule(JNIEnv *env, jobject module, jboolean is_open, jstring version,
@@ -1231,11 +1232,11 @@
JvmtiVMObjectAllocEventCollector oam;
ResourceMark rm(THREAD);
HandleMark hm(THREAD);
Handle java_class(THREAD, JNIHandles::resolve(cls));
oop result = java_lang_Class::name(java_class, CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, result);
+ return (jstring) JNIHandles::make_local(THREAD, result);
JVM_END
JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassInterfaces");
@@ -1244,11 +1245,11 @@
// 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);
+ return (jobjectArray) JNIHandles::make_local(THREAD, r);
}
Klass* klass = java_lang_Class::as_Klass(mirror);
// Figure size of result array
int size;
@@ -1272,11 +1273,11 @@
} else {
// All arrays implement java.lang.Cloneable and java.io.Serializable
result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror());
result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror());
}
- return (jobjectArray) JNIHandles::make_local(env, result());
+ return (jobjectArray) JNIHandles::make_local(THREAD, result());
JVM_END
JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
JVMWrapper("JVM_IsInterface");
@@ -1323,11 +1324,11 @@
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);
+ return (jobjectArray) JNIHandles::make_local(THREAD, signers_copy);
JVM_END
JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))
JVMWrapper("JVM_SetClassSigners");
@@ -1353,19 +1354,19 @@
// Primitive types does not have a protection domain.
return NULL;
}
oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls));
- return (jobject) JNIHandles::make_local(env, pd);
+ return (jobject) JNIHandles::make_local(THREAD, pd);
JVM_END
// Returns the inherited_access_control_context field of the running thread.
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);
+ return JNIHandles::make_local(THREAD, result);
JVM_END
class RegisterArrayForGC {
private:
JavaThread *_thread;
@@ -1440,11 +1441,11 @@
// we had a privileged system domain
if (local_array->is_empty()) {
if (is_privileged && privileged_context.is_null()) return NULL;
oop result = java_security_AccessControlContext::create(objArrayHandle(), is_privileged, privileged_context, CHECK_NULL);
- return JNIHandles::make_local(env, result);
+ return JNIHandles::make_local(THREAD, result);
}
// the resource area must be registered in case of a gc
RegisterArrayForGC ragc(thread, local_array);
objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(),
@@ -1454,11 +1455,11 @@
h_context->obj_at_put(index, local_array->at(index));
}
oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL);
- return JNIHandles::make_local(env, result);
+ return JNIHandles::make_local(THREAD, result);
JVM_END
JVM_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
JVMWrapper("JVM_IsArrayClass");
@@ -1496,20 +1497,20 @@
// of an InstanceKlass
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
- return (jobjectArray)JNIHandles::make_local(env, result);
+ return (jobjectArray)JNIHandles::make_local(THREAD, result);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
InnerClassesIterator iter(k);
if (iter.length() == 0) {
// Neither an inner nor outer class
oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
- return (jobjectArray)JNIHandles::make_local(env, result);
+ return (jobjectArray)JNIHandles::make_local(THREAD, result);
}
// find inner class info
constantPoolHandle cp(thread, k->constants());
int length = iter.length();
@@ -1547,14 +1548,14 @@
// Return array of right length
objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL);
for(int i = 0; i < members; i++) {
res->obj_at_put(i, result->obj_at(i));
}
- return (jobjectArray)JNIHandles::make_local(env, res);
+ return (jobjectArray)JNIHandles::make_local(THREAD, res);
}
- return (jobjectArray)JNIHandles::make_local(env, result());
+ return (jobjectArray)JNIHandles::make_local(THREAD, result());
JVM_END
JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
{
@@ -1568,11 +1569,11 @@
Klass* outer_klass
= InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
)->compute_enclosing_class(&inner_is_member, CHECK_NULL);
if (outer_klass == NULL) return NULL; // already a top-level class
if (!inner_is_member) return NULL; // a hidden or unsafe anonymous class (inside a method)
- return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, outer_klass->java_mirror());
}
JVM_END
JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
{
@@ -1586,11 +1587,11 @@
if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
if (noff != 0) {
constantPoolHandle i_cp(thread, k->constants());
Symbol* name = i_cp->symbol_at(noff);
Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, str());
+ return (jstring) JNIHandles::make_local(THREAD, str());
}
}
return NULL;
}
JVM_END
@@ -1605,11 +1606,11 @@
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
if (k->is_instance_klass()) {
Symbol* sym = InstanceKlass::cast(k)->generic_signature();
if (sym == NULL) return NULL;
Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, str());
+ return (jstring) JNIHandles::make_local(THREAD, str());
}
}
return NULL;
JVM_END
@@ -1621,11 +1622,11 @@
// Return null for arrays and primitives
if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
if (k->is_instance_klass()) {
typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, a);
+ return (jbyteArray) JNIHandles::make_local(THREAD, a);
}
}
return NULL;
JVM_END
@@ -1693,11 +1694,11 @@
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
if (k->is_instance_klass()) {
AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations();
if (type_annotations != NULL) {
typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, a);
+ return (jbyteArray) JNIHandles::make_local(THREAD, a);
}
}
}
return NULL;
JVM_END
@@ -1713,11 +1714,11 @@
}
AnnotationArray* type_annotations = m->type_annotations();
if (type_annotations != NULL) {
typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, a);
+ return (jbyteArray) JNIHandles::make_local(THREAD, a);
}
return NULL;
JVM_END
@@ -1729,11 +1730,11 @@
bool gotFd = jvm_get_field_common(field, fd, CHECK_NULL);
if (!gotFd) {
return NULL;
}
- return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.type_annotations(), THREAD));
+ return (jbyteArray) JNIHandles::make_local(THREAD, Annotations::make_java_array(fd.type_annotations(), THREAD));
JVM_END
static void bounds_check(const constantPoolHandle& cp, jint index, TRAPS) {
if (!cp->is_within_bounds(index)) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds");
@@ -1785,11 +1786,11 @@
int flags = params[i].flags;
oop param = Reflection::new_parameter(reflected_method, i, sym,
flags, CHECK_NULL);
result->obj_at_put(i, param);
}
- return (jobjectArray)JNIHandles::make_local(env, result());
+ return (jobjectArray)JNIHandles::make_local(THREAD, result());
}
}
JVM_END
// New (JDK 1.4) reflection implementation /////////////////////////////////////
@@ -1802,11 +1803,11 @@
// Exclude primitive types and array types
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
- return (jobjectArray) JNIHandles::make_local(env, res);
+ return (jobjectArray) JNIHandles::make_local(THREAD, res);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
constantPoolHandle cp(THREAD, k->constants());
@@ -1837,11 +1838,11 @@
result->obj_at_put(out_idx, field);
++out_idx;
}
}
assert(out_idx == num_fields, "just checking");
- return (jobjectArray) JNIHandles::make_local(env, result());
+ return (jobjectArray) JNIHandles::make_local(THREAD, result());
}
JVM_END
JVM_ENTRY(jboolean, JVM_IsRecord(JNIEnv *env, jclass cls))
{
@@ -1885,11 +1886,11 @@
}
}
// Return empty array if ofClass is not a record.
objArrayOop result = oopFactory::new_objArray(SystemDictionary::RecordComponent_klass(), 0, CHECK_NULL);
- return (jobjectArray)JNIHandles::make_local(env, result);
+ return (jobjectArray)JNIHandles::make_local(THREAD, result);
}
JVM_END
static bool select_method(const methodHandle& method, bool want_constructor) {
if (want_constructor) {
@@ -1910,11 +1911,11 @@
// Exclude primitive types and array types
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
|| java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) {
// Return empty array
oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
- return (jobjectArray) JNIHandles::make_local(env, res);
+ return (jobjectArray) JNIHandles::make_local(THREAD, res);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
// Ensure class is linked
@@ -1963,11 +1964,11 @@
}
result->obj_at_put(i, m);
}
}
- return (jobjectArray) JNIHandles::make_local(env, result());
+ return (jobjectArray) JNIHandles::make_local(THREAD, result());
}
JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
{
JVMWrapper("JVM_GetClassDeclaredMethods");
@@ -2500,11 +2501,11 @@
// command-line assertion arguments (i.e., -ea, -da).
JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
JVMWrapper("JVM_AssertionStatusDirectives");
JvmtiVMObjectAllocEventCollector oam;
oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
- return JNIHandles::make_local(env, asd);
+ return JNIHandles::make_local(THREAD, asd);
JVM_END
// Verification ////////////////////////////////////////////////////////////////////////////////
// Reflection for the verifier /////////////////////////////////////////////////////////////////
@@ -3283,11 +3284,11 @@
JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
JVMWrapper("JVM_CurrentThread");
oop jthread = thread->threadObj();
assert (thread != NULL, "no current thread!");
- return JNIHandles::make_local(env, jthread);
+ return JNIHandles::make_local(THREAD, jthread);
JVM_END
JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_Interrupt");
@@ -3375,11 +3376,11 @@
// Fill in mirrors corresponding to method holders
for (int i = 0; i < klass_array->length(); i++) {
result->obj_at_put(i, klass_array->at(i)->java_mirror());
}
- return (jobjectArray) JNIHandles::make_local(env, result);
+ return (jobjectArray) JNIHandles::make_local(THREAD, result);
JVM_END
// java.lang.Package ////////////////////////////////////////////////////////////////
@@ -3411,11 +3412,11 @@
MonitorLocker ml(Heap_lock);
oop ref = Universe::reference_pending_list();
if (ref != NULL) {
Universe::set_reference_pending_list(NULL);
}
- return JNIHandles::make_local(env, ref);
+ return JNIHandles::make_local(THREAD, ref);
JVM_END
JVM_ENTRY(jboolean, JVM_HasReferencePendingList(JNIEnv* env))
JVMWrapper("JVM_HasReferencePendingList");
MonitorLocker ml(Heap_lock);
@@ -3439,11 +3440,11 @@
JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
oop loader = vfst.method()->method_holder()->class_loader();
if (loader != NULL && !SystemDictionary::is_platform_class_loader(loader)) {
- return JNIHandles::make_local(env, loader);
+ return JNIHandles::make_local(THREAD, loader);
}
}
return NULL;
JVM_END
@@ -3478,11 +3479,11 @@
JvmtiVMObjectAllocEventCollector oam;
arrayOop a = check_array(env, arr, false, CHECK_NULL);
jvalue value;
BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL);
oop box = Reflection::box(&value, type, CHECK_NULL);
- return JNIHandles::make_local(env, box);
+ return JNIHandles::make_local(THREAD, box);
JVM_END
JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode))
JVMWrapper("JVM_GetPrimitiveArrayElement");
@@ -3528,22 +3529,22 @@
JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length))
JVMWrapper("JVM_NewArray");
JvmtiVMObjectAllocEventCollector oam;
oop element_mirror = JNIHandles::resolve(eltClass);
oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL);
- return JNIHandles::make_local(env, result);
+ return JNIHandles::make_local(THREAD, result);
JVM_END
JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim))
JVMWrapper("JVM_NewMultiArray");
JvmtiVMObjectAllocEventCollector oam;
arrayOop dim_array = check_array(env, dim, true, CHECK_NULL);
oop element_mirror = JNIHandles::resolve(eltClass);
assert(dim_array->is_typeArray(), "just checking");
oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL);
- return JNIHandles::make_local(env, result);
+ return JNIHandles::make_local(THREAD, result);
JVM_END
// Library support ///////////////////////////////////////////////////////////////////////////
@@ -3606,11 +3607,11 @@
JVMWrapper("JVM_InternString");
JvmtiVMObjectAllocEventCollector oam;
if (str == NULL) return NULL;
oop string = JNIHandles::resolve_non_null(str);
oop result = StringTable::intern(string, CHECK_NULL);
- return (jstring) JNIHandles::make_local(env, result);
+ return (jstring) JNIHandles::make_local(THREAD, result);
JVM_END
// VM Raw monitor support //////////////////////////////////////////////////////////////////////
@@ -3665,11 +3666,11 @@
// Check if we should initialize the class
if (init && klass->is_instance_klass()) {
klass->initialize(CHECK_NULL);
}
- return (jclass) JNIHandles::make_local(env, klass->java_mirror());
+ return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
}
// Method ///////////////////////////////////////////////////////////////////////////////////////////
@@ -3679,18 +3680,18 @@
if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
method_handle = Handle(THREAD, JNIHandles::resolve(method));
Handle receiver(THREAD, JNIHandles::resolve(obj));
objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
- jobject res = JNIHandles::make_local(env, result);
+ jobject res = JNIHandles::make_local(THREAD, result);
if (JvmtiExport::should_post_vm_object_alloc()) {
oop ret_type = java_lang_reflect_Method::return_type(method_handle());
assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");
if (java_lang_Class::is_primitive(ret_type)) {
// Only for primitive type vm allocates memory for java object.
// See box() method.
- JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
+ JvmtiExport::post_vm_object_alloc(thread, result);
}
}
return res;
} else {
THROW_0(vmSymbols::java_lang_StackOverflowError());
@@ -3701,13 +3702,13 @@
JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
JVMWrapper("JVM_NewInstanceFromConstructor");
oop constructor_mirror = JNIHandles::resolve(c);
objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
- jobject res = JNIHandles::make_local(env, result);
+ jobject res = JNIHandles::make_local(THREAD, result);
if (JvmtiExport::should_post_vm_object_alloc()) {
- JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
+ JvmtiExport::post_vm_object_alloc(thread, result);
}
return res;
JVM_END
// Atomic ///////////////////////////////////////////////////////////////////////////////////////////
@@ -3816,11 +3817,11 @@
InstanceKlass* lambda_ik = SystemDictionaryShared::get_shared_lambda_proxy_class(caller_ik, invoked_name, invoked_type,
method_type, m, instantiated_method_type);
jclass jcls = NULL;
if (lambda_ik != NULL) {
InstanceKlass* loaded_lambda = SystemDictionaryShared::prepare_shared_lambda_proxy_class(lambda_ik, caller_ik, initialize, THREAD);
- jcls = loaded_lambda == NULL ? NULL : (jclass) JNIHandles::make_local(env, loaded_lambda->java_mirror());
+ jcls = loaded_lambda == NULL ? NULL : (jclass) JNIHandles::make_local(THREAD, loaded_lambda->java_mirror());
}
return jcls;
#else
return NULL;
#endif // INCLUDE_CDS
@@ -3874,11 +3875,11 @@
for (int i = 0; i < num_threads; i++) {
Handle h = tle.get_threadObj(i);
threads_ah->obj_at_put(i, h());
}
- return (jobjectArray) JNIHandles::make_local(env, threads_ah());
+ return (jobjectArray) JNIHandles::make_local(THREAD, threads_ah());
JVM_END
// Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods
// Return StackTraceElement[][], each element is the stack trace of a thread in
@@ -3916,11 +3917,11 @@
}
// The JavaThread references in thread_handle_array are validated
// in VM_ThreadDump::doit().
Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL);
- return (jobjectArray)JNIHandles::make_local(env, stacktraces());
+ return (jobjectArray)JNIHandles::make_local(THREAD, stacktraces());
JVM_END
// JVM monitoring and management support
JVM_ENTRY_NO_ENV(void*, JVM_GetManagement(jint version))
@@ -4009,11 +4010,11 @@
}
for (int i = 0; i < num_args; i++, index++) {
Handle h = java_lang_String::create_from_platform_dependent_str(vm_args[i], CHECK_NULL);
result_h->obj_at_put(index, h());
}
- return (jobjectArray) JNIHandles::make_local(env, result_h());
+ return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
JVM_END
JVM_ENTRY_NO_ENV(jint, JVM_FindSignal(const char *name))
return os::get_signal_number(name);
JVM_END
< prev index next >