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

comparison src/share/vm/classfile/classFileParser.cpp @ 6934:4735d2c84362

7200776: Implement default methods in interfaces Summary: Add generic type analysis and default method selection algorithms Reviewed-by: coleenp, acorn

author	kamg
date	Thu, 11 Oct 2012 12:25:42 -0400
parents	e52361627b65
children	18fb7da42534

comparison

equal deleted inserted replaced

-:a1b8cf9cf970
+:4735d2c84362
 #include "precompiled.hpp"
 #include "classfile/classFileParser.hpp"
 #include "classfile/classLoader.hpp"
 #include "classfile/classLoaderData.hpp"
 #include "classfile/classLoaderData.inline.hpp"
+#include "classfile/defaultMethods.hpp"
+#include "classfile/genericSignatures.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/verificationType.hpp"
 #include "classfile/verifier.hpp"
 #define JAVA_6_VERSION                    50
 // Used for backward compatibility reasons:
 // - to check NameAndType_info signatures more aggressively
 #define JAVA_7_VERSION                    51
+// Extension method support.
+#define JAVA_8_VERSION                    52
 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
 Array<Klass*>* ClassFileParser::parse_interfaces(constantPoolHandle cp,
 int length,
 ClassLoaderData* loader_data,
 Handle protection_domain,
 Symbol* class_name,
+bool* has_default_methods,
 TRAPS) {
 ClassFileStream* cfs = stream();
 assert(length > 0, "only called for length>0");
 // FIXME: Leak at later OOM.
 Array<Klass*>* interfaces = MetadataFactory::new_array<Klass*>(loader_data, length, NULL, CHECK_NULL);
 interf = KlassHandle(THREAD, k);
 }
 if (!Klass::cast(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) {
 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(),
+guarantee_property(
+!access_flags.is_native() && !access_flags.is_abstract(),
 "Code attribute in native or abstract methods in class file %s",
 CHECK_(nullHandle));
 }
 if (parsed_code_attribute) {
 classfile_parse_error("Multiple Code 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(runtime_visible_annotations, runtime_visible_annotations_length, cp, &parsed_annotations, CHECK_(nullHandle));
+parse_annotations(runtime_visible_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();
 assert(runtime_invisible_annotations != NULL, "null invisible annotations");
 guarantee_property(access_flags.is_native() || access_flags.is_abstract() || parsed_code_attribute,
 "Absent Code attribute in method that is not native or abstract in class file %s", CHECK_(nullHandle));
 }
 // All sizing information for a Method* is finally available, now create it
-Method* m = Method::allocate(loader_data, code_length, access_flags,
+Method* m = Method::allocate(
-linenumber_table_length,
+loader_data, code_length, access_flags, linenumber_table_length,
-total_lvt_length,
+total_lvt_length, exception_table_length, checked_exceptions_length,
-exception_table_length,
+ConstMethod::NORMAL, CHECK_(nullHandle));
-checked_exceptions_length,
-CHECK_(nullHandle));
 ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);
 // Fill in information from fixed part (access_flags already set)
 m->set_constants(cp());
 #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);
 // Copy byte codes
 m->set_code(code_start);
 AccessFlags* promoted_flags,
 bool* has_final_method,
 Array<AnnotationArray*>** methods_annotations,
 Array<AnnotationArray*>** methods_parameter_annotations,
 Array<AnnotationArray*>** methods_default_annotations,
+bool* has_default_methods,
 TRAPS) {
 ClassFileStream* cfs = stream();
 AnnotationArray* method_annotations = NULL;
 AnnotationArray* method_parameter_annotations = NULL;
 AnnotationArray* method_default_annotations = NULL;
 &method_default_annotations,
 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());
 if (*methods_annotations == NULL) {
 *methods_annotations =
 MetadataFactory::new_array<AnnotationArray*>(loader_data, length, NULL, CHECK_NULL);
 }
 return annotations;
 }
+#ifndef PRODUCT
+static void parseAndPrintGenericSignatures(
+instanceKlassHandle this_klass, TRAPS) {
+assert(ParseAllGenericSignatures == true, "Shouldn't call otherwise");
+ResourceMark rm;
+if (this_klass->generic_signature() != NULL) {
+using namespace generic;
+ClassDescriptor* spec = ClassDescriptor::parse_generic_signature(this_klass(), CHECK);
+tty->print_cr("Parsing %s", this_klass->generic_signature()->as_C_string());
+spec->print_on(tty);
+for (int i = 0; i < this_klass->methods()->length(); ++i) {
+Method* m = this_klass->methods()->at(i);
+MethodDescriptor* method_spec = MethodDescriptor::parse_generic_signature(m, spec);
+Symbol* sig = m->generic_signature();
+if (sig == NULL) {
+sig = m->signature();
+}
+tty->print_cr("Parsing %s", sig->as_C_string());
+method_spec->print_on(tty);
+}
+}
+}
+#endif // ndef PRODUCT
 instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
 Handle class_loader,
 Handle protection_domain,
 KlassHandle host_klass,
 GrowableArray<Handle>* cp_patches,
 // agent attached, then the cached class bytes may not be the
 // original class bytes.
 unsigned char *cached_class_file_bytes = NULL;
 jint cached_class_file_length;
 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
+bool has_default_methods = false;
+ResourceMark rm(THREAD);
 ClassFileStream* cfs = stream();
 // Timing
 assert(THREAD->is_Java_thread(), "must be a JavaThread");
 JavaThread* jt = (JavaThread*) THREAD;
 u2 itfs_len = cfs->get_u2_fast();
 Array<Klass*>* local_interfaces;
 if (itfs_len == 0) {
 local_interfaces = Universe::the_empty_klass_array();
 } else {
-local_interfaces = parse_interfaces(cp, itfs_len, loader_data, protection_domain, _class_name, CHECK_(nullHandle));
+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;
 &promoted_flags,
 &has_final_method,
 &methods_annotations,
 &methods_parameter_annotations,
 &methods_default_annotations,
+&has_default_methods,
 CHECK_(nullHandle));
 // Additional attributes
 ClassAnnotationCollector parsed_annotations;
 parse_classfile_attributes(loader_data, cp, &parsed_annotations, CHECK_(nullHandle));
 KlassHandle kh (THREAD, k);
 super_klass = instanceKlassHandle(THREAD, kh());
 }
 if (super_klass.not_null()) {
+if (super_klass->has_default_methods()) {
+has_default_methods = true;
+}
 if (super_klass->is_interface()) {
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
 vmSymbols::java_lang_IncompatibleClassChangeError(),
 // Size of Java vtable (in words)
 int vtable_size = 0;
 int itable_size = 0;
 int num_miranda_methods = 0;
-klassVtable::compute_vtable_size_and_num_mirandas(vtable_size,
+GrowableArray<Method*> all_mirandas(20);
-num_miranda_methods,
-super_klass(),
+klassVtable::compute_vtable_size_and_num_mirandas(
-methods,
+&vtable_size, &num_miranda_methods, &all_mirandas, super_klass(), methods,
-access_flags,
+access_flags, class_loader, class_name, local_interfaces,
-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);
 }
 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.
 // (We used to do this lazily, but now we query it in Rewriter,
 // which is eagerly done for every method, so we might as well do it now,
 // when everything is fresh in memory.)
 // JVMTI: we have an InstanceKlass now, tell it about the cached bytes
 this_klass->set_cached_class_file(cached_class_file_bytes,
 cached_class_file_length);
 }
+// Fill in field values obtained by parse_classfile_attributes
+if (parsed_annotations.has_any_annotations())
+parsed_annotations.apply_to(this_klass);
+// Create annotations
+if (_annotations != NULL && this_klass->annotations() == NULL) {
+Annotations* anno = Annotations::allocate(loader_data, CHECK_NULL);
+this_klass->set_annotations(anno);
+}
+apply_parsed_class_attributes(this_klass);
 // Miranda methods
 if ((num_miranda_methods > 0) ||
 // if this class introduced new miranda methods or
 (super_klass.not_null() && (super_klass->has_miranda_methods()))
 // super class exists and this class inherited miranda methods
 ) {
 this_klass->set_has_miranda_methods(); // then set a flag
 }
-// Fill in field values obtained by parse_classfile_attributes
-if (parsed_annotations.has_any_annotations()) {
-parsed_annotations.apply_to(this_klass);
-}
-// Create annotations
-if (_annotations != NULL && this_klass->annotations() == NULL) {
-Annotations* anno = Annotations::allocate(loader_data, CHECK_NULL);
-this_klass->set_annotations(anno);
-}
-apply_parsed_class_attributes(this_klass);
-// Compute transitive closure of interfaces this class implements
 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 in has_finalizer, has_vanilla_constructor, and layout_helper
 set_precomputed_flags(this_klass);
 check_final_method_override(this_klass, CHECK_(nullHandle));
 // check that if this class is an interface then it doesn't have static methods
 if (this_klass->is_interface()) {
 check_illegal_static_method(this_klass, CHECK_(nullHandle));
+}
+#ifdef ASSERT
+if (ParseAllGenericSignatures) {
+parseAndPrintGenericSignatures(this_klass, CHECK_(nullHandle));
+}
+#endif
+// Generate any default methods - default methods are interface methods
+// that have a default implementation.  This is new with Lambda project.
+if (has_default_methods && !access_flags.is_interface() &&
+local_interfaces->length() > 0) {
+DefaultMethods::generate_default_methods(
+this_klass(), &all_mirandas, CHECK_(nullHandle));
 }
 // Allocate mirror and initialize static fields
 java_lang_Class::create_mirror(this_klass, CHECK_(nullHandle));
 ClassLoadingService::notify_class_loaded(InstanceKlass::cast(this_klass()),
 false /* not shared class */);
 if (TraceClassLoading) {
+ResourceMark rm;
 // 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()) {
 InstanceKlass::cast(caller)->external_name());
 } else {
 tty->print("[Loaded %s]\n", this_klass->external_name());
 }
 } else {
-ResourceMark rm;
 tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
 InstanceKlass::cast(class_loader->klass())->external_name());
 }
 }
 if (TraceClassResolution) {
+ResourceMark rm;
 // print out the superclass.
 const char * from = Klass::cast(this_klass())->external_name();
 if (this_klass->java_super() != NULL) {
 tty->print("RESOLVE %s %s (super)\n", from, InstanceKlass::cast(this_klass->java_super())->external_name());
 }
 }
 }
 #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());
 instanceKlassHandle this_klass (THREAD, preserve_this_klass);
 debug_only(this_klass->verify();)
 return this_klass;
 }
 unsigned int
 ClassFileParser::compute_oop_map_count(instanceKlassHandle super,
 unsigned int nonstatic_oop_map_count,
 int first_nonstatic_oop_offset) {
 const bool is_abstract     = (flags & JVM_ACC_ABSTRACT)     != 0;
 const bool is_bridge       = (flags & JVM_ACC_BRIDGE)       != 0;
 const bool is_strict       = (flags & JVM_ACC_STRICT)       != 0;
 const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
 const bool major_gte_15    = _major_version >= JAVA_1_5_VERSION;
+const bool major_gte_8     = _major_version >= JAVA_8_VERSION;
 const bool is_initializer  = (name == vmSymbols::object_initializer_name());
 bool is_illegal = false;
 if (is_interface) {
-if (!is_abstract || !is_public || is_static || is_final ||
+if (!is_public || is_static || is_final || is_native ||
-is_native || (major_gte_15 && (is_synchronized || is_strict))) {
+((is_synchronized || is_strict) && major_gte_15 &&
+(!major_gte_8 || is_abstract)) ||
+(!major_gte_8 && !is_abstract)) {
 is_illegal = true;
 }
 } else { // not interface
 if (is_initializer) {
 if (is_static || is_final || is_synchronized || is_native ||

Mercurial > hg > graal-compiler

comparison src/share/vm/classfile/classFileParser.cpp @ 6934:4735d2c84362