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

equal deleted inserted replaced

-:1e3d7ca55ffc
+:d317e5e08194
 u2 length = cfs->get_u2_fast();
 *java_fields_count_ptr = length;
 int num_injected = 0;
 InjectedField* injected = JavaClasses::get_injected(class_name, &num_injected);
+int total_fields = length + num_injected;
-// Tuples of shorts [access, name index, sig index, initial value index, byte offset, generic signature index]
-typeArrayOop new_fields = oopFactory::new_permanent_shortArray((length + num_injected) * FieldInfo::field_slots, CHECK_(nullHandle));
+// The field array starts with tuples of shorts
-typeArrayHandle fields(THREAD, new_fields);
+// [access, name index, sig index, initial value index, byte offset].
+// A generic signature slot only exists for field with generic
+// signature attribute. And the access flag is set with
+// JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE for that field. The generic
+// signature slots are at the end of the field array and after all
+// other fields data.
+//
+//   f1: [access, name index, sig index, initial value index, low_offset, high_offset]
+//   f2: [access, name index, sig index, initial value index, low_offset, high_offset]
+//       ...
+//   fn: [access, name index, sig index, initial value index, low_offset, high_offset]
+//       [generic signature index]
+//       [generic signature index]
+//       ...
+//
+// Allocate a temporary resource array for field data. For each field,
+// a slot is reserved in the temporary array for the generic signature
+// index. After parsing all fields, the data are copied to a permanent
+// 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));
 typeArrayHandle field_annotations;
+// 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_(nullHandle));  // access_flags, name_index, descriptor_index, attributes_count
 AccessFlags access_flags;
 jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
 (*fields_annotations)->obj_at_put(n, field_annotations());
 }
 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(fields(), n);
+fa[generic_signature_slot] = generic_signature_index;
+generic_signature_slot ++;
+num_generic_signature ++;
+}
+}
+FieldInfo* field = FieldInfo::from_field_array(fa, n);
 field->initialize(access_flags.as_short(),
 name_index,
 signature_index,
 constantvalue_index,
-generic_signature_index,
 0);
 BasicType type = cp->basic_type_for_signature_at(signature_index);
 // Remember how many oops we encountered and compute allocation type
 // The correct offset is computed later (all oop fields will be located together)
 // We temporarily store the allocation type in the offset field
 field->set_offset(atype);
 }
+int index = length;
 if (num_injected != 0) {
-int index = length;
 for (int n = 0; n < num_injected; n++) {
 // Check for duplicates
 if (injected[n].may_be_java) {
 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(fields(), i);
+FieldInfo* f = FieldInfo::from_field_array(fa, i);
 if (name      == cp->symbol_at(f->name_index()) &&
 signature == cp->symbol_at(f->signature_index())) {
 // Symbol is desclared in Java so skip this one
 duplicate = true;
 break;
 continue;
 }
 }
 // Injected field
-FieldInfo* field = FieldInfo::from_field_array(fields(), index);
+FieldInfo* field = FieldInfo::from_field_array(fa, index);
 field->initialize(JVM_ACC_FIELD_INTERNAL,
 injected[n].name_index,
 injected[n].signature_index,
 0,
-0,
 0);
 BasicType type = FieldType::basic_type(injected[n].signature());
 // Remember how many oops we encountered and compute allocation type
 // The correct offset is computed later (all oop fields will be located together)
 // We temporarily store the allocation type in the offset field
 field->set_offset(atype);
 index++;
 }
+}
-if (index < length + num_injected) {
-// sometimes injected fields already exist in the Java source so
+// Now copy the fields' data from the temporary resource array.
-// the fields array could be too long.  In that case trim the
+// Sometimes injected fields already exist in the Java source so
-// fields array.
+// the fields array could be too long.  In that case the
-new_fields = oopFactory::new_permanent_shortArray(index * FieldInfo::field_slots, CHECK_(nullHandle));
+// fields array is trimed. Also unused slots that were reserved
-for (int i = 0; i < index * FieldInfo::field_slots; i++) {
+// for generic signature indexes are discarded.
-new_fields->short_at_put(i, fields->short_at(i));
+typeArrayOop new_fields = oopFactory::new_permanent_shortArray(
-}
+index * FieldInfo::field_slots + num_generic_signature,
-fields = new_fields;
+CHECK_(nullHandle));
-}
+typeArrayHandle fields(THREAD, new_fields);
+{
+int i = 0;
+for (; i < index * FieldInfo::field_slots; i++) {
+new_fields->short_at_put(i, fa[i]);
+}
+for (int j = total_fields * FieldInfo::field_slots;
+j < generic_signature_slot; j++) {
+new_fields->short_at_put(i++, fa[j]);
+}
+assert(i == new_fields->length(), "");
 }
 if (_need_verify && length > 1) {
 // Check duplicated fields
 ResourceMark rm(THREAD);

changeset 12772	d317e5e08194
parent 12587	8f819769ca1b
child 13282	9872915dd78d
child 13195	be27e1b6a4b9
child 13291	9de3b1387cb8