< prev index next >

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

Print this page




 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;


< prev index next >