src/hotspot/share/opto/parse1.cpp

@@ -123,13 +123,13 @@
   case T_FLOAT:   l = new LoadFNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::FLOAT,         MemNode::unordered); break;
   case T_ADDRESS: l = new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM,  MemNode::unordered); break;
   case T_OBJECT:  l = new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM, MemNode::unordered); break;
   case T_VALUETYPE: {
     // Load oop and create a new ValueTypeNode
-    const TypeValueTypePtr* vtptr_type = TypeValueTypePtr::make(type->is_valuetype(), TypePtr::NotNull);
+    const TypeValueTypePtr* vtptr_type = TypeValueTypePtr::make(TypePtr::NotNull, type->is_valuetype()->value_klass());
     l = _gvn.transform(new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, vtptr_type, MemNode::unordered));
-    l = ValueTypeNode::make(this, l);
+    l = ValueTypeNode::make_from_oop(this, l);
     break;
   }
   case T_VALUETYPEPTR: {
     l = new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeValueTypePtr::NOTNULL, MemNode::unordered);
     break;

@@ -806,11 +806,11 @@
     if ((_caller->has_method() || tf()->returns_value_type_as_fields()) &&
         ret_type->isa_valuetypeptr() &&
         !ret_type->is_valuetypeptr()->is__Value()) {
       // When inlining or with multiple return values: return value
       // type as ValueTypeNode not as oop
-      ret_type = ret_type->is_valuetypeptr()->value_type();
+      ret_type = TypeValueType::make(ret_type->is_valuetypeptr()->value_klass());
     }
     int         ret_size = type2size[ret_type->basic_type()];
     Node*       ret_phi  = new PhiNode(region, ret_type);
     gvn().set_type_bottom(ret_phi);
     _exits.ensure_stack(ret_size);

@@ -856,15 +856,15 @@
         // Value type arguments are not passed by reference: we get an
         // argument per field of the value type. Build ValueTypeNodes
         // from the value type arguments.
         const Type* t = tf->domain_sig()->field_at(i);
         if (t->isa_valuetypeptr() && !t->is_valuetypeptr()->is__Value()) {
-          ciValueKlass* vk = t->is_valuetypeptr()->value_type()->value_klass();
+          ciValueKlass* vk = t->is_valuetypeptr()->value_klass();
           Node* ctl = map->control();
-          Node* vt = ValueTypeNode::make(gvn, ctl, map->memory(), start, vk, j, true);
+          ValueTypeNode* vt = ValueTypeNode::make_from_multi(gvn, ctl, map->memory(), start, vk, j, true);
           map->set_control(ctl);
-          map->init_req(i, gvn.transform(vt));
+          map->init_req(i, vt);
           j += vk->value_arg_slots();
         } else {
           Node* parm = gvn.transform(new ParmNode(start, j));
           map->init_req(i, parm);
           // Record all these guys for later GVN.

@@ -876,11 +876,11 @@
       Node* parm = gvn.transform(new ParmNode(start, i));
       // Check if parameter is a value type pointer
       if (gvn.type(parm)->isa_valuetypeptr()) {
         // Create ValueTypeNode from the oop and replace the parameter
         Node* ctl = map->control();
-        parm = ValueTypeNode::make(gvn, ctl, map->memory(), parm);
+        parm = ValueTypeNode::make_from_oop(gvn, ctl, map->memory(), parm);
         map->set_control(ctl);
       }
       map->init_req(i, parm);
       // Record all these guys for later GVN.
       record_for_igvn(parm);