src/hotspot/share/opto/valuetypenode.cpp

@@ -193,11 +193,11 @@
   ciField* field = value_klass()->declared_nonstatic_field_at(index);
   assert(!field->is_flattenable() || field->type()->is_valuetype(), "must be a value type");
   return field->is_flattenable();
 }
 
-int ValueTypeBaseNode::make_scalar_in_safepoint(Unique_Node_List& worklist, SafePointNode* sfpt, Node* root, PhaseGVN* gvn) {
+int ValueTypeBaseNode::make_scalar_in_safepoint(PhaseIterGVN* igvn, Unique_Node_List& worklist, SafePointNode* sfpt) {
   ciValueKlass* vk = value_klass();
   uint nfields = vk->nof_nonstatic_fields();
   JVMState* jvms = sfpt->jvms();
   int start = jvms->debug_start();
   int end   = jvms->debug_end();

@@ -207,52 +207,49 @@
   SafePointScalarObjectNode* sobj = new SafePointScalarObjectNode(value_ptr(),
 #ifdef ASSERT
                                                                   NULL,
 #endif
                                                                   first_ind, nfields);
-  sobj->init_req(0, root);
+  sobj->init_req(0, igvn->C->root());
   // Iterate over the value type fields in order of increasing
   // offset and add the field values to the safepoint.
   for (uint j = 0; j < nfields; ++j) {
     int offset = vk->nonstatic_field_at(j)->offset();
     Node* value = field_value_by_offset(offset, true /* include flattened value type fields */);
     if (value->is_ValueType()) {
-      if (value->as_ValueType()->is_allocated(gvn)) {
-        value = value->as_ValueType()->get_oop();
-      } else {
-        // Add non-flattened value type field to the worklist to process later
+      // Add value type field to the worklist to process later
         worklist.push(value);
       }
-    }
     sfpt->add_req(value);
   }
   jvms->set_endoff(sfpt->req());
-  if (gvn != NULL) {
-    sobj = gvn->transform(sobj)->as_SafePointScalarObject();
-    gvn->igvn_rehash_node_delayed(sfpt);
-  }
+  sobj = igvn->transform(sobj)->as_SafePointScalarObject();
+  igvn->rehash_node_delayed(sfpt);
   return sfpt->replace_edges_in_range(this, sobj, start, end);
 }
 
-void ValueTypeBaseNode::make_scalar_in_safepoints(Node* root, PhaseGVN* gvn) {
+void ValueTypeBaseNode::make_scalar_in_safepoints(PhaseIterGVN* igvn) {
   // Process all safepoint uses and scalarize value type
   Unique_Node_List worklist;
   for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) {
-    Node* u = fast_out(i);
-    if (u->is_SafePoint() && !u->is_CallLeaf() && (!u->is_Call() || u->as_Call()->has_debug_use(this))) {
-      SafePointNode* sfpt = u->as_SafePoint();
-      Node* in_oop = get_oop();
-      const Type* oop_type = in_oop->bottom_type();
-      assert(Opcode() == Op_ValueTypePtr || !isa_ValueType()->is_allocated(gvn), "already heap allocated value types should be linked directly");
-      int nb = make_scalar_in_safepoint(worklist, sfpt, root, gvn);
+    SafePointNode* sfpt = fast_out(i)->isa_SafePoint();
+    if (sfpt != NULL && !sfpt->is_CallLeaf() && (!sfpt->is_Call() || sfpt->as_Call()->has_debug_use(this))) {
+      int nb = 0;
+      if (is_allocated(igvn) && get_oop()->is_Con()) {
+        // Value type is allocated with a constant oop, link it directly
+        nb = sfpt->replace_edges_in_range(this, get_oop(), sfpt->jvms()->debug_start(), sfpt->jvms()->debug_end());
+        igvn->rehash_node_delayed(sfpt);
+      } else {
+        nb = make_scalar_in_safepoint(igvn, worklist, sfpt);
+      }
       --i; imax -= nb;
     }
   }
   // Now scalarize non-flattened fields
   for (uint i = 0; i < worklist.size(); ++i) {
     Node* vt = worklist.at(i);
-    vt->as_ValueType()->make_scalar_in_safepoints(root, gvn);
+    vt->as_ValueType()->make_scalar_in_safepoints(igvn);
   }
 }
 
 void ValueTypeBaseNode::initialize(GraphKit* kit, MultiNode* multi, ciValueKlass* vk, int base_offset, uint& base_input, bool in) {
   assert(base_offset >= 0, "offset in value type must be positive");

@@ -808,17 +805,11 @@
             if (addp != NULL) {
               for (DUIterator_Fast kmax, k = addp->fast_outs(kmax); k < kmax; k++) {
                 StoreNode* store = addp->fast_out(k)->isa_Store();
                 if (store != NULL && store->outcnt() != 0) {
                   // Remove the useless store
-                  Node* mem = store->in(MemNode::Memory);
-                  Node* val = store->in(MemNode::ValueIn);
-                  val = val->is_EncodeP() ? val->in(1) : val;
-                  const Type* val_type = igvn->type(val);
-                  assert(val_type->is_zero_type() || (val->is_Con() && val_type->make_ptr()->is_valuetypeptr()),
-                         "must be zero-type or default value store");
-                  igvn->replace_in_uses(store, mem);
+                  igvn->replace_in_uses(store, store->in(MemNode::Memory));
                 }
               }
             }
           }
           // Replace allocation by pre-allocated oop