src/hotspot/share/opto/valuetypenode.cpp

@@ -188,12 +188,11 @@
   int start = jvms->debug_start();
   int end   = jvms->debug_end();
   // Replace safepoint edge by SafePointScalarObjectNode and add field values
   assert(jvms != NULL, "missing JVMS");
   uint first_ind = (sfpt->req() - jvms->scloff());
-  const TypeValueTypePtr* res_type = value_type_ptr();
-  SafePointScalarObjectNode* sobj = new SafePointScalarObjectNode(res_type,
+  SafePointScalarObjectNode* sobj = new SafePointScalarObjectNode(value_ptr(),
 #ifdef ASSERT
                                                                   NULL,
 #endif
                                                                   first_ind, nfields);
   sobj->init_req(0, root);

@@ -325,11 +324,11 @@
         con_type = Type::make_from_constant(constant, /*require_const=*/ true);
       }
       if (con_type != NULL) {
         // Found a constant field value
         value = gvn.transform(gvn.makecon(con_type));
-        if (con_type->isa_valuetypeptr()) {
+        if (con_type->is_valuetypeptr()) {
           // Constant, non-flattened value type field
           value = ValueTypeNode::make_from_oop(gvn, ctl, mem, value, ft->as_value_klass());
         }
       } else {
         // Load field value from memory

@@ -402,11 +401,11 @@
   }
   // Not able to prove that value type is allocated.
   // Emit runtime check that may be folded later.
   assert(!is_allocated(&kit->gvn()), "should not be allocated");
   RegionNode* region = new RegionNode(3);
-  PhiNode* oop = new PhiNode(region, value_type_ptr());
+  PhiNode* oop = new PhiNode(region, value_ptr());
   PhiNode* io  = new PhiNode(region, Type::ABIO);
   PhiNode* mem = new PhiNode(region, Type::MEMORY, TypePtr::BOTTOM);
 
   // Oop is non-NULL, use it
   region->init_req(1, kit->control());

@@ -593,11 +592,11 @@
     IfNode* iff = gvn.transform(new IfNode(ctl, tst, PROB_MAX, COUNT_UNKNOWN))->as_If();
 
     Node* region = new RegionNode(3);
     region->init_req(1, gvn.transform(new IfTrueNode(iff)));
     region->init_req(2, gvn.transform(new IfFalseNode(iff)));
-    Node* new_oop = new PhiNode(region, vt->value_type_ptr());
+    Node* new_oop = new PhiNode(region, vt->value_ptr());
     new_oop->init_req(1, oop);
     new_oop->init_req(2, gvn.zerocon(T_VALUETYPE));
 
     gvn.hash_delete(vt);
     vt->set_oop(gvn.transform(new_oop));

@@ -664,12 +663,12 @@
       if (lbase == NULL || (lbase != base && base != NULL) || loffset != offset) {
         return NULL;
       } else if (base == NULL) {
         // Set base and check if pointer type matches
         base = lbase;
-        const TypeValueTypePtr* vtptr = phase->type(base)->isa_valuetypeptr();
-        if (vtptr == NULL || !vtptr->value_klass()->equals(vk)) {
+        const TypeInstPtr* vtptr = phase->type(base)->isa_instptr();
+        if (vtptr == NULL || !vtptr->klass()->equals(vk)) {
           return NULL;
         }
       }
     } else if (value->isa_ValueType()) {
       // Check value type field load recursively

@@ -915,10 +914,10 @@
 }
 
 ValueTypePtrNode* ValueTypePtrNode::make_from_oop(PhaseGVN& gvn, Node*& ctl, Node* mem, Node* oop) {
   // Create and initialize a ValueTypePtrNode by loading all field
   // values from a heap-allocated version and also save the oop.
-  ciValueKlass* vk = gvn.type(oop)->is_valuetypeptr()->value_klass();
+  ciValueKlass* vk = gvn.type(oop)->value_klass();
   ValueTypePtrNode* vtptr = new ValueTypePtrNode(vk, oop);
   vtptr->load(gvn, ctl, mem, oop, oop, vk);
   return vtptr;
 }