truffle: src/share/vm/classfile/classFileParser.cpp comparison

comparison src/share/vm/classfile/classFileParser.cpp @ 6226:9c9fb30d2b3b

Merge

author	kvn
date	Mon, 16 Jul 2012 19:50:52 -0700
parents	04ade88d9712 6d8f36bcef55
children	dd785aabe02b

comparison

equal deleted inserted replaced

-:54e66510c9cd
+:9c9fb30d2b3b
 }
 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(Handle class_loader, TRAPS) {
 ClassFileStream* cfs = stream();
 constantPoolHandle nullHandle;
 bool is_static, u2 signature_index,
 u2* constantvalue_index_addr,
 bool* is_synthetic_addr,
 u2* generic_signature_index_addr,
 typeArrayHandle* field_annotations,
+ClassFileParser::FieldAnnotationCollector* parsed_annotations,
 TRAPS) {
 ClassFileStream* cfs = stream();
 assert(attributes_count > 0, "length should be greater than 0");
 u2 constantvalue_index = 0;
 u2 generic_signature_index = 0;
 u2 constantvalue_index = 0;
 bool is_synthetic = false;
 u2 generic_signature_index = 0;
 bool is_static = access_flags.is_static();
+FieldAnnotationCollector parsed_annotations;
 u2 attributes_count = cfs->get_u2_fast();
 if (attributes_count > 0) {
 parse_field_attributes(cp, attributes_count, is_static, signature_index,
 &constantvalue_index, &is_synthetic,
 &generic_signature_index, &field_annotations,
+&parsed_annotations,
 CHECK_(nullHandle));
 if (field_annotations.not_null()) {
 if (fields_annotations->is_null()) {
 objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
 *fields_annotations = objArrayHandle(THREAD, md);
 field->initialize(access_flags.as_short(),
 name_index,
 signature_index,
 constantvalue_index,
 0);
+if (parsed_annotations.has_any_annotations())
+parsed_annotations.apply_to(field);
 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);
 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());
 }
+// Skip an annotation.  Return >=limit if there is any problem.
+int ClassFileParser::skip_annotation(u1* buffer, int limit, int index) {
+// annotation := atype:u2 do(nmem:u2) {member:u2 value}
+// value := switch (tag:u1) { ... }
+index += 2;  // skip atype
+if ((index += 2) >= limit)  return limit;  // read nmem
+int nmem = Bytes::get_Java_u2(buffer+index-2);
+while (--nmem >= 0 && index < limit) {
+index += 2; // skip member
+index = skip_annotation_value(buffer, limit, index);
+}
+return index;
+}
+// Skip an annotation value.  Return >=limit if there is any problem.
+int ClassFileParser::skip_annotation_value(u1* buffer, int limit, int index) {
+// value := switch (tag:u1) {
+//   case B, C, I, S, Z, D, F, J, c: con:u2;
+//   case e: e_class:u2 e_name:u2;
+//   case s: s_con:u2;
+//   case [: do(nval:u2) {value};
+//   case @: annotation;
+//   case s: s_con:u2;
+// }
+if ((index += 1) >= limit)  return limit;  // read tag
+u1 tag = buffer[index-1];
+switch (tag) {
+case 'B': case 'C': case 'I': case 'S': case 'Z':
+case 'D': case 'F': case 'J': case 'c': case 's':
+index += 2;  // skip con or s_con
+break;
+case 'e':
+index += 4;  // skip e_class, e_name
+break;
+case '[':
+{
+if ((index += 2) >= limit)  return limit;  // read nval
+int nval = Bytes::get_Java_u2(buffer+index-2);
+while (--nval >= 0 && index < limit) {
+index = skip_annotation_value(buffer, limit, index);
+}
+}
+break;
+case '@':
+index = skip_annotation(buffer, limit, index);
+break;
+default:
+assert(false, "annotation tag");
+return limit;  //  bad tag byte
+}
+return index;
+}
+// Sift through annotations, looking for those significant to the VM:
+void ClassFileParser::parse_annotations(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 nann = Bytes::get_Java_u2(buffer+index-2);
+enum {  // initial annotation layout
+atype_off = 0,      // utf8 such as 'Ljava/lang/annotation/Retention;'
+count_off = 2,      // u2   such as 1 (one value)
+member_off = 4,     // utf8 such as 'value'
+tag_off = 6,        // u1   such as 'c' (type) or 'e' (enum)
+e_tag_val = 'e',
+e_type_off = 7,   // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;'
+e_con_off = 9,    // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME'
+e_size = 11,     // end of 'e' annotation
+c_tag_val = 'c',
+c_con_off = 7,    // utf8 payload, such as 'I' or 'Ljava/lang/String;'
+c_size = 9,       // end of 'c' annotation
+min_size = 6        // smallest possible size (zero members)
+};
+while ((--nann) >= 0 && (index-2 + min_size <= limit)) {
+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);
+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);
+if (member == NULL)  break;  // invalid member name
+}
+// Here is where parsing particular annotations will take place.
+AnnotationCollector::ID id = coll->annotation_index(aname);
+if (id == AnnotationCollector::_unknown)  continue;
+coll->set_annotation(id);
+// If there are no values, just set the bit and move on:
+if (count == 0)   continue;
+// For the record, here is how annotation payloads can be collected.
+// Suppose we want to capture @Retention.value.  Here is how:
+//if (id == AnnotationCollector::_class_Retention) {
+//  Symbol* payload = NULL;
+//  if (count == 1
+//      && e_size == (index0 - index)  // match size
+//      && e_tag_val == *(abase + tag_off)
+//      && (check_symbol_at(cp, Bytes::get_Java_u2(abase + e_type_off))
+//          == vmSymbols::RetentionPolicy_signature())
+//      && member == vmSymbols::value_name()) {
+//    payload = check_symbol_at(cp, Bytes::get_Java_u2(abase + e_con_off));
+//  }
+//  check_property(payload != NULL,
+//                 "Invalid @Retention annotation at offset %u in class file %s",
+//                 index0, CHECK);
+//  if (payload != NULL) {
+//      payload->increment_refcount();
+//      coll->_class_RetentionPolicy = payload;
+//  }
+//}
+}
+}
+ClassFileParser::AnnotationCollector::ID ClassFileParser::AnnotationCollector::annotation_index(Symbol* name) {
+vmSymbols::SID sid = vmSymbols::find_sid(name);
+switch (sid) {
+case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_ForceInline_signature):
+if (_location != _in_method)  break;  // only allow for methods
+return _method_ForceInline;
+default: break;
+}
+return AnnotationCollector::_unknown;
+}
+void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) {
+fatal("no field annotations yet");
+}
+void ClassFileParser::MethodAnnotationCollector::apply_to(methodHandle m) {
+if (has_annotation(_method_ForceInline))
+m->set_force_inline(true);
+}
+void ClassFileParser::ClassAnnotationCollector::apply_to(instanceKlassHandle k) {
+fatal("no class annotations yet");
+}
 #define MAX_ARGS_SIZE 255
 #define MAX_CODE_SIZE 65535
 #define INITIAL_MAX_LVT_NUMBER 256
 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions
-// attribute is inlined. This is curbersome to avoid since we inline most of the parts in the
+// attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the
 // methodOop to save footprint, so we only know the size of the resulting methodOop when the
 // entire method attribute is parsed.
 //
 // The promoted_flags parameter is used to pass relevant access_flags
 // from the method back up to the containing klass. These flag values
 bool parsed_checked_exceptions_attribute = false;
 bool parsed_stackmap_attribute = false;
 // stackmap attribute - JDK1.5
 typeArrayHandle stackmap_data;
 u2 generic_signature_index = 0;
+MethodAnnotationCollector parsed_annotations;
 u1* runtime_visible_annotations = NULL;
 int runtime_visible_annotations_length = 0;
 u1* runtime_invisible_annotations = NULL;
 int runtime_invisible_annotations_length = 0;
 u1* runtime_visible_parameter_annotations = NULL;
 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));
 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");
 }
 }
 clear_hashtable(lvt_Hash);
 }
+if (parsed_annotations.has_any_annotations())
+parsed_annotations.apply_to(m);
 *method_annotations = assemble_annotations(runtime_visible_annotations,
 runtime_visible_annotations_length,
 runtime_invisible_annotations,
 runtime_invisible_annotations_length,
 CHECK_(nullHandle));
 return typeArrayHandle(THREAD, Universe::the_empty_int_array());
 }
 }
-void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, 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()) &&
 cp->tag_at(sourcefile_index).is_utf8(),
 "Invalid SourceFile attribute at constant pool index %u in class file %s",
 sourcefile_index, CHECK);
-k->set_source_file_name(cp->symbol_at(sourcefile_index));
+set_class_sourcefile(cp->symbol_at(sourcefile_index));
 }
 void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
-instanceKlassHandle k,
 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
 if (JvmtiExport::can_get_source_debug_extension()) {
-k->set_source_debug_extension((char*)sde_buffer, length);
+assert((length+1) > length, "Overflow checking");
+u1* sde = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, u1, length+1);
+for (int i = 0; i < length; i++) {
+sde[i] = sde_buffer[i];
+}
+sde[length] = '\0';
+set_class_sde_buffer((char*)sde, length);
 }
 // Got utf8 string, set stream position forward
 cfs->skip_u1(length, CHECK);
 }
 u2 ClassFileParser::parse_classfile_inner_classes_attribute(u1* inner_classes_attribute_start,
 bool parsed_enclosingmethod_attribute,
 u2 enclosing_method_class_index,
 u2 enclosing_method_method_index,
 constantPoolHandle cp,
-instanceKlassHandle k, TRAPS) {
+TRAPS) {
 ClassFileStream* cfs = stream();
 u1* current_mark = cfs->current();
 u2 length = 0;
 if (inner_classes_attribute_start != NULL) {
 cfs->set_current(inner_classes_attribute_start);
 inner_classes->short_at_put(index++, enclosing_method_method_index);
 }
 assert(index == size, "wrong size");
 // Update instanceKlass with inner class info.
-k->set_inner_classes(inner_classes());
+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, instanceKlassHandle k, TRAPS) {
+void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS) {
-k->set_is_synthetic();
+set_class_synthetic_flag(true);
 }
-void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
+void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS) {
 ClassFileStream* cfs = stream();
 u2 signature_index = cfs->get_u2(CHECK);
 check_property(
 valid_cp_range(signature_index, cp->length()) &&
 cp->tag_at(signature_index).is_utf8(),
 "Invalid constant pool index %u in Signature attribute in class file %s",
 signature_index, CHECK);
-k->set_generic_signature(cp->symbol_at(signature_index));
+set_class_generic_signature(cp->symbol_at(signature_index));
 }
-void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k,
+void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp,
 u4 attribute_byte_length, TRAPS) {
 ClassFileStream* cfs = stream();
 u1* current_start = cfs->current();
 cfs->guarantee_more(2, CHECK);  // length
 cp->set_operands(operands());
 }
-void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
+void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp,
+ClassFileParser::ClassAnnotationCollector* parsed_annotations,
+TRAPS) {
 ClassFileStream* cfs = stream();
 // Set inner classes attribute to default sentinel
-k->set_inner_classes(Universe::the_empty_short_array());
+set_class_inner_classes(typeArrayHandle(THREAD, 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;
 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, k, CHECK);
+parse_classfile_sourcefile_attribute(cp, CHECK);
 } else if (tag == vmSymbols::tag_source_debug_extension()) {
 // Check for SourceDebugExtension tag
-parse_classfile_source_debug_extension_attribute(cp, k, (int)attribute_length, CHECK);
+parse_classfile_source_debug_extension_attribute(cp, (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, k, CHECK);
+parse_classfile_synthetic_attribute(cp, 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, k, CHECK);
+parse_classfile_signature_attribute(cp, 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(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;
 runtime_invisible_annotations = cfs->get_u1_buffer();
 assert(runtime_invisible_annotations != NULL, "null invisible annotations");
 } 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(cp, k, attribute_length, CHECK);
+parse_classfile_bootstrap_methods_attribute(cp, attribute_length, CHECK);
 } else {
 // Unknown attribute
 cfs->skip_u1(attribute_length, CHECK);
 }
 } else {
 typeArrayHandle annotations = assemble_annotations(runtime_visible_annotations,
 runtime_visible_annotations_length,
 runtime_invisible_annotations,
 runtime_invisible_annotations_length,
 CHECK);
-k->set_class_annotations(annotations());
+set_class_annotations(annotations);
 if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) {
 u2 num_of_classes = parse_classfile_inner_classes_attribute(
 inner_classes_attribute_start,
 parsed_innerclasses_attribute,
 enclosing_method_class_index,
 enclosing_method_method_index,
-cp, k, CHECK);
+cp, 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);
 }
 guarantee_property(parsed_bootstrap_methods_attribute,
 "Missing BootstrapMethods attribute in class file %s", CHECK);
 }
 }
+void ClassFileParser::apply_parsed_class_attributes(instanceKlassHandle k) {
+if (_synthetic_flag)
+k->set_is_synthetic();
+if (_sourcefile != NULL) {
+_sourcefile->increment_refcount();
+k->set_source_file_name(_sourcefile);
+}
+if (_generic_signature != NULL) {
+_generic_signature->increment_refcount();
+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());
+k->set_class_annotations(_annotations());
+}
 typeArrayHandle ClassFileParser::assemble_annotations(u1* runtime_visible_annotations,
 int runtime_visible_annotations_length,
 u1* runtime_invisible_annotations,
 int runtime_invisible_annotations_length, TRAPS) {
 NULL,
 jt->get_thread_stat()->perf_recursion_counts_addr(),
 jt->get_thread_stat()->perf_timers_addr(),
 PerfClassTraceTime::PARSE_CLASS);
-_has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
+init_parsed_class_attributes();
-_max_bootstrap_specifier_index = -1;
 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_(nullHandle));
 objArrayHandle methods_annotations(THREAD, methods_annotations_oop);
 objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop);
 objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop);
+// Additional attributes
+ClassAnnotationCollector parsed_annotations;
+parse_classfile_attributes(cp, &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_class_index > 0 && super_klass.is_null()) {
 Symbol*  sk  = cp->klass_name_at(super_class_index);
 if (access_flags.is_interface()) {
 // super class exists and this class inherited miranda methods
 ) {
 this_klass->set_has_miranda_methods(); // then set a flag
 }
-// Additional attributes
+// Fill in field values obtained by parse_classfile_attributes
-parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle));
+if (parsed_annotations.has_any_annotations())
+parsed_annotations.apply_to(this_klass);
-// Make sure this is the end of class file stream
+apply_parsed_class_attributes(this_klass);
-guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
 // VerifyOops believes that once this has been set, the object is completely loaded.
 // Compute transitive closure of interfaces this class implements
 this_klass->set_transitive_interfaces(transitive_interfaces());
 klassItable::setup_itable_offset_table(this_klass);
 // 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);
 // reinitialize modifiers, using the InnerClasses attribute
 int computed_modifiers = this_klass->compute_modifier_flags(CHECK_(nullHandle));
 this_klass->set_modifier_flags(computed_modifiers);

Mercurial > hg > truffle

comparison src/share/vm/classfile/classFileParser.cpp @ 6226:9c9fb30d2b3b