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

equal deleted inserted replaced

-:104ff83451f1
+:50da9e5eb858
 #define JAVA_7_VERSION                    51
 // Extension method support.
 #define JAVA_8_VERSION                    52
+void ClassFileParser::parse_constant_pool_entries(int length, TRAPS) {
-void ClassFileParser::parse_constant_pool_entries(ClassLoaderData* loader_data, constantPoolHandle cp, int length, TRAPS) {
 // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
 // this function (_current can be allocated in a register, with scalar
 // replacement of aggregates). The _current pointer is copied back to
 // stream() when this function returns. DON'T call another method within
 // this method that uses stream().
 ClassFileStream* cfs = &cfs1;
 #ifdef ASSERT
 assert(cfs->allocated_on_stack(),"should be local");
 u1* old_current = cfs0->current();
 #endif
-Handle class_loader(THREAD, loader_data->class_loader());
+Handle class_loader(THREAD, _loader_data->class_loader());
 // Used for batching symbol allocations.
 const char* names[SymbolTable::symbol_alloc_batch_size];
 int lengths[SymbolTable::symbol_alloc_batch_size];
 int indices[SymbolTable::symbol_alloc_batch_size];
 switch (tag) {
 case JVM_CONSTANT_Class :
 {
 cfs->guarantee_more(3, CHECK);  // name_index, tag/access_flags
 u2 name_index = cfs->get_u2_fast();
-cp->klass_index_at_put(index, name_index);
+_cp->klass_index_at_put(index, name_index);
 }
 break;
 case JVM_CONSTANT_Fieldref :
 {
 cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 u2 class_index = cfs->get_u2_fast();
 u2 name_and_type_index = cfs->get_u2_fast();
-cp->field_at_put(index, class_index, name_and_type_index);
+_cp->field_at_put(index, class_index, name_and_type_index);
 }
 break;
 case JVM_CONSTANT_Methodref :
 {
 cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 u2 class_index = cfs->get_u2_fast();
 u2 name_and_type_index = cfs->get_u2_fast();
-cp->method_at_put(index, class_index, name_and_type_index);
+_cp->method_at_put(index, class_index, name_and_type_index);
 }
 break;
 case JVM_CONSTANT_InterfaceMethodref :
 {
 cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 u2 class_index = cfs->get_u2_fast();
 u2 name_and_type_index = cfs->get_u2_fast();
-cp->interface_method_at_put(index, class_index, name_and_type_index);
+_cp->interface_method_at_put(index, class_index, name_and_type_index);
 }
 break;
 case JVM_CONSTANT_String :
 {
 cfs->guarantee_more(3, CHECK);  // string_index, tag/access_flags
 u2 string_index = cfs->get_u2_fast();
-cp->string_index_at_put(index, string_index);
+_cp->string_index_at_put(index, string_index);
 }
 break;
 case JVM_CONSTANT_MethodHandle :
 case JVM_CONSTANT_MethodType :
 if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
 }
 if (tag == JVM_CONSTANT_MethodHandle) {
 cfs->guarantee_more(4, CHECK);  // ref_kind, method_index, tag/access_flags
 u1 ref_kind = cfs->get_u1_fast();
 u2 method_index = cfs->get_u2_fast();
-cp->method_handle_index_at_put(index, ref_kind, method_index);
+_cp->method_handle_index_at_put(index, ref_kind, method_index);
 } else if (tag == JVM_CONSTANT_MethodType) {
 cfs->guarantee_more(3, CHECK);  // signature_index, tag/access_flags
 u2 signature_index = cfs->get_u2_fast();
-cp->method_type_index_at_put(index, signature_index);
+_cp->method_type_index_at_put(index, signature_index);
 } else {
 ShouldNotReachHere();
 }
 break;
 case JVM_CONSTANT_InvokeDynamic :
 cfs->guarantee_more(5, CHECK);  // bsm_index, nt, tag/access_flags
 u2 bootstrap_specifier_index = cfs->get_u2_fast();
 u2 name_and_type_index = cfs->get_u2_fast();
 if (_max_bootstrap_specifier_index < (int) bootstrap_specifier_index)
 _max_bootstrap_specifier_index = (int) bootstrap_specifier_index;  // collect for later
-cp->invoke_dynamic_at_put(index, bootstrap_specifier_index, name_and_type_index);
+_cp->invoke_dynamic_at_put(index, bootstrap_specifier_index, name_and_type_index);
 }
 break;
 case JVM_CONSTANT_Integer :
 {
 cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags
 u4 bytes = cfs->get_u4_fast();
-cp->int_at_put(index, (jint) bytes);
+_cp->int_at_put(index, (jint) bytes);
 }
 break;
 case JVM_CONSTANT_Float :
 {
 cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags
 u4 bytes = cfs->get_u4_fast();
-cp->float_at_put(index, *(jfloat*)&bytes);
+_cp->float_at_put(index, *(jfloat*)&bytes);
 }
 break;
 case JVM_CONSTANT_Long :
 // A mangled type might cause you to overrun allocated memory
 guarantee_property(index+1 < length,
 "Invalid constant pool entry %u in class file %s",
 index, CHECK);
 {
 cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags
 u8 bytes = cfs->get_u8_fast();
-cp->long_at_put(index, bytes);
+_cp->long_at_put(index, bytes);
 }
 index++;   // Skip entry following eigth-byte constant, see JVM book p. 98
 break;
 case JVM_CONSTANT_Double :
 // A mangled type might cause you to overrun allocated memory
 "Invalid constant pool entry %u in class file %s",
 index, CHECK);
 {
 cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags
 u8 bytes = cfs->get_u8_fast();
-cp->double_at_put(index, *(jdouble*)&bytes);
+_cp->double_at_put(index, *(jdouble*)&bytes);
 }
 index++;   // Skip entry following eigth-byte constant, see JVM book p. 98
 break;
 case JVM_CONSTANT_NameAndType :
 {
 cfs->guarantee_more(5, CHECK);  // name_index, signature_index, tag/access_flags
 u2 name_index = cfs->get_u2_fast();
 u2 signature_index = cfs->get_u2_fast();
-cp->name_and_type_at_put(index, name_index, signature_index);
+_cp->name_and_type_at_put(index, name_index, signature_index);
 }
 break;
 case JVM_CONSTANT_Utf8 :
 {
 cfs->guarantee_more(2, CHECK);  // utf8_length
 names[names_count] = (char*)utf8_buffer;
 lengths[names_count] = utf8_length;
 indices[names_count] = index;
 hashValues[names_count++] = hash;
 if (names_count == SymbolTable::symbol_alloc_batch_size) {
-SymbolTable::new_symbols(loader_data, cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);
 names_count = 0;
 }
 } else {
-cp->symbol_at_put(index, result);
+_cp->symbol_at_put(index, result);
 }
 }
 break;
 default:
 classfile_parse_error(
 }
 }
 // Allocate the remaining symbols
 if (names_count > 0) {
-SymbolTable::new_symbols(loader_data, cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);
 }
 // Copy _current pointer of local copy back to stream().
 #ifdef ASSERT
 assert(cfs0->current() == old_current, "non-exclusive use of stream()");
 #endif
 cfs0->set_current(cfs1.current());
 }
-// This class unreferences constant pool symbols if an error has occurred
-// while parsing the class before it is assigned into the class.
-// If it gets an error after that it is unloaded and the constant pool will
-// be cleaned up then.
-class ConstantPoolCleaner : public StackObj {
-constantPoolHandle _cphandle;
-bool               _in_error;
-public:
-ConstantPoolCleaner(constantPoolHandle cp) : _cphandle(cp), _in_error(true) {}
-~ConstantPoolCleaner() {
-if (_in_error && _cphandle.not_null()) {
-_cphandle->unreference_symbols();
-}
-}
-void set_in_error(bool clean) { _in_error = clean; }
-};
 bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }
 inline Symbol* check_symbol_at(constantPoolHandle cp, int index) {
 if (valid_cp_range(index, cp->length()) && cp->tag_at(index).is_utf8())
 return cp->symbol_at(index);
 else
 return NULL;
 }
-constantPoolHandle ClassFileParser::parse_constant_pool(ClassLoaderData* loader_data, TRAPS) {
+constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
 ClassFileStream* cfs = stream();
 constantPoolHandle nullHandle;
 cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
 u2 length = cfs->get_u2_fast();
 guarantee_property(
 length >= 1, "Illegal constant pool size %u in class file %s",
 length, CHECK_(nullHandle));
-ConstantPool* constant_pool =
+ConstantPool* constant_pool = ConstantPool::allocate(_loader_data, length,
-ConstantPool::allocate(loader_data,
+CHECK_(nullHandle));
-length,
+_cp = constant_pool; // save in case of errors
-CHECK_(nullHandle));
 constantPoolHandle cp (THREAD, constant_pool);
-ConstantPoolCleaner cp_in_error(cp); // set constant pool to be cleaned up.
 // parsing constant pool entries
-parse_constant_pool_entries(loader_data, cp, length, CHECK_(nullHandle));
+parse_constant_pool_entries(length, CHECK_(nullHandle));
 int index = 1;  // declared outside of loops for portability
 // first verification pass - validate cross references and fixup class and string constants
 for (index = 1; index < length; index++) {          // Index 0 is unused
 // fall through
 case JVM_CONSTANT_InterfaceMethodref : {
 if (!_need_verify) break;
 int klass_ref_index = cp->klass_ref_index_at(index);
 int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
-check_property(valid_cp_range(klass_ref_index, length) &&
+check_property(valid_klass_reference_at(klass_ref_index),
-is_klass_reference(cp, klass_ref_index),
 "Invalid constant pool index %u in class file %s",
 klass_ref_index,
 CHECK_(nullHandle));
 check_property(valid_cp_range(name_and_type_ref_index, length) &&
 cp->tag_at(name_and_type_ref_index).is_name_and_type(),
 break;
 case JVM_CONSTANT_NameAndType : {
 if (!_need_verify) break;
 int name_ref_index = cp->name_ref_index_at(index);
 int signature_ref_index = cp->signature_ref_index_at(index);
-check_property(
+check_property(valid_symbol_at(name_ref_index),
-valid_cp_range(name_ref_index, length) &&
+"Invalid constant pool index %u in class file %s",
-cp->tag_at(name_ref_index).is_utf8(),
+name_ref_index, CHECK_(nullHandle));
-"Invalid constant pool index %u in class file %s",
+check_property(valid_symbol_at(signature_ref_index),
-name_ref_index, CHECK_(nullHandle));
+"Invalid constant pool index %u in class file %s",
-check_property(
+signature_ref_index, CHECK_(nullHandle));
-valid_cp_range(signature_ref_index, length) &&
-cp->tag_at(signature_ref_index).is_utf8(),
-"Invalid constant pool index %u in class file %s",
-signature_ref_index, CHECK_(nullHandle));
 break;
 }
 case JVM_CONSTANT_Utf8 :
 break;
 case JVM_CONSTANT_UnresolvedClass :         // fall-through
 ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
 break;
 case JVM_CONSTANT_ClassIndex :
 {
 int class_index = cp->klass_index_at(index);
-check_property(
+check_property(valid_symbol_at(class_index),
-valid_cp_range(class_index, length) &&
+"Invalid constant pool index %u in class file %s",
-cp->tag_at(class_index).is_utf8(),
+class_index, CHECK_(nullHandle));
-"Invalid constant pool index %u in class file %s",
-class_index, CHECK_(nullHandle));
 cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));
 }
 break;
 case JVM_CONSTANT_StringIndex :
 {
 int string_index = cp->string_index_at(index);
-check_property(
+check_property(valid_symbol_at(string_index),
-valid_cp_range(string_index, length) &&
+"Invalid constant pool index %u in class file %s",
-cp->tag_at(string_index).is_utf8(),
+string_index, CHECK_(nullHandle));
-"Invalid constant pool index %u in class file %s",
-string_index, CHECK_(nullHandle));
 Symbol* sym = cp->symbol_at(string_index);
 cp->unresolved_string_at_put(index, sym);
 }
 break;
 case JVM_CONSTANT_MethodHandle :
 }
 break;
 case JVM_CONSTANT_MethodType :
 {
 int ref_index = cp->method_type_index_at(index);
-check_property(
+check_property(valid_symbol_at(ref_index) && EnableInvokeDynamic,
-valid_cp_range(ref_index, length) &&
+"Invalid constant pool index %u in class file %s",
-cp->tag_at(ref_index).is_utf8() &&
+ref_index, CHECK_(nullHandle));
-EnableInvokeDynamic,
-"Invalid constant pool index %u in class file %s",
-ref_index, CHECK_(nullHandle));
 }
 break;
 case JVM_CONSTANT_InvokeDynamic :
 {
 int name_and_type_ref_index = cp->invoke_dynamic_name_and_type_ref_index_at(index);
 }
 }
 }
 if (!_need_verify) {
-cp_in_error.set_in_error(false);
 return cp;
 }
 // second verification pass - checks the strings are of the right format.
 // but not yet to the other entries
 assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");
 }
 }  // end of switch
 }  // end of for
-cp_in_error.set_in_error(false);
 return cp;
 }
 void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS) {
 return true;
 }
-Array<Klass*>* ClassFileParser::parse_interfaces(constantPoolHandle cp,
+Array<Klass*>* ClassFileParser::parse_interfaces(int length,
-int length,
-ClassLoaderData* loader_data,
 Handle protection_domain,
 Symbol* class_name,
 bool* has_default_methods,
 TRAPS) {
-ClassFileStream* cfs = stream();
+if (length == 0) {
-assert(length > 0, "only called for length>0");
+_local_interfaces = Universe::the_empty_klass_array();
-// FIXME: Leak at later OOM.
+} else {
-Array<Klass*>* interfaces = MetadataFactory::new_array<Klass*>(loader_data, length, NULL, CHECK_NULL);
+ClassFileStream* cfs = stream();
+assert(length > 0, "only called for length>0");
-int index;
+_local_interfaces = MetadataFactory::new_array<Klass*>(_loader_data, length, NULL, CHECK_NULL);
-for (index = 0; index < length; index++) {
-u2 interface_index = cfs->get_u2(CHECK_NULL);
+int index;
-KlassHandle interf;
-check_property(
-valid_cp_range(interface_index, cp->length()) &&
-is_klass_reference(cp, interface_index),
-"Interface name has bad constant pool index %u in class file %s",
-interface_index, CHECK_NULL);
-if (cp->tag_at(interface_index).is_klass()) {
-interf = KlassHandle(THREAD, cp->resolved_klass_at(interface_index));
-} else {
-Symbol*  unresolved_klass  = cp->klass_name_at(interface_index);
-// Don't need to check legal name because it's checked when parsing constant pool.
-// But need to make sure it's not an array type.
-guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,
-"Bad interface name in class file %s", CHECK_NULL);
-Handle class_loader(THREAD, loader_data->class_loader());
-// Call resolve_super so classcircularity is checked
-Klass* k = SystemDictionary::resolve_super_or_fail(class_name,
-unresolved_klass, class_loader, protection_domain,
-false, CHECK_NULL);
-interf = KlassHandle(THREAD, k);
-}
-if (!interf()->is_interface()) {
-THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", NULL);
-}
-if (InstanceKlass::cast(interf())->has_default_methods()) {
-*has_default_methods = true;
-}
-interfaces->at_put(index, interf());
-}
-if (!_need_verify || length <= 1) {
-return interfaces;
-}
-// Check if there's any duplicates in interfaces
-ResourceMark rm(THREAD);
-NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(
-THREAD, NameSigHash*, HASH_ROW_SIZE);
-initialize_hashtable(interface_names);
-bool dup = false;
-{
-debug_only(No_Safepoint_Verifier nsv;)
 for (index = 0; index < length; index++) {
-Klass* k = interfaces->at(index);
+u2 interface_index = cfs->get_u2(CHECK_NULL);
-Symbol* name = InstanceKlass::cast(k)->name();
+KlassHandle interf;
-// If no duplicates, add (name, NULL) in hashtable interface_names.
+check_property(
-if (!put_after_lookup(name, NULL, interface_names)) {
+valid_klass_reference_at(interface_index),
-dup = true;
+"Interface name has bad constant pool index %u in class file %s",
-break;
+interface_index, CHECK_NULL);
-}
+if (_cp->tag_at(interface_index).is_klass()) {
-}
+interf = KlassHandle(THREAD, _cp->resolved_klass_at(interface_index));
-}
+} else {
-if (dup) {
+Symbol*  unresolved_klass  = _cp->klass_name_at(interface_index);
-classfile_parse_error("Duplicate interface name in class file %s", CHECK_NULL);
-}
+// Don't need to check legal name because it's checked when parsing constant pool.
+// But need to make sure it's not an array type.
-return interfaces;
+guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,
-}
+"Bad interface name in class file %s", CHECK_NULL);
+Handle class_loader(THREAD, _loader_data->class_loader());
-void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS) {
+// Call resolve_super so classcircularity is checked
+Klass* k = SystemDictionary::resolve_super_or_fail(class_name,
+unresolved_klass, class_loader, protection_domain,
+false, CHECK_NULL);
+interf = KlassHandle(THREAD, k);
+}
+if (!interf()->is_interface()) {
+THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", NULL);
+}
+if (InstanceKlass::cast(interf())->has_default_methods()) {
+*has_default_methods = true;
+}
+_local_interfaces->at_put(index, interf());
+}
+if (!_need_verify || length <= 1) {
+return _local_interfaces;
+}
+// Check if there's any duplicates in interfaces
+ResourceMark rm(THREAD);
+NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(
+THREAD, NameSigHash*, HASH_ROW_SIZE);
+initialize_hashtable(interface_names);
+bool dup = false;
+{
+debug_only(No_Safepoint_Verifier nsv;)
+for (index = 0; index < length; index++) {
+Klass* k = _local_interfaces->at(index);
+Symbol* name = InstanceKlass::cast(k)->name();
+// If no duplicates, add (name, NULL) in hashtable interface_names.
+if (!put_after_lookup(name, NULL, interface_names)) {
+dup = true;
+break;
+}
+}
+}
+if (dup) {
+classfile_parse_error("Duplicate interface name in class file %s", CHECK_NULL);
+}
+}
+return _local_interfaces;
+}
+void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, TRAPS) {
 // Make sure the constant pool entry is of a type appropriate to this field
 guarantee_property(
 (constantvalue_index > 0 &&
-constantvalue_index < cp->length()),
+constantvalue_index < _cp->length()),
 "Bad initial value index %u in ConstantValue attribute in class file %s",
 constantvalue_index, CHECK);
-constantTag value_type = cp->tag_at(constantvalue_index);
+constantTag value_type = _cp->tag_at(constantvalue_index);
-switch ( cp->basic_type_for_signature_at(signature_index) ) {
+switch ( _cp->basic_type_for_signature_at(signature_index) ) {
 case T_LONG:
 guarantee_property(value_type.is_long(), "Inconsistent constant value type in class file %s", CHECK);
 break;
 case T_FLOAT:
 guarantee_property(value_type.is_float(), "Inconsistent constant value type in class file %s", CHECK);
 break;
 case T_BYTE: case T_CHAR: case T_SHORT: case T_BOOLEAN: case T_INT:
 guarantee_property(value_type.is_int(), "Inconsistent constant value type in class file %s", CHECK);
 break;
 case T_OBJECT:
-guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;")
+guarantee_property((_cp->symbol_at(signature_index)->equals("Ljava/lang/String;")
 && value_type.is_string()),
 "Bad string initial value in class file %s", CHECK);
 break;
 default:
 classfile_parse_error(
 }
 }
 // Parse attributes for a field.
-void ClassFileParser::parse_field_attributes(ClassLoaderData* loader_data,
+void ClassFileParser::parse_field_attributes(u2 attributes_count,
-constantPoolHandle cp,
-u2 attributes_count,
 bool is_static, u2 signature_index,
 u2* constantvalue_index_addr,
 bool* is_synthetic_addr,
 u2* generic_signature_index_addr,
-AnnotationArray** field_annotations,
-AnnotationArray** field_type_annotations,
 ClassFileParser::FieldAnnotationCollector* parsed_annotations,
 TRAPS) {
 ClassFileStream* cfs = stream();
 assert(attributes_count > 0, "length should be greater than 0");
 u2 constantvalue_index = 0;
 int runtime_invisible_type_annotations_length = 0;
 while (attributes_count--) {
 cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
 u2 attribute_name_index = cfs->get_u2_fast();
 u4 attribute_length = cfs->get_u4_fast();
-check_property(valid_cp_range(attribute_name_index, cp->length()) &&
+check_property(valid_symbol_at(attribute_name_index),
-cp->tag_at(attribute_name_index).is_utf8(),
 "Invalid field attribute index %u in class file %s",
 attribute_name_index,
 CHECK);
-Symbol* attribute_name = cp->symbol_at(attribute_name_index);
+Symbol* attribute_name = _cp->symbol_at(attribute_name_index);
 if (is_static && attribute_name == vmSymbols::tag_constant_value()) {
 // ignore if non-static
 if (constantvalue_index != 0) {
 classfile_parse_error("Duplicate ConstantValue attribute in class file %s", CHECK);
 }
 attribute_length == 2,
 "Invalid ConstantValue field attribute length %u in class file %s",
 attribute_length, CHECK);
 constantvalue_index = cfs->get_u2(CHECK);
 if (_need_verify) {
-verify_constantvalue(constantvalue_index, signature_index, cp, CHECK);
+verify_constantvalue(constantvalue_index, signature_index, CHECK);
 }
 } else if (attribute_name == vmSymbols::tag_synthetic()) {
 if (attribute_length != 0) {
 classfile_parse_error(
 "Invalid Synthetic field attribute length %u in class file %s",
 generic_signature_index = cfs->get_u2(CHECK);
 } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
 runtime_visible_annotations_length = attribute_length;
 runtime_visible_annotations = cfs->get_u1_buffer();
 assert(runtime_visible_annotations != NULL, "null visible annotations");
-parse_annotations(loader_data,
+parse_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
 runtime_visible_annotations_length,
-cp,
 parsed_annotations,
 CHECK);
 cfs->skip_u1(runtime_visible_annotations_length, CHECK);
 } else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
 runtime_invisible_annotations_length = attribute_length;
 }
 *constantvalue_index_addr = constantvalue_index;
 *is_synthetic_addr = is_synthetic;
 *generic_signature_index_addr = generic_signature_index;
-*field_annotations = assemble_annotations(loader_data,
+AnnotationArray* a = assemble_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
 runtime_visible_annotations_length,
 runtime_invisible_annotations,
 runtime_invisible_annotations_length,
 CHECK);
-*field_type_annotations = assemble_annotations(loader_data,
+parsed_annotations->set_field_annotations(a);
-runtime_visible_type_annotations,
+a = assemble_annotations(runtime_visible_type_annotations,
 runtime_visible_type_annotations_length,
 runtime_invisible_type_annotations,
 runtime_invisible_type_annotations_length,
 CHECK);
+parsed_annotations->set_field_type_annotations(a);
 return;
 }
 // Field allocation types. Used for computing field offsets.
 count[atype]++;
 return atype;
 }
 };
-Array<u2>* ClassFileParser::parse_fields(ClassLoaderData* loader_data,
+Array<u2>* ClassFileParser::parse_fields(Symbol* class_name,
-Symbol* class_name,
-constantPoolHandle cp,
 bool is_interface,
 FieldAllocationCount *fac,
-Array<AnnotationArray*>** fields_annotations,
-Array<AnnotationArray*>** fields_type_annotations,
 u2* java_fields_count_ptr, TRAPS) {
 ClassFileStream* cfs = stream();
 cfs->guarantee_more(2, CHECK_NULL);  // length
 u2 length = cfs->get_u2_fast();
 *java_fields_count_ptr = length;
 // array and any unused slots will be discarded.
 ResourceMark rm(THREAD);
 u2* fa = NEW_RESOURCE_ARRAY_IN_THREAD(
 THREAD, u2, total_fields * (FieldInfo::field_slots + 1));
-AnnotationArray* field_annotations = NULL;
-AnnotationArray* field_type_annotations = NULL;
 // The generic signature slots start after all other fields' data.
 int generic_signature_slot = total_fields * FieldInfo::field_slots;
 int num_generic_signature = 0;
 for (int n = 0; n < length; n++) {
 cfs->guarantee_more(8, CHECK_NULL);  // access_flags, name_index, descriptor_index, attributes_count
 jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
 verify_legal_field_modifiers(flags, is_interface, CHECK_NULL);
 access_flags.set_flags(flags);
 u2 name_index = cfs->get_u2_fast();
-int cp_size = cp->length();
+int cp_size = _cp->length();
-check_property(
+check_property(valid_symbol_at(name_index),
-valid_cp_range(name_index, cp_size) && cp->tag_at(name_index).is_utf8(),
 "Invalid constant pool index %u for field name in class file %s",
-name_index, CHECK_NULL);
+name_index,
-Symbol*  name = cp->symbol_at(name_index);
+CHECK_NULL);
+Symbol*  name = _cp->symbol_at(name_index);
 verify_legal_field_name(name, CHECK_NULL);
 u2 signature_index = cfs->get_u2_fast();
-check_property(
+check_property(valid_symbol_at(signature_index),
-valid_cp_range(signature_index, cp_size) &&
-cp->tag_at(signature_index).is_utf8(),
 "Invalid constant pool index %u for field signature in class file %s",
 signature_index, CHECK_NULL);
-Symbol*  sig = cp->symbol_at(signature_index);
+Symbol*  sig = _cp->symbol_at(signature_index);
 verify_legal_field_signature(name, sig, CHECK_NULL);
 u2 constantvalue_index = 0;
 bool is_synthetic = false;
 u2 generic_signature_index = 0;
 bool is_static = access_flags.is_static();
-FieldAnnotationCollector parsed_annotations;
+FieldAnnotationCollector parsed_annotations(_loader_data);
 u2 attributes_count = cfs->get_u2_fast();
 if (attributes_count > 0) {
-parse_field_attributes(loader_data,
+parse_field_attributes(attributes_count, is_static, signature_index,
-cp, attributes_count, is_static, signature_index,
 &constantvalue_index, &is_synthetic,
-&generic_signature_index, &field_annotations,
+&generic_signature_index, &parsed_annotations,
-&field_type_annotations, &parsed_annotations,
 CHECK_NULL);
-if (field_annotations != NULL) {
+if (parsed_annotations.field_annotations() != NULL) {
-if (*fields_annotations == NULL) {
+if (_fields_annotations == NULL) {
-*fields_annotations = MetadataFactory::new_array<AnnotationArray*>(
+_fields_annotations = MetadataFactory::new_array<AnnotationArray*>(
-loader_data, length, NULL,
+_loader_data, length, NULL,
 CHECK_NULL);
 }
-(*fields_annotations)->at_put(n, field_annotations);
+_fields_annotations->at_put(n, parsed_annotations.field_annotations());
-}
+parsed_annotations.set_field_annotations(NULL);
-if (field_type_annotations != NULL) {
+}
-if (*fields_type_annotations == NULL) {
+if (parsed_annotations.field_type_annotations() != NULL) {
-*fields_type_annotations = MetadataFactory::new_array<AnnotationArray*>(
+if (_fields_type_annotations == NULL) {
-loader_data, length, NULL,
+_fields_type_annotations = MetadataFactory::new_array<AnnotationArray*>(
+_loader_data, length, NULL,
 CHECK_NULL);
 }
-(*fields_type_annotations)->at_put(n, field_type_annotations);
+_fields_type_annotations->at_put(n, parsed_annotations.field_type_annotations());
-}
+parsed_annotations.set_field_type_annotations(NULL);
+}
 if (is_synthetic) {
 access_flags.set_is_synthetic();
 }
 if (generic_signature_index != 0) {
 access_flags.set_field_has_generic_signature();
 FieldInfo* field = FieldInfo::from_field_array(fa, n);
 field->initialize(access_flags.as_short(),
 name_index,
 signature_index,
 constantvalue_index);
-BasicType type = cp->basic_type_for_signature_at(signature_index);
+BasicType type = _cp->basic_type_for_signature_at(signature_index);
 // Remember how many oops we encountered and compute allocation type
 FieldAllocationType atype = fac->update(is_static, type);
 field->set_allocation_type(atype);
 Symbol* name      = injected[n].name();
 Symbol* signature = injected[n].signature();
 bool duplicate = false;
 for (int i = 0; i < length; i++) {
 FieldInfo* f = FieldInfo::from_field_array(fa, i);
-if (name      == cp->symbol_at(f->name_index()) &&
+if (name      == _cp->symbol_at(f->name_index()) &&
-signature == cp->symbol_at(f->signature_index())) {
+signature == _cp->symbol_at(f->signature_index())) {
 // Symbol is desclared in Java so skip this one
 duplicate = true;
 break;
 }
 }
 // Sometimes injected fields already exist in the Java source so
 // the fields array could be too long.  In that case the
 // fields array is trimed. Also unused slots that were reserved
 // for generic signature indexes are discarded.
 Array<u2>* fields = MetadataFactory::new_array<u2>(
-loader_data, index * FieldInfo::field_slots + num_generic_signature,
+_loader_data, index * FieldInfo::field_slots + num_generic_signature,
 CHECK_NULL);
+_fields = fields; // save in case of error
 {
 int i = 0;
 for (; i < index * FieldInfo::field_slots; i++) {
 fields->at_put(i, fa[i]);
 }
 THREAD, NameSigHash*, HASH_ROW_SIZE);
 initialize_hashtable(names_and_sigs);
 bool dup = false;
 {
 debug_only(No_Safepoint_Verifier nsv;)
-for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
+for (AllFieldStream fs(fields, _cp); !fs.done(); fs.next()) {
 Symbol* name = fs.name();
 Symbol* sig = fs.signature();
 // If no duplicates, add name/signature in hashtable names_and_sigs.
 if (!put_after_lookup(name, sig, names_and_sigs)) {
 dup = true;
 *dest++ = Bytes::get_Java_u2((u1*) (src++));
 }
 }
-u2* ClassFileParser::parse_exception_table(ClassLoaderData* loader_data,
+u2* ClassFileParser::parse_exception_table(u4 code_length,
-u4 code_length,
 u4 exception_table_length,
-constantPoolHandle cp,
 TRAPS) {
 ClassFileStream* cfs = stream();
 u2* exception_table_start = cfs->get_u2_buffer();
 assert(exception_table_start != NULL, "null exception table");
 CHECK_NULL);
 guarantee_property(handler_pc < code_length,
 "Illegal exception table handler in class file %s",
 CHECK_NULL);
 if (catch_type_index != 0) {
-guarantee_property(valid_cp_range(catch_type_index, cp->length()) &&
+guarantee_property(valid_klass_reference_at(catch_type_index),
-is_klass_reference(cp, catch_type_index),
 "Catch type in exception table has bad constant type in class file %s", CHECK_NULL);
 }
 }
 } else {
 cfs->skip_u2_fast(exception_table_length * 4);
 // Function is used to parse both attributes:
 //       LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)
 u2* ClassFileParser::parse_localvariable_table(u4 code_length,
 u2 max_locals,
 u4 code_attribute_length,
-constantPoolHandle cp,
 u2* localvariable_table_length,
 bool isLVTT,
 TRAPS) {
 ClassFileStream* cfs = stream();
 const char * tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable";
 if (end_pc > code_length) {
 classfile_parse_error(
 "Invalid length %u in %s in class file %s",
 length, tbl_name, CHECK_NULL);
 }
-int cp_size = cp->length();
+int cp_size = _cp->length();
-guarantee_property(
+guarantee_property(valid_symbol_at(name_index),
-valid_cp_range(name_index, cp_size) &&
-cp->tag_at(name_index).is_utf8(),
 "Name index %u in %s has bad constant type in class file %s",
 name_index, tbl_name, CHECK_NULL);
-guarantee_property(
+guarantee_property(valid_symbol_at(descriptor_index),
-valid_cp_range(descriptor_index, cp_size) &&
-cp->tag_at(descriptor_index).is_utf8(),
 "Signature index %u in %s has bad constant type in class file %s",
 descriptor_index, tbl_name, CHECK_NULL);
-Symbol*  name = cp->symbol_at(name_index);
+Symbol*  name = _cp->symbol_at(name_index);
-Symbol*  sig = cp->symbol_at(descriptor_index);
+Symbol*  sig = _cp->symbol_at(descriptor_index);
 verify_legal_field_name(name, CHECK_NULL);
 u2 extra_slot = 0;
 if (!isLVTT) {
 verify_legal_field_signature(name, sig, CHECK_NULL);
 return localvariable_table_start;
 }
 void ClassFileParser::parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
-u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS) {
+u1* u1_array, u2* u2_array, TRAPS) {
 ClassFileStream* cfs = stream();
 u2 index = 0; // index in the array with long/double occupying two slots
 u4 i1 = *u1_index;
 u4 i2 = *u2_index + 1;
 for(int i = 0; i < array_length; i++) {
 index++;
 if (tag == ITEM_Long || tag == ITEM_Double) {
 index++;
 } else if (tag == ITEM_Object) {
 u2 class_index = u2_array[i2++] = cfs->get_u2(CHECK);
-guarantee_property(valid_cp_range(class_index, cp->length()) &&
+guarantee_property(valid_klass_reference_at(class_index),
-is_klass_reference(cp, class_index),
 "Bad class index %u in StackMap in class file %s",
 class_index, CHECK);
 } else if (tag == ITEM_Uninitialized) {
 u2 offset = u2_array[i2++] = cfs->get_u2(CHECK);
 guarantee_property(
 u2_array[*u2_index] = index;
 *u1_index = i1;
 *u2_index = i2;
 }
-Array<u1>* ClassFileParser::parse_stackmap_table(
+u1* ClassFileParser::parse_stackmap_table(
-ClassLoaderData* loader_data,
 u4 code_attribute_length, TRAPS) {
 if (code_attribute_length == 0)
 return NULL;
 ClassFileStream* cfs = stream();
 stream()->skip_u1(code_attribute_length, CHECK_NULL);
 if (!_need_verify && !DumpSharedSpaces) {
 return NULL;
 }
+return stackmap_table_start;
-Array<u1>* stackmap_data =
-MetadataFactory::new_array<u1>(loader_data, code_attribute_length, 0, CHECK_NULL);
-memcpy((void*)stackmap_data->adr_at(0),
-(void*)stackmap_table_start, code_attribute_length);
-return stackmap_data;
 }
 u2* ClassFileParser::parse_checked_exceptions(u2* checked_exceptions_length,
 u4 method_attribute_length,
-constantPoolHandle cp, TRAPS) {
+TRAPS) {
 ClassFileStream* cfs = stream();
 cfs->guarantee_more(2, CHECK_NULL);  // checked_exceptions_length
 *checked_exceptions_length = cfs->get_u2_fast();
 unsigned int size = (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2);
 u2* checked_exceptions_start = cfs->get_u2_buffer();
 u2 len = *checked_exceptions_length;
 cfs->guarantee_more(2 * len, CHECK_NULL);
 for (int i = 0; i < len; i++) {
 checked_exception = cfs->get_u2_fast();
 check_property(
-valid_cp_range(checked_exception, cp->length()) &&
+valid_klass_reference_at(checked_exception),
-is_klass_reference(cp, checked_exception),
 "Exception name has bad type at constant pool %u in class file %s",
 checked_exception, CHECK_NULL);
 }
 }
 // check exceptions attribute length
 }
 return index;
 }
 // Sift through annotations, looking for those significant to the VM:
-void ClassFileParser::parse_annotations(ClassLoaderData* loader_data,
+void ClassFileParser::parse_annotations(u1* buffer, int limit,
-u1* buffer, int limit,
-constantPoolHandle cp,
 ClassFileParser::AnnotationCollector* coll,
 TRAPS) {
 // annotations := do(nann:u2) {annotation}
 int index = 0;
 if ((index += 2) >= limit)  return;  // read nann
 int index0 = index;
 index = skip_annotation(buffer, limit, index);
 u1* abase = buffer + index0;
 int atype = Bytes::get_Java_u2(abase + atype_off);
 int count = Bytes::get_Java_u2(abase + count_off);
-Symbol* aname = check_symbol_at(cp, atype);
+Symbol* aname = check_symbol_at(_cp, atype);
 if (aname == NULL)  break;  // invalid annotation name
 Symbol* member = NULL;
 if (count >= 1) {
 int member_index = Bytes::get_Java_u2(abase + member_off);
-member = check_symbol_at(cp, member_index);
+member = check_symbol_at(_cp, member_index);
 if (member == NULL)  break;  // invalid member name
 }
 // Here is where parsing particular annotations will take place.
-AnnotationCollector::ID id = coll->annotation_index(loader_data, aname);
+AnnotationCollector::ID id = coll->annotation_index(_loader_data, aname);
 if (id == AnnotationCollector::_unknown)  continue;
 coll->set_annotation(id);
 if (id == AnnotationCollector::_sun_misc_Contended) {
 if (count == 1
 void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) {
 if (is_contended())
 f->set_contended_group(contended_group());
 }
+ClassFileParser::FieldAnnotationCollector::~FieldAnnotationCollector() {
+// If there's an error deallocate metadata for field annotations
+MetadataFactory::free_array<u1>(_loader_data, _field_annotations);
+MetadataFactory::free_array<u1>(_loader_data, _field_type_annotations);
+}
 void ClassFileParser::MethodAnnotationCollector::apply_to(methodHandle m) {
 if (has_annotation(_method_ForceInline))
 m->set_force_inline(true);
 if (has_annotation(_method_DontInline))
 m->set_dont_inline(true);
 // If no duplicates, add LVT elem in hashtable lvt_Hash.
 if (LVT_put_after_lookup(lvt, lvt_Hash) == false
 && _need_verify
 && _major_version >= JAVA_1_5_VERSION) {
 clear_hashtable(lvt_Hash);
-ConstantPool* cp = cm->constants();
 classfile_parse_error("Duplicated LocalVariableTable attribute "
 "entry for '%s' in class file %s",
-cp->symbol_at(lvt->name_cp_index)->as_utf8(),
+_cp->symbol_at(lvt->name_cp_index)->as_utf8(),
 CHECK);
 }
 }
 }
 int index = hash(&lvtt_elem);
 LVT_Hash* entry = LVT_lookup(&lvtt_elem, index, lvt_Hash);
 if (entry == NULL) {
 if (_need_verify) {
 clear_hashtable(lvt_Hash);
-ConstantPool* cp = cm->constants();
 classfile_parse_error("LVTT entry for '%s' in class file %s "
 "does not match any LVT entry",
-cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
+_cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
 CHECK);
 }
 } else if (entry->_elem->signature_cp_index != 0 && _need_verify) {
 clear_hashtable(lvt_Hash);
-ConstantPool* cp = cm->constants();
 classfile_parse_error("Duplicated LocalVariableTypeTable attribute "
 "entry for '%s' in class file %s",
-cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
+_cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
 CHECK);
 } else {
 // to add generic signatures into LocalVariableTable
 entry->_elem->signature_cp_index = lvtt_elem.descriptor_cp_index;
 }
 }
 clear_hashtable(lvt_Hash);
 }
-void ClassFileParser::copy_method_annotations(ClassLoaderData* loader_data,
+void ClassFileParser::copy_method_annotations(ConstMethod* cm,
-ConstMethod* cm,
 u1* runtime_visible_annotations,
 int runtime_visible_annotations_length,
 u1* runtime_invisible_annotations,
 int runtime_invisible_annotations_length,
 u1* runtime_visible_parameter_annotations,
 AnnotationArray* a;
 if (runtime_visible_annotations_length +
 runtime_invisible_annotations_length > 0) {
-a = assemble_annotations(loader_data,
+a = assemble_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
 runtime_visible_annotations_length,
 runtime_invisible_annotations,
 runtime_invisible_annotations_length,
 CHECK);
 cm->set_method_annotations(a);
 }
 if (runtime_visible_parameter_annotations_length +
 runtime_invisible_parameter_annotations_length > 0) {
-a = assemble_annotations(loader_data,
+a = assemble_annotations(runtime_visible_parameter_annotations,
-runtime_visible_parameter_annotations,
 runtime_visible_parameter_annotations_length,
 runtime_invisible_parameter_annotations,
 runtime_invisible_parameter_annotations_length,
 CHECK);
 cm->set_parameter_annotations(a);
 }
 if (annotation_default_length > 0) {
-a = assemble_annotations(loader_data,
+a = assemble_annotations(annotation_default,
-annotation_default,
 annotation_default_length,
 NULL,
 0,
 CHECK);
 cm->set_default_annotations(a);
 }
 if (runtime_visible_type_annotations_length +
 runtime_invisible_type_annotations_length > 0) {
-a = assemble_annotations(loader_data,
+a = assemble_annotations(runtime_visible_type_annotations,
-runtime_visible_type_annotations,
 runtime_visible_type_annotations_length,
 runtime_invisible_type_annotations,
 runtime_invisible_type_annotations_length,
 CHECK);
 cm->set_type_annotations(a);
 //
 // The promoted_flags parameter is used to pass relevant access_flags
 // from the method back up to the containing klass. These flag values
 // are added to klass's access_flags.
-methodHandle ClassFileParser::parse_method(ClassLoaderData* loader_data,
+methodHandle ClassFileParser::parse_method(bool is_interface,
-constantPoolHandle cp,
-bool is_interface,
 AccessFlags *promoted_flags,
 TRAPS) {
 ClassFileStream* cfs = stream();
 methodHandle nullHandle;
 ResourceMark rm(THREAD);
 // Parse fixed parts
 cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
 int flags = cfs->get_u2_fast();
 u2 name_index = cfs->get_u2_fast();
-int cp_size = cp->length();
+int cp_size = _cp->length();
 check_property(
-valid_cp_range(name_index, cp_size) &&
+valid_symbol_at(name_index),
-cp->tag_at(name_index).is_utf8(),
 "Illegal constant pool index %u for method name in class file %s",
 name_index, CHECK_(nullHandle));
-Symbol*  name = cp->symbol_at(name_index);
+Symbol*  name = _cp->symbol_at(name_index);
 verify_legal_method_name(name, CHECK_(nullHandle));
 u2 signature_index = cfs->get_u2_fast();
 guarantee_property(
-valid_cp_range(signature_index, cp_size) &&
+valid_symbol_at(signature_index),
-cp->tag_at(signature_index).is_utf8(),
 "Illegal constant pool index %u for method signature in class file %s",
 signature_index, CHECK_(nullHandle));
-Symbol*  signature = cp->symbol_at(signature_index);
+Symbol*  signature = _cp->symbol_at(signature_index);
 AccessFlags access_flags;
 if (name == vmSymbols::class_initializer_name()) {
 // We ignore the other access flags for a valid class initializer.
 // (JVM Spec 2nd ed., chapter 4.6)
 bool method_parameters_four_byte_flags;
 bool parsed_code_attribute = false;
 bool parsed_checked_exceptions_attribute = false;
 bool parsed_stackmap_attribute = false;
 // stackmap attribute - JDK1.5
-Array<u1>* stackmap_data = NULL;
+u1* stackmap_data = NULL;
+int stackmap_data_length = 0;
 u2 generic_signature_index = 0;
 MethodAnnotationCollector parsed_annotations;
 u1* runtime_visible_annotations = NULL;
 int runtime_visible_annotations_length = 0;
 u1* runtime_invisible_annotations = NULL;
 while (method_attributes_count--) {
 cfs->guarantee_more(6, CHECK_(nullHandle));  // method_attribute_name_index, method_attribute_length
 u2 method_attribute_name_index = cfs->get_u2_fast();
 u4 method_attribute_length = cfs->get_u4_fast();
 check_property(
-valid_cp_range(method_attribute_name_index, cp_size) &&
+valid_symbol_at(method_attribute_name_index),
-cp->tag_at(method_attribute_name_index).is_utf8(),
 "Invalid method attribute name index %u in class file %s",
 method_attribute_name_index, CHECK_(nullHandle));
-Symbol* method_attribute_name = cp->symbol_at(method_attribute_name_index);
+Symbol* method_attribute_name = _cp->symbol_at(method_attribute_name_index);
 if (method_attribute_name == vmSymbols::tag_code()) {
 // Parse Code attribute
 if (_need_verify) {
 guarantee_property(
 !access_flags.is_native() && !access_flags.is_abstract(),
 // Exception handler table
 cfs->guarantee_more(2, CHECK_(nullHandle));  // exception_table_length
 exception_table_length = cfs->get_u2_fast();
 if (exception_table_length > 0) {
 exception_table_start =
-parse_exception_table(loader_data, code_length, exception_table_length, cp, CHECK_(nullHandle));
+parse_exception_table(code_length, exception_table_length, CHECK_(nullHandle));
 }
 // Parse additional attributes in code attribute
 cfs->guarantee_more(2, CHECK_(nullHandle));  // code_attributes_count
 u2 code_attributes_count = cfs->get_u2_fast();
 u2 code_attribute_name_index = cfs->get_u2_fast();
 u4 code_attribute_length = cfs->get_u4_fast();
 calculated_attribute_length += code_attribute_length +
 sizeof(code_attribute_name_index) +
 sizeof(code_attribute_length);
-check_property(valid_cp_range(code_attribute_name_index, cp_size) &&
+check_property(valid_symbol_at(code_attribute_name_index),
-cp->tag_at(code_attribute_name_index).is_utf8(),
 "Invalid code attribute name index %u in class file %s",
 code_attribute_name_index,
 CHECK_(nullHandle));
 if (LoadLineNumberTables &&
-cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {
+_cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {
 // Parse and compress line number table
 parse_linenumber_table(code_attribute_length, code_length,
 &linenumber_table, CHECK_(nullHandle));
 } else if (LoadLocalVariableTables &&
-cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {
+_cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {
 // Parse local variable table
 if (!lvt_allocated) {
 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
 THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
 }
 localvariable_table_start[lvt_cnt] =
 parse_localvariable_table(code_length,
 max_locals,
 code_attribute_length,
-cp,
 &localvariable_table_length[lvt_cnt],
 false,    // is not LVTT
 CHECK_(nullHandle));
 total_lvt_length += localvariable_table_length[lvt_cnt];
 lvt_cnt++;
 } else if (LoadLocalVariableTypeTables &&
 _major_version >= JAVA_1_5_VERSION &&
-cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {
+_cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {
 if (!lvt_allocated) {
 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
 THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
 THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
 }
 localvariable_type_table_start[lvtt_cnt] =
 parse_localvariable_table(code_length,
 max_locals,
 code_attribute_length,
-cp,
 &localvariable_type_table_length[lvtt_cnt],
 true,     // is LVTT
 CHECK_(nullHandle));
 lvtt_cnt++;
 } else if (UseSplitVerifier &&
 _major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION &&
-cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {
+_cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {
 // Stack map is only needed by the new verifier in JDK1.5.
 if (parsed_stackmap_attribute) {
 classfile_parse_error("Multiple StackMapTable attributes in class file %s", CHECK_(nullHandle));
 }
-stackmap_data = parse_stackmap_table(loader_data, code_attribute_length, CHECK_(nullHandle));
+stackmap_data = parse_stackmap_table(code_attribute_length, CHECK_(nullHandle));
+stackmap_data_length = code_attribute_length;
 parsed_stackmap_attribute = true;
 } else {
 // Skip unknown attributes
 cfs->skip_u1(code_attribute_length, CHECK_(nullHandle));
 }
 }
 parsed_checked_exceptions_attribute = true;
 checked_exceptions_start =
 parse_checked_exceptions(&checked_exceptions_length,
 method_attribute_length,
-cp, CHECK_(nullHandle));
+CHECK_(nullHandle));
 } else if (method_attribute_name == vmSymbols::tag_method_parameters()) {
 // reject multiple method parameters
 if (method_parameters_seen) {
 classfile_parse_error("Multiple MethodParameters attributes in class file %s", CHECK_(nullHandle));
 }
 generic_signature_index = cfs->get_u2_fast();
 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
 runtime_visible_annotations_length = method_attribute_length;
 runtime_visible_annotations = cfs->get_u1_buffer();
 assert(runtime_visible_annotations != NULL, "null visible annotations");
-parse_annotations(loader_data,
+parse_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
+runtime_visible_annotations_length, &parsed_annotations,
-runtime_visible_annotations_length, cp, &parsed_annotations,
 CHECK_(nullHandle));
 cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle));
 } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
 runtime_invisible_annotations_length = method_attribute_length;
 runtime_invisible_annotations = cfs->get_u1_buffer();
 runtime_invisible_type_annotations_length,
 annotation_default_length,
 0);
 Method* m = Method::allocate(
-loader_data, code_length, access_flags, &sizes,
+_loader_data, code_length, access_flags, &sizes,
 ConstMethod::NORMAL, CHECK_(nullHandle));
 ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);
 // Fill in information from fixed part (access_flags already set)
-m->set_constants(cp());
+m->set_constants(_cp);
 m->set_name_index(name_index);
 m->set_signature_index(signature_index);
 #ifdef CC_INTERP
 // hmm is there a gc issue here??
-ResultTypeFinder rtf(cp->symbol_at(signature_index));
+ResultTypeFinder rtf(_cp->symbol_at(signature_index));
 m->set_result_index(rtf.type());
 #endif
 if (args_size >= 0) {
 m->set_size_of_parameters(args_size);
 #endif
 // Fill in code attribute information
 m->set_max_stack(max_stack);
 m->set_max_locals(max_locals);
-m->constMethod()->set_stackmap_data(stackmap_data);
+if (stackmap_data != NULL) {
+m->constMethod()->copy_stackmap_data(_loader_data, stackmap_data,
+stackmap_data_length, CHECK_NULL);
+}
 // Copy byte codes
 m->set_code(code_start);
 // Copy line number table
 if (parsed_annotations.has_any_annotations())
 parsed_annotations.apply_to(m);
 // Copy annotations
-copy_method_annotations(loader_data, m->constMethod(),
+copy_method_annotations(m->constMethod(),
 runtime_visible_annotations,
 runtime_visible_annotations_length,
 runtime_invisible_annotations,
 runtime_invisible_annotations_length,
 runtime_visible_parameter_annotations,
 // The promoted_flags parameter is used to pass relevant access_flags
 // from the methods back up to the containing klass. These flag values
 // are added to klass's access_flags.
-Array<Method*>* ClassFileParser::parse_methods(ClassLoaderData* loader_data,
+Array<Method*>* ClassFileParser::parse_methods(bool is_interface,
-constantPoolHandle cp,
-bool is_interface,
 AccessFlags* promoted_flags,
 bool* has_final_method,
 bool* has_default_methods,
 TRAPS) {
 ClassFileStream* cfs = stream();
 cfs->guarantee_more(2, CHECK_NULL);  // length
 u2 length = cfs->get_u2_fast();
 if (length == 0) {
-return Universe::the_empty_method_array();
+_methods = Universe::the_empty_method_array();
 } else {
-// FIXME: Handle leaks at later failures.
+_methods = MetadataFactory::new_array<Method*>(_loader_data, length, NULL, CHECK_NULL);
-Array<Method*>* methods = MetadataFactory::new_array<Method*>(loader_data, length, NULL, CHECK_NULL);
 HandleMark hm(THREAD);
 for (int index = 0; index < length; index++) {
-methodHandle method = parse_method(loader_data,
+methodHandle method = parse_method(is_interface,
-cp, is_interface,
 promoted_flags,
 CHECK_NULL);
 if (method->is_final()) {
 *has_final_method = true;
 }
 if (is_interface && !method->is_abstract() && !method->is_static()) {
 // default method
 *has_default_methods = true;
 }
-methods->at_put(index, method());
+_methods->at_put(index, method());
 }
 if (_need_verify && length > 1) {
 // Check duplicated methods
 ResourceMark rm(THREAD);
 initialize_hashtable(names_and_sigs);
 bool dup = false;
 {
 debug_only(No_Safepoint_Verifier nsv;)
 for (int i = 0; i < length; i++) {
-Method* m = methods->at(i);
+Method* m = _methods->at(i);
 // If no duplicates, add name/signature in hashtable names_and_sigs.
 if (!put_after_lookup(m->name(), m->signature(), names_and_sigs)) {
 dup = true;
 break;
 }
 if (dup) {
 classfile_parse_error("Duplicate method name&signature in class file %s",
 CHECK_NULL);
 }
 }
-return methods;
+}
-}
+return _methods;
 }
-Array<int>* ClassFileParser::sort_methods(ClassLoaderData* loader_data,
+intArray* ClassFileParser::sort_methods(Array<Method*>* methods) {
-Array<Method*>* methods,
-TRAPS) {
 int length = methods->length();
 // If JVMTI original method ordering or sharing is enabled we have to
 // remember the original class file ordering.
 // We temporarily use the vtable_index field in the Method* to store the
 // class file index, so we can read in after calling qsort.
 }
 // Sort method array by ascending method name (for faster lookups & vtable construction)
 // Note that the ordering is not alphabetical, see Symbol::fast_compare
 Method::sort_methods(methods);
+intArray* method_ordering = NULL;
 // If JVMTI original method ordering or sharing is enabled construct int
 // array remembering the original ordering
 if (JvmtiExport::can_maintain_original_method_order() || DumpSharedSpaces) {
-Array<int>* method_ordering = MetadataFactory::new_array<int>(loader_data, length, CHECK_NULL);
+method_ordering = new intArray(length);
 for (int index = 0; index < length; index++) {
 Method* m = methods->at(index);
 int old_index = m->vtable_index();
 assert(old_index >= 0 && old_index < length, "invalid method index");
 method_ordering->at_put(index, old_index);
 m->set_vtable_index(Method::invalid_vtable_index);
 }
-return method_ordering;
+}
-} else {
+return method_ordering;
-return Universe::the_empty_int_array();
+}
-}
-}
+void ClassFileParser::parse_classfile_sourcefile_attribute(TRAPS) {
-void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS) {
 ClassFileStream* cfs = stream();
 cfs->guarantee_more(2, CHECK);  // sourcefile_index
 u2 sourcefile_index = cfs->get_u2_fast();
 check_property(
-valid_cp_range(sourcefile_index, cp->length()) &&
+valid_symbol_at(sourcefile_index),
-cp->tag_at(sourcefile_index).is_utf8(),
 "Invalid SourceFile attribute at constant pool index %u in class file %s",
 sourcefile_index, CHECK);
-set_class_sourcefile(cp->symbol_at(sourcefile_index));
+set_class_sourcefile(_cp->symbol_at(sourcefile_index));
 }
-void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
+void ClassFileParser::parse_classfile_source_debug_extension_attribute(int length, TRAPS) {
-int length, TRAPS) {
 ClassFileStream* cfs = stream();
 u1* sde_buffer = cfs->get_u1_buffer();
 assert(sde_buffer != NULL, "null sde buffer");
 // Don't bother storing it if there is no way to retrieve it
 // Inner classes can be static, private or protected (classic VM does this)
 #define RECOGNIZED_INNER_CLASS_MODIFIERS (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED | JVM_ACC_STATIC)
 // Return number of classes in the inner classes attribute table
-u2 ClassFileParser::parse_classfile_inner_classes_attribute(ClassLoaderData* loader_data,
+u2 ClassFileParser::parse_classfile_inner_classes_attribute(u1* inner_classes_attribute_start,
-u1* inner_classes_attribute_start,
 bool parsed_enclosingmethod_attribute,
 u2 enclosing_method_class_index,
 u2 enclosing_method_method_index,
-constantPoolHandle cp,
 TRAPS) {
 ClassFileStream* cfs = stream();
 u1* current_mark = cfs->current();
 u2 length = 0;
 if (inner_classes_attribute_start != NULL) {
 //    inner_class_access_flags,
 //    ...
 //    enclosing_method_class_index,
 //    enclosing_method_method_index]
 int size = length * 4 + (parsed_enclosingmethod_attribute ? 2 : 0);
-// FIXME: Will leak on exceptions.
+Array<u2>* inner_classes = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0);
-Array<u2>* inner_classes = MetadataFactory::new_array<u2>(loader_data, size, CHECK_0);
+_inner_classes = inner_classes;
 int index = 0;
-int cp_size = cp->length();
+int cp_size = _cp->length();
 cfs->guarantee_more(8 * length, CHECK_0);  // 4-tuples of u2
 for (int n = 0; n < length; n++) {
 // Inner class index
 u2 inner_class_info_index = cfs->get_u2_fast();
 check_property(
 inner_class_info_index == 0 ||
-(valid_cp_range(inner_class_info_index, cp_size) &&
+valid_klass_reference_at(inner_class_info_index),
-is_klass_reference(cp, inner_class_info_index)),
 "inner_class_info_index %u has bad constant type in class file %s",
 inner_class_info_index, CHECK_0);
 // Outer class index
 u2 outer_class_info_index = cfs->get_u2_fast();
 check_property(
 outer_class_info_index == 0 ||
-(valid_cp_range(outer_class_info_index, cp_size) &&
+valid_klass_reference_at(outer_class_info_index),
-is_klass_reference(cp, outer_class_info_index)),
 "outer_class_info_index %u has bad constant type in class file %s",
 outer_class_info_index, CHECK_0);
 // Inner class name
 u2 inner_name_index = cfs->get_u2_fast();
 check_property(
-inner_name_index == 0 || (valid_cp_range(inner_name_index, cp_size) &&
+inner_name_index == 0 || valid_symbol_at(inner_name_index),
-cp->tag_at(inner_name_index).is_utf8()),
 "inner_name_index %u has bad constant type in class file %s",
 inner_name_index, CHECK_0);
 if (_need_verify) {
 guarantee_property(inner_class_info_index != outer_class_info_index,
 "Class is both outer and inner class in class file %s", CHECK_0);
 inner_classes->at_put(index++, enclosing_method_class_index);
 inner_classes->at_put(index++, enclosing_method_method_index);
 }
 assert(index == size, "wrong size");
-// Update InstanceKlass with inner class info.
-set_class_inner_classes(inner_classes);
 // Restore buffer's current position.
 cfs->set_current(current_mark);
 return length;
 }
-void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS) {
+void ClassFileParser::parse_classfile_synthetic_attribute(TRAPS) {
 set_class_synthetic_flag(true);
 }
-void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS) {
+void ClassFileParser::parse_classfile_signature_attribute(TRAPS) {
 ClassFileStream* cfs = stream();
 u2 signature_index = cfs->get_u2(CHECK);
 check_property(
-valid_cp_range(signature_index, cp->length()) &&
+valid_symbol_at(signature_index),
-cp->tag_at(signature_index).is_utf8(),
 "Invalid constant pool index %u in Signature attribute in class file %s",
 signature_index, CHECK);
-set_class_generic_signature(cp->symbol_at(signature_index));
+set_class_generic_signature(_cp->symbol_at(signature_index));
 }
-void ClassFileParser::parse_classfile_bootstrap_methods_attribute(ClassLoaderData* loader_data,
+void ClassFileParser::parse_classfile_bootstrap_methods_attribute(u4 attribute_byte_length, TRAPS) {
-constantPoolHandle cp,
-u4 attribute_byte_length, TRAPS) {
 ClassFileStream* cfs = stream();
 u1* current_start = cfs->current();
 cfs->guarantee_more(2, CHECK);  // length
 int attribute_array_length = cfs->get_u2_fast();
 // The attribute is copied into a short[] array.
 // The array begins with a series of short[2] pairs, one for each tuple.
 int index_size = (attribute_array_length * 2);
-Array<u2>* operands = MetadataFactory::new_array<u2>(loader_data, index_size + operand_count, CHECK);
+Array<u2>* operands = MetadataFactory::new_array<u2>(_loader_data, index_size + operand_count, CHECK);
+// Eagerly assign operands so they will be deallocated with the constant
+// pool if there is an error.
+_cp->set_operands(operands);
 int operand_fill_index = index_size;
-int cp_size = cp->length();
+int cp_size = _cp->length();
 for (int n = 0; n < attribute_array_length; n++) {
 // Store a 32-bit offset into the header of the operand array.
 ConstantPool::operand_offset_at_put(operands, n, operand_fill_index);
 cfs->guarantee_more(sizeof(u2) * 2, CHECK);  // bsm, argc
 u2 bootstrap_method_index = cfs->get_u2_fast();
 u2 argument_count = cfs->get_u2_fast();
 check_property(
 valid_cp_range(bootstrap_method_index, cp_size) &&
-cp->tag_at(bootstrap_method_index).is_method_handle(),
+_cp->tag_at(bootstrap_method_index).is_method_handle(),
 "bootstrap_method_index %u has bad constant type in class file %s",
 bootstrap_method_index,
 CHECK);
 operands->at_put(operand_fill_index++, bootstrap_method_index);
 operands->at_put(operand_fill_index++, argument_count);
 cfs->guarantee_more(sizeof(u2) * argument_count, CHECK);  // argv[argc]
 for (int j = 0; j < argument_count; j++) {
 u2 argument_index = cfs->get_u2_fast();
 check_property(
 valid_cp_range(argument_index, cp_size) &&
-cp->tag_at(argument_index).is_loadable_constant(),
+_cp->tag_at(argument_index).is_loadable_constant(),
 "argument_index %u has bad constant type in class file %s",
 argument_index,
 CHECK);
 operands->at_put(operand_fill_index++, argument_index);
 }
 u1* current_end = cfs->current();
 guarantee_property(current_end == current_start + attribute_byte_length,
 "Bad length on BootstrapMethods in class file %s",
 CHECK);
+}
-cp->set_operands(operands);
-}
+void ClassFileParser::parse_classfile_attributes(ClassFileParser::ClassAnnotationCollector* parsed_annotations,
-void ClassFileParser::parse_classfile_attributes(ClassLoaderData* loader_data,
-constantPoolHandle cp,
-ClassFileParser::ClassAnnotationCollector* parsed_annotations,
 TRAPS) {
 ClassFileStream* cfs = stream();
 // Set inner classes attribute to default sentinel
-set_class_inner_classes(Universe::the_empty_short_array());
+_inner_classes = Universe::the_empty_short_array();
 cfs->guarantee_more(2, CHECK);  // attributes_count
 u2 attributes_count = cfs->get_u2_fast();
 bool parsed_sourcefile_attribute = false;
 bool parsed_innerclasses_attribute = false;
 bool parsed_enclosingmethod_attribute = false;
 while (attributes_count--) {
 cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
 u2 attribute_name_index = cfs->get_u2_fast();
 u4 attribute_length = cfs->get_u4_fast();
 check_property(
-valid_cp_range(attribute_name_index, cp->length()) &&
+valid_symbol_at(attribute_name_index),
-cp->tag_at(attribute_name_index).is_utf8(),
 "Attribute name has bad constant pool index %u in class file %s",
 attribute_name_index, CHECK);
-Symbol* tag = cp->symbol_at(attribute_name_index);
+Symbol* tag = _cp->symbol_at(attribute_name_index);
 if (tag == vmSymbols::tag_source_file()) {
 // Check for SourceFile tag
 if (_need_verify) {
 guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
 }
 if (parsed_sourcefile_attribute) {
 classfile_parse_error("Multiple SourceFile attributes in class file %s", CHECK);
 } else {
 parsed_sourcefile_attribute = true;
 }
-parse_classfile_sourcefile_attribute(cp, CHECK);
+parse_classfile_sourcefile_attribute(CHECK);
 } else if (tag == vmSymbols::tag_source_debug_extension()) {
 // Check for SourceDebugExtension tag
-parse_classfile_source_debug_extension_attribute(cp, (int)attribute_length, CHECK);
+parse_classfile_source_debug_extension_attribute((int)attribute_length, CHECK);
 } else if (tag == vmSymbols::tag_inner_classes()) {
 // Check for InnerClasses tag
 if (parsed_innerclasses_attribute) {
 classfile_parse_error("Multiple InnerClasses attributes in class file %s", CHECK);
 } else {
 if (attribute_length != 0) {
 classfile_parse_error(
 "Invalid Synthetic classfile attribute length %u in class file %s",
 attribute_length, CHECK);
 }
-parse_classfile_synthetic_attribute(cp, CHECK);
+parse_classfile_synthetic_attribute(CHECK);
 } else if (tag == vmSymbols::tag_deprecated()) {
 // Check for Deprecatd tag - 4276120
 if (attribute_length != 0) {
 classfile_parse_error(
 "Invalid Deprecated classfile attribute length %u in class file %s",
 if (attribute_length != 2) {
 classfile_parse_error(
 "Wrong Signature attribute length %u in class file %s",
 attribute_length, CHECK);
 }
-parse_classfile_signature_attribute(cp, CHECK);
+parse_classfile_signature_attribute(CHECK);
 } else if (tag == vmSymbols::tag_runtime_visible_annotations()) {
 runtime_visible_annotations_length = attribute_length;
 runtime_visible_annotations = cfs->get_u1_buffer();
 assert(runtime_visible_annotations != NULL, "null visible annotations");
-parse_annotations(loader_data,
+parse_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
 runtime_visible_annotations_length,
-cp,
 parsed_annotations,
 CHECK);
 cfs->skip_u1(runtime_visible_annotations_length, CHECK);
 } else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_annotations()) {
 runtime_invisible_annotations_length = attribute_length;
 enclosing_method_method_index = cfs->get_u2_fast();
 if (enclosing_method_class_index == 0) {
 classfile_parse_error("Invalid class index in EnclosingMethod attribute in class file %s", CHECK);
 }
 // Validate the constant pool indices and types
-if (!cp->is_within_bounds(enclosing_method_class_index) ||
+check_property(valid_klass_reference_at(enclosing_method_class_index),
-!is_klass_reference(cp, enclosing_method_class_index)) {
+"Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK);
-classfile_parse_error("Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK);
-}
 if (enclosing_method_method_index != 0 &&
-(!cp->is_within_bounds(enclosing_method_method_index) ||
+(!_cp->is_within_bounds(enclosing_method_method_index) ||
-!cp->tag_at(enclosing_method_method_index).is_name_and_type())) {
+!_cp->tag_at(enclosing_method_method_index).is_name_and_type())) {
 classfile_parse_error("Invalid or out-of-bounds method index in EnclosingMethod attribute in class file %s", CHECK);
 }
 } else if (tag == vmSymbols::tag_bootstrap_methods() &&
 _major_version >= Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
 if (parsed_bootstrap_methods_attribute)
 classfile_parse_error("Multiple BootstrapMethods attributes in class file %s", CHECK);
 parsed_bootstrap_methods_attribute = true;
-parse_classfile_bootstrap_methods_attribute(loader_data, cp, attribute_length, CHECK);
+parse_classfile_bootstrap_methods_attribute(attribute_length, CHECK);
 } else if (tag == vmSymbols::tag_runtime_visible_type_annotations()) {
 runtime_visible_type_annotations_length = attribute_length;
 runtime_visible_type_annotations = cfs->get_u1_buffer();
 assert(runtime_visible_type_annotations != NULL, "null visible type annotations");
 // No need for the VM to parse Type annotations
 } else {
 // Unknown attribute
 cfs->skip_u1(attribute_length, CHECK);
 }
 }
-AnnotationArray* annotations = assemble_annotations(loader_data,
+_annotations = assemble_annotations(runtime_visible_annotations,
-runtime_visible_annotations,
+runtime_visible_annotations_length,
-runtime_visible_annotations_length,
+runtime_invisible_annotations,
-runtime_invisible_annotations,
+runtime_invisible_annotations_length,
-runtime_invisible_annotations_length,
+CHECK);
-CHECK);
+_type_annotations = assemble_annotations(runtime_visible_type_annotations,
-set_class_annotations(annotations);
+runtime_visible_type_annotations_length,
-AnnotationArray* type_annotations = assemble_annotations(loader_data,
+runtime_invisible_type_annotations,
-runtime_visible_type_annotations,
+runtime_invisible_type_annotations_length,
-runtime_visible_type_annotations_length,
+CHECK);
-runtime_invisible_type_annotations,
-runtime_invisible_type_annotations_length,
-CHECK);
-set_class_type_annotations(type_annotations);
 if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) {
 u2 num_of_classes = parse_classfile_inner_classes_attribute(
-loader_data,
 inner_classes_attribute_start,
 parsed_innerclasses_attribute,
 enclosing_method_class_index,
 enclosing_method_method_index,
-cp, CHECK);
+CHECK);
 if (parsed_innerclasses_attribute &&_need_verify && _major_version >= JAVA_1_5_VERSION) {
 guarantee_property(
 inner_classes_attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes,
 "Wrong InnerClasses attribute length in class file %s", CHECK);
 }
 k->set_generic_signature(_generic_signature);
 }
 if (_sde_buffer != NULL) {
 k->set_source_debug_extension(_sde_buffer, _sde_length);
 }
-k->set_inner_classes(_inner_classes);
+}
-}
+// Transfer ownership of metadata allocated to the InstanceKlass.
-AnnotationArray* ClassFileParser::assemble_annotations(ClassLoaderData* loader_data,
+void ClassFileParser::apply_parsed_class_metadata(
-u1* runtime_visible_annotations,
+instanceKlassHandle this_klass,
+int java_fields_count, TRAPS) {
+// Assign annotations if needed
+if (_annotations != NULL || _type_annotations != NULL ||
+_fields_annotations != NULL || _fields_type_annotations != NULL) {
+Annotations* annotations = Annotations::allocate(_loader_data, CHECK);
+annotations->set_class_annotations(_annotations);
+annotations->set_class_type_annotations(_type_annotations);
+annotations->set_fields_annotations(_fields_annotations);
+annotations->set_fields_type_annotations(_fields_type_annotations);
+this_klass->set_annotations(annotations);
+}
+_cp->set_pool_holder(this_klass());
+this_klass->set_constants(_cp);
+this_klass->set_fields(_fields, java_fields_count);
+this_klass->set_methods(_methods);
+this_klass->set_inner_classes(_inner_classes);
+this_klass->set_local_interfaces(_local_interfaces);
+this_klass->set_transitive_interfaces(_transitive_interfaces);
+// Clear out these fields so they don't get deallocated by the destructor
+clear_class_metadata();
+}
+AnnotationArray* ClassFileParser::assemble_annotations(u1* runtime_visible_annotations,
 int runtime_visible_annotations_length,
 u1* runtime_invisible_annotations,
 int runtime_invisible_annotations_length, TRAPS) {
 AnnotationArray* annotations = NULL;
 if (runtime_visible_annotations != NULL ||
 runtime_invisible_annotations != NULL) {
-annotations = MetadataFactory::new_array<u1>(loader_data,
+annotations = MetadataFactory::new_array<u1>(_loader_data,
 runtime_visible_annotations_length +
 runtime_invisible_annotations_length,
 CHECK_(annotations));
 if (runtime_visible_annotations != NULL) {
 for (int i = 0; i < runtime_visible_annotations_length; i++) {
 method_spec->print_on(tty);
 }
 }
 }
 #endif // ndef PRODUCT
+instanceKlassHandle ClassFileParser::parse_super_class(int super_class_index,
+TRAPS) {
+instanceKlassHandle super_klass;
+if (super_class_index == 0) {
+check_property(_class_name == vmSymbols::java_lang_Object(),
+"Invalid superclass index %u in class file %s",
+super_class_index,
+CHECK_NULL);
+} else {
+check_property(valid_klass_reference_at(super_class_index),
+"Invalid superclass index %u in class file %s",
+super_class_index,
+CHECK_NULL);
+// The class name should be legal because it is checked when parsing constant pool.
+// However, make sure it is not an array type.
+bool is_array = false;
+if (_cp->tag_at(super_class_index).is_klass()) {
+super_klass = instanceKlassHandle(THREAD, _cp->resolved_klass_at(super_class_index));
+if (_need_verify)
+is_array = super_klass->oop_is_array();
+} else if (_need_verify) {
+is_array = (_cp->unresolved_klass_at(super_class_index)->byte_at(0) == JVM_SIGNATURE_ARRAY);
+}
+if (_need_verify) {
+guarantee_property(!is_array,
+"Bad superclass name in class file %s", CHECK_NULL);
+}
+}
+return super_klass;
+}
+// Values needed for oopmap and InstanceKlass creation
+class FieldLayoutInfo : public StackObj {
+public:
+int*          nonstatic_oop_offsets;
+unsigned int* nonstatic_oop_counts;
+unsigned int  nonstatic_oop_map_count;
+unsigned int  total_oop_map_count;
+int           instance_size;
+int           nonstatic_field_size;
+int           static_field_size;
+bool          has_nonstatic_fields;
+};
+// Layout fields and fill in FieldLayoutInfo.  Could use more refactoring!
+void ClassFileParser::layout_fields(Handle class_loader,
+FieldAllocationCount* fac,
+ClassAnnotationCollector* parsed_annotations,
+FieldLayoutInfo* info,
+TRAPS) {
+// get the padding width from the option
+// TODO: Ask VM about specific CPU we are running on
+int pad_size = ContendedPaddingWidth;
+// Field size and offset computation
+int nonstatic_field_size = _super_klass() == NULL ? 0 : _super_klass()->nonstatic_field_size();
+#ifndef PRODUCT
+int orig_nonstatic_field_size = 0;
+#endif
+int next_static_oop_offset;
+int next_static_double_offset;
+int next_static_word_offset;
+int next_static_short_offset;
+int next_static_byte_offset;
+int next_nonstatic_oop_offset;
+int next_nonstatic_double_offset;
+int next_nonstatic_word_offset;
+int next_nonstatic_short_offset;
+int next_nonstatic_byte_offset;
+int next_nonstatic_type_offset;
+int first_nonstatic_oop_offset;
+int first_nonstatic_field_offset;
+int next_nonstatic_field_offset;
+int next_nonstatic_padded_offset;
+// Count the contended fields by type.
+int nonstatic_contended_count = 0;
+FieldAllocationCount fac_contended;
+for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
+FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
+if (fs.is_contended()) {
+fac_contended.count[atype]++;
+if (!fs.access_flags().is_static()) {
+nonstatic_contended_count++;
+}
+}
+}
+int contended_count = nonstatic_contended_count;
+// Calculate the starting byte offsets
+next_static_oop_offset      = InstanceMirrorKlass::offset_of_static_fields();
+next_static_double_offset   = next_static_oop_offset +
+((fac->count[STATIC_OOP]) * heapOopSize);
+if ( fac->count[STATIC_DOUBLE] &&
+(Universe::field_type_should_be_aligned(T_DOUBLE) ||
+Universe::field_type_should_be_aligned(T_LONG)) ) {
+next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong);
+}
+next_static_word_offset     = next_static_double_offset +
+((fac->count[STATIC_DOUBLE]) * BytesPerLong);
+next_static_short_offset    = next_static_word_offset +
+((fac->count[STATIC_WORD]) * BytesPerInt);
+next_static_byte_offset     = next_static_short_offset +
+((fac->count[STATIC_SHORT]) * BytesPerShort);
+first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
+nonstatic_field_size * heapOopSize;
+// class is contended, pad before all the fields
+if (parsed_annotations->is_contended()) {
+first_nonstatic_field_offset += pad_size;
+}
+next_nonstatic_field_offset = first_nonstatic_field_offset;
+unsigned int nonstatic_double_count = fac->count[NONSTATIC_DOUBLE] - fac_contended.count[NONSTATIC_DOUBLE];
+unsigned int nonstatic_word_count   = fac->count[NONSTATIC_WORD]   - fac_contended.count[NONSTATIC_WORD];
+unsigned int nonstatic_short_count  = fac->count[NONSTATIC_SHORT]  - fac_contended.count[NONSTATIC_SHORT];
+unsigned int nonstatic_byte_count   = fac->count[NONSTATIC_BYTE]   - fac_contended.count[NONSTATIC_BYTE];
+unsigned int nonstatic_oop_count    = fac->count[NONSTATIC_OOP]    - fac_contended.count[NONSTATIC_OOP];
+bool super_has_nonstatic_fields =
+(_super_klass() != NULL && _super_klass->has_nonstatic_fields());
+bool has_nonstatic_fields = super_has_nonstatic_fields ||
+((nonstatic_double_count + nonstatic_word_count +
+nonstatic_short_count + nonstatic_byte_count +
+nonstatic_oop_count) != 0);
+// Prepare list of oops for oop map generation.
+int* nonstatic_oop_offsets;
+unsigned int* nonstatic_oop_counts;
+unsigned int nonstatic_oop_map_count = 0;
+nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
+THREAD, int, nonstatic_oop_count + 1);
+nonstatic_oop_counts  = NEW_RESOURCE_ARRAY_IN_THREAD(
+THREAD, unsigned int, nonstatic_oop_count + 1);
+first_nonstatic_oop_offset = 0; // will be set for first oop field
+#ifndef PRODUCT
+if( PrintCompactFieldsSavings ) {
+next_nonstatic_double_offset = next_nonstatic_field_offset +
+(nonstatic_oop_count * heapOopSize);
+if ( nonstatic_double_count > 0 ) {
+next_nonstatic_double_offset = align_size_up(next_nonstatic_double_offset, BytesPerLong);
+}
+next_nonstatic_word_offset  = next_nonstatic_double_offset +
+(nonstatic_double_count * BytesPerLong);
+next_nonstatic_short_offset = next_nonstatic_word_offset +
+(nonstatic_word_count * BytesPerInt);
+next_nonstatic_byte_offset  = next_nonstatic_short_offset +
+(nonstatic_short_count * BytesPerShort);
+next_nonstatic_type_offset  = align_size_up((next_nonstatic_byte_offset +
+nonstatic_byte_count ), heapOopSize );
+orig_nonstatic_field_size   = nonstatic_field_size +
+((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
+}
+#endif
+bool compact_fields   = CompactFields;
+int  allocation_style = FieldsAllocationStyle;
+if( allocation_style < 0 || allocation_style > 2 ) { // Out of range?
+assert(false, "0 <= FieldsAllocationStyle <= 2");
+allocation_style = 1; // Optimistic
+}
+// The next classes have predefined hard-coded fields offsets
+// (see in JavaClasses::compute_hard_coded_offsets()).
+// Use default fields allocation order for them.
+if( (allocation_style != 0 || compact_fields ) && class_loader.is_null() &&
+(_class_name == vmSymbols::java_lang_AssertionStatusDirectives() ||
+_class_name == vmSymbols::java_lang_Class() ||
+_class_name == vmSymbols::java_lang_ClassLoader() ||
+_class_name == vmSymbols::java_lang_ref_Reference() ||
+_class_name == vmSymbols::java_lang_ref_SoftReference() ||
+_class_name == vmSymbols::java_lang_StackTraceElement() ||
+_class_name == vmSymbols::java_lang_String() ||
+_class_name == vmSymbols::java_lang_Throwable() ||
+_class_name == vmSymbols::java_lang_Boolean() ||
+_class_name == vmSymbols::java_lang_Character() ||
+_class_name == vmSymbols::java_lang_Float() ||
+_class_name == vmSymbols::java_lang_Double() ||
+_class_name == vmSymbols::java_lang_Byte() ||
+_class_name == vmSymbols::java_lang_Short() ||
+_class_name == vmSymbols::java_lang_Integer() ||
+_class_name == vmSymbols::java_lang_Long())) {
+allocation_style = 0;     // Allocate oops first
+compact_fields   = false; // Don't compact fields
+}
+if( allocation_style == 0 ) {
+// Fields order: oops, longs/doubles, ints, shorts/chars, bytes, padded fields
+next_nonstatic_oop_offset    = next_nonstatic_field_offset;
+next_nonstatic_double_offset = next_nonstatic_oop_offset +
+(nonstatic_oop_count * heapOopSize);
+} else if( allocation_style == 1 ) {
+// Fields order: longs/doubles, ints, shorts/chars, bytes, oops, padded fields
+next_nonstatic_double_offset = next_nonstatic_field_offset;
+} else if( allocation_style == 2 ) {
+// Fields allocation: oops fields in super and sub classes are together.
+if( nonstatic_field_size > 0 && _super_klass() != NULL &&
+_super_klass->nonstatic_oop_map_size() > 0 ) {
+unsigned int map_count = _super_klass->nonstatic_oop_map_count();
+OopMapBlock* first_map = _super_klass->start_of_nonstatic_oop_maps();
+OopMapBlock* last_map = first_map + map_count - 1;
+int next_offset = last_map->offset() + (last_map->count() * heapOopSize);
+if (next_offset == next_nonstatic_field_offset) {
+allocation_style = 0;   // allocate oops first
+next_nonstatic_oop_offset    = next_nonstatic_field_offset;
+next_nonstatic_double_offset = next_nonstatic_oop_offset +
+(nonstatic_oop_count * heapOopSize);
+}
+}
+if( allocation_style == 2 ) {
+allocation_style = 1;     // allocate oops last
+next_nonstatic_double_offset = next_nonstatic_field_offset;
+}
+} else {
+ShouldNotReachHere();
+}
+int nonstatic_oop_space_count   = 0;
+int nonstatic_word_space_count  = 0;
+int nonstatic_short_space_count = 0;
+int nonstatic_byte_space_count  = 0;
+int nonstatic_oop_space_offset;
+int nonstatic_word_space_offset;
+int nonstatic_short_space_offset;
+int nonstatic_byte_space_offset;
+if( nonstatic_double_count > 0 ) {
+int offset = next_nonstatic_double_offset;
+next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
+if( compact_fields && offset != next_nonstatic_double_offset ) {
+// Allocate available fields into the gap before double field.
+int length = next_nonstatic_double_offset - offset;
+assert(length == BytesPerInt, "");
+nonstatic_word_space_offset = offset;
+if( nonstatic_word_count > 0 ) {
+nonstatic_word_count      -= 1;
+nonstatic_word_space_count = 1; // Only one will fit
+length -= BytesPerInt;
+offset += BytesPerInt;
+}
+nonstatic_short_space_offset = offset;
+while( length >= BytesPerShort && nonstatic_short_count > 0 ) {
+nonstatic_short_count       -= 1;
+nonstatic_short_space_count += 1;
+length -= BytesPerShort;
+offset += BytesPerShort;
+}
+nonstatic_byte_space_offset = offset;
+while( length > 0 && nonstatic_byte_count > 0 ) {
+nonstatic_byte_count       -= 1;
+nonstatic_byte_space_count += 1;
+length -= 1;
+}
+// Allocate oop field in the gap if there are no other fields for that.
+nonstatic_oop_space_offset = offset;
+if( length >= heapOopSize && nonstatic_oop_count > 0 &&
+allocation_style != 0 ) { // when oop fields not first
+nonstatic_oop_count      -= 1;
+nonstatic_oop_space_count = 1; // Only one will fit
+length -= heapOopSize;
+offset += heapOopSize;
+}
+}
+}
+next_nonstatic_word_offset  = next_nonstatic_double_offset +
+(nonstatic_double_count * BytesPerLong);
+next_nonstatic_short_offset = next_nonstatic_word_offset +
+(nonstatic_word_count * BytesPerInt);
+next_nonstatic_byte_offset  = next_nonstatic_short_offset +
+(nonstatic_short_count * BytesPerShort);
+next_nonstatic_padded_offset = next_nonstatic_byte_offset +
+nonstatic_byte_count;
+// let oops jump before padding with this allocation style
+if( allocation_style == 1 ) {
+next_nonstatic_oop_offset = next_nonstatic_padded_offset;
+if( nonstatic_oop_count > 0 ) {
+next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
+}
+next_nonstatic_padded_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
+}
+// Iterate over fields again and compute correct offsets.
+// The field allocation type was temporarily stored in the offset slot.
+// oop fields are located before non-oop fields (static and non-static).
+for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
+// skip already laid out fields
+if (fs.is_offset_set()) continue;
+// contended instance fields are handled below
+if (fs.is_contended() && !fs.access_flags().is_static()) continue;
+int real_offset;
+FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
+// pack the rest of the fields
+switch (atype) {
+case STATIC_OOP:
+real_offset = next_static_oop_offset;
+next_static_oop_offset += heapOopSize;
+break;
+case STATIC_BYTE:
+real_offset = next_static_byte_offset;
+next_static_byte_offset += 1;
+break;
+case STATIC_SHORT:
+real_offset = next_static_short_offset;
+next_static_short_offset += BytesPerShort;
+break;
+case STATIC_WORD:
+real_offset = next_static_word_offset;
+next_static_word_offset += BytesPerInt;
+break;
+case STATIC_DOUBLE:
+real_offset = next_static_double_offset;
+next_static_double_offset += BytesPerLong;
+break;
+case NONSTATIC_OOP:
+if( nonstatic_oop_space_count > 0 ) {
+real_offset = nonstatic_oop_space_offset;
+nonstatic_oop_space_offset += heapOopSize;
+nonstatic_oop_space_count  -= 1;
+} else {
+real_offset = next_nonstatic_oop_offset;
+next_nonstatic_oop_offset += heapOopSize;
+}
+// Update oop maps
+if( nonstatic_oop_map_count > 0 &&
+nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
+real_offset -
+int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
+heapOopSize ) {
+// Extend current oop map
+nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
+} else {
+// Create new oop map
+nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
+nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
+nonstatic_oop_map_count += 1;
+if( first_nonstatic_oop_offset == 0 ) { // Undefined
+first_nonstatic_oop_offset = real_offset;
+}
+}
+break;
+case NONSTATIC_BYTE:
+if( nonstatic_byte_space_count > 0 ) {
+real_offset = nonstatic_byte_space_offset;
+nonstatic_byte_space_offset += 1;
+nonstatic_byte_space_count  -= 1;
+} else {
+real_offset = next_nonstatic_byte_offset;
+next_nonstatic_byte_offset += 1;
+}
+break;
+case NONSTATIC_SHORT:
+if( nonstatic_short_space_count > 0 ) {
+real_offset = nonstatic_short_space_offset;
+nonstatic_short_space_offset += BytesPerShort;
+nonstatic_short_space_count  -= 1;
+} else {
+real_offset = next_nonstatic_short_offset;
+next_nonstatic_short_offset += BytesPerShort;
+}
+break;
+case NONSTATIC_WORD:
+if( nonstatic_word_space_count > 0 ) {
+real_offset = nonstatic_word_space_offset;
+nonstatic_word_space_offset += BytesPerInt;
+nonstatic_word_space_count  -= 1;
+} else {
+real_offset = next_nonstatic_word_offset;
+next_nonstatic_word_offset += BytesPerInt;
+}
+break;
+case NONSTATIC_DOUBLE:
+real_offset = next_nonstatic_double_offset;
+next_nonstatic_double_offset += BytesPerLong;
+break;
+default:
+ShouldNotReachHere();
+}
+fs.set_offset(real_offset);
+}
+// Handle the contended cases.
+//
+// Each contended field should not intersect the cache line with another contended field.
+// In the absence of alignment information, we end up with pessimistically separating
+// the fields with full-width padding.
+//
+// Additionally, this should not break alignment for the fields, so we round the alignment up
+// for each field.
+if (contended_count > 0) {
+// if there is at least one contended field, we need to have pre-padding for them
+if (nonstatic_contended_count > 0) {
+next_nonstatic_padded_offset += pad_size;
+}
+// collect all contended groups
+BitMap bm(_cp->size());
+for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
+// skip already laid out fields
+if (fs.is_offset_set()) continue;
+if (fs.is_contended()) {
+bm.set_bit(fs.contended_group());
+}
+}
+int current_group = -1;
+while ((current_group = (int)bm.get_next_one_offset(current_group + 1)) != (int)bm.size()) {
+for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
+// skip already laid out fields
+if (fs.is_offset_set()) continue;
+// skip non-contended fields and fields from different group
+if (!fs.is_contended() || (fs.contended_group() != current_group)) continue;
+// handle statics below
+if (fs.access_flags().is_static()) continue;
+int real_offset;
+FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
+switch (atype) {
+case NONSTATIC_BYTE:
+next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, 1);
+real_offset = next_nonstatic_padded_offset;
+next_nonstatic_padded_offset += 1;
+break;
+case NONSTATIC_SHORT:
+next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerShort);
+real_offset = next_nonstatic_padded_offset;
+next_nonstatic_padded_offset += BytesPerShort;
+break;
+case NONSTATIC_WORD:
+next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerInt);
+real_offset = next_nonstatic_padded_offset;
+next_nonstatic_padded_offset += BytesPerInt;
+break;
+case NONSTATIC_DOUBLE:
+next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerLong);
+real_offset = next_nonstatic_padded_offset;
+next_nonstatic_padded_offset += BytesPerLong;
+break;
+case NONSTATIC_OOP:
+next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, heapOopSize);
+real_offset = next_nonstatic_padded_offset;
+next_nonstatic_padded_offset += heapOopSize;
+// Create new oop map
+nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
+nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
+nonstatic_oop_map_count += 1;
+if( first_nonstatic_oop_offset == 0 ) { // Undefined
+first_nonstatic_oop_offset = real_offset;
+}
+break;
+default:
+ShouldNotReachHere();
+}
+if (fs.contended_group() == 0) {
+// Contended group defines the equivalence class over the fields:
+// the fields within the same contended group are not inter-padded.
+// The only exception is default group, which does not incur the
+// equivalence, and so requires intra-padding.
+next_nonstatic_padded_offset += pad_size;
+}
+fs.set_offset(real_offset);
+} // for
+// Start laying out the next group.
+// Note that this will effectively pad the last group in the back;
+// this is expected to alleviate memory contention effects for
+// subclass fields and/or adjacent object.
+// If this was the default group, the padding is already in place.
+if (current_group != 0) {
+next_nonstatic_padded_offset += pad_size;
+}
+}
+// handle static fields
+}
+// Size of instances
+int notaligned_offset = next_nonstatic_padded_offset;
+// Entire class is contended, pad in the back.
+// This helps to alleviate memory contention effects for subclass fields
+// and/or adjacent object.
+if (parsed_annotations->is_contended()) {
+notaligned_offset += pad_size;
+}
+int next_static_type_offset     = align_size_up(next_static_byte_offset, wordSize);
+int static_field_size           = (next_static_type_offset -
+InstanceMirrorKlass::offset_of_static_fields()) / wordSize;
+next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
+nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
+- first_nonstatic_field_offset)/heapOopSize);
+next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
+int instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
+assert(instance_size == align_object_size(align_size_up(
+(instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize + ((parsed_annotations->is_contended()) ? pad_size : 0)),
+wordSize) / wordSize), "consistent layout helper value");
+// Number of non-static oop map blocks allocated at end of klass.
+const unsigned int total_oop_map_count =
+compute_oop_map_count(_super_klass, nonstatic_oop_map_count,
+first_nonstatic_oop_offset);
+#ifndef PRODUCT
+if( PrintCompactFieldsSavings ) {
+ResourceMark rm;
+if( nonstatic_field_size < orig_nonstatic_field_size ) {
+tty->print("[Saved %d of %d bytes in %s]\n",
+(orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
+orig_nonstatic_field_size*heapOopSize,
+_class_name);
+} else if( nonstatic_field_size > orig_nonstatic_field_size ) {
+tty->print("[Wasted %d over %d bytes in %s]\n",
+(nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
+orig_nonstatic_field_size*heapOopSize,
+_class_name);
+}
+}
+if (PrintFieldLayout) {
+print_field_layout(_class_name,
+_fields,
+_cp,
+instance_size,
+first_nonstatic_field_offset,
+next_nonstatic_field_offset,
+next_static_type_offset);
+}
+#endif
+// Pass back information needed for InstanceKlass creation
+info->nonstatic_oop_offsets = nonstatic_oop_offsets;
+info->nonstatic_oop_counts = nonstatic_oop_counts;
+info->nonstatic_oop_map_count = nonstatic_oop_map_count;
+info->total_oop_map_count = total_oop_map_count;
+info->instance_size = instance_size;
+info->static_field_size = static_field_size;
+info->nonstatic_field_size = nonstatic_field_size;
+info->has_nonstatic_fields = has_nonstatic_fields;
+}
 instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
 ClassLoaderData* loader_data,
 Handle protection_domain,
 NULL,
 jt->get_thread_stat()->perf_recursion_counts_addr(),
 jt->get_thread_stat()->perf_timers_addr(),
 PerfClassTraceTime::PARSE_CLASS);
-init_parsed_class_attributes();
+init_parsed_class_attributes(loader_data);
 if (JvmtiExport::should_post_class_file_load_hook()) {
 // Get the cached class file bytes (if any) from the class that
 // is being redefined or retransformed. We use jvmti_thread_state()
 // instead of JvmtiThreadState::state_for(jt) so we don't allocate
 // Check if verification needs to be relaxed for this class file
 // Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
 _relax_verify = Verifier::relax_verify_for(class_loader());
 // Constant pool
-constantPoolHandle cp = parse_constant_pool(loader_data, CHECK_(nullHandle));
+constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
-ConstantPoolCleaner error_handler(cp); // set constant pool to be cleaned up.
 int cp_size = cp->length();
 cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len
 }
 verify_legal_class_modifiers(flags, CHECK_(nullHandle));
 access_flags.set_flags(flags);
 // This class and superclass
-instanceKlassHandle super_klass;
 u2 this_class_index = cfs->get_u2_fast();
 check_property(
 valid_cp_range(this_class_index, cp_size) &&
 cp->tag_at(this_class_index).is_unresolved_klass(),
 "Invalid this class index %u in constant pool in class file %s",
 if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
 tty->print_cr("]");
 }
 u2 super_class_index = cfs->get_u2_fast();
-if (super_class_index == 0) {
+instanceKlassHandle super_klass = parse_super_class(super_class_index,
-check_property(class_name == vmSymbols::java_lang_Object(),
+CHECK_NULL);
-"Invalid superclass index %u in class file %s",
-super_class_index,
-CHECK_(nullHandle));
-} else {
-check_property(valid_cp_range(super_class_index, cp_size) &&
-is_klass_reference(cp, super_class_index),
-"Invalid superclass index %u in class file %s",
-super_class_index,
-CHECK_(nullHandle));
-// The class name should be legal because it is checked when parsing constant pool.
-// However, make sure it is not an array type.
-bool is_array = false;
-if (cp->tag_at(super_class_index).is_klass()) {
-super_klass = instanceKlassHandle(THREAD, cp->resolved_klass_at(super_class_index));
-if (_need_verify)
-is_array = super_klass->oop_is_array();
-} else if (_need_verify) {
-is_array = (cp->unresolved_klass_at(super_class_index)->byte_at(0) == JVM_SIGNATURE_ARRAY);
-}
-if (_need_verify) {
-guarantee_property(!is_array,
-"Bad superclass name in class file %s", CHECK_(nullHandle));
-}
-}
 // Interfaces
 u2 itfs_len = cfs->get_u2_fast();
-Array<Klass*>* local_interfaces;
+Array<Klass*>* local_interfaces =
-if (itfs_len == 0) {
+parse_interfaces(itfs_len, protection_domain, _class_name,
-local_interfaces = Universe::the_empty_klass_array();
+&has_default_methods, CHECK_(nullHandle));
-} else {
-local_interfaces = parse_interfaces(
-cp, itfs_len, loader_data, protection_domain, _class_name,
-&has_default_methods, CHECK_(nullHandle));
-}
 u2 java_fields_count = 0;
 // Fields (offsets are filled in later)
 FieldAllocationCount fac;
-Array<AnnotationArray*>* fields_annotations = NULL;
+Array<u2>* fields = parse_fields(class_name,
-Array<AnnotationArray*>* fields_type_annotations = NULL;
+access_flags.is_interface(),
-Array<u2>* fields = parse_fields(loader_data, class_name, cp, access_flags.is_interface(), &fac, &fields_annotations,
+&fac, &java_fields_count,
-&fields_type_annotations,
+CHECK_(nullHandle));
-&java_fields_count,
-CHECK_(nullHandle));
 // Methods
 bool has_final_method = false;
 AccessFlags promoted_flags;
 promoted_flags.set_flags(0);
-Array<Method*>* methods = parse_methods(loader_data,
+Array<Method*>* methods = parse_methods(access_flags.is_interface(),
-cp, access_flags.is_interface(),
 &promoted_flags,
 &has_final_method,
 &has_default_methods,
 CHECK_(nullHandle));
 // Additional attributes
 ClassAnnotationCollector parsed_annotations;
-parse_classfile_attributes(loader_data, cp, &parsed_annotations, CHECK_(nullHandle));
+parse_classfile_attributes(&parsed_annotations, 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));
 // We check super class after class file is parsed and format is checked
 if (super_klass->is_final()) {
 THROW_MSG_(vmSymbols::java_lang_VerifyError(), "Cannot inherit from final class", nullHandle);
 }
 }
+// save super klass for error handling.
+_super_klass = super_klass;
 // Compute the transitive list of all unique interfaces implemented by this class
-Array<Klass*>* transitive_interfaces = compute_transitive_interfaces(loader_data, super_klass, local_interfaces, CHECK_(nullHandle));
+_transitive_interfaces =
+compute_transitive_interfaces(super_klass, local_interfaces, CHECK_(nullHandle));
 // sort methods
-Array<int>* method_ordering = sort_methods(loader_data,
+intArray* method_ordering = sort_methods(methods);
-methods,
-CHECK_(nullHandle));
 // promote flags from parse_methods() to the klass' flags
 access_flags.add_promoted_flags(promoted_flags.as_int());
 // Size of Java vtable (in words)
 &vtable_size, &num_miranda_methods, &all_mirandas, super_klass(), methods,
 access_flags, class_loader, class_name, local_interfaces,
 CHECK_(nullHandle));
 // Size of Java itable (in words)
-itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(transitive_interfaces);
+itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(_transitive_interfaces);
-// get the padding width from the option
+FieldLayoutInfo info;
-// TODO: Ask VM about specific CPU we are running on
+layout_fields(class_loader, &fac, &parsed_annotations, &info, CHECK_NULL);
-int pad_size = ContendedPaddingWidth;
+int total_oop_map_size2 =
-// Field size and offset computation
+InstanceKlass::nonstatic_oop_map_size(info.total_oop_map_count);
-int nonstatic_field_size = super_klass() == NULL ? 0 : super_klass->nonstatic_field_size();
-#ifndef PRODUCT
-int orig_nonstatic_field_size = 0;
-#endif
-int next_static_oop_offset;
-int next_static_double_offset;
-int next_static_word_offset;
-int next_static_short_offset;
-int next_static_byte_offset;
-int next_nonstatic_oop_offset;
-int next_nonstatic_double_offset;
-int next_nonstatic_word_offset;
-int next_nonstatic_short_offset;
-int next_nonstatic_byte_offset;
-int next_nonstatic_type_offset;
-int first_nonstatic_oop_offset;
-int first_nonstatic_field_offset;
-int next_nonstatic_field_offset;
-int next_nonstatic_padded_offset;
-// Count the contended fields by type.
-int nonstatic_contended_count = 0;
-FieldAllocationCount fac_contended;
-for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
-FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
-if (fs.is_contended()) {
-fac_contended.count[atype]++;
-if (!fs.access_flags().is_static()) {
-nonstatic_contended_count++;
-}
-}
-}
-int contended_count = nonstatic_contended_count;
-// Calculate the starting byte offsets
-next_static_oop_offset      = InstanceMirrorKlass::offset_of_static_fields();
-next_static_double_offset   = next_static_oop_offset +
-((fac.count[STATIC_OOP]) * heapOopSize);
-if ( fac.count[STATIC_DOUBLE] &&
-(Universe::field_type_should_be_aligned(T_DOUBLE) ||
-Universe::field_type_should_be_aligned(T_LONG)) ) {
-next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong);
-}
-next_static_word_offset     = next_static_double_offset +
-((fac.count[STATIC_DOUBLE]) * BytesPerLong);
-next_static_short_offset    = next_static_word_offset +
-((fac.count[STATIC_WORD]) * BytesPerInt);
-next_static_byte_offset     = next_static_short_offset +
-((fac.count[STATIC_SHORT]) * BytesPerShort);
-first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
-nonstatic_field_size * heapOopSize;
-// class is contended, pad before all the fields
-if (parsed_annotations.is_contended()) {
-first_nonstatic_field_offset += pad_size;
-}
-next_nonstatic_field_offset = first_nonstatic_field_offset;
-unsigned int nonstatic_double_count = fac.count[NONSTATIC_DOUBLE] - fac_contended.count[NONSTATIC_DOUBLE];
-unsigned int nonstatic_word_count   = fac.count[NONSTATIC_WORD]   - fac_contended.count[NONSTATIC_WORD];
-unsigned int nonstatic_short_count  = fac.count[NONSTATIC_SHORT]  - fac_contended.count[NONSTATIC_SHORT];
-unsigned int nonstatic_byte_count   = fac.count[NONSTATIC_BYTE]   - fac_contended.count[NONSTATIC_BYTE];
-unsigned int nonstatic_oop_count    = fac.count[NONSTATIC_OOP]    - fac_contended.count[NONSTATIC_OOP];
-bool super_has_nonstatic_fields =
-(super_klass() != NULL && super_klass->has_nonstatic_fields());
-bool has_nonstatic_fields  =  super_has_nonstatic_fields ||
-((nonstatic_double_count + nonstatic_word_count +
-nonstatic_short_count + nonstatic_byte_count +
-nonstatic_oop_count) != 0);
-// Prepare list of oops for oop map generation.
-int* nonstatic_oop_offsets;
-unsigned int* nonstatic_oop_counts;
-unsigned int nonstatic_oop_map_count = 0;
-nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
-THREAD, int, nonstatic_oop_count + 1);
-nonstatic_oop_counts  = NEW_RESOURCE_ARRAY_IN_THREAD(
-THREAD, unsigned int, nonstatic_oop_count + 1);
-first_nonstatic_oop_offset = 0; // will be set for first oop field
-#ifndef PRODUCT
-if( PrintCompactFieldsSavings ) {
-next_nonstatic_double_offset = next_nonstatic_field_offset +
-(nonstatic_oop_count * heapOopSize);
-if ( nonstatic_double_count > 0 ) {
-next_nonstatic_double_offset = align_size_up(next_nonstatic_double_offset, BytesPerLong);
-}
-next_nonstatic_word_offset  = next_nonstatic_double_offset +
-(nonstatic_double_count * BytesPerLong);
-next_nonstatic_short_offset = next_nonstatic_word_offset +
-(nonstatic_word_count * BytesPerInt);
-next_nonstatic_byte_offset  = next_nonstatic_short_offset +
-(nonstatic_short_count * BytesPerShort);
-next_nonstatic_type_offset  = align_size_up((next_nonstatic_byte_offset +
-nonstatic_byte_count ), heapOopSize );
-orig_nonstatic_field_size   = nonstatic_field_size +
-((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
-}
-#endif
-bool compact_fields   = CompactFields;
-int  allocation_style = FieldsAllocationStyle;
-if( allocation_style < 0 || allocation_style > 2 ) { // Out of range?
-assert(false, "0 <= FieldsAllocationStyle <= 2");
-allocation_style = 1; // Optimistic
-}
-// The next classes have predefined hard-coded fields offsets
-// (see in JavaClasses::compute_hard_coded_offsets()).
-// Use default fields allocation order for them.
-if( (allocation_style != 0 || compact_fields ) && class_loader.is_null() &&
-(class_name == vmSymbols::java_lang_AssertionStatusDirectives() ||
-class_name == vmSymbols::java_lang_Class() ||
-class_name == vmSymbols::java_lang_ClassLoader() ||
-class_name == vmSymbols::java_lang_ref_Reference() ||
-class_name == vmSymbols::java_lang_ref_SoftReference() ||
-class_name == vmSymbols::java_lang_StackTraceElement() ||
-class_name == vmSymbols::java_lang_String() ||
-class_name == vmSymbols::java_lang_Throwable() ||
-class_name == vmSymbols::java_lang_Boolean() ||
-class_name == vmSymbols::java_lang_Character() ||
-class_name == vmSymbols::java_lang_Float() ||
-class_name == vmSymbols::java_lang_Double() ||
-class_name == vmSymbols::java_lang_Byte() ||
-class_name == vmSymbols::java_lang_Short() ||
-class_name == vmSymbols::java_lang_Integer() ||
-class_name == vmSymbols::java_lang_Long())) {
-allocation_style = 0;     // Allocate oops first
-compact_fields   = false; // Don't compact fields
-}
-if( allocation_style == 0 ) {
-// Fields order: oops, longs/doubles, ints, shorts/chars, bytes, padded fields
-next_nonstatic_oop_offset    = next_nonstatic_field_offset;
-next_nonstatic_double_offset = next_nonstatic_oop_offset +
-(nonstatic_oop_count * heapOopSize);
-} else if( allocation_style == 1 ) {
-// Fields order: longs/doubles, ints, shorts/chars, bytes, oops, padded fields
-next_nonstatic_double_offset = next_nonstatic_field_offset;
-} else if( allocation_style == 2 ) {
-// Fields allocation: oops fields in super and sub classes are together.
-if( nonstatic_field_size > 0 && super_klass() != NULL &&
-super_klass->nonstatic_oop_map_size() > 0 ) {
-int map_count = super_klass->nonstatic_oop_map_count();
-OopMapBlock* first_map = super_klass->start_of_nonstatic_oop_maps();
-OopMapBlock* last_map = first_map + map_count - 1;
-int next_offset = last_map->offset() + (last_map->count() * heapOopSize);
-if (next_offset == next_nonstatic_field_offset) {
-allocation_style = 0;   // allocate oops first
-next_nonstatic_oop_offset    = next_nonstatic_field_offset;
-next_nonstatic_double_offset = next_nonstatic_oop_offset +
-(nonstatic_oop_count * heapOopSize);
-}
-}
-if( allocation_style == 2 ) {
-allocation_style = 1;     // allocate oops last
-next_nonstatic_double_offset = next_nonstatic_field_offset;
-}
-} else {
-ShouldNotReachHere();
-}
-int nonstatic_oop_space_count   = 0;
-int nonstatic_word_space_count  = 0;
-int nonstatic_short_space_count = 0;
-int nonstatic_byte_space_count  = 0;
-int nonstatic_oop_space_offset;
-int nonstatic_word_space_offset;
-int nonstatic_short_space_offset;
-int nonstatic_byte_space_offset;
-if( nonstatic_double_count > 0 ) {
-int offset = next_nonstatic_double_offset;
-next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
-if( compact_fields && offset != next_nonstatic_double_offset ) {
-// Allocate available fields into the gap before double field.
-int length = next_nonstatic_double_offset - offset;
-assert(length == BytesPerInt, "");
-nonstatic_word_space_offset = offset;
-if( nonstatic_word_count > 0 ) {
-nonstatic_word_count      -= 1;
-nonstatic_word_space_count = 1; // Only one will fit
-length -= BytesPerInt;
-offset += BytesPerInt;
-}
-nonstatic_short_space_offset = offset;
-while( length >= BytesPerShort && nonstatic_short_count > 0 ) {
-nonstatic_short_count       -= 1;
-nonstatic_short_space_count += 1;
-length -= BytesPerShort;
-offset += BytesPerShort;
-}
-nonstatic_byte_space_offset = offset;
-while( length > 0 && nonstatic_byte_count > 0 ) {
-nonstatic_byte_count       -= 1;
-nonstatic_byte_space_count += 1;
-length -= 1;
-}
-// Allocate oop field in the gap if there are no other fields for that.
-nonstatic_oop_space_offset = offset;
-if( length >= heapOopSize && nonstatic_oop_count > 0 &&
-allocation_style != 0 ) { // when oop fields not first
-nonstatic_oop_count      -= 1;
-nonstatic_oop_space_count = 1; // Only one will fit
-length -= heapOopSize;
-offset += heapOopSize;
-}
-}
-}
-next_nonstatic_word_offset  = next_nonstatic_double_offset +
-(nonstatic_double_count * BytesPerLong);
-next_nonstatic_short_offset = next_nonstatic_word_offset +
-(nonstatic_word_count * BytesPerInt);
-next_nonstatic_byte_offset  = next_nonstatic_short_offset +
-(nonstatic_short_count * BytesPerShort);
-next_nonstatic_padded_offset = next_nonstatic_byte_offset +
-nonstatic_byte_count;
-// let oops jump before padding with this allocation style
-if( allocation_style == 1 ) {
-next_nonstatic_oop_offset = next_nonstatic_padded_offset;
-if( nonstatic_oop_count > 0 ) {
-next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
-}
-next_nonstatic_padded_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
-}
-// Iterate over fields again and compute correct offsets.
-// The field allocation type was temporarily stored in the offset slot.
-// oop fields are located before non-oop fields (static and non-static).
-for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
-// skip already laid out fields
-if (fs.is_offset_set()) continue;
-// contended instance fields are handled below
-if (fs.is_contended() && !fs.access_flags().is_static()) continue;
-int real_offset;
-FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
-// pack the rest of the fields
-switch (atype) {
-case STATIC_OOP:
-real_offset = next_static_oop_offset;
-next_static_oop_offset += heapOopSize;
-break;
-case STATIC_BYTE:
-real_offset = next_static_byte_offset;
-next_static_byte_offset += 1;
-break;
-case STATIC_SHORT:
-real_offset = next_static_short_offset;
-next_static_short_offset += BytesPerShort;
-break;
-case STATIC_WORD:
-real_offset = next_static_word_offset;
-next_static_word_offset += BytesPerInt;
-break;
-case STATIC_DOUBLE:
-real_offset = next_static_double_offset;
-next_static_double_offset += BytesPerLong;
-break;
-case NONSTATIC_OOP:
-if( nonstatic_oop_space_count > 0 ) {
-real_offset = nonstatic_oop_space_offset;
-nonstatic_oop_space_offset += heapOopSize;
-nonstatic_oop_space_count  -= 1;
-} else {
-real_offset = next_nonstatic_oop_offset;
-next_nonstatic_oop_offset += heapOopSize;
-}
-// Update oop maps
-if( nonstatic_oop_map_count > 0 &&
-nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
-real_offset -
-int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
-heapOopSize ) {
-// Extend current oop map
-nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
-} else {
-// Create new oop map
-nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
-nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
-nonstatic_oop_map_count += 1;
-if( first_nonstatic_oop_offset == 0 ) { // Undefined
-first_nonstatic_oop_offset = real_offset;
-}
-}
-break;
-case NONSTATIC_BYTE:
-if( nonstatic_byte_space_count > 0 ) {
-real_offset = nonstatic_byte_space_offset;
-nonstatic_byte_space_offset += 1;
-nonstatic_byte_space_count  -= 1;
-} else {
-real_offset = next_nonstatic_byte_offset;
-next_nonstatic_byte_offset += 1;
-}
-break;
-case NONSTATIC_SHORT:
-if( nonstatic_short_space_count > 0 ) {
-real_offset = nonstatic_short_space_offset;
-nonstatic_short_space_offset += BytesPerShort;
-nonstatic_short_space_count  -= 1;
-} else {
-real_offset = next_nonstatic_short_offset;
-next_nonstatic_short_offset += BytesPerShort;
-}
-break;
-case NONSTATIC_WORD:
-if( nonstatic_word_space_count > 0 ) {
-real_offset = nonstatic_word_space_offset;
-nonstatic_word_space_offset += BytesPerInt;
-nonstatic_word_space_count  -= 1;
-} else {
-real_offset = next_nonstatic_word_offset;
-next_nonstatic_word_offset += BytesPerInt;
-}
-break;
-case NONSTATIC_DOUBLE:
-real_offset = next_nonstatic_double_offset;
-next_nonstatic_double_offset += BytesPerLong;
-break;
-default:
-ShouldNotReachHere();
-}
-fs.set_offset(real_offset);
-}
-// Handle the contended cases.
-//
-// Each contended field should not intersect the cache line with another contended field.
-// In the absence of alignment information, we end up with pessimistically separating
-// the fields with full-width padding.
-//
-// Additionally, this should not break alignment for the fields, so we round the alignment up
-// for each field.
-if (contended_count > 0) {
-// if there is at least one contended field, we need to have pre-padding for them
-if (nonstatic_contended_count > 0) {
-next_nonstatic_padded_offset += pad_size;
-}
-// collect all contended groups
-BitMap bm(cp->size());
-for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
-// skip already laid out fields
-if (fs.is_offset_set()) continue;
-if (fs.is_contended()) {
-bm.set_bit(fs.contended_group());
-}
-}
-int current_group = -1;
-while ((current_group = (int)bm.get_next_one_offset(current_group + 1)) != (int)bm.size()) {
-for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
-// skip already laid out fields
-if (fs.is_offset_set()) continue;
-// skip non-contended fields and fields from different group
-if (!fs.is_contended() || (fs.contended_group() != current_group)) continue;
-// handle statics below
-if (fs.access_flags().is_static()) continue;
-int real_offset;
-FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
-switch (atype) {
-case NONSTATIC_BYTE:
-next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, 1);
-real_offset = next_nonstatic_padded_offset;
-next_nonstatic_padded_offset += 1;
-break;
-case NONSTATIC_SHORT:
-next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerShort);
-real_offset = next_nonstatic_padded_offset;
-next_nonstatic_padded_offset += BytesPerShort;
-break;
-case NONSTATIC_WORD:
-next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerInt);
-real_offset = next_nonstatic_padded_offset;
-next_nonstatic_padded_offset += BytesPerInt;
-break;
-case NONSTATIC_DOUBLE:
-next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, BytesPerLong);
-real_offset = next_nonstatic_padded_offset;
-next_nonstatic_padded_offset += BytesPerLong;
-break;
-case NONSTATIC_OOP:
-next_nonstatic_padded_offset = align_size_up(next_nonstatic_padded_offset, heapOopSize);
-real_offset = next_nonstatic_padded_offset;
-next_nonstatic_padded_offset += heapOopSize;
-// Create new oop map
-nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
-nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
-nonstatic_oop_map_count += 1;
-if( first_nonstatic_oop_offset == 0 ) { // Undefined
-first_nonstatic_oop_offset = real_offset;
-}
-break;
-default:
-ShouldNotReachHere();
-}
-if (fs.contended_group() == 0) {
-// Contended group defines the equivalence class over the fields:
-// the fields within the same contended group are not inter-padded.
-// The only exception is default group, which does not incur the
-// equivalence, and so requires intra-padding.
-next_nonstatic_padded_offset += pad_size;
-}
-fs.set_offset(real_offset);
-} // for
-// Start laying out the next group.
-// Note that this will effectively pad the last group in the back;
-// this is expected to alleviate memory contention effects for
-// subclass fields and/or adjacent object.
-// If this was the default group, the padding is already in place.
-if (current_group != 0) {
-next_nonstatic_padded_offset += pad_size;
-}
-}
-// handle static fields
-} // handle contended
-// Size of instances
-int instance_size;
-int notaligned_offset = next_nonstatic_padded_offset;
-// Entire class is contended, pad in the back.
-// This helps to alleviate memory contention effects for subclass fields
-// and/or adjacent object.
-if (parsed_annotations.is_contended()) {
-notaligned_offset += pad_size;
-}
-int next_static_type_offset     = align_size_up(next_static_byte_offset, wordSize);
-int static_field_size           = (next_static_type_offset -
-InstanceMirrorKlass::offset_of_static_fields()) / wordSize;
-next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
-nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
-- first_nonstatic_field_offset)/heapOopSize);
-next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
-instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
-assert(instance_size == align_object_size(align_size_up(
-(instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize + ((parsed_annotations.is_contended()) ? pad_size : 0)),
-wordSize) / wordSize), "consistent layout helper value");
-// Number of non-static oop map blocks allocated at end of klass.
-const unsigned int total_oop_map_count =
-compute_oop_map_count(super_klass, nonstatic_oop_map_count,
-first_nonstatic_oop_offset);
 // Compute reference type
 ReferenceType rt;
 if (super_klass() == NULL) {
 rt = REF_NONE;
 } else {
 rt = super_klass->reference_type();
 }
 // We can now create the basic Klass* for this klass
-int total_oop_map_size2 =
+_klass = InstanceKlass::allocate_instance_klass(loader_data,
-InstanceKlass::nonstatic_oop_map_size(total_oop_map_count);
+vtable_size,
+itable_size,
-Klass* ik = InstanceKlass::allocate_instance_klass(loader_data,
+info.static_field_size,
-vtable_size,
+total_oop_map_size2,
-itable_size,
+rt,
-static_field_size,
+access_flags,
-total_oop_map_size2,
+name,
-rt,
+super_klass(),
-access_flags,
+!host_klass.is_null(),
-name,
+CHECK_(nullHandle));
-super_klass(),
+instanceKlassHandle this_klass (THREAD, _klass);
-!host_klass.is_null(),
-CHECK_(nullHandle));
+assert(this_klass->static_field_size() == info.static_field_size, "sanity");
+assert(this_klass->nonstatic_oop_map_count() == info.total_oop_map_count,
-// Add all classes to our internal class loader list here,
-// including classes in the bootstrap (NULL) class loader.
-loader_data->add_class(ik);
-instanceKlassHandle this_klass (THREAD, ik);
-assert(this_klass->static_field_size() == static_field_size, "sanity");
-assert(this_klass->nonstatic_oop_map_count() == total_oop_map_count,
 "sanity");
 // Fill in information already parsed
 this_klass->set_should_verify_class(verify);
-jint lh = Klass::instance_layout_helper(instance_size, false);
+jint lh = Klass::instance_layout_helper(info.instance_size, false);
 this_klass->set_layout_helper(lh);
 assert(this_klass->oop_is_instance(), "layout is correct");
-assert(this_klass->size_helper() == instance_size, "correct size_helper");
+assert(this_klass->size_helper() == info.instance_size, "correct size_helper");
 // Not yet: supers are done below to support the new subtype-checking fields
 //this_klass->set_super(super_klass());
 this_klass->set_class_loader_data(loader_data);
-this_klass->set_nonstatic_field_size(nonstatic_field_size);
+this_klass->set_nonstatic_field_size(info.nonstatic_field_size);
-this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
+this_klass->set_has_nonstatic_fields(info.has_nonstatic_fields);
 this_klass->set_static_oop_field_count(fac.count[STATIC_OOP]);
-cp->set_pool_holder(this_klass());
-error_handler.set_in_error(false);   // turn off error handler for cp
+apply_parsed_class_metadata(this_klass, java_fields_count, CHECK_NULL);
-this_klass->set_constants(cp());
-this_klass->set_local_interfaces(local_interfaces);
-this_klass->set_fields(fields, java_fields_count);
-this_klass->set_methods(methods);
 if (has_final_method) {
 this_klass->set_has_final_method();
 }
-this_klass->set_method_ordering(method_ordering);
+this_klass->copy_method_ordering(method_ordering, CHECK_NULL);
 // The InstanceKlass::_methods_jmethod_ids cache and the
 // InstanceKlass::_methods_cached_itable_indices cache are
 // both managed on the assumption that the initial cache
 // size is equal to the number of methods in the class. If
 // that changes, then InstanceKlass::idnum_can_increment()
 this_klass->set_initial_method_idnum(methods->length());
 this_klass->set_name(cp->klass_name_at(this_class_index));
 if (is_anonymous())  // I am well known to myself
 cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
-// Assign allocations if needed
-if (_annotations != NULL || _type_annotations != NULL ||
-fields_annotations != NULL || fields_type_annotations != NULL) {
-Annotations* annotations = Annotations::allocate(loader_data, CHECK_NULL);
-annotations->set_class_annotations(_annotations);
-annotations->set_class_type_annotations(_type_annotations);
-annotations->set_fields_annotations(fields_annotations);
-annotations->set_fields_type_annotations(fields_type_annotations);
-this_klass->set_annotations(annotations);
-}
 this_klass->set_minor_version(minor_version);
 this_klass->set_major_version(major_version);
 this_klass->set_has_default_methods(has_default_methods);
 // Set up Method*::intrinsic_id as soon as we know the names of methods.
 // super class exists and this class inherited miranda methods
 ) {
 this_klass->set_has_miranda_methods(); // then set a flag
 }
-this_klass->set_transitive_interfaces(transitive_interfaces);
 // Fill in information needed to compute superclasses.
 this_klass->initialize_supers(super_klass(), CHECK_(nullHandle));
 // Initialize itable offset tables
 klassItable::setup_itable_offset_table(this_klass);
 // Compute transitive closure of interfaces this class implements
 // Do final class setup
-fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts);
+fill_oop_maps(this_klass, info.nonstatic_oop_map_count, info.nonstatic_oop_offsets, info.nonstatic_oop_counts);
 // Fill in has_finalizer, has_vanilla_constructor, and layout_helper
 set_precomputed_flags(this_klass);
 // reinitialize modifiers, using the InnerClasses attribute
 tty->print("RESOLVE %s %s (interface)\n", from, to);
 }
 }
 }
-#ifndef PRODUCT
-if( PrintCompactFieldsSavings ) {
-ResourceMark rm;
-if( nonstatic_field_size < orig_nonstatic_field_size ) {
-tty->print("[Saved %d of %d bytes in %s]\n",
-(orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
-orig_nonstatic_field_size*heapOopSize,
-this_klass->external_name());
-} else if( nonstatic_field_size > orig_nonstatic_field_size ) {
-tty->print("[Wasted %d over %d bytes in %s]\n",
-(nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
-orig_nonstatic_field_size*heapOopSize,
-this_klass->external_name());
-}
-}
-#endif
-#ifndef PRODUCT
-if (PrintFieldLayout) {
-print_field_layout(name,
-fields,
-cp,
-instance_size,
-first_nonstatic_field_offset,
-next_nonstatic_field_offset,
-next_static_type_offset);
-}
-#endif
 // preserve result across HandleMark
 preserve_this_klass = this_klass();
 }
 // Create new handle outside HandleMark (might be needed for
 // Extended Class Redefinition)
 instanceKlassHandle this_klass (THREAD, preserve_this_klass);
 debug_only(this_klass->verify();)
+// Clear class if no error has occurred so destructor doesn't deallocate it
+_klass = NULL;
 return this_klass;
+}
+// Destructor to clean up if there's an error
+ClassFileParser::~ClassFileParser() {
+MetadataFactory::free_metadata(_loader_data, _cp);
+MetadataFactory::free_array<u2>(_loader_data, _fields);
+// Free methods
+InstanceKlass::deallocate_methods(_loader_data, _methods);
+// beware of the Universe::empty_blah_array!!
+if (_inner_classes != Universe::the_empty_short_array()) {
+MetadataFactory::free_array<u2>(_loader_data, _inner_classes);
+}
+// Free interfaces
+InstanceKlass::deallocate_interfaces(_loader_data, _super_klass(),
+_local_interfaces, _transitive_interfaces);
+MetadataFactory::free_array<u1>(_loader_data, _annotations);
+MetadataFactory::free_array<u1>(_loader_data, _type_annotations);
+Annotations::free_contents(_loader_data, _fields_annotations);
+Annotations::free_contents(_loader_data, _fields_type_annotations);
+clear_class_metadata();
+// deallocate the klass if already created.
+MetadataFactory::free_metadata(_loader_data, _klass);
+_klass = NULL;
 }
 void ClassFileParser::print_field_layout(Symbol* name,
 Array<u2>* fields,
 constantPoolHandle cp,
 }
 }
 }
 }
-// utility method for appending and array with check for duplicates
+// utility methods for appending an array with check for duplicates
 void append_interfaces(GrowableArray<Klass*>* result, Array<Klass*>* ifs) {
 // iterate over new interfaces
 for (int i = 0; i < ifs->length(); i++) {
 Klass* e = ifs->at(i);
 // add new interface
 result->append_if_missing(e);
 }
 }
+Array<Klass*>* ClassFileParser::compute_transitive_interfaces(
-Array<Klass*>* ClassFileParser::compute_transitive_interfaces(ClassLoaderData* loader_data, instanceKlassHandle super, Array<Klass*>* local_ifs, TRAPS) {
+instanceKlassHandle super,
+Array<Klass*>* local_ifs, TRAPS) {
 // Compute maximum size for transitive interfaces
 int max_transitive_size = 0;
 int super_size = 0;
 // Add superclass transitive interfaces size
 if (super.not_null()) {
 append_interfaces(result, local_ifs);
 // length will be less than the max_transitive_size if duplicates were removed
 int length = result->length();
 assert(length <= max_transitive_size, "just checking");
-Array<Klass*>* new_result = MetadataFactory::new_array<Klass*>(loader_data, length, CHECK_NULL);
+Array<Klass*>* new_result = MetadataFactory::new_array<Klass*>(_loader_data, length, CHECK_NULL);
 for (int i = 0; i < length; i++) {
 Klass* e = result->at(i);
 assert(e != NULL, "just checking");
 new_result->at_put(i, e);
 }
 return new_result;
 }
 }
 void ClassFileParser::check_super_class_access(instanceKlassHandle this_klass, TRAPS) {
 Klass* super = this_klass->super();
 if ((super != NULL) &&
 (!Reflection::verify_class_access(this_klass(), super, false))) {

changeset 15935	50da9e5eb858
parent 15932	a27c3d066552
child 16617	6235d2c7549f
child 16445	cb44d5b3ad89