graal-compiler: src/share/vm/classfile/classFileParser.cpp comparison

comparison src/share/vm/classfile/classFileParser.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	18e21237807b 0fa1f71a905b
children	1da7aef31a08

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "classfile/classLoaderData.inline.hpp"
 #include "classfile/defaultMethods.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
+#if INCLUDE_CDS
+#include "classfile/systemDictionaryShared.hpp"
+#endif
 #include "classfile/verificationType.hpp"
 #include "classfile/verifier.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "memory/allocation.hpp"
 #include "memory/gcLocker.hpp"
 #include "runtime/timer.hpp"
 #include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
 #include "utilities/array.hpp"
 #include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
 // We generally try to create the oops directly when parsing, rather than
 // allocating temporary data structures and copying the bytes twice. A
 // temporary area is only needed when parsing utf8 entries in the constant
 // pool and when parsing line number tables.
 // are added to klass's access_flags.
 Array<Method*>* ClassFileParser::parse_methods(bool is_interface,
 AccessFlags* promoted_flags,
 bool* has_final_method,
-bool* has_default_methods,
+bool* declares_default_methods,
 TRAPS) {
 ClassFileStream* cfs = stream();
 cfs->guarantee_more(2, CHECK_NULL);  // length
 u2 length = cfs->get_u2_fast();
 if (length == 0) {
 CHECK_NULL);
 if (method->is_final()) {
 *has_final_method = true;
 }
-if (is_interface && !(*has_default_methods)
+// declares_default_methods: declares concrete instance methods, any access flags
-&& !method->is_abstract() && !method->is_static()
+// used for interface initialization, and default method inheritance analysis
-&& !method->is_private()) {
+if (is_interface && !(*declares_default_methods)
-// default method
+&& !method->is_abstract() && !method->is_static()) {
-*has_default_methods = true;
+*declares_default_methods = true;
 }
 _methods->at_put(index, method());
 }
 if (_need_verify && length > 1) {
 void ClassFileParser::parse_classfile_bootstrap_methods_attribute(u4 attribute_byte_length, TRAPS) {
 ClassFileStream* cfs = stream();
 u1* current_start = cfs->current();
-cfs->guarantee_more(attribute_byte_length, CHECK);
-int attribute_array_length = cfs->get_u2_fast();
-guarantee_property(_max_bootstrap_specifier_index < attribute_array_length,
-"Short length on BootstrapMethods in class file %s",
-CHECK);
 guarantee_property(attribute_byte_length >= sizeof(u2),
 "Invalid BootstrapMethods attribute length %u in class file %s",
 attribute_byte_length,
+CHECK);
+cfs->guarantee_more(attribute_byte_length, CHECK);
+int attribute_array_length = cfs->get_u2_fast();
+guarantee_property(_max_bootstrap_specifier_index < attribute_array_length,
+"Short length on BootstrapMethods in class file %s",
 CHECK);
 // The attribute contains a counted array of counted tuples of shorts,
 // represending bootstrap specifiers:
 //    length*{bootstrap_method_index, argument_count*{argument_index}}
 if (_sde_buffer != NULL) {
 k->set_source_debug_extension(_sde_buffer, _sde_length);
 }
 }
-// Transfer ownership of metadata allocated to the InstanceKlass.
+// Create the Annotations object that will
-void ClassFileParser::apply_parsed_class_metadata(
+// hold the annotations array for the Klass.
-instanceKlassHandle this_klass,
+void ClassFileParser::create_combined_annotations(TRAPS) {
-int java_fields_count, TRAPS) {
+if (_annotations == NULL &&
-// Assign annotations if needed
+_type_annotations == NULL &&
-if (_annotations != NULL || _type_annotations != NULL ||
+_fields_annotations == NULL &&
-_fields_annotations != NULL || _fields_type_annotations != NULL) {
+_fields_type_annotations == NULL) {
+// Don't create the Annotations object unnecessarily.
+return;
+}
 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);
-}
+// This is the Annotations object that will be
+// assigned to InstanceKlass being constructed.
+_combined_annotations = annotations;
+// The annotations arrays below has been transfered the
+// _combined_annotations so these fields can now be cleared.
+_annotations             = NULL;
+_type_annotations        = NULL;
+_fields_annotations      = NULL;
+_fields_type_annotations = NULL;
+}
+// Transfer ownership of metadata allocated to the InstanceKlass.
+void ClassFileParser::apply_parsed_class_metadata(
+instanceKlassHandle this_klass,
+int java_fields_count, TRAPS) {
 _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);
+this_klass->set_annotations(_combined_annotations);
 // Clear out these fields so they don't get deallocated by the destructor
 clear_class_metadata();
 }
 // agent attached, then the cached class bytes may not be the
 // original class bytes.
 JvmtiCachedClassFileData *cached_class_file = NULL;
 Handle class_loader(THREAD, loader_data->class_loader());
 bool has_default_methods = false;
+bool declares_default_methods = false;
 ResourceMark rm(THREAD);
 ClassFileStream* cfs = stream();
 // Timing
 assert(THREAD->is_Java_thread(), "must be a JavaThread");
 _cp_patches = cp_patches;
 instanceKlassHandle nullHandle;
 // Figure out whether we can skip format checking (matching classic VM behavior)
-_need_verify = Verifier::should_verify_for(class_loader(), verify);
+if (DumpSharedSpaces) {
+// verify == true means it's a 'remote' class (i.e., non-boot class)
+// Verification decision is based on BytecodeVerificationRemote flag
+// for those classes.
+_need_verify = (verify) ? BytecodeVerificationRemote :
+BytecodeVerificationLocal;
+} else {
+_need_verify = Verifier::should_verify_for(class_loader(), verify);
+}
 // Set the verify flag in stream
 cfs->set_verify(_need_verify);
 // Save the class file name for easier error message printing.
 magic, CHECK_(nullHandle));
 // Version numbers
 u2 minor_version = cfs->get_u2_fast();
 u2 major_version = cfs->get_u2_fast();
+if (DumpSharedSpaces && major_version < JAVA_1_5_VERSION) {
+ResourceMark rm;
+warning("Pre JDK 1.5 class not supported by CDS: %u.%u %s",
+major_version,  minor_version, name->as_C_string());
+Exceptions::fthrow(
+THREAD_AND_LOCATION,
+vmSymbols::java_lang_UnsupportedClassVersionError(),
+"Unsupported major.minor version for dump time %u.%u",
+major_version,
+minor_version);
+}
 // Check version numbers - we check this even with verifier off
 if (!is_supported_version(major_version, minor_version)) {
 if (name == NULL) {
 Exceptions::fthrow(
 if (TraceClassLoadingPreorder) {
 tty->print("[Loading %s", (name != NULL) ? name->as_klass_external_name() : "NoName");
 if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
 tty->print_cr("]");
 }
+#if INCLUDE_CDS
+if (DumpLoadedClassList != NULL && cfs->source() != NULL && classlist_file->is_open()) {
+// Only dump the classes that can be stored into CDS archive
+if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
+if (name != NULL) {
+ResourceMark rm(THREAD);
+classlist_file->print_cr("%s", name->as_C_string());
+classlist_file->flush();
+}
+}
+}
+#endif
 u2 super_class_index = cfs->get_u2_fast();
 instanceKlassHandle super_klass = parse_super_class(super_class_index,
 CHECK_NULL);
 AccessFlags promoted_flags;
 promoted_flags.set_flags(0);
 Array<Method*>* methods = parse_methods(access_flags.is_interface(),
 &promoted_flags,
 &has_final_method,
-&has_default_methods,
+&declares_default_methods,
 CHECK_(nullHandle));
+if (declares_default_methods) {
+has_default_methods = true;
+}
 // Additional attributes
 ClassAnnotationCollector parsed_annotations;
 parse_classfile_attributes(&parsed_annotations, CHECK_(nullHandle));
+// Finalize the Annotations metadata object,
+// now that all annotation arrays have been created.
+create_combined_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
 cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
 this_klass->set_minor_version(minor_version);
 this_klass->set_major_version(major_version);
 this_klass->set_has_default_methods(has_default_methods);
+this_klass->set_declares_default_methods(declares_default_methods);
 if (!host_klass.is_null()) {
 assert (this_klass->is_anonymous(), "should be the same");
 this_klass->set_host_klass(host_klass());
 }
 check_illegal_static_method(this_klass, CHECK_(nullHandle));
 }
 }
 // Allocate mirror and initialize static fields
-java_lang_Class::create_mirror(this_klass, protection_domain, CHECK_(nullHandle));
+java_lang_Class::create_mirror(this_klass, class_loader, protection_domain,
+CHECK_(nullHandle));
 // Generate any default methods - default methods are interface methods
 // that have a default implementation.  This is new with Lambda project.
 if (has_default_methods ) {
 DefaultMethods::generate_default_methods(
 // print in a single call to reduce interleaving of output
 if (cfs->source() != NULL) {
 tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
 cfs->source());
 } else if (class_loader.is_null()) {
-if (THREAD->is_Java_thread()) {
+Klass* caller =
-Klass* caller = ((JavaThread*)THREAD)->security_get_caller_class(1);
+THREAD->is_Java_thread()
+? ((JavaThread*)THREAD)->security_get_caller_class(1)
+: NULL;
+// caller can be NULL, for example, during a JVMTI VM_Init hook
+if (caller != NULL) {
 tty->print("[Loaded %s by instance of %s]\n",
 this_klass->external_name(),
 InstanceKlass::cast(caller)->external_name());
 } else {
 tty->print("[Loaded %s]\n", this_klass->external_name());
 // Free interfaces
 InstanceKlass::deallocate_interfaces(_loader_data, _super_klass(),
 _local_interfaces, _transitive_interfaces);
-MetadataFactory::free_array<u1>(_loader_data, _annotations);
+if (_combined_annotations != NULL) {
-MetadataFactory::free_array<u1>(_loader_data, _type_annotations);
+// After all annotations arrays have been created, they are installed into the
-Annotations::free_contents(_loader_data, _fields_annotations);
+// Annotations object that will be assigned to the InstanceKlass being created.
-Annotations::free_contents(_loader_data, _fields_type_annotations);
+// Deallocate the Annotations object and the installed annotations arrays.
+_combined_annotations->deallocate_contents(_loader_data);
+// If the _combined_annotations pointer is non-NULL,
+// then the other annotations fields should have been cleared.
+assert(_annotations             == NULL, "Should have been cleared");
+assert(_type_annotations        == NULL, "Should have been cleared");
+assert(_fields_annotations      == NULL, "Should have been cleared");
+assert(_fields_type_annotations == NULL, "Should have been cleared");
+} else {
+// If the annotations arrays were not installed into the Annotations object,
+// then they have to be deallocated explicitly.
+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.  Don't directly deallocate, but add
 // to the deallocate list so that the klass is removed from the CLD::_klasses list

Mercurial > hg > graal-compiler

comparison src/share/vm/classfile/classFileParser.cpp @ 20804:7848fc12602b