8249869: [lworld] Remove LW2 specific code from the JIT

Author: TobiHartmann

src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

@@ -498,20 +498,19 @@ void LIR_Assembler::return_op(LIR_Opr result) {
 
   ciMethod* method = compilation()->method();
 
-  if (InlineTypeReturnedAsFields && method->signature()->returns_never_null()) {
-    ciType* return_type = method->return_type();
-    if (return_type->is_valuetype()) {
-      ciValueKlass* vk = return_type->as_value_klass();
-      if (vk->can_be_returned_as_fields()) {
-        address unpack_handler = vk->unpack_handler();
-        assert(unpack_handler != NULL, "must be");
-        __ far_call(RuntimeAddress(unpack_handler));
-        // At this point, rax points to the value object (for interpreter or C1 caller).
-        // The fields of the object are copied into registers (for C2 caller).
-      }
+  ciType* return_type = method->return_type();
+  if (InlineTypeReturnedAsFields && return_type->is_valuetype()) {
+    ciValueKlass* vk = return_type->as_value_klass();
+    if (vk->can_be_returned_as_fields()) {
+      address unpack_handler = vk->unpack_handler();
+      assert(unpack_handler != NULL, "must be");
+      __ far_call(RuntimeAddress(unpack_handler));
+      // At this point, rax points to the value object (for interpreter or C1 caller).
+      // The fields of the object are copied into registers (for C2 caller).
     }
   }
 
+
   // Pop the stack before the safepoint code
   __ remove_frame(initial_frame_size_in_bytes(), needs_stack_repair());
 
@@ -1586,7 +1585,7 @@ void LIR_Assembler::emit_opFlattenedArrayCheck(LIR_OpFlattenedArrayCheck* op) {
 
 void LIR_Assembler::emit_opNullFreeArrayCheck(LIR_OpNullFreeArrayCheck* op) {
   // This is called when we use aastore into a an array declared as "[LVT;",
-  // where we know VT is not flattenable (due to InlineArrayElemMaxFlatSize, etc).
+  // where we know VT is not flattened (due to InlineArrayElemMaxFlatSize, etc).
   // However, we need to do a NULL check if the actual array is a "[QVT;".
 
   __ load_storage_props(op->tmp()->as_register(), op->array()->as_register());

src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp

@@ -528,21 +528,19 @@ void LIR_Assembler::return_op(LIR_Opr result) {
   }
 
   ciMethod* method = compilation()->method();
-  if (InlineTypeReturnedAsFields && method->signature()->returns_never_null()) {
-    ciType* return_type = method->return_type();
-    if (return_type->is_valuetype()) {
-      ciValueKlass* vk = return_type->as_value_klass();
-      if (vk->can_be_returned_as_fields()) {
+  ciType* return_type = method->return_type();
+  if (InlineTypeReturnedAsFields && return_type->is_valuetype()) {
+    ciValueKlass* vk = return_type->as_value_klass();
+    if (vk->can_be_returned_as_fields()) {
 #ifndef _LP64
-        Unimplemented();
+      Unimplemented();
 #else
-        address unpack_handler = vk->unpack_handler();
-        assert(unpack_handler != NULL, "must be");
-        __ call(RuntimeAddress(unpack_handler));
-        // At this point, rax points to the value object (for interpreter or C1 caller).
-        // The fields of the object are copied into registers (for C2 caller).
+      address unpack_handler = vk->unpack_handler();
+      assert(unpack_handler != NULL, "must be");
+      __ call(RuntimeAddress(unpack_handler));
+      // At this point, rax points to the value object (for interpreter or C1 caller).
+      // The fields of the object are copied into registers (for C2 caller).
 #endif
-      }
     }
   }
 

src/hotspot/share/c1/c1_Canonicalizer.cpp

@@ -647,7 +647,7 @@ void Canonicalizer::do_NewMultiArray  (NewMultiArray*   x) {}
 void Canonicalizer::do_WithField      (WithField*       x) {}
 void Canonicalizer::do_DefaultValue   (DefaultValue*    x) {}
 void Canonicalizer::do_CheckCast      (CheckCast*       x) {
-  if (x->klass()->is_loaded() && !x->is_never_null()) {
+  if (x->klass()->is_loaded() && !x->klass()->is_valuetype()) {
     // Don't canonicalize for non-nullable types -- we need to throw NPE.
     Value obj = x->obj();
     ciType* klass = obj->exact_type();

src/hotspot/share/c1/c1_GraphBuilder.cpp

@@ -1779,9 +1779,6 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
         }
         LoadField* load_field = new LoadField(append(obj), offset, field, true,
                                         state_before, needs_patching);
-        if (field->is_flattenable()) {
-          load_field->set_never_null(true);
-        }
         push(type, append(load_field));
       }
       break;
@@ -1792,7 +1789,7 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
       if (state_before == NULL) {
         state_before = copy_state_for_exception();
       }
-      if (field->type()->basic_type() == T_BOOLEAN) {
+      if (field_type == T_BOOLEAN) {
         Value mask = append(new Constant(new IntConstant(1)));
         val = append(new LogicOp(Bytecodes::_iand, val, mask));
       }
@@ -1814,8 +1811,8 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
         if (!const_oop->is_null_object() && const_oop->is_loaded()) {
           ciConstant field_value = field->constant_value_of(const_oop);
           if (field_value.is_valid()) {
-            if (field->is_flattenable() && field_value.is_null_or_zero()) {
-              // Non-flattened but flattenable inline type field. Replace null by the default value.
+            if (field->signature()->is_Q_signature() && field_value.is_null_or_zero()) {
+              // Non-flattened inline type field. Replace null by the default value.
               constant = new Constant(new InstanceConstant(field->type()->as_value_klass()->default_value_instance()));
             } else {
               constant = make_constant(field_value, field);
@@ -2372,7 +2369,7 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
   }
 
   Invoke* result = new Invoke(code, result_type, recv, args, vtable_index, target, state_before,
-                              declared_signature->returns_never_null());
+                              declared_signature->return_type()->is_valuetype());
   // push result
   append_split(result);
 
@@ -2420,7 +2417,7 @@ void GraphBuilder::new_type_array() {
 void GraphBuilder::new_object_array() {
   bool will_link;
   ciKlass* klass = stream()->get_klass(will_link);
-  bool never_null = stream()->is_klass_never_null();
+  bool never_null = stream()->is_inline_klass();
   ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_exhandling();
   NewArray* n = new NewObjectArray(klass, ipop(), state_before, never_null);
   apush(append_split(n));
@@ -2447,7 +2444,7 @@ bool GraphBuilder::direct_compare(ciKlass* k) {
 void GraphBuilder::check_cast(int klass_index) {
   bool will_link;
   ciKlass* klass = stream()->get_klass(will_link);
-  bool never_null = stream()->is_klass_never_null();
+  bool never_null = stream()->is_inline_klass();
   ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_for_exception();
   CheckCast* c = new CheckCast(klass, apop(), state_before, never_null);
   apush(append_split(c));
@@ -3471,7 +3468,7 @@ ValueStack* GraphBuilder::state_at_entry() {
     // don't allow T_ARRAY to propagate into locals types
     if (is_reference_type(basic_type)) basic_type = T_OBJECT;
     ValueType* vt = as_ValueType(basic_type);
-    state->store_local(idx, new Local(type, vt, idx, false, sig->is_never_null_at(i)));
+    state->store_local(idx, new Local(type, vt, idx, false, type->is_valuetype()));
     idx += type->size();
   }
 

src/hotspot/share/c1/c1_Instruction.hpp

@@ -871,7 +871,9 @@ LEAF(LoadField, AccessField)
             ValueStack* state_before, bool needs_patching,
             ciValueKlass* value_klass = NULL, Value default_value = NULL )
   : AccessField(obj, offset, field, is_static, state_before, needs_patching)
-  {}
+  {
+    set_never_null(field->signature()->is_Q_signature());
+  }
 
   ciType* declared_type() const;
 

src/hotspot/share/c1/c1_LIR.cpp

@@ -1040,7 +1040,7 @@ void LIR_OpJavaCall::emit_code(LIR_Assembler* masm) {
 
 bool LIR_OpJavaCall::maybe_return_as_fields(ciValueKlass** vk_ret) const {
   if (InlineTypeReturnedAsFields) {
-    if (method()->signature()->maybe_returns_never_null()) {
+    if (method()->signature()->maybe_returns_value_type()) {
       ciType* return_type = method()->return_type();
       if (return_type->is_valuetype()) {
         ciValueKlass* vk = return_type->as_value_klass();

src/hotspot/share/c1/c1_LIRGenerator.cpp

@@ -1554,7 +1554,7 @@ void LIRGenerator::do_StoreField(StoreField* x) {
   if (x->needs_null_check() &&
       (needs_patching ||
        MacroAssembler::needs_explicit_null_check(x->offset()))) {
-    if (needs_patching && x->field()->is_flattenable()) {
+    if (needs_patching && x->field()->signature()->is_Q_signature()) {
       // We are storing a field of type "QT;" into holder class H, but H is not yet
       // loaded. (If H had been loaded, then T must also have already been loaded
       // due to the "Q" signature, and needs_patching would be false).
@@ -1693,7 +1693,7 @@ bool LIRGenerator::needs_flattened_array_store_check(StoreIndexed* x) {
     if (type != NULL && type->is_klass()) {
       ciKlass* klass = type->as_klass();
       if (!klass->can_be_value_klass() || (klass->is_valuetype() && !klass->as_value_klass()->flatten_array())) {
-        // This is known to be a non-flattenable object. If the array is flattened,
+        // This is known to be a non-flattened object. If the array is flattened,
         // it will be caught by the code generated by array_store_check().
         return false;
       }
@@ -1900,7 +1900,7 @@ LIR_Opr LIRGenerator::access_resolve(DecoratorSet decorators, LIR_Opr obj) {
   return _barrier_set->resolve(this, decorators, obj);
 }
 
-Constant* LIRGenerator::flattenable_load_field_prolog(LoadField* x, CodeEmitInfo* info) {
+Constant* LIRGenerator::flattened_field_load_prolog(LoadField* x, CodeEmitInfo* info) {
   ciField* field = x->field();
   ciInstanceKlass* holder = field->holder();
   Constant* default_value = NULL;
@@ -2004,8 +2004,8 @@ void LIRGenerator::do_LoadField(LoadField* x) {
 #endif
 
   Constant* default_value = NULL;
-  if (x->field()->is_flattenable()) {
-    default_value = flattenable_load_field_prolog(x, info);
+  if (x->field()->signature()->is_Q_signature()) {
+    default_value = flattened_field_load_prolog(x, info);
   }
 
   bool stress_deopt = StressLoopInvariantCodeMotion && info && info->deoptimize_on_exception();

src/hotspot/share/c1/c1_LIRGenerator.hpp

@@ -268,7 +268,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
   void do_update_CRC32C(Intrinsic* x);
   void do_vectorizedMismatch(Intrinsic* x);
 
-  Constant* flattenable_load_field_prolog(LoadField* x, CodeEmitInfo* info);
+  Constant* flattened_field_load_prolog(LoadField* x, CodeEmitInfo* info);
   void access_flattened_array(bool is_load, LIRItem& array, LIRItem& index, LIRItem& obj_item);
   bool needs_flattened_array_store_check(StoreIndexed* x);
   void check_flattened_array(LIR_Opr array, LIR_Opr value, CodeStub* slow_path);

src/hotspot/share/ci/ciClassList.hpp

@@ -67,7 +67,6 @@ class     ciArrayKlass;
 class       ciValueArrayKlass;
 class       ciObjArrayKlass;
 class       ciTypeArrayKlass;
-class    ciWrapper;
 
 // Simulate Java Language style package-private access with
 // friend declarations.
@@ -115,7 +114,6 @@ friend class ciReplay;                 \
 friend class ciTypeArray;              \
 friend class ciType;                   \
 friend class ciReturnAddress;          \
-friend class ciWrapper;                \
 friend class ciKlass;                  \
 friend class ciInstanceKlass;          \
 friend class ciValueKlass;             \

src/hotspot/share/ci/ciEnv.cpp

@@ -608,10 +608,10 @@ ciKlass* ciEnv::get_klass_by_index(const constantPoolHandle& cpool,
 }
 
 // ------------------------------------------------------------------
-// ciEnv::is_klass_never_null
+// ciEnv::is_inline_klass
 //
-// Get information about nullability from the constant pool.
-bool ciEnv::is_klass_never_null(const constantPoolHandle& cpool, int index) {
+// Check if the klass is an inline klass.
+bool ciEnv::is_inline_klass(const constantPoolHandle& cpool, int index) {
   GUARDED_VM_ENTRY(return cpool->klass_name_at(index)->is_Q_signature();)
 }