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

comparison src/share/vm/classfile/classFileParser.cpp @ 165:437d03ea40b1

6703888: Compressed Oops: use the 32-bits gap after klass in a object Summary: Use the gap also for a narrow oop field and a boxing object value. Reviewed-by: coleenp, never

author	kvn
date	Wed, 21 May 2008 16:31:35 -0700
parents	7f3a69574470
children	1f809e010142

comparison

equal deleted inserted replaced

-:c436414a719e
+:437d03ea40b1
 (fac.static_short_count * BytesPerShort);
 next_static_type_offset     = align_size_up((next_static_byte_offset +
 fac.static_byte_count ), wordSize );
 static_field_size           = (next_static_type_offset -
 next_static_oop_offset) / wordSize;
-first_nonstatic_field_offset = (instanceOopDesc::header_size() +
+first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
-nonstatic_field_size) * wordSize;
+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()) {
 java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
 next_nonstatic_short_offset = next_nonstatic_word_offset +
 (nonstatic_word_count * BytesPerInt);
 next_nonstatic_byte_offset  = next_nonstatic_short_offset +
 (nonstatic_short_count * BytesPerShort);
 next_nonstatic_type_offset  = align_size_up((next_nonstatic_byte_offset +
-nonstatic_byte_count ), wordSize );
+nonstatic_byte_count ), heapOopSize );
 orig_nonstatic_field_size   = nonstatic_field_size +
-((next_nonstatic_type_offset - first_nonstatic_field_offset)/wordSize);
+((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
 }
 #endif
 bool compact_fields   = CompactFields;
 int  allocation_style = FieldsAllocationStyle;
 if( allocation_style < 0 || allocation_style > 1 ) { // Out of range?
 int nonstatic_oop_space_offset;
 int nonstatic_word_space_offset;
 int nonstatic_short_space_offset;
 int nonstatic_byte_space_offset;
-bool compact_into_header = (UseCompressedOops &&
+if( nonstatic_double_count > 0 ) {
-allocation_style == 1 && compact_fields &&
+int offset = next_nonstatic_double_offset;
-!super_has_nonstatic_fields);
-if( compact_into_header || nonstatic_double_count > 0 ) {
-int offset;
-// Pack something in with the header if no super klass has done so.
-if (compact_into_header) {
-offset = oopDesc::klass_gap_offset_in_bytes();
-} else {
-offset = next_nonstatic_double_offset;
-}
 next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
 if( compact_fields && offset != next_nonstatic_double_offset ) {
 // Allocate available fields into the gap before double field.
 int length = next_nonstatic_double_offset - offset;
 assert(length == BytesPerInt, "");
 nonstatic_byte_space_count += 1;
 length -= 1;
 }
 // Allocate oop field in the gap if there are no other fields for that.
 nonstatic_oop_space_offset = offset;
-if(!compact_into_header && length >= heapOopSize &&
+if( length >= heapOopSize && nonstatic_oop_count > 0 &&
-nonstatic_oop_count > 0 &&
 allocation_style != 0 ) { // when oop fields not first
 nonstatic_oop_count      -= 1;
 nonstatic_oop_space_count = 1; // Only one will fit
 length -= heapOopSize;
 offset += heapOopSize;
 if( allocation_style == 0 ) {
 notaligned_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
 } else { // allocation_style == 1
 next_nonstatic_oop_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
 if( nonstatic_oop_count > 0 ) {
-notaligned_offset = next_nonstatic_oop_offset;
 next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
 }
 notaligned_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
 }
-next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
+next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
 nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
-- first_nonstatic_field_offset)/wordSize);
+- first_nonstatic_field_offset)/heapOopSize);
 // Iterate over fields again and compute correct offsets.
 // The field allocation type was temporarily stored in the offset slot.
 // oop fields are located before non-oop fields (static and non-static).
 int len = fields->length();
 }
 // Size of instances
 int instance_size;
+next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
 instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
-assert(instance_size == align_object_size(instanceOopDesc::header_size() + nonstatic_field_size), "consistent layout helper value");
+assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value");
 // Size of non-static oop map blocks (in words) allocated at end of klass
 int nonstatic_oop_map_size = compute_oop_map_size(super_klass, nonstatic_oop_map_count, first_nonstatic_oop_offset);
 // Compute reference type
 }
 #ifndef PRODUCT
 if( PrintCompactFieldsSavings ) {
 if( nonstatic_field_size < orig_nonstatic_field_size ) {
-tty->print("[Saved %d of %3d words in %s]\n",
+tty->print("[Saved %d of %d bytes in %s]\n",
-orig_nonstatic_field_size - nonstatic_field_size,
+(orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
-orig_nonstatic_field_size, this_klass->external_name());
+orig_nonstatic_field_size*heapOopSize,
+this_klass->external_name());
 } else if( nonstatic_field_size > orig_nonstatic_field_size ) {
-tty->print("[Wasted %d over %3d words in %s]\n",
+tty->print("[Wasted %d over %d bytes in %s]\n",
-nonstatic_field_size - orig_nonstatic_field_size,
+(nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
-orig_nonstatic_field_size, this_klass->external_name());
+orig_nonstatic_field_size*heapOopSize,
+this_klass->external_name());
 }
 }
 #endif
 // preserve result across HandleMark

Mercurial > hg > truffle

comparison src/share/vm/classfile/classFileParser.cpp @ 165:437d03ea40b1