# HG changeset patch # User Thomas Wuerthinger # Date 1321458392 -3600 # Node ID 5a8c44b5fb8086b28e948488c197d03d02f00eb1 # Parent 81ad8ab1f9fe5b0255014a8dfdca4c051586fe23 Remove ci usage on field lookup. diff -r 81ad8ab1f9fe -r 5a8c44b5fb80 src/share/vm/graal/graalCompiler.cpp --- a/src/share/vm/graal/graalCompiler.cpp Wed Nov 16 16:02:04 2011 +0100 +++ b/src/share/vm/graal/graalCompiler.cpp Wed Nov 16 16:46:32 2011 +0100 @@ -180,17 +180,9 @@ return createHotSpotTypeResolved(klass, name, CHECK_NULL); } -oop GraalCompiler::get_RiField(ciField *field, ciInstanceKlass* accessor_klass, Handle field_holder, Handle field_type, Bytecodes::Code byteCode, TRAPS) { - int offset; - if (byteCode != Bytecodes::_illegal) { - bool will_link = field->will_link_from_vm(accessor_klass, byteCode); - offset = (field->holder()->is_loaded() && will_link) ? field->offset() : -1; - } else { - offset = field->offset(); - } - Handle field_name = VmIds::toString(field->name()->get_symbol(), CHECK_0); - int flags = field->flags().as_int(); - return VMExits::createRiField(field_holder, field_name, field_type, offset, flags, THREAD); +oop GraalCompiler::get_RiField(int offset, int flags, Symbol* field_name, Handle field_holder, Handle field_type, Bytecodes::Code byteCode, TRAPS) { + Handle name = VmIds::toString(field_name, CHECK_NULL); + return VMExits::createRiField(field_holder, name, field_type, offset, flags, CHECK_NULL); } oop GraalCompiler::createHotSpotTypeResolved(KlassHandle klass, Handle name, TRAPS) { diff -r 81ad8ab1f9fe -r 5a8c44b5fb80 src/share/vm/graal/graalCompiler.hpp --- a/src/share/vm/graal/graalCompiler.hpp Wed Nov 16 16:02:04 2011 +0100 +++ b/src/share/vm/graal/graalCompiler.hpp Wed Nov 16 16:46:32 2011 +0100 @@ -61,7 +61,7 @@ static oop get_RiType(constantPoolHandle cp, int index, KlassHandle accessor, TRAPS); static oop get_RiType(Symbol* klass_name, TRAPS); static oop get_RiType(KlassHandle klass, TRAPS); - static oop get_RiField(ciField *field, ciInstanceKlass* accessor_klass, Handle field_holder, Handle field_type, Bytecodes::Code byteCode, TRAPS); + static oop get_RiField(int offset, int flags, Symbol* field_name, Handle field_holder, Handle field_type, Bytecodes::Code byteCode, TRAPS); static oop createHotSpotTypeResolved(KlassHandle klass, Handle name, TRAPS); static oop createHotSpotMethodResolved(methodHandle method, TRAPS); diff -r 81ad8ab1f9fe -r 5a8c44b5fb80 src/share/vm/graal/graalVMEntries.cpp --- a/src/share/vm/graal/graalVMEntries.cpp Wed Nov 16 16:02:04 2011 +0100 +++ b/src/share/vm/graal/graalVMEntries.cpp Wed Nov 16 16:46:32 2011 +0100 @@ -534,10 +534,16 @@ int nt_index = cp->name_and_type_ref_index_at(index); int sig_index = cp->signature_ref_index_at(nt_index); Symbol* signature = cp->symbol_at(sig_index); + int name_index = cp->name_ref_index_at(nt_index); + Symbol* name = cp->symbol_at(name_index); int holder_index = cp->klass_ref_index_at(index); Handle holder = GraalCompiler::get_RiType(cp, holder_index, cp->pool_holder(), CHECK_NULL); + instanceKlassHandle holder_klass; Bytecodes::Code code = (Bytecodes::Code)(((int) byteCode) & 0xFF); + int offset = -1; + AccessFlags flags; + BasicType basic_type; if (holder->klass() == SystemDictionary::HotSpotTypeResolved_klass()) { FieldAccessInfo result; LinkResolver::resolve_field(result, cp, index, @@ -546,61 +552,81 @@ if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; } - //result.field_offset(); - holder = GraalCompiler::get_RiType(result.klass(), CHECK_NULL); + offset = result.field_offset(); + flags = result.access_flags(); + holder_klass = result.klass()->as_klassOop(); + basic_type = result.field_type(); + holder = GraalCompiler::get_RiType(holder_klass, CHECK_NULL); } - + Handle type = GraalCompiler::get_RiTypeFromSignature(cp, sig_index, cp->pool_holder(), CHECK_NULL); - Handle field_handle = GraalCompiler::get_RiField(field, loading_klass, holder, type, code, THREAD); - bool is_constant = field->is_constant(); - if (is_constant && field->is_static()) { - ciConstant constant = field->constant_value(); - oop constant_object = NULL; - switch (constant.basic_type()) { - case T_OBJECT: - case T_ARRAY: - { - ciObject* obj = constant.as_object(); - if (obj->is_null_object()) { - constant_object = VMExits::createCiConstantObject(NULL, CHECK_0); - } else if (obj->can_be_constant()) { - constant_object = VMExits::createCiConstantObject(constant.as_object()->get_oop(), CHECK_0); - } - } - break; - case T_DOUBLE: - constant_object = VMExits::createCiConstantDouble(constant.as_double(), CHECK_0); - break; - case T_FLOAT: - constant_object = VMExits::createCiConstantFloat(constant.as_float(), CHECK_0); - break; - case T_LONG: - constant_object = VMExits::createCiConstant(CiKind::Long(), constant.as_long(), CHECK_0); - break; - case T_INT: - constant_object = VMExits::createCiConstant(CiKind::Int(), constant.as_int(), CHECK_0); - break; - case T_SHORT: - constant_object = VMExits::createCiConstant(CiKind::Short(), constant.as_int(), CHECK_0); - break; - case T_CHAR: - constant_object = VMExits::createCiConstant(CiKind::Char(), constant.as_int(), CHECK_0); - break; - case T_BYTE: - constant_object = VMExits::createCiConstant(CiKind::Byte(), constant.as_int(), CHECK_0); - break; - case T_BOOLEAN: - constant_object = VMExits::createCiConstant(CiKind::Boolean(), constant.as_int(), CHECK_0); - break; - default: - constant.print(); - fatal("Unhandled constant"); - break; + Handle field_handle = GraalCompiler::get_RiField(offset, flags.as_int(), name, holder, type, code, THREAD); + + oop constant_object = NULL; + // Check to see if the field is constant. + if (!holder_klass.is_null() && holder_klass->is_initialized() && flags.is_final() && flags.is_static()) { + // This field just may be constant. The only cases where it will + // not be constant are: + // + // 1. The field holds a non-perm-space oop. The field is, strictly + // speaking, constant but we cannot embed non-perm-space oops into + // generated code. For the time being we need to consider the + // field to be not constant. + // 2. The field is a *special* static&final field whose value + // may change. The three examples are java.lang.System.in, + // java.lang.System.out, and java.lang.System.err. + + bool ok = true; + assert( SystemDictionary::System_klass() != NULL, "Check once per vm"); + if( holder_klass->as_klassOop() == SystemDictionary::System_klass() ) { + // Check offsets for case 2: System.in, System.out, or System.err + if( offset == java_lang_System::in_offset_in_bytes() || + offset == java_lang_System::out_offset_in_bytes() || + offset == java_lang_System::err_offset_in_bytes() ) { + ok = false; + } } - if (constant_object != NULL) { - HotSpotField::set_constant(field_handle, constant_object); + + if (ok) { + Handle mirror = holder_klass->java_mirror(); + switch(basic_type) { + case T_OBJECT: + case T_ARRAY: + constant_object = VMExits::createCiConstantObject(mirror->obj_field(offset), CHECK_0); + break; + case T_DOUBLE: + constant_object = VMExits::createCiConstantDouble(mirror->double_field(offset), CHECK_0); + break; + case T_FLOAT: + constant_object = VMExits::createCiConstantFloat(mirror->float_field(offset), CHECK_0); + break; + case T_LONG: + constant_object = VMExits::createCiConstant(CiKind::Long(), mirror->long_field(offset), CHECK_0); + break; + case T_INT: + constant_object = VMExits::createCiConstant(CiKind::Int(), mirror->int_field(offset), CHECK_0); + break; + case T_SHORT: + constant_object = VMExits::createCiConstant(CiKind::Short(), mirror->short_field(offset), CHECK_0); + break; + case T_CHAR: + constant_object = VMExits::createCiConstant(CiKind::Char(), mirror->char_field(offset), CHECK_0); + break; + case T_BYTE: + constant_object = VMExits::createCiConstant(CiKind::Byte(), mirror->byte_field(offset), CHECK_0); + break; + case T_BOOLEAN: + constant_object = VMExits::createCiConstant(CiKind::Boolean(), mirror->bool_field(offset), CHECK_0); + break; + default: + fatal("Unhandled constant"); + break; + } } } + if (constant_object != NULL) { + HotSpotField::set_constant(field_handle, constant_object); + } return JNIHandles::make_local(THREAD, field_handle()); }