src/hotspot/share/opto/callGenerator.cpp

@@ -184,11 +184,11 @@
   // Check if return value is a value type pointer
   const TypeValueTypePtr* vtptr = gvn.type(ret)->isa_valuetypeptr();
   if (vtptr != NULL) {
     if (!vtptr->is__Value()) {
       // Create ValueTypeNode from the oop and replace the return value
-      Node* vt = ValueTypeNode::make(&kit, ret);
+      ValueTypeNode* vt = ValueTypeNode::make_from_oop(&kit, ret);
       kit.push_node(T_VALUETYPE, vt);
     } else {
       kit.push_node(T_VALUETYPE, ret);
     }
   } else {

@@ -278,11 +278,11 @@
   Node* ret = kit.set_results_for_java_call(call);
   // Check if return value is a value type pointer
   if (gvn.type(ret)->isa_valuetypeptr()) {
     // Create ValueTypeNode from the oop and replace the return value
     Node* ctl = kit.control();
-    Node* vt = ValueTypeNode::make(&kit, ret);
+    ValueTypeNode* vt = ValueTypeNode::make_from_oop(&kit, ret);
     kit.set_control(ctl);
     kit.push_node(T_VALUETYPE, vt);
   } else {
     kit.push_node(method()->return_type()->basic_type(), ret);
   }

@@ -438,21 +438,21 @@
     const Type* t = domain_sig->field_at(TypeFunc::Parms + i1);
     if (!ValueTypePassFieldsAsArgs) {
       Node* arg = call->in(TypeFunc::Parms + i1);
       if (t->isa_valuetypeptr()) {
         Node* ctl = map->control();
-        arg = ValueTypeNode::make(gvn, ctl, map->memory(), arg);
+        arg = ValueTypeNode::make_from_oop(gvn, ctl, map->memory(), arg);
         map->set_control(ctl);
       }
       map->set_argument(jvms, i1, arg);
     } else {
       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(), call, vk, j, true);
+        ValueTypeNode* vt = ValueTypeNode::make_from_multi(gvn, ctl, map->memory(), call, vk, j, true);
         map->set_control(ctl);
-        map->set_argument(jvms, i1, gvn.transform(vt));
+        map->set_argument(jvms, i1, vt);
         j += vk->value_arg_slots();
       } else {
         map->set_argument(jvms, i1, call->in(j));
         j++;
       }

@@ -504,12 +504,12 @@
     const Type* vt_t = call->_tf->range_sig()->field_at(TypeFunc::Parms);
     bool returned_as_fields = call->tf()->returns_value_type_as_fields();
     if (result->is_ValueType()) {
       ValueTypeNode* vt = result->as_ValueType();
       if (!returned_as_fields) {
-        result = vt->allocate(&kit)->get_oop();
-        result = gvn.transform(new ValueTypePtrNode(vt, result, C));
+        vt = vt->allocate(&kit)->as_ValueType();
+        result = ValueTypePtrNode::make_from_value_type(gvn, vt);
       } else {
         // Return of multiple values (the fields of a value type)
         vt->replace_call_results(&kit, call, C);
         if (gvn.type(vt->get_oop()) == TypePtr::NULL_PTR) {
           result = vt->tagged_klass(gvn);

@@ -520,11 +520,11 @@
     } else if (gvn.type(result)->isa_valuetypeptr() && returned_as_fields) {
       assert(!vt_t->is_valuetypeptr()->is__Value(), "__Value not supported");
       Node* cast = new CheckCastPPNode(NULL, result, vt_t);
       gvn.record_for_igvn(cast);
       Node* ctl = kit.control();
-      ValueTypePtrNode* vtptr = ValueTypePtrNode::make(gvn, ctl, kit.merged_memory(), gvn.transform(cast));
+      ValueTypePtrNode* vtptr = ValueTypePtrNode::make_from_oop(gvn, ctl, kit.merged_memory(), gvn.transform(cast));
       kit.set_control(ctl);
       vtptr->replace_call_results(&kit, call, C);
       result = cast;
     } else if (!return_type->is__Value()) {
       assert(result->is_top(), "what else?");

@@ -916,22 +916,22 @@
   const Type* arg_type = arg->bottom_type();
   const Type* sig_type = TypeOopPtr::make_from_klass(t->as_klass());
   if (t->is_valuetype()) {
     assert(!(arg_type->isa_valuetype() && t->is__Value()), "need a pointer to the value type");
     if (arg_type->isa_valuetypeptr() && !t->is__Value()) {
+      // Value type arguments cannot be NULL
+      sig_type = sig_type->join_speculative(TypePtr::NOTNULL);
       Node* cast = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
-      Node* vt = ValueTypeNode::make(&kit, cast);
+      ValueTypeNode* vt = ValueTypeNode::make_from_oop(&kit, cast);
       kit.set_argument(arg_nb, vt);
     } else {
       assert(t->is__Value() || arg->is_ValueType(), "inconsistent argument");
     }
-  } else {
-    if (arg_type->isa_oopptr() && !arg_type->higher_equal(sig_type)) {
+  } else if (arg_type->isa_oopptr() && !arg_type->higher_equal(sig_type)) {
       Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
       kit.set_argument(arg_nb, cast_obj);
     }
-  }
 }
 
 CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const, bool delayed_forbidden) {
   GraphKit kit(jvms);
   PhaseGVN& gvn = kit.gvn();