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

equal deleted inserted replaced

-:582dd25571b2
+:96d498ec7ae1
 #include "oops/instanceKlass.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/klassOop.hpp"
 #include "oops/klassVtable.hpp"
 #include "oops/methodOop.hpp"
-#include "oops/symbolOop.hpp"
+#include "oops/symbol.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/perfData.hpp"
 #include "runtime/reflection.hpp"
 #include "runtime/signature.hpp"
 utf8_buffer = (u1*) str;
 utf8_length = (int) strlen(str);
 }
 unsigned int hash;
-symbolOop result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
+Symbol* result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
 if (result == NULL) {
 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) {
-oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
 names_count = 0;
 }
 } else {
 cp->symbol_at_put(index, result);
 }
 }
 }
 // Allocate the remaining symbols
 if (names_count > 0) {
-oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(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); }
 constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
 ClassFileStream* cfs = stream();
 methodOopDesc::IsSafeConc,
 CHECK_(nullHandle));
 constantPoolHandle cp (THREAD, constant_pool);
 cp->set_partially_loaded();    // Enables heap verify to work on partial constantPoolOops
+ConstantPoolCleaner cp_in_error(cp); // set constant pool to be cleaned up.
 // parsing constant pool entries
 parse_constant_pool_entries(cp, length, CHECK_(nullHandle));
 int index = 1;  // declared outside of loops for portability
 check_property(
 valid_cp_range(string_index, length) &&
 cp->tag_at(string_index).is_utf8(),
 "Invalid constant pool index %u in class file %s",
 string_index, CHECK_(nullHandle));
-symbolOop sym = cp->symbol_at(string_index);
+Symbol* sym = cp->symbol_at(string_index);
 cp->unresolved_string_at_put(index, sym);
 }
 break;
 case JVM_CONSTANT_MethodHandle :
 {
 index, CHECK_(nullHandle));
 }
 }
 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
 for (index = 1; index < length; index++) {
 jbyte tag = cp->tag_at(index).value();
 switch (tag) {
 case JVM_CONSTANT_UnresolvedClass: {
-symbolHandle class_name(THREAD, cp->unresolved_klass_at(index));
+Symbol*  class_name = cp->unresolved_klass_at(index);
 // check the name, even if _cp_patches will overwrite it
 verify_legal_class_name(class_name, CHECK_(nullHandle));
 break;
 }
 case JVM_CONSTANT_NameAndType: {
 if (_need_verify && _major_version >= JAVA_7_VERSION) {
 int sig_index = cp->signature_ref_index_at(index);
 int name_index = cp->name_ref_index_at(index);
-symbolHandle name(THREAD, cp->symbol_at(name_index));
+Symbol*  name = cp->symbol_at(name_index);
-symbolHandle sig(THREAD, cp->symbol_at(sig_index));
+Symbol*  sig = cp->symbol_at(sig_index);
 if (sig->byte_at(0) == JVM_SIGNATURE_FUNC) {
 verify_legal_method_signature(name, sig, CHECK_(nullHandle));
 } else {
 verify_legal_field_signature(name, sig, CHECK_(nullHandle));
 }
 int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
 // already verified to be utf8
 int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
 // already verified to be utf8
 int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);
-symbolHandle name(THREAD, cp->symbol_at(name_ref_index));
+Symbol*  name = cp->symbol_at(name_ref_index);
-symbolHandle signature(THREAD, cp->symbol_at(signature_ref_index));
+Symbol*  signature = cp->symbol_at(signature_ref_index);
 if (tag == JVM_CONSTANT_Fieldref) {
 verify_legal_field_name(name, CHECK_(nullHandle));
 if (_need_verify && _major_version >= JAVA_7_VERSION) {
 // Signature is verified above, when iterating NameAndType_info.
 // Need only to be sure it's the right type.
 } else {
 verify_legal_method_signature(name, signature, CHECK_(nullHandle));
 }
 if (tag == JVM_CONSTANT_Methodref) {
 // 4509014: If a class method name begins with '<', it must be "<init>".
-assert(!name.is_null(), "method name in constant pool is null");
+assert(name != NULL, "method name in constant pool is null");
 unsigned int name_len = name->utf8_length();
 assert(name_len > 0, "bad method name");  // already verified as legal name
 if (name->byte_at(0) == '<') {
-if (name() != vmSymbols::object_initializer_name()) {
+if (name != vmSymbols::object_initializer_name()) {
 classfile_parse_error(
 "Bad method name at constant pool index %u in class file %s",
 name_ref_index, CHECK_(nullHandle));
 }
 }
 case JVM_REF_invokeSpecial:
 case JVM_REF_newInvokeSpecial:
 {
 int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);
 int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
-symbolHandle name(THREAD, cp->symbol_at(name_ref_index));
+Symbol*  name = cp->symbol_at(name_ref_index);
 if (ref_kind == JVM_REF_newInvokeSpecial) {
-if (name() != vmSymbols::object_initializer_name()) {
+if (name != vmSymbols::object_initializer_name()) {
 classfile_parse_error(
 "Bad constructor name at constant pool index %u in class file %s",
 name_ref_index, CHECK_(nullHandle));
 }
 } else {
-if (name() == vmSymbols::object_initializer_name()) {
+if (name == vmSymbols::object_initializer_name()) {
 classfile_parse_error(
 "Bad method name at constant pool index %u in class file %s",
 name_ref_index, CHECK_(nullHandle));
 }
 }
 // Other ref_kinds are already fully checked in previous pass.
 }
 break;
 }
 case JVM_CONSTANT_MethodType: {
-symbolHandle no_name = vmSymbolHandles::type_name(); // place holder
+Symbol* no_name = vmSymbols::type_name(); // place holder
-symbolHandle signature(THREAD, cp->method_type_signature_at(index));
+Symbol*  signature = cp->method_type_signature_at(index);
 verify_legal_method_signature(no_name, signature, CHECK_(nullHandle));
 break;
 }
+case JVM_CONSTANT_Utf8: {
+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) {
 cp->klass_at_put(index, java_lang_Class::as_klassOop(patch()));
 } else {
 guarantee_property(java_lang_String::is_instance(patch()),
 "Illegal class patch at %d in class file %s",
 index, CHECK);
-symbolHandle name = java_lang_String::as_symbol(patch(), CHECK);
+Symbol* name = java_lang_String::as_symbol(patch(), CHECK);
-cp->unresolved_klass_at_put(index, name());
+cp->unresolved_klass_at_put(index, name);
 }
 break;
 case JVM_CONSTANT_UnresolvedString :
 // Patching a string means pre-resolving it.
 class NameSigHash: public ResourceObj {
 public:
-symbolOop     _name;       // name
+Symbol*       _name;       // name
-symbolOop     _sig;        // signature
+Symbol*       _sig;        // signature
 NameSigHash*  _next;       // Next entry in hash table
 };
 #define HASH_ROW_SIZE 256
-unsigned int hash(symbolOop name, symbolOop sig) {
+unsigned int hash(Symbol* name, Symbol* sig) {
 unsigned int raw_hash = 0;
 raw_hash += ((unsigned int)(uintptr_t)name) >> (LogHeapWordSize + 2);
 raw_hash += ((unsigned int)(uintptr_t)sig) >> LogHeapWordSize;
 return (raw_hash + (unsigned int)(uintptr_t)name) % HASH_ROW_SIZE;
 // Return false if the name/sig combination is found in table.
 // Return true if no duplicate is found. And name/sig is added as a new entry in table.
 // The old format checker uses heap sort to find duplicates.
 // NOTE: caller should guarantee that GC doesn't happen during the life cycle
-// of table since we don't expect symbolOop's to move.
+// of table since we don't expect Symbol*'s to move.
-bool put_after_lookup(symbolOop name, symbolOop sig, NameSigHash** table) {
+bool put_after_lookup(Symbol* name, Symbol* sig, NameSigHash** table) {
 assert(name != NULL, "name in constant pool is NULL");
 // First lookup for duplicates
 int index = hash(name, sig);
 NameSigHash* entry = table[index];
 objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,
 int length,
 Handle class_loader,
 Handle protection_domain,
-symbolHandle class_name,
+Symbol* class_name,
 TRAPS) {
 ClassFileStream* cfs = stream();
 assert(length > 0, "only called for length>0");
 objArrayHandle nullHandle;
 objArrayOop interface_oop = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
 "Interface name has bad constant pool index %u in class file %s",
 interface_index, CHECK_(nullHandle));
 if (cp->tag_at(interface_index).is_klass()) {
 interf = KlassHandle(THREAD, cp->resolved_klass_at(interface_index));
 } else {
-symbolHandle unresolved_klass (THREAD, cp->klass_name_at(interface_index));
+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_(nullHandle));
 bool dup = false;
 {
 debug_only(No_Safepoint_Verifier nsv;)
 for (index = 0; index < length; index++) {
 klassOop k = (klassOop)interfaces->obj_at(index);
-symbolOop name = instanceKlass::cast(k)->name();
+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;
 }
 check_property(valid_cp_range(attribute_name_index, cp->length()) &&
 cp->tag_at(attribute_name_index).is_utf8(),
 "Invalid field attribute index %u in class file %s",
 attribute_name_index,
 CHECK);
-symbolOop 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);
 }
 int cp_size = cp->length();
 check_property(
 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_(nullHandle));
-symbolHandle name(THREAD, cp->symbol_at(name_index));
+Symbol*  name = cp->symbol_at(name_index);
 verify_legal_field_name(name, CHECK_(nullHandle));
 u2 signature_index = cfs->get_u2_fast();
 check_property(
 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_(nullHandle));
-symbolHandle sig(THREAD, cp->symbol_at(signature_index));
+Symbol*  sig = cp->symbol_at(signature_index);
 verify_legal_field_signature(name, sig, CHECK_(nullHandle));
 u2 constantvalue_index = 0;
 bool is_synthetic = false;
 u2 generic_signature_index = 0;
 bool dup = false;
 {
 debug_only(No_Safepoint_Verifier nsv;)
 for (int i = 0; i < length*instanceKlass::next_offset; i += instanceKlass::next_offset) {
 int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);
-symbolOop name = cp->symbol_at(name_index);
+Symbol* name = cp->symbol_at(name_index);
 int sig_index = fields->ushort_at(i + instanceKlass::signature_index_offset);
-symbolOop sig = cp->symbol_at(sig_index);
+Symbol* sig = cp->symbol_at(sig_index);
 // If no duplicates, add name/signature in hashtable names_and_sigs.
 if (!put_after_lookup(name, sig, names_and_sigs)) {
 dup = true;
 break;
 }
 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);
-symbolHandle name(THREAD, cp->symbol_at(name_index));
+Symbol*  name = cp->symbol_at(name_index);
-symbolHandle sig(THREAD, 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);
 // 4894874: check special cases for double and long local variables
-if (sig() == vmSymbols::type_signature(T_DOUBLE) ||
+if (sig == vmSymbols::type_signature(T_DOUBLE) ||
-sig() == vmSymbols::type_signature(T_LONG)) {
+sig == vmSymbols::type_signature(T_LONG)) {
 extra_slot = 1;
 }
 }
 guarantee_property((index + extra_slot) < max_locals,
 "Invalid index %u in %s in class file %s",
 }
 return checked_exceptions_start;
 }
 void ClassFileParser::throwIllegalSignature(
-const char* type, symbolHandle name, symbolHandle sig, TRAPS) {
+const char* type, Symbol* name, Symbol* sig, TRAPS) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(THREAD_AND_LOCATION,
 vmSymbols::java_lang_ClassFormatError(),
 "%s \"%s\" in class %s has illegal signature \"%s\"", type,
 name->as_C_string(), _class_name->as_C_string(), sig->as_C_string());
 check_property(
 valid_cp_range(name_index, cp_size) &&
 cp->tag_at(name_index).is_utf8(),
 "Illegal constant pool index %u for method name in class file %s",
 name_index, CHECK_(nullHandle));
-symbolHandle name(THREAD, 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) &&
 cp->tag_at(signature_index).is_utf8(),
 "Illegal constant pool index %u for method signature in class file %s",
 signature_index, CHECK_(nullHandle));
-symbolHandle signature(THREAD, cp->symbol_at(signature_index));
+Symbol*  signature = cp->symbol_at(signature_index);
 AccessFlags access_flags;
 if (name == vmSymbols::class_initializer_name()) {
 // We ignore the access flags for a class initializer. (JVM Spec. p. 116)
 flags = JVM_ACC_STATIC;
 valid_cp_range(method_attribute_name_index, cp_size) &&
 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));
-symbolOop 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(),
 "Code attribute in native or abstract methods in class file %s",
 annotation_default_length,
 NULL,
 0,
 CHECK_(nullHandle));
-if (name() == vmSymbols::finalize_method_name() &&
+if (name == vmSymbols::finalize_method_name() &&
-signature() == vmSymbols::void_method_signature()) {
+signature == vmSymbols::void_method_signature()) {
 if (m->is_empty_method()) {
 _has_empty_finalizer = true;
 } else {
 _has_finalizer = true;
 }
 }
-if (name() == vmSymbols::object_initializer_name() &&
+if (name == vmSymbols::object_initializer_name() &&
-signature() == vmSymbols::void_method_signature() &&
+signature == vmSymbols::void_method_signature() &&
 m->is_vanilla_constructor()) {
 _has_vanilla_constructor = true;
 }
 if (EnableMethodHandles && (m->is_method_handle_invoke() ||
 assert(!m->valid_vtable_index(), "vtable index should not be set");
 m->set_vtable_index(index);
 }
 }
 // Sort method array by ascending method name (for faster lookups & vtable construction)
-// Note that the ordering is not alphabetical, see symbolOopDesc::fast_compare
+// Note that the ordering is not alphabetical, see Symbol::fast_compare
 methodOopDesc::sort_methods(methods(),
 methods_annotations(),
 methods_parameter_annotations(),
 methods_default_annotations());
 // Don't bother storing it if there is no way to retrieve it
 if (JvmtiExport::can_get_source_debug_extension()) {
 // Optimistically assume that only 1 byte UTF format is used
 // (common case)
-symbolOop sde_symbol = oopFactory::new_symbol((char*)sde_buffer,
+TempNewSymbol sde_symbol = SymbolTable::new_symbol((const char*)sde_buffer, length, CHECK);
-length, CHECK);
 k->set_source_debug_extension(sde_symbol);
+// Note that set_source_debug_extension() increments the reference count
+// for its copy of the Symbol*, so use a TempNewSymbol here.
 }
 // Got utf8 string, set stream position forward
 cfs->skip_u1(length, CHECK);
 }
 check_property(
 valid_cp_range(attribute_name_index, cp->length()) &&
 cp->tag_at(attribute_name_index).is_utf8(),
 "Attribute name has bad constant pool index %u in class file %s",
 attribute_name_index, CHECK);
-symbolOop 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);
 }
 h_k()->long_field_put(fd->offset(), fd->long_initial_value());
 break;
 case T_OBJECT:
 {
 #ifdef ASSERT
-symbolOop sym = oopFactory::new_symbol("Ljava/lang/String;", CHECK);
+TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);
 assert(fd->signature() == sym, "just checking");
 #endif
 oop string = fd->string_initial_value(CHECK);
 h_k()->obj_field_put(fd->offset(), string);
 }
 for (int i = 0; i < n; i += instanceKlass::next_offset ) {
 int name_index =
 (*fields_ptr)()->ushort_at(i + instanceKlass::name_index_offset);
 int sig_index  =
 (*fields_ptr)()->ushort_at(i + instanceKlass::signature_index_offset);
-symbolOop f_name = cp->symbol_at(name_index);
+Symbol* f_name = cp->symbol_at(name_index);
-symbolOop f_sig  = cp->symbol_at(sig_index);
+Symbol* f_sig  = cp->symbol_at(sig_index);
 if (f_sig == vmSymbols::reference_signature() && reference_index == 0) {
 // Save the index for reference signature for later use.
 // The fake discovered field does not entries in the
 // constant pool so the index for its signature cannot
 // be extracted from the constant pool.  It will need
 bool found_vmentry = false;
 for (int i = 0; i < fields->length(); i += instanceKlass::next_offset) {
 int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);
 int sig_index  = fields->ushort_at(i + instanceKlass::signature_index_offset);
 int acc_flags  = fields->ushort_at(i + instanceKlass::access_flags_offset);
-symbolOop f_name = cp->symbol_at(name_index);
+Symbol* f_name = cp->symbol_at(name_index);
-symbolOop f_sig  = cp->symbol_at(sig_index);
+Symbol* f_sig  = cp->symbol_at(sig_index);
 if (f_name == vmSymbols::vmentry_name() && (acc_flags & JVM_ACC_STATIC) == 0) {
 if (f_sig == vmSymbols::machine_word_signature()) {
 // If the signature of vmentry is already changed, we're done.
 found_vmentry = true;
 break;
 THROW_MSG(vmSymbols::java_lang_VirtualMachineError(),
 "missing vmentry byte field in java.dyn.MethodHandle");
 }
-instanceKlassHandle ClassFileParser::parseClassFile(symbolHandle name,
+instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
 Handle class_loader,
 Handle protection_domain,
 KlassHandle host_klass,
 GrowableArray<Handle>* cp_patches,
-symbolHandle& parsed_name,
+TempNewSymbol& parsed_name,
 bool verify,
 TRAPS) {
 // So that JVMTI can cache class file in the state before retransformable agents
 // have modified it
 unsigned char *cached_class_file_bytes = NULL;
 // Set the verify flag in stream
 cfs->set_verify(_need_verify);
 // Save the class file name for easier error message printing.
-_class_name = name.not_null()? name : vmSymbolHandles::unknown_class_name();
+_class_name = (name != NULL) ? name : vmSymbols::unknown_class_name();
 cfs->guarantee_more(8, CHECK_(nullHandle));  // magic, major, minor
 // Magic value
 u4 magic = cfs->get_u4_fast();
 guarantee_property(magic == JAVA_CLASSFILE_MAGIC,
 u2 minor_version = cfs->get_u2_fast();
 u2 major_version = cfs->get_u2_fast();
 // Check version numbers - we check this even with verifier off
 if (!is_supported_version(major_version, minor_version)) {
-if (name.is_null()) {
+if (name == NULL) {
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
+vmSymbols::java_lang_UnsupportedClassVersionError(),
 "Unsupported major.minor version %u.%u",
 major_version,
 minor_version);
 } else {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
+vmSymbols::java_lang_UnsupportedClassVersionError(),
 "%s : Unsupported major.minor version %u.%u",
 name->as_C_string(),
 major_version,
 minor_version);
 }
 // 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(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
 // Access flags
 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",
 this_class_index, CHECK_(nullHandle));
-symbolHandle class_name (THREAD, cp->unresolved_klass_at(this_class_index));
+Symbol*  class_name  = cp->unresolved_klass_at(this_class_index);
-assert(class_name.not_null(), "class_name can't be null");
+assert(class_name != NULL, "class_name can't be null");
 // It's important to set parsed_name *before* resolving the super class.
 // (it's used for cleanup by the caller if parsing fails)
 parsed_name = class_name;
+// parsed_name is returned and can be used if there's an error, so add to
+// its reference count.  Caller will decrement the refcount.
+parsed_name->increment_refcount();
 // Update _class_name which could be null previously to be class_name
 _class_name = class_name;
 // Don't need to check whether this class name is legal or not.
 // release all handles when parsing is done
 { HandleMark hm(THREAD);
 // Checks if name in class file matches requested name
-if (name.not_null() && class_name() != name()) {
+if (name != NULL && class_name != name) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_NoClassDefFoundError(),
+vmSymbols::java_lang_NoClassDefFoundError(),
 "%s (wrong name: %s)",
 name->as_C_string(),
 class_name->as_C_string()
 );
 return nullHandle;
 }
 if (TraceClassLoadingPreorder) {
-tty->print("[Loading %s", name()->as_klass_external_name());
+tty->print("[Loading %s", name->as_klass_external_name());
 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) {
-check_property(class_name() == vmSymbols::java_lang_Object(),
+check_property(class_name == vmSymbols::java_lang_Object(),
 "Invalid superclass index %u in class file %s",
 super_class_index,
 CHECK_(nullHandle));
 } else {
 check_property(valid_cp_range(super_class_index, cp_size) &&
 objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop);
 objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop);
 // We check super class after class file is parsed and format is checked
 if (super_class_index > 0 && super_klass.is_null()) {
-symbolHandle sk (THREAD, cp->klass_name_at(super_class_index));
+Symbol*  sk  = cp->klass_name_at(super_class_index);
 if (access_flags.is_interface()) {
 // Before attempting to resolve the superclass, check for class format
 // errors not checked yet.
-guarantee_property(sk() == vmSymbols::java_lang_Object(),
+guarantee_property(sk == vmSymbols::java_lang_Object(),
 "Interfaces must have java.lang.Object as superclass in class file %s",
 CHECK_(nullHandle));
 }
 klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
 sk,
 if (super_klass.not_null()) {
 if (super_klass->is_interface()) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_IncompatibleClassChangeError(),
+vmSymbols::java_lang_IncompatibleClassChangeError(),
 "class %s has interface %s as super class",
 class_name->as_klass_external_name(),
 super_klass->external_name()
 );
 return nullHandle;
 first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
 nonstatic_field_size * heapOopSize;
 next_nonstatic_field_offset = first_nonstatic_field_offset;
 // Add fake fields for java.lang.Class instances (also see below)
-if (class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
+if (class_name == vmSymbols::java_lang_Class() && class_loader.is_null()) {
 java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
 }
 // adjust the vmentry field declaration in java.dyn.MethodHandle
-if (EnableMethodHandles && class_name() == vmSymbols::sun_dyn_MethodHandleImpl() && class_loader.is_null()) {
+if (EnableMethodHandles && class_name == vmSymbols::sun_dyn_MethodHandleImpl() && class_loader.is_null()) {
 java_dyn_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
 }
 // Add a fake "discovered" field if it is not present
 // for compatibility with earlier jdk's.
-if (class_name() == vmSymbols::java_lang_ref_Reference()
+if (class_name == vmSymbols::java_lang_ref_Reference()
 && class_loader.is_null()) {
 java_lang_ref_Reference_fix_pre(&fields, cp, &fac, CHECK_(nullHandle));
 }
 // end of "discovered" field compactibility fix
 nonstatic_oop_counts  = NEW_RESOURCE_ARRAY_IN_THREAD(
 THREAD, unsigned int, nonstatic_oop_count + 1);
 // Add fake fields for java.lang.Class instances (also see above).
 // FieldsAllocationStyle and CompactFields values will be reset to default.
-if(class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
+if(class_name == vmSymbols::java_lang_Class() && class_loader.is_null()) {
 java_lang_Class_fix_post(&next_nonstatic_field_offset);
 nonstatic_oop_offsets[0] = first_nonstatic_field_offset;
 const uint fake_oop_count = (next_nonstatic_field_offset -
 first_nonstatic_field_offset) / heapOopSize;
 nonstatic_oop_counts[0] = fake_oop_count;
 // 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_AssertionStatusDirectives() ||
-class_name() == vmSymbols::java_lang_Class() ||
+class_name == vmSymbols::java_lang_Class() ||
-class_name() == vmSymbols::java_lang_ClassLoader() ||
+class_name == vmSymbols::java_lang_ClassLoader() ||
-class_name() == vmSymbols::java_lang_ref_Reference() ||
+class_name == vmSymbols::java_lang_ref_Reference() ||
-class_name() == vmSymbols::java_lang_ref_SoftReference() ||
+class_name == vmSymbols::java_lang_ref_SoftReference() ||
-class_name() == vmSymbols::java_lang_StackTraceElement() ||
+class_name == vmSymbols::java_lang_StackTraceElement() ||
-class_name() == vmSymbols::java_lang_String() ||
+class_name == vmSymbols::java_lang_String() ||
-class_name() == vmSymbols::java_lang_Throwable() ||
+class_name == vmSymbols::java_lang_Throwable() ||
-class_name() == vmSymbols::java_lang_Boolean() ||
+class_name == vmSymbols::java_lang_Boolean() ||
-class_name() == vmSymbols::java_lang_Character() ||
+class_name == vmSymbols::java_lang_Character() ||
-class_name() == vmSymbols::java_lang_Float() ||
+class_name == vmSymbols::java_lang_Float() ||
-class_name() == vmSymbols::java_lang_Double() ||
+class_name == vmSymbols::java_lang_Double() ||
-class_name() == vmSymbols::java_lang_Byte() ||
+class_name == vmSymbols::java_lang_Byte() ||
-class_name() == vmSymbols::java_lang_Short() ||
+class_name == vmSymbols::java_lang_Short() ||
-class_name() == vmSymbols::java_lang_Integer() ||
+class_name == vmSymbols::java_lang_Integer() ||
-class_name() == vmSymbols::java_lang_Long())) {
+class_name == vmSymbols::java_lang_Long())) {
 allocation_style = 0;     // Allocate oops first
 compact_fields   = false; // Don't compact fields
 }
 if( allocation_style == 0 ) {
 this_klass->set_class_loader(class_loader());
 this_klass->set_nonstatic_field_size(nonstatic_field_size);
 this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
 this_klass->set_static_oop_field_size(fac.static_oop_count);
 cp->set_pool_holder(this_klass());
+error_handler.set_in_error(false);   // turn off error handler for cp
 this_klass->set_constants(cp());
 this_klass->set_local_interfaces(local_interfaces());
 this_klass->set_fields(fields());
 this_klass->set_methods(methods());
 if (has_final_method) {
 if ((super != NULL) &&
 (!Reflection::verify_class_access(this_klass->as_klassOop(), super, false))) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_IllegalAccessError(),
+vmSymbols::java_lang_IllegalAccessError(),
 "class %s cannot access its superclass %s",
 this_klass->external_name(),
 instanceKlass::cast(super)->external_name()
 );
 return;
 assert (k != NULL && Klass::cast(k)->is_interface(), "invalid interface");
 if (!Reflection::verify_class_access(this_klass->as_klassOop(), k, false)) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_IllegalAccessError(),
+vmSymbols::java_lang_IllegalAccessError(),
 "class %s cannot access its superinterface %s",
 this_klass->external_name(),
 instanceKlass::cast(k)->external_name()
 );
 return;
 // skip private, static and <init> methods
 if ((!m->is_private()) &&
 (!m->is_static()) &&
 (m->name() != vmSymbols::object_initializer_name())) {
-symbolOop name = m->name();
+Symbol* name = m->name();
-symbolOop signature = m->signature();
+Symbol* signature = m->signature();
 klassOop k = this_klass->super();
 methodOop super_m = NULL;
 while (k != NULL) {
 // skip supers that don't have final methods.
 if (k->klass_part()->has_final_method()) {
 // this class can access super final method and therefore override
 ) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_VerifyError(),
+vmSymbols::java_lang_VerifyError(),
 "class %s overrides final method %s.%s",
 this_klass->external_name(),
 name->as_C_string(),
 signature->as_C_string()
 );
 // if m is static and not the init method, throw a verify error
 if ((m->is_static()) && (m->name() != vmSymbols::class_initializer_name())) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_VerifyError(),
+vmSymbols::java_lang_VerifyError(),
 "Illegal static method %s in interface %s",
 m->name()->as_C_string(),
 this_klass->external_name()
 );
 return;
 (is_interface && major_gte_15 && (is_super || is_enum)) ||
 (!is_interface && major_gte_15 && is_annotation)) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Illegal class modifiers in class %s: 0x%X",
 _class_name->as_C_string(), flags
 );
 return;
 }
 if (is_illegal) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Illegal field modifiers in class %s: 0x%X",
 _class_name->as_C_string(), flags);
 return;
 }
 }
 void ClassFileParser::verify_legal_method_modifiers(
-jint flags, bool is_interface, symbolHandle name, TRAPS) {
+jint flags, bool is_interface, Symbol* name, TRAPS) {
 if (!_need_verify) { return; }
 const bool is_public       = (flags & JVM_ACC_PUBLIC)       != 0;
 const bool is_private      = (flags & JVM_ACC_PRIVATE)      != 0;
 const bool is_static       = (flags & JVM_ACC_STATIC)       != 0;
 if (is_illegal) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Method %s in class %s has illegal modifiers: 0x%X",
 name->as_C_string(), _class_name->as_C_string(), flags);
 return;
 }
 }
 }  // end of switch
 } // end of for
 }
 // Checks if name is a legal class name.
-void ClassFileParser::verify_legal_class_name(symbolHandle name, TRAPS) {
+void ClassFileParser::verify_legal_class_name(Symbol* name, TRAPS) {
 if (!_need_verify || _relax_verify) { return; }
 char buf[fixed_buffer_size];
 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = name->utf8_length();
 }
 if (!legal) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Illegal class name \"%s\" in class file %s", bytes,
 _class_name->as_C_string()
 );
 return;
 }
 }
 // Checks if name is a legal field name.
-void ClassFileParser::verify_legal_field_name(symbolHandle name, TRAPS) {
+void ClassFileParser::verify_legal_field_name(Symbol* name, TRAPS) {
 if (!_need_verify || _relax_verify) { return; }
 char buf[fixed_buffer_size];
 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = name->utf8_length();
 if (!legal) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Illegal field name \"%s\" in class %s", bytes,
 _class_name->as_C_string()
 );
 return;
 }
 }
 // Checks if name is a legal method name.
-void ClassFileParser::verify_legal_method_name(symbolHandle name, TRAPS) {
+void ClassFileParser::verify_legal_method_name(Symbol* name, TRAPS) {
 if (!_need_verify || _relax_verify) { return; }
-assert(!name.is_null(), "method name is null");
+assert(name != NULL, "method name is null");
 char buf[fixed_buffer_size];
 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = name->utf8_length();
 bool legal = false;
 if (!legal) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_ClassFormatError(),
+vmSymbols::java_lang_ClassFormatError(),
 "Illegal method name \"%s\" in class %s", bytes,
 _class_name->as_C_string()
 );
 return;
 }
 }
 // Checks if signature is a legal field signature.
-void ClassFileParser::verify_legal_field_signature(symbolHandle name, symbolHandle signature, TRAPS) {
+void ClassFileParser::verify_legal_field_signature(Symbol* name, Symbol* signature, TRAPS) {
 if (!_need_verify) { return; }
 char buf[fixed_buffer_size];
 char* bytes = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = signature->utf8_length();
 }
 }
 // Checks if signature is a legal method signature.
 // Returns number of parameters
-int ClassFileParser::verify_legal_method_signature(symbolHandle name, symbolHandle signature, TRAPS) {
+int ClassFileParser::verify_legal_method_signature(Symbol* name, Symbol* signature, TRAPS) {
 if (!_need_verify) {
 // make sure caller's args_size will be less than 0 even for non-static
 // method so it will be recomputed in compute_size_of_parameters().
 return -2;
 }
 args.push_int(unicode_ch);
 // public static boolean isJavaIdentifierStart(char ch);
 JavaCalls::call_static(&result,
 klass,
-vmSymbolHandles::isJavaIdentifierStart_name(),
+vmSymbols::isJavaIdentifierStart_name(),
-vmSymbolHandles::int_bool_signature(),
+vmSymbols::int_bool_signature(),
 &args,
 THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 if (not_first_ch) {
 // public static boolean isJavaIdentifierPart(char ch);
 JavaCalls::call_static(&result,
 klass,
-vmSymbolHandles::isJavaIdentifierPart_name(),
+vmSymbols::isJavaIdentifierPart_name(),
-vmSymbolHandles::int_bool_signature(),
+vmSymbols::int_bool_signature(),
 &args,
 THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;

changeset 8076	96d498ec7ae1
parent 7709	8e90b245b989
child 8296	b1c2163e4e59