522 JVMCIKlassHandle resolved_klass(THREAD); 523 Klass* accessing_klass = NULL; 524 Handle class_loader; 525 Handle protection_domain; 526 if (accessing_class != NULL) { 527 accessing_klass = JVMCIENV->asKlass(accessing_class); 528 class_loader = Handle(THREAD, accessing_klass->class_loader()); 529 protection_domain = Handle(THREAD, accessing_klass->protection_domain()); 530 } else { 531 // Use the System class loader 532 class_loader = Handle(THREAD, SystemDictionary::java_system_loader()); 533 JVMCIENV->runtime()->initialize(JVMCIENV); 534 } 535 536 if (resolve) { 537 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0); 538 if (resolved_klass == NULL) { 539 JVMCI_THROW_MSG_NULL(ClassNotFoundException, str); 540 } 541 } else { 542 if (class_name->char_at(0) == JVM_SIGNATURE_CLASS && 543 class_name->char_at(class_name->utf8_length()-1) == JVM_SIGNATURE_ENDCLASS) { 544 // This is a name from a signature. Strip off the trimmings. 545 // Call recursive to keep scope of strippedsym. 546 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1, 547 class_name->utf8_length()-2); 548 resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0); 549 } else if (FieldType::is_array(class_name)) { 550 FieldArrayInfo fd; 551 // dimension and object_key in FieldArrayInfo are assigned as a side-effect 552 // of this call 553 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0); 554 if (t == T_OBJECT) { 555 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(), 556 class_name->utf8_length()-2-fd.dimension()); 557 resolved_klass = SystemDictionary::find(strippedsym, 558 class_loader, 559 protection_domain, 560 CHECK_0); 561 if (!resolved_klass.is_null()) { 562 resolved_klass = resolved_klass->array_klass(fd.dimension(), CHECK_0); 563 } 564 } else { 565 resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlassObj(t))->array_klass(fd.dimension(), CHECK_0); 566 } 567 } else { 568 resolved_klass = SystemDictionary::find(class_name, class_loader, protection_domain, CHECK_0); 569 } 570 } 571 JVMCIObject result = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL); 572 return JVMCIENV->get_jobject(result); 573 C2V_END 574 575 C2V_VMENTRY_NULL(jobject, getArrayType, (JNIEnv* env, jobject, jobject jvmci_type)) 576 if (jvmci_type == NULL) { 577 JVMCI_THROW_0(NullPointerException); 578 } 579 580 JVMCIObject jvmci_type_object = JVMCIENV->wrap(jvmci_type); 581 JVMCIKlassHandle array_klass(THREAD); 582 if (JVMCIENV->isa_HotSpotResolvedPrimitiveType(jvmci_type_object)) { 583 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->get_HotSpotResolvedPrimitiveType_kind(jvmci_type_object), JVMCI_CHECK_0); 584 if (type == T_VOID) { 585 return NULL; 1019 C2V_END 1020 1021 C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod)) 1022 // The incoming arguments array would have to contain JavaConstants instead of regular objects 1023 // and the return value would have to be wrapped as a JavaConstant. 1024 requireInHotSpot("executeHotSpotNmethod", JVMCI_CHECK_NULL); 1025 1026 HandleMark hm; 1027 1028 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod); 1029 nmethodLocker locker; 1030 nmethod* nm = JVMCIENV->get_nmethod(nmethod_mirror, locker); 1031 if (nm == NULL) { 1032 JVMCI_THROW_NULL(InvalidInstalledCodeException); 1033 } 1034 methodHandle mh(THREAD, nm->method()); 1035 Symbol* signature = mh->signature(); 1036 JavaCallArguments jca(mh->size_of_parameters()); 1037 1038 JavaArgumentUnboxer jap(signature, &jca, (arrayOop) JNIHandles::resolve(args), mh->is_static()); 1039 JavaValue result(jap.get_ret_type()); 1040 jca.set_alternative_target(nm); 1041 JavaCalls::call(&result, mh, &jca, CHECK_NULL); 1042 1043 if (jap.get_ret_type() == T_VOID) { 1044 return NULL; 1045 } else if (is_reference_type(jap.get_ret_type())) { 1046 return JNIHandles::make_local((oop) result.get_jobject()); 1047 } else { 1048 jvalue *value = (jvalue *) result.get_value_addr(); 1049 // Narrow the value down if required (Important on big endian machines) 1050 switch (jap.get_ret_type()) { 1051 case T_BOOLEAN: 1052 value->z = (jboolean) value->i; 1053 break; 1054 case T_BYTE: 1055 value->b = (jbyte) value->i; 1056 break; 1057 case T_CHAR: 1058 value->c = (jchar) value->i; 1059 break; 1060 case T_SHORT: 1061 value->s = (jshort) value->i; 1062 break; 1063 default: 1064 break; 1065 } 1066 JVMCIObject o = JVMCIENV->create_box(jap.get_ret_type(), value, JVMCI_CHECK_NULL); 1067 return JVMCIENV->get_jobject(o); 1068 } 1069 C2V_END 1070 1071 C2V_VMENTRY_NULL(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, jobject jvmci_method)) 1072 Method* method = JVMCIENV->asMethod(jvmci_method); 1073 if (!method->has_linenumber_table()) { 1074 return NULL; 1075 } 1076 u2 num_entries = 0; 1077 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); 1078 while (streamForSize.read_pair()) { 1079 num_entries++; 1080 } 1081 1082 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 1083 JVMCIPrimitiveArray result = JVMCIENV->new_longArray(2 * num_entries, JVMCI_CHECK_NULL); 1084 1085 int i = 0; 1086 jlong value; | 522 JVMCIKlassHandle resolved_klass(THREAD); 523 Klass* accessing_klass = NULL; 524 Handle class_loader; 525 Handle protection_domain; 526 if (accessing_class != NULL) { 527 accessing_klass = JVMCIENV->asKlass(accessing_class); 528 class_loader = Handle(THREAD, accessing_klass->class_loader()); 529 protection_domain = Handle(THREAD, accessing_klass->protection_domain()); 530 } else { 531 // Use the System class loader 532 class_loader = Handle(THREAD, SystemDictionary::java_system_loader()); 533 JVMCIENV->runtime()->initialize(JVMCIENV); 534 } 535 536 if (resolve) { 537 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0); 538 if (resolved_klass == NULL) { 539 JVMCI_THROW_MSG_NULL(ClassNotFoundException, str); 540 } 541 } else { 542 if (Signature::has_envelope(class_name)) { 543 // This is a name from a signature. Strip off the trimmings. 544 // Call recursive to keep scope of strippedsym. 545 TempNewSymbol strippedsym = Signature::strip_envelope(class_name); 546 resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0); 547 } else if (Signature::is_array(class_name)) { 548 SignatureStream ss(class_name, false); 549 int ndim = ss.skip_array_prefix(); 550 if (ss.type() == T_OBJECT) { 551 Symbol* strippedsym = ss.as_symbol(); 552 resolved_klass = SystemDictionary::find(strippedsym, 553 class_loader, 554 protection_domain, 555 CHECK_0); 556 if (!resolved_klass.is_null()) { 557 resolved_klass = resolved_klass->array_klass(ndim, CHECK_0); 558 } 559 } else { 560 resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlassObj(ss.type()))->array_klass(ndim, CHECK_0); 561 } 562 } else { 563 resolved_klass = SystemDictionary::find(class_name, class_loader, protection_domain, CHECK_0); 564 } 565 } 566 JVMCIObject result = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL); 567 return JVMCIENV->get_jobject(result); 568 C2V_END 569 570 C2V_VMENTRY_NULL(jobject, getArrayType, (JNIEnv* env, jobject, jobject jvmci_type)) 571 if (jvmci_type == NULL) { 572 JVMCI_THROW_0(NullPointerException); 573 } 574 575 JVMCIObject jvmci_type_object = JVMCIENV->wrap(jvmci_type); 576 JVMCIKlassHandle array_klass(THREAD); 577 if (JVMCIENV->isa_HotSpotResolvedPrimitiveType(jvmci_type_object)) { 578 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->get_HotSpotResolvedPrimitiveType_kind(jvmci_type_object), JVMCI_CHECK_0); 579 if (type == T_VOID) { 580 return NULL; 1014 C2V_END 1015 1016 C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod)) 1017 // The incoming arguments array would have to contain JavaConstants instead of regular objects 1018 // and the return value would have to be wrapped as a JavaConstant. 1019 requireInHotSpot("executeHotSpotNmethod", JVMCI_CHECK_NULL); 1020 1021 HandleMark hm; 1022 1023 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod); 1024 nmethodLocker locker; 1025 nmethod* nm = JVMCIENV->get_nmethod(nmethod_mirror, locker); 1026 if (nm == NULL) { 1027 JVMCI_THROW_NULL(InvalidInstalledCodeException); 1028 } 1029 methodHandle mh(THREAD, nm->method()); 1030 Symbol* signature = mh->signature(); 1031 JavaCallArguments jca(mh->size_of_parameters()); 1032 1033 JavaArgumentUnboxer jap(signature, &jca, (arrayOop) JNIHandles::resolve(args), mh->is_static()); 1034 JavaValue result(jap.return_type()); 1035 jca.set_alternative_target(nm); 1036 JavaCalls::call(&result, mh, &jca, CHECK_NULL); 1037 1038 if (jap.return_type() == T_VOID) { 1039 return NULL; 1040 } else if (is_reference_type(jap.return_type())) { 1041 return JNIHandles::make_local((oop) result.get_jobject()); 1042 } else { 1043 jvalue *value = (jvalue *) result.get_value_addr(); 1044 // Narrow the value down if required (Important on big endian machines) 1045 switch (jap.return_type()) { 1046 case T_BOOLEAN: 1047 value->z = (jboolean) value->i; 1048 break; 1049 case T_BYTE: 1050 value->b = (jbyte) value->i; 1051 break; 1052 case T_CHAR: 1053 value->c = (jchar) value->i; 1054 break; 1055 case T_SHORT: 1056 value->s = (jshort) value->i; 1057 break; 1058 default: 1059 break; 1060 } 1061 JVMCIObject o = JVMCIENV->create_box(jap.return_type(), value, JVMCI_CHECK_NULL); 1062 return JVMCIENV->get_jobject(o); 1063 } 1064 C2V_END 1065 1066 C2V_VMENTRY_NULL(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, jobject jvmci_method)) 1067 Method* method = JVMCIENV->asMethod(jvmci_method); 1068 if (!method->has_linenumber_table()) { 1069 return NULL; 1070 } 1071 u2 num_entries = 0; 1072 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); 1073 while (streamForSize.read_pair()) { 1074 num_entries++; 1075 } 1076 1077 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 1078 JVMCIPrimitiveArray result = JVMCIENV->new_longArray(2 * num_entries, JVMCI_CHECK_NULL); 1079 1080 int i = 0; 1081 jlong value; |