jdk-sandbox: comparison hotspot/src/share/vm/classfile/classFileParser.cpp

equal deleted inserted replaced

-:693c6b883b54
+:8c1e3dd5fe1b
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/constantPoolOop.hpp"
 #include "oops/instanceKlass.hpp"
+#include "oops/instanceMirrorKlass.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/klassOop.hpp"
 #include "oops/klassVtable.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/symbol.hpp"
 }
 return annotations;
 }
-static void initialize_static_field(fieldDescriptor* fd, TRAPS) {
-KlassHandle h_k (THREAD, fd->field_holder());
-assert(h_k.not_null() && fd->is_static(), "just checking");
-if (fd->has_initial_value()) {
-BasicType t = fd->field_type();
-switch (t) {
-case T_BYTE:
-h_k()->byte_field_put(fd->offset(), fd->int_initial_value());
-break;
-case T_BOOLEAN:
-h_k()->bool_field_put(fd->offset(), fd->int_initial_value());
-break;
-case T_CHAR:
-h_k()->char_field_put(fd->offset(), fd->int_initial_value());
-break;
-case T_SHORT:
-h_k()->short_field_put(fd->offset(), fd->int_initial_value());
-break;
-case T_INT:
-h_k()->int_field_put(fd->offset(), fd->int_initial_value());
-break;
-case T_FLOAT:
-h_k()->float_field_put(fd->offset(), fd->float_initial_value());
-break;
-case T_DOUBLE:
-h_k()->double_field_put(fd->offset(), fd->double_initial_value());
-break;
-case T_LONG:
-h_k()->long_field_put(fd->offset(), fd->long_initial_value());
-break;
-case T_OBJECT:
-{
-#ifdef ASSERT
-TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);
-assert(fd->signature() == sym, "just checking");
-#endif
-oop string = fd->string_initial_value(CHECK);
-h_k()->obj_field_put(fd->offset(), string);
-}
-break;
-default:
-THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
-"Illegal ConstantValue attribute in class file");
-}
-}
-}
 void ClassFileParser::java_lang_ref_Reference_fix_pre(typeArrayHandle* fields_ptr,
 constantPoolHandle cp, FieldAllocationCount *fac_ptr, TRAPS) {
 // This code is for compatibility with earlier jdk's that do not
 // have the "discovered" field in java.lang.ref.Reference.  For 1.5
 // the check for the "discovered" field should issue a warning if
 }
 return;
 }
-void ClassFileParser::java_lang_Class_fix_pre(objArrayHandle* methods_ptr,
+void ClassFileParser::java_lang_Class_fix_pre(int* nonstatic_field_size,
-FieldAllocationCount *fac_ptr, TRAPS) {
+FieldAllocationCount *fac_ptr) {
 // Add fake fields for java.lang.Class instances
 //
 // This is not particularly nice. We should consider adding a
 // private transient object field at the Java level to
 // java.lang.Class. Alternatively we could add a subclass of
 // nonstatic oop fields were added at the Java level. The offsets
 // of these fake fields can't change between these two JDK
 // versions because when the offsets are computed at bootstrap
 // time we don't know yet which version of the JDK we're running in.
-// The values below are fake but will force two non-static oop fields and
+// The values below are fake but will force three non-static oop fields and
 // a corresponding non-static oop map block to be allocated.
 const int extra = java_lang_Class::number_of_fake_oop_fields;
 fac_ptr->nonstatic_oop_count += extra;
+// Reserve some leading space for fake ints
+*nonstatic_field_size += align_size_up(java_lang_Class::hc_number_of_fake_int_fields * BytesPerInt, heapOopSize) / heapOopSize;
 }
 void ClassFileParser::java_lang_Class_fix_post(int* next_nonstatic_oop_offset_ptr) {
 // Cause the extra fake fields in java.lang.Class to show up before
 int first_nonstatic_oop_offset;
 int first_nonstatic_field_offset;
 int next_nonstatic_field_offset;
 // Calculate the starting byte offsets
-next_static_oop_offset      = (instanceKlass::header_size() +
+next_static_oop_offset      = instanceMirrorKlass::offset_of_static_fields();
-align_object_offset(vtable_size) +
-align_object_offset(itable_size)) * wordSize;
 next_static_double_offset   = next_static_oop_offset +
 (fac.static_oop_count * heapOopSize);
 if ( fac.static_double_count &&
 (Universe::field_type_should_be_aligned(T_DOUBLE) ||
 Universe::field_type_should_be_aligned(T_LONG)) ) {
 (fac.static_short_count * BytesPerShort);
 next_static_type_offset     = align_size_up((next_static_byte_offset +
 fac.static_byte_count ), wordSize );
 static_field_size           = (next_static_type_offset -
 next_static_oop_offset) / wordSize;
+// Add fake fields for java.lang.Class instances (also see below)
+if (class_name == vmSymbols::java_lang_Class() && class_loader.is_null()) {
+java_lang_Class_fix_pre(&nonstatic_field_size, &fac);
+}
 first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
 nonstatic_field_size * heapOopSize;
 next_nonstatic_field_offset = first_nonstatic_field_offset;
-// Add fake fields for java.lang.Class instances (also see below)
-if (class_name == vmSymbols::java_lang_Class() && class_loader.is_null()) {
-java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
-}
 // adjust the vmentry field declaration in java.lang.invoke.MethodHandle
 if (EnableMethodHandles && class_name == vmSymbols::java_lang_invoke_MethodHandle() && class_loader.is_null()) {
 java_lang_invoke_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
 }
 } else {
 rt = super_klass->reference_type();
 }
 // We can now create the basic klassOop for this klass
-klassOop ik = oopFactory::new_instanceKlass(vtable_size, itable_size,
+klassOop ik = oopFactory::new_instanceKlass(name, vtable_size, itable_size,
 static_field_size,
 total_oop_map_count,
 rt, CHECK_(nullHandle));
 instanceKlassHandle this_klass (THREAD, ik);
 // Not yet: supers are done below to support the new subtype-checking fields
 //this_klass->set_super(super_klass());
 this_klass->set_class_loader(class_loader());
 this_klass->set_nonstatic_field_size(nonstatic_field_size);
 this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
-this_klass->set_static_oop_field_size(fac.static_oop_count);
+this_klass->set_static_oop_field_count(fac.static_oop_count);
 cp->set_pool_holder(this_klass());
 error_handler.set_in_error(false);   // turn off error handler for cp
 this_klass->set_constants(cp());
 this_klass->set_local_interfaces(local_interfaces());
 this_klass->set_fields(fields());
 parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle));
 // Make sure this is the end of class file stream
 guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
-// Initialize static fields
-this_klass->do_local_static_fields(&initialize_static_field, CHECK_(nullHandle));
 // VerifyOops believes that once this has been set, the object is completely loaded.
 // Compute transitive closure of interfaces this class implements
 this_klass->set_transitive_interfaces(transitive_interfaces());
 // Fill in information needed to compute superclasses.
 // check that if this class is an interface then it doesn't have static methods
 if (this_klass->is_interface()) {
 check_illegal_static_method(this_klass, CHECK_(nullHandle));
 }
+// Allocate mirror and initialize static fields
+java_lang_Class::create_mirror(this_klass, CHECK_(nullHandle));
 ClassLoadingService::notify_class_loaded(instanceKlass::cast(this_klass()),
 false /* not shared class */);
 if (TraceClassLoading) {

changeset 8725	8c1e3dd5fe1b
parent 8676	9098d4e927e1
child 8883	5569135acca3