src/share/vm/classfile/classFileParser.cpp

@@ -3962,10 +3962,11 @@
   int static_value_type_count = 0;
   int nonstatic_value_type_count = 0;
   int* nonstatic_value_type_indexes = NULL;
   Klass** nonstatic_value_type_klasses = NULL;
   unsigned int value_type_oop_map_count = 0;
+  int not_flattened_value_types = 0;
 
   int max_nonstatic_value_type = fac->count[NONSTATIC_VALUETYPE] + 1;
 
   nonstatic_value_type_indexes = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, int,
                                                               max_nonstatic_value_type);

@@ -3983,21 +3984,33 @@
       Klass* klass = SystemDictionary::resolve_or_fail(signature,
                                                        Handle(THREAD, _loader_data->class_loader()),
                                                        _protection_domain, true, CHECK);
       assert(klass != NULL, "Sanity check");
       assert(klass->access_flags().is_value_type(), "Value type expected");
+      ValueKlass* vk = ValueKlass::cast(klass);
+      // Conditions to apply flattening or not should be defined
+      //in a single place
+      if (vk->size_helper() <= ValueArrayElemMaxFlatSize) {
       nonstatic_value_type_indexes[nonstatic_value_type_count] = fs.index();
       nonstatic_value_type_klasses[nonstatic_value_type_count] = klass;
       nonstatic_value_type_count++;
 
       ValueKlass* vklass = ValueKlass::cast(klass);
       if (vklass->contains_oops()) {
         value_type_oop_map_count += vklass->nonstatic_oop_map_count();
       }
+        fs.set_flattening(true);
+      } else {
+        not_flattened_value_types++;
+        fs.set_flattening(false);
+      }
     }
   }
 
+  // Adjusting non_static_oop_count to take into account not flattened value types;
+  nonstatic_oop_count += not_flattened_value_types;
+
   // Total non-static fields count, including every contended field
   unsigned int nonstatic_fields_count = fac->count[NONSTATIC_DOUBLE] + fac->count[NONSTATIC_WORD] +
                                         fac->count[NONSTATIC_SHORT] + fac->count[NONSTATIC_BYTE] +
                                         fac->count[NONSTATIC_OOP] + fac->count[NONSTATIC_VALUETYPE];
 

@@ -4024,11 +4037,12 @@
   //
   int super_oop_map_count = (_super_klass == NULL) ? 0 :_super_klass->nonstatic_oop_map_count();
   int max_oop_map_count =
       super_oop_map_count +
       fac->count[NONSTATIC_OOP] +
-      value_type_oop_map_count;
+      value_type_oop_map_count +
+      not_flattened_value_types;
 
   OopMapBlocksBuilder* nonstatic_oop_maps = new OopMapBlocksBuilder(max_oop_map_count, THREAD);
   if (super_oop_map_count > 0) {
     nonstatic_oop_maps->initialize_inherited_blocks(_super_klass->start_of_nonstatic_oop_maps(),
                                                     _super_klass->nonstatic_oop_map_count());

@@ -4212,11 +4226,11 @@
       case STATIC_DOUBLE:
         real_offset = next_static_double_offset;
         next_static_double_offset += BytesPerLong;
         break;
       case NONSTATIC_VALUETYPE:
-      {
+        if (fs.is_flatten()) {
         Klass* klass = nonstatic_value_type_klasses[next_value_type_index];
         assert(klass != NULL, "Klass should have been loaded and resolved earlier");
         assert(klass->access_flags().is_value_type(),"Must be a value type");
         ValueKlass* vklass = ValueKlass::cast(klass);
         real_offset = next_nonstatic_valuetype_offset;

@@ -4232,12 +4246,14 @@
           while (map < last_map) {
             nonstatic_oop_maps->add(map->offset() + diff, map->count());
             map++;
           }
         }
-      }
       break;
+        } else {
+          // Fall through
+        }
       case NONSTATIC_OOP:
         if( nonstatic_oop_space_count > 0 ) {
           real_offset = nonstatic_oop_space_offset;
           nonstatic_oop_space_offset += heapOopSize;
           nonstatic_oop_space_count  -= 1;