Model klass loading directly from OOP rather than OOP + klass pointer offset

robcasloz · robcasloz · commit 6cb4219f101e · 2024-09-16T09:49:29.000+02:00
diff --git a/src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp b/src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp
@@ -6508,13 +6508,3 @@ void C2_MacroAssembler::vector_rearrange_int_float(BasicType bt, XMMRegister dst
     vpermps(dst, shuffle, src, vlen_enc);
   }
 }
-
-#ifdef _LP64
-void C2_MacroAssembler::load_nklass_compact_c2(Register dst, Address src) {
-  // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
-  // obj-start, so that we can load from the object's mark-word instead. Usually the address
-  // comes as obj-start in obj and klass_offset_in_bytes in disp.
-  movq(dst, src.plus_disp(-oopDesc::klass_offset_in_bytes()));
-  shrq(dst, markWord::klass_shift);
-}
-#endif
diff --git a/src/hotspot/cpu/x86/c2_MacroAssembler_x86.hpp b/src/hotspot/cpu/x86/c2_MacroAssembler_x86.hpp
@@ -505,6 +505,4 @@
   void vgather8b_offset(BasicType elem_bt, XMMRegister dst, Register base, Register idx_base,
                               Register offset, Register rtmp, int vlen_enc);
 
-  void load_nklass_compact_c2(Register dst, Address src);
-
 #endif // CPU_X86_C2_MACROASSEMBLER_X86_HPP
diff --git a/src/hotspot/cpu/x86/x86_64.ad b/src/hotspot/cpu/x86/x86_64.ad
@@ -4369,30 +4369,34 @@ instruct loadKlass(rRegP dst, memory mem)
 // Load narrow Klass Pointer
 instruct loadNKlass(rRegN dst, memory mem)
 %{
-  predicate(!UseCompactObjectHeaders);
   match(Set dst (LoadNKlass mem));
 
   ins_cost(125); // XXX
   format %{ "movl    $dst, $mem\t# compressed klass ptr" %}
   ins_encode %{
-    __ movl($dst$$Register, $mem$$Address);
+    if (UseNewCode) {
+      // The incoming address is pointing into obj-start.
+      if (UseCompactObjectHeaders) {
+        __ movq($dst$$Register, $mem$$Address.plus_disp(oopDesc::mark_offset_in_bytes()));
+        __ shrq($dst$$Register, markWord::klass_shift);
+      } else {
+        __ movl($dst$$Register, $mem$$Address.plus_disp(oopDesc::klass_offset_in_bytes()));
+      }
+    } else {
+      if (UseCompactObjectHeaders) {
+        // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
+        // obj-start, so that we can load from the object's mark-word instead. Usually the address
+        // comes as obj-start in obj and klass_offset_in_bytes in disp.
+        __ movq($dst$$Register, $mem$$Address.plus_disp(-oopDesc::klass_offset_in_bytes()));
+        __ shrq($dst$$Register, markWord::klass_shift);
+      } else {
+        __ movl($dst$$Register, $mem$$Address);
+      }
+    }
   %}
   ins_pipe(ialu_reg_mem); // XXX
 %}
 
-instruct loadNKlassCompactHeaders(rRegN dst, memory mem, rFlagsReg cr)
-%{
-  predicate(UseCompactObjectHeaders);
-  match(Set dst (LoadNKlass mem));
-  effect(KILL cr);
-  ins_cost(125); // XXX
-  format %{ "movl    $dst, $mem\t# compressed klass ptr" %}
-  ins_encode %{
-    __ load_nklass_compact_c2($dst$$Register, $mem$$Address);
-  %}
-  ins_pipe(pipe_slow); // XXX
-%}
-
 // Load Float
 instruct loadF(regF dst, memory mem)
 %{
@@ -11730,7 +11734,7 @@ instruct compN_rReg_imm_klass(rFlagsRegU cr, rRegN op1, immNKlass op2) %{
 
 instruct compN_mem_imm_klass(rFlagsRegU cr, memory mem, immNKlass src)
 %{
-  predicate(!UseCompactObjectHeaders);
+  predicate(!UseNewCode && !UseCompactObjectHeaders);
   match(Set cr (CmpN src (LoadNKlass mem)));
 
   format %{ "cmpl    $mem, $src\t# compressed klass ptr" %}
diff --git a/src/hotspot/share/oops/oop.hpp b/src/hotspot/share/oops/oop.hpp
@@ -331,6 +331,7 @@ class oopDesc {
   static int klass_offset_in_bytes()     {
 #ifdef _LP64
     if (UseCompactObjectHeaders) {
+      assert(!UseNewCode, "the prototype solution should not rely on this function");
       // NOTE: The only place where this is used with compact headers is
       // the C2 compiler, and even there we don't use it to access the (narrow)Klass*
       // directly. It is used only as a placeholder to identify the special memory slice
diff --git a/src/hotspot/share/opto/arraycopynode.cpp b/src/hotspot/share/opto/arraycopynode.cpp
@@ -140,7 +140,7 @@ int ArrayCopyNode::get_count(PhaseGVN *phase) const {
       // 3 or 4 elements) might lead to the same length input
       // (e.g. 2 double-words).
       assert(!ary_src->size()->is_con() || (get_length_if_constant(phase) >= 0) ||
-             phase->is_IterGVN() || phase->C->inlining_incrementally() || StressReflectiveCode, "inconsistent");
+             phase->is_IterGVN() || phase->C->inlining_incrementally() || StressReflectiveCode || UseNewCode, "inconsistent");
       if (ary_src->size()->is_con()) {
         return ary_src->size()->get_con();
       }
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
@@ -1362,7 +1362,7 @@ const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const {
       } else if( offset == arrayOopDesc::length_offset_in_bytes() ) {
         // range is OK as-is.
         tj = ta = TypeAryPtr::RANGE;
-      } else if( offset == oopDesc::klass_offset_in_bytes() ) {
+      } else if( !UseNewCode && offset == oopDesc::klass_offset_in_bytes() ) {
         tj = TypeInstPtr::KLASS; // all klass loads look alike
         ta = TypeAryPtr::RANGE; // generic ignored junk
         ptr = TypePtr::BotPTR;
@@ -1524,7 +1524,8 @@ const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const {
   offset = tj->offset();
   assert( offset != Type::OffsetTop, "Offset has fallen from constant" );
 
-  assert( (offset != Type::OffsetBot && tj->base() != Type::AryPtr) ||
+  assert( UseNewCode ||
+          (offset != Type::OffsetBot && tj->base() != Type::AryPtr) ||
           (offset == Type::OffsetBot && tj->base() == Type::AryPtr) ||
           (offset == Type::OffsetBot && tj == TypeOopPtr::BOTTOM) ||
           (offset == Type::OffsetBot && tj == TypePtr::BOTTOM) ||
@@ -1676,7 +1677,10 @@ Compile::AliasType* Compile::find_alias_type(const TypePtr* adr_type, bool no_cr
     // Add a new alias type.
     idx = _num_alias_types++;
     _alias_types[idx]->Init(idx, flat);
-    if (flat == TypeInstPtr::KLASS)  alias_type(idx)->set_rewritable(false);
+    if (flat == TypeInstPtr::KLASS)  {
+      assert(!UseNewCode, "should not exist");
+      alias_type(idx)->set_rewritable(false);
+    }
     if (flat == TypeAryPtr::RANGE)   alias_type(idx)->set_rewritable(false);
     if (flat->isa_instptr()) {
       if (flat->offset() == java_lang_Class::klass_offset()
diff --git a/src/hotspot/share/opto/doCall.cpp b/src/hotspot/share/opto/doCall.cpp
@@ -942,8 +942,12 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
   // Get the exception oop klass from its header
   Node* ex_klass_node = nullptr;
   if (has_exception_handler() && !ex_type->klass_is_exact()) {
-    Node* p = basic_plus_adr( ex_node, ex_node, oopDesc::klass_offset_in_bytes());
-    ex_klass_node = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS, TypeInstKlassPtr::OBJECT));
+    if (UseNewCode) {
+      ex_klass_node = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), ex_node, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+    } else {
+      Node* p = basic_plus_adr( ex_node, ex_node, oopDesc::klass_offset_in_bytes());
+      ex_klass_node = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS, TypeInstKlassPtr::OBJECT));
+    }
 
     // Compute the exception klass a little more cleverly.
     // Obvious solution is to simple do a LoadKlass from the 'ex_node'.
@@ -960,8 +964,13 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
           ex_klass_node->init_req(i, top());
           continue;
         }
-        Node* p = basic_plus_adr(ex_in, ex_in, oopDesc::klass_offset_in_bytes());
-        Node* k = _gvn.transform( LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS, TypeInstKlassPtr::OBJECT));
+        Node* k;
+        if (UseNewCode) {
+          k = _gvn.transform( LoadKlassNode::make(_gvn, nullptr, immutable_memory(), ex_in, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+        } else {
+          Node* p = basic_plus_adr(ex_in, ex_in, oopDesc::klass_offset_in_bytes());
+          k = _gvn.transform( LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS, TypeInstKlassPtr::OBJECT));
+        }
         ex_klass_node->init_req( i, k );
       }
       ex_klass_node = _gvn.transform(ex_klass_node);
diff --git a/src/hotspot/share/opto/escape.cpp b/src/hotspot/share/opto/escape.cpp
@@ -3385,7 +3385,7 @@ bool ConnectionGraph::is_oop_field(Node* n, int offset, bool* unsafe) {
         bt = T_OBJECT;
       }
     }
-  } else if (offset != oopDesc::klass_offset_in_bytes()) {
+  } else if (UseNewCode || offset != oopDesc::klass_offset_in_bytes()) {
     if (adr_type->isa_instptr()) {
       ciField* field = _compile->alias_type(adr_type->isa_instptr())->field();
       if (field != nullptr) {
@@ -4388,7 +4388,9 @@ void ConnectionGraph::split_unique_types(GrowableArray<Node *>  &alloc_worklist,
       // the header emitted during macro expansion wouldn't have
       // correct memory state otherwise.
       _compile->get_alias_index(tinst->add_offset(oopDesc::mark_offset_in_bytes()));
-      _compile->get_alias_index(tinst->add_offset(oopDesc::klass_offset_in_bytes()));
+      if (!UseNewCode) {
+        _compile->get_alias_index(tinst->add_offset(oopDesc::klass_offset_in_bytes()));
+      }
       if (alloc->is_Allocate() && (t->isa_instptr() || t->isa_aryptr())) {
 
         // First, put on the worklist all Field edges from Connection Graph
diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
@@ -1198,6 +1198,9 @@ Node* GraphKit::load_object_klass(Node* obj) {
   // Special-case a fresh allocation to avoid building nodes:
   Node* akls = AllocateNode::Ideal_klass(obj, &_gvn);
   if (akls != nullptr)  return akls;
+  if (UseNewCode) {
+    return _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), obj, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+  }
   Node* k_adr = basic_plus_adr(obj, oopDesc::klass_offset_in_bytes());
   return _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), k_adr, TypeInstPtr::KLASS));
 }
@@ -3661,7 +3664,9 @@ Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
     // Add an edge in the MergeMem for the header fields so an access
     // to one of those has correct memory state
     set_memory(minit_out, C->get_alias_index(oop_type->add_offset(oopDesc::mark_offset_in_bytes())));
-    set_memory(minit_out, C->get_alias_index(oop_type->add_offset(oopDesc::klass_offset_in_bytes())));
+    if (!UseNewCode) {
+      set_memory(minit_out, C->get_alias_index(oop_type->add_offset(oopDesc::klass_offset_in_bytes())));
+    }
     if (oop_type->isa_aryptr()) {
       const TypePtr* telemref = oop_type->add_offset(Type::OffsetBot);
       int            elemidx  = C->get_alias_index(telemref);
diff --git a/src/hotspot/share/opto/library_call.cpp b/src/hotspot/share/opto/library_call.cpp
@@ -2395,6 +2395,7 @@ bool LibraryCallKit::inline_unsafe_access(bool is_store, const BasicType type, c
   Compile::AliasType* alias_type = C->alias_type(adr_type);
   assert(alias_type->index() != Compile::AliasIdxBot, "no bare pointers here");
 
+  assert(!UseNewCode || alias_type->adr_type() != TypeInstPtr::KLASS, "should not exist");
   if (alias_type->adr_type() == TypeInstPtr::KLASS ||
       alias_type->adr_type() == TypeAryPtr::RANGE) {
     set_map(old_map);
diff --git a/src/hotspot/share/opto/macro.cpp b/src/hotspot/share/opto/macro.cpp
@@ -2334,8 +2334,12 @@ void PhaseMacroExpand::expand_subtypecheck_node(SubTypeCheckNode *check) {
     if (_igvn.type(obj_or_subklass)->isa_klassptr()) {
       subklass = obj_or_subklass;
     } else {
-      Node* k_adr = basic_plus_adr(obj_or_subklass, oopDesc::klass_offset_in_bytes());
-      subklass = _igvn.transform(LoadKlassNode::make(_igvn, nullptr, C->immutable_memory(), k_adr, TypeInstPtr::KLASS));
+      if (UseNewCode) {
+        subklass = _igvn.transform(LoadKlassNode::make(_igvn, nullptr, C->immutable_memory(), obj_or_subklass, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+      } else {
+        Node* k_adr = basic_plus_adr(obj_or_subklass, oopDesc::klass_offset_in_bytes());
+        subklass = _igvn.transform(LoadKlassNode::make(_igvn, nullptr, C->immutable_memory(), k_adr, TypeInstPtr::KLASS));
+      }
     }
 
     Node* not_subtype_ctrl = Phase::gen_subtype_check(subklass, superklass, &ctrl, nullptr, _igvn, check->method(), check->bci());
diff --git a/src/hotspot/share/opto/memnode.cpp b/src/hotspot/share/opto/memnode.cpp
@@ -941,7 +941,8 @@ Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypeP
   Compile* C = gvn.C;
 
   // sanity check the alias category against the created node type
-  assert(!(adr_type->isa_oopptr() &&
+  assert(UseNewCode ||
+         !(adr_type->isa_oopptr() &&
            adr_type->offset() == oopDesc::klass_offset_in_bytes()),
          "use LoadKlassNode instead");
   assert(!(adr_type->isa_aryptr() &&
@@ -2408,7 +2409,14 @@ Node* LoadKlassNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const
   const TypePtr *adr_type = adr->bottom_type()->isa_ptr();
   assert(adr_type != nullptr, "expecting TypeKlassPtr");
 #ifdef _LP64
-  if (adr_type->is_ptr_to_narrowklass()) {
+  bool use_load_nklass;
+  if (UseNewCode && adr_type->isa_oopptr() && tk == TypeInstKlassPtr::OBJECT) {
+    // We assume LoadNKlassNode can only load from object header.
+    use_load_nklass = UseCompressedClassPointers;
+  } else {
+    use_load_nklass = adr_type->is_ptr_to_narrowklass();
+  }
+  if (use_load_nklass) {
     assert(UseCompressedClassPointers, "no compressed klasses");
     Node* load_klass = gvn.transform(new LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowklass(), MemNode::unordered));
     return new DecodeNKlassNode(load_klass, load_klass->bottom_type()->make_ptr());
@@ -2473,14 +2481,15 @@ const Type* LoadNode::klass_value_common(PhaseGVN* phase) const {
     }
     if (!tinst->is_loaded())
       return _type;             // Bail out if not loaded
-    if (offset == oopDesc::klass_offset_in_bytes()) {
+    if (!UseNewCode && (offset == oopDesc::klass_offset_in_bytes())) {
       return tinst->as_klass_type(true);
     }
   }
 
   // Check for loading klass from an array
   const TypeAryPtr *tary = tp->isa_aryptr();
-  if (tary != nullptr &&
+  if (!UseNewCode &&
+      tary != nullptr &&
       tary->offset() == oopDesc::klass_offset_in_bytes()) {
     return tary->as_klass_type(true);
   }
@@ -2547,7 +2556,7 @@ Node* LoadNode::klass_identity_common(PhaseGVN* phase) {
 
   // We can fetch the klass directly through an AllocateNode.
   // This works even if the klass is not constant (clone or newArray).
-  if (offset == oopDesc::klass_offset_in_bytes()) {
+  if (!UseNewCode && offset == oopDesc::klass_offset_in_bytes()) {
     Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
     if (allocated_klass != nullptr) {
       return allocated_klass;
diff --git a/src/hotspot/share/opto/parse1.cpp b/src/hotspot/share/opto/parse1.cpp
@@ -2120,8 +2120,13 @@ void Parse::call_register_finalizer() {
   // Insert a dynamic test for whether the instance needs
   // finalization.  In general this will fold up since the concrete
   // class is often visible so the access flags are constant.
-  Node* klass_addr = basic_plus_adr( receiver, receiver, oopDesc::klass_offset_in_bytes() );
-  Node* klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), klass_addr, TypeInstPtr::KLASS));
+  Node* klass;
+  if (UseNewCode) {
+    klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), receiver, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+  } else {
+    Node* klass_addr = basic_plus_adr( receiver, receiver, oopDesc::klass_offset_in_bytes() );
+    klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), klass_addr, TypeInstPtr::KLASS));
+  }
 
   Node* access_flags_addr = basic_plus_adr(klass, klass, in_bytes(Klass::misc_flags_offset()));
   Node* access_flags = make_load(nullptr, access_flags_addr, TypeInt::UBYTE, T_BOOLEAN, MemNode::unordered);
diff --git a/src/hotspot/share/opto/parseHelper.cpp b/src/hotspot/share/opto/parseHelper.cpp
@@ -154,10 +154,15 @@ void Parse::array_store_check() {
   }
 
   // Extract the array klass type
-  int klass_offset = oopDesc::klass_offset_in_bytes();
-  Node* p = basic_plus_adr( ary, ary, klass_offset );
-  // p's type is array-of-OOPS plus klass_offset
-  Node* array_klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS));
+  Node* array_klass;
+  if (UseNewCode) {
+    array_klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), ary, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+  } else {
+    int klass_offset = oopDesc::klass_offset_in_bytes();
+    Node* p = basic_plus_adr( ary, ary, klass_offset );
+    // p's type is array-of-OOPS plus klass_offset
+    array_klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS));
+  }
   // Get the array klass
   const TypeKlassPtr *tak = _gvn.type(array_klass)->is_klassptr();
 
diff --git a/src/hotspot/share/opto/runtime.cpp b/src/hotspot/share/opto/runtime.cpp
@@ -1781,6 +1781,7 @@ const TypeFunc *OptoRuntime::register_finalizer_Type() {
 const TypeFunc *OptoRuntime::class_id_load_barrier_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(1);
+  assert(!UseNewCode, "FIXME");
   fields[TypeFunc::Parms+0] = TypeInstPtr::KLASS;
   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms + 1, fields);
 
diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp
@@ -1161,7 +1161,7 @@ Node *CmpPNode::Ideal( PhaseGVN *phase, bool can_reshape ) {
   Node* ldk2 = AddPNode::Ideal_base_and_offset(adr1, phase, con2);
   if (ldk2 == nullptr)
     return nullptr;
-  if (con2 == oopDesc::klass_offset_in_bytes()) {
+  if (!UseNewCode && con2 == oopDesc::klass_offset_in_bytes()) {
     // We are inspecting an object's concrete class.
     // Short-circuit the check if the query is abstract.
     if (superklass->is_interface() ||
diff --git a/src/hotspot/share/opto/subtypenode.cpp b/src/hotspot/share/opto/subtypenode.cpp
@@ -94,7 +94,7 @@ Node *SubTypeCheckNode::Ideal(PhaseGVN* phase, bool can_reshape) {
   if (addr != nullptr) {
     intptr_t con = 0;
     Node* obj = AddPNode::Ideal_base_and_offset(addr, phase, con);
-    if (con == oopDesc::klass_offset_in_bytes() && obj != nullptr) {
+    if (!UseNewCode && con == oopDesc::klass_offset_in_bytes() && obj != nullptr) {
       assert(is_oop(phase, obj), "only for oop input");
       set_req_X(ObjOrSubKlass, obj, phase);
       return this;
@@ -218,8 +218,12 @@ Node* SubTypeCheckNode::load_klass(PhaseGVN* phase) const {
   const Type* sub_t = phase->type(obj_or_subklass);
   Node* subklass = nullptr;
   if (sub_t->isa_oopptr()) {
-    Node* adr = phase->transform(new AddPNode(obj_or_subklass, obj_or_subklass, phase->MakeConX(oopDesc::klass_offset_in_bytes())));
-    subklass  = phase->transform(LoadKlassNode::make(*phase, nullptr, phase->C->immutable_memory(), adr, TypeInstPtr::KLASS));
+    if (UseNewCode) {
+      subklass = phase->transform(LoadKlassNode::make(*phase, nullptr, phase->C->immutable_memory(), obj_or_subklass, TypeInstPtr::BOTTOM, TypeInstKlassPtr::OBJECT));
+    } else {
+      Node* adr = phase->transform(new AddPNode(obj_or_subklass, obj_or_subklass, phase->MakeConX(oopDesc::klass_offset_in_bytes())));
+      subklass  = phase->transform(LoadKlassNode::make(*phase, nullptr, phase->C->immutable_memory(), adr, TypeInstPtr::KLASS));
+    }
     record_for_cleanup(subklass, phase);
   } else {
     subklass = obj_or_subklass;
@@ -244,4 +248,4 @@ void SubTypeCheckNode::dump_spec(outputStream* st) const {
     st->print(":%d", _bci);
   }
 }
-#endif
+#endif
diff --git a/src/hotspot/share/opto/type.cpp b/src/hotspot/share/opto/type.cpp
@@ -555,8 +555,10 @@ void Type::Initialize_shared(Compile* current) {
   TypeInstPtr::MIRROR  = TypeInstPtr::make(TypePtr::NotNull, current->env()->Class_klass());
   TypeInstPtr::MARK    = TypeInstPtr::make(TypePtr::BotPTR,  current->env()->Object_klass(),
                                            false, nullptr, oopDesc::mark_offset_in_bytes());
-  TypeInstPtr::KLASS   = TypeInstPtr::make(TypePtr::BotPTR,  current->env()->Object_klass(),
+  if (!UseNewCode) {
+    TypeInstPtr::KLASS = TypeInstPtr::make(TypePtr::BotPTR,  current->env()->Object_klass(),
                                            false, nullptr, oopDesc::klass_offset_in_bytes());
+  }
   TypeOopPtr::BOTTOM  = TypeOopPtr::make(TypePtr::BotPTR, OffsetBot, TypeOopPtr::InstanceBot);
 
   TypeMetadataPtr::BOTTOM = TypeMetadataPtr::make(TypePtr::BotPTR, nullptr, OffsetBot);
@@ -3530,7 +3532,7 @@ TypeOopPtr::TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, const TypeInterfaces* inter
   }
 #ifdef _LP64
   if (_offset > 0 || _offset == Type::OffsetTop || _offset == Type::OffsetBot) {
-    if (_offset == oopDesc::klass_offset_in_bytes()) {
+    if (!UseNewCode &&_offset == oopDesc::klass_offset_in_bytes()) {
       _is_ptr_to_narrowklass = UseCompressedClassPointers;
     } else if (klass() == nullptr) {
       // Array with unknown body type
diff --git a/src/hotspot/share/opto/type.hpp b/src/hotspot/share/opto/type.hpp
@@ -1404,7 +1404,7 @@ class TypeAryPtr : public TypeOopPtr {
 
     if (UseCompressedOops && (elem()->make_oopptr() != nullptr && !top_or_bottom) &&
         _offset != 0 && _offset != arrayOopDesc::length_offset_in_bytes() &&
-        _offset != arrayOopDesc::klass_offset_in_bytes()) {
+        (UseNewCode || _offset != arrayOopDesc::klass_offset_in_bytes())) {
       _is_ptr_to_narrowoop = true;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -6508,13 +6508,3 @@ void C2_MacroAssembler::vector_rearrange_int_float(BasicType bt, XMMRegister dst`
`6508`	`6508`	`vpermps(dst, shuffle, src, vlen_enc);`
`6509`	`6509`	`}`
`6510`	`6510`	`}`
`6511`		`-`
`6512`		`-#ifdef _LP64`
`6513`		`-void C2_MacroAssembler::load_nklass_compact_c2(Register dst, Address src) {`
`6514`		`- // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract`
`6515`		`- // obj-start, so that we can load from the object's mark-word instead. Usually the address`
`6516`		`- // comes as obj-start in obj and klass_offset_in_bytes in disp.`
`6517`		`- movq(dst, src.plus_disp(-oopDesc::klass_offset_in_bytes()));`
`6518`		`- shrq(dst, markWord::klass_shift);`
`6519`		`-}`
`6520`		`-#endif`
Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ int ArrayCopyNode::get_count(PhaseGVN *phase) const {`
`140`	`140`	`// 3 or 4 elements) might lead to the same length input`
`141`	`141`	`// (e.g. 2 double-words).`
`142`	`142`	`assert(!ary_src->size()->is_con() \|\| (get_length_if_constant(phase) >= 0) \|\|`
`143`		`- phase->is_IterGVN() \|\| phase->C->inlining_incrementally() \|\| StressReflectiveCode, "inconsistent");`
	`143`	`+ phase->is_IterGVN() \|\| phase->C->inlining_incrementally() \|\| StressReflectiveCode \|\| UseNewCode, "inconsistent");`
`144`	`144`	`if (ary_src->size()->is_con()) {`
`145`	`145`	`return ary_src->size()->get_con();`
`146`	`146`	`}`