OMWorld Lilliput changes

src/hotspot/cpu/aarch64/c1_CodeStubs_aarch64.cpp

@@ -32,7 +32,6 @@
 #include "c1/c1_Runtime1.hpp"
 #include "classfile/javaClasses.hpp"
 #include "nativeInst_aarch64.hpp"
-#include "runtime/objectMonitor.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "vmreg_aarch64.inline.hpp"
 
@@ -234,14 +233,6 @@ void MonitorExitStub::emit_code(LIR_Assembler* ce) {
   __ far_jump(RuntimeAddress(Runtime1::entry_for(exit_id)));
 }
 
-void LoadKlassStub::emit_code(LIR_Assembler* ce) {
-  assert(UseCompactObjectHeaders, "Only use with compact object headers");
-  __ bind(_entry);
-  Register d = _result->as_register();
-  __ ldr(d, Address(d, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-  __ b(_continuation);
-}
-
 // Implementation of patching:
 // - Copy the code at given offset to an inlined buffer (first the bytes, then the number of bytes)
 // - Replace original code with a call to the stub

src/hotspot/cpu/aarch64/c2_CodeStubs_aarch64.cpp

@@ -91,15 +91,4 @@ void C2HandleAnonOMOwnerStub::emit(C2_MacroAssembler& masm) {
   __ b(continuation());
 }
 
-int C2LoadNKlassStub::max_size() const {
-  return 8;
-}
-
-void C2LoadNKlassStub::emit(C2_MacroAssembler& masm) {
-  __ bind(entry());
-  Register d = dst();
-  __ ldr(d, Address(d, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-  __ b(continuation());
-}
-
 #undef __

src/hotspot/cpu/aarch64/c2_MacroAssembler_aarch64.cpp

@@ -2853,9 +2853,6 @@ bool C2_MacroAssembler::in_scratch_emit_size() {
 }
 
 void C2_MacroAssembler::load_nklass_compact(Register dst, Register obj, Register index, int scale, int disp) {
-  C2LoadNKlassStub* stub = new (Compile::current()->comp_arena()) C2LoadNKlassStub(dst);
-  Compile::current()->output()->add_stub(stub);
-
   // Note: Don't clobber obj anywhere in that method!
 
   // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
@@ -2871,10 +2868,5 @@ void C2_MacroAssembler::load_nklass_compact(Register dst, Register obj, Register
     lea(dst, Address(obj, index, Address::lsl(scale)));
     ldr(dst, Address(dst, offset));
   }
-  // NOTE: We can't use tbnz here, because the target is sometimes too far away
-  // and cannot be encoded.
-  tst(dst, markWord::monitor_value);
-  br(Assembler::NE, stub->entry());
-  bind(stub->continuation());
   lsr(dst, dst, markWord::klass_shift);
 }

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -4483,17 +4483,7 @@ void MacroAssembler::load_method_holder(Register holder, Register method) {
 void MacroAssembler::load_nklass(Register dst, Register src) {
   assert(UseCompactObjectHeaders, "expects UseCompactObjectHeaders");
 
-  Label fast;
-
-  // Check if we can take the (common) fast path, if obj is unlocked.
   ldr(dst, Address(src, oopDesc::mark_offset_in_bytes()));
-  tbz(dst, exact_log2(markWord::monitor_value), fast);
-
-  // Fetch displaced header
-  ldr(dst, Address(dst, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-
-  // Fast-path: shift and decode Klass*.
-  bind(fast);
   lsr(dst, dst, markWord::klass_shift);
 }
 

src/hotspot/cpu/arm/c1_CodeStubs_arm.cpp

@@ -217,11 +217,6 @@ void MonitorExitStub::emit_code(LIR_Assembler* ce) {
   __ b(_continuation);
 }
 
-void LoadKlassStub::emit_code(LIR_Assembler* ce) {
-  // Currently not needed.
-  Unimplemented();
-}
-
 // Call return is directly after patch word
 int PatchingStub::_patch_info_offset = 0;
 

src/hotspot/cpu/ppc/c1_CodeStubs_ppc.cpp

@@ -298,11 +298,6 @@ void MonitorExitStub::emit_code(LIR_Assembler* ce) {
   __ b(_continuation);
 }
 
-void LoadKlassStub::emit_code(LIR_Assembler* ce) {
-  // Currently not needed.
-  Unimplemented();
-}
-
 // Implementation of patching:
 // - Copy the code at given offset to an inlined buffer (first the bytes, then the number of bytes).
 // - Replace original code with a call to the stub.

src/hotspot/cpu/s390/c1_CodeStubs_s390.cpp

@@ -253,11 +253,6 @@ void MonitorExitStub::emit_code(LIR_Assembler* ce) {
   __ branch_optimized(Assembler::bcondAlways, _continuation);
 }
 
-void LoadKlassStub::emit_code(LIR_Assembler* ce) {
-  // Currently not needed.
-  Unimplemented();
-}
-
 // Implementation of patching:
 // - Copy the code at given offset to an inlined buffer (first the bytes, then the number of bytes).
 // - Replace original code with a call to the stub.

src/hotspot/cpu/x86/c1_CodeStubs_x86.cpp

@@ -30,7 +30,6 @@
 #include "c1/c1_Runtime1.hpp"
 #include "classfile/javaClasses.hpp"
 #include "nativeInst_x86.hpp"
-#include "runtime/objectMonitor.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "utilities/align.hpp"
 #include "utilities/macros.hpp"
@@ -279,18 +278,6 @@ void MonitorExitStub::emit_code(LIR_Assembler* ce) {
   __ jmp(_continuation);
 }
 
-void LoadKlassStub::emit_code(LIR_Assembler* ce) {
-  assert(UseCompactObjectHeaders, "only with compact headers");
-  __ bind(_entry);
-#ifdef _LP64
-  Register d = _result->as_register();
-  __ movq(d, Address(d, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-  __ jmp(_continuation);
-#else
-  __ should_not_reach_here();
-#endif
-}
-
 // Implementation of patching:
 // - Copy the code at given offset to an inlined buffer (first the bytes, then the number of bytes)
 // - Replace original code with a call to the stub

src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp

@@ -3507,12 +3507,7 @@ void LIR_Assembler::emit_load_klass(LIR_OpLoadKlass* op) {
     assert_different_registers(tmp, obj);
     assert_different_registers(tmp, result);
 
-    // Check if we can take the (common) fast path, if obj is unlocked.
     __ movq(result, Address(obj, oopDesc::mark_offset_in_bytes()));
-    __ testb(result, markWord::monitor_value);
-    __ jcc(Assembler::notZero, *op->stub()->entry());
-    __ bind(*op->stub()->continuation());
-    // Fast-path: shift and decode Klass*.
     __ shrq(result, markWord::klass_shift);
     __ decode_klass_not_null(result, tmp);
   } else if (UseCompressedClassPointers) {

src/hotspot/cpu/x86/c2_CodeStubs_x86.cpp

@@ -225,17 +225,4 @@ void C2FastUnlockPlaceholderStub::emit(C2_MacroAssembler& masm) {
   }
 }
 
-#ifdef _LP64
-int C2LoadNKlassStub::max_size() const {
-  return 10;
-}
-
-void C2LoadNKlassStub::emit(C2_MacroAssembler& masm) {
-  __ bind(entry());
-  Register d = dst();
-  __ movq(d, Address(d, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-  __ jmp(continuation());
-}
-#endif
-
 #undef __

src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp

@@ -6833,9 +6833,6 @@ void C2_MacroAssembler::vector_rearrange_int_float(BasicType bt, XMMRegister dst
 
 #ifdef _LP64
 void C2_MacroAssembler::load_nklass_compact_c2(Register dst, Register obj, Register index, Address::ScaleFactor scale, int disp) {
-  C2LoadNKlassStub* stub = new (Compile::current()->comp_arena()) C2LoadNKlassStub(dst);
-  Compile::current()->output()->add_stub(stub);
-
   // Note: Don't clobber obj anywhere in that method!
 
   // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
@@ -6846,9 +6843,6 @@ void C2_MacroAssembler::load_nklass_compact_c2(Register dst, Register obj, Regis
   // and offset to load the mark-word.
   int offset = oopDesc::mark_offset_in_bytes() + disp - oopDesc::klass_offset_in_bytes();
   movq(dst, Address(obj, index, scale, offset));
-  testb(dst, markWord::monitor_value);
-  jcc(Assembler::notZero, stub->entry());
-  bind(stub->continuation());
   shrq(dst, markWord::klass_shift);
 }
 #endif

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -5329,15 +5329,7 @@ void MacroAssembler::load_method_holder(Register holder, Register method) {
 void MacroAssembler::load_nklass_compact(Register dst, Register src) {
   assert(UseCompactObjectHeaders, "expect compact object headers");
 
-  Label fast;
   movq(dst, Address(src, oopDesc::mark_offset_in_bytes()));
-  testb(dst, markWord::monitor_value);
-  jccb(Assembler::zero, fast);
-
-  // Fetch displaced header
-  movq(dst, Address(dst, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
-
-  bind(fast);
   shrq(dst, markWord::klass_shift);
 }
 #endif

src/hotspot/cpu/x86/x86_64.ad

@@ -4430,7 +4430,7 @@ instruct loadNKlassCompactHeaders(rRegN dst, memory mem, rFlagsReg cr)
     Address::ScaleFactor sf = (index != noreg) ? static_cast<Address::ScaleFactor>($mem$$scale) : Address::no_scale;
     __ load_nklass_compact_c2($dst$$Register, $mem$$base$$Register, index, sf, $mem$$disp);
   %}
-  ins_pipe(pipe_slow); // XXX
+  ins_pipe(ialu_reg_mem); // XXX
 %}
 
 // Load Float

src/hotspot/share/c1/c1_CodeStubs.hpp

@@ -581,22 +581,4 @@ class ArrayCopyStub: public CodeStub {
 #endif // PRODUCT
 };
 
-class LoadKlassStub: public CodeStub {
-private:
-  LIR_Opr          _result;
-
-public:
-  LoadKlassStub(LIR_Opr result) :
-    CodeStub(), _result(result) {};
-
-  virtual void emit_code(LIR_Assembler* e);
-  virtual void visit(LIR_OpVisitState* visitor) {
-    visitor->do_temp(_result);
-    visitor->do_output(_result);
-  }
-#ifndef PRODUCT
-virtual void print_name(outputStream* out) const { out->print("LoadKlassStub"); }
-#endif // PRODUCT
-};
-
 #endif // SHARE_C1_C1_CODESTUBS_HPP

src/hotspot/share/c1/c1_LIR.cpp

@@ -890,7 +890,6 @@ void LIR_OpVisitState::visit(LIR_Op* op) {
 
       do_input(opLoadKlass->_obj);
       do_output(opLoadKlass->_result);
-      if (opLoadKlass->_stub) do_stub(opLoadKlass->_stub);
       if (opLoadKlass->_info) do_info(opLoadKlass->_info);
       break;
     }
@@ -1071,9 +1070,6 @@ void LIR_OpLock::emit_code(LIR_Assembler* masm) {
 
 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
   masm->emit_load_klass(this);
-  if (stub()) {
-    masm->append_code_stub(stub());
-  }
 }
 
 #ifdef ASSERT
@@ -2050,9 +2046,6 @@ void LIR_OpLock::print_instr(outputStream* out) const {
 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
   obj()->print(out);        out->print(" ");
   result_opr()->print(out); out->print(" ");
-  if (stub()) {
-    out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
-  }
 }
 
 #ifdef ASSERT

src/hotspot/share/c1/c1_LIR.hpp

@@ -1903,16 +1903,13 @@ class LIR_OpLoadKlass: public LIR_Op {
 
  private:
   LIR_Opr _obj;
-  CodeStub* _stub;
  public:
-  LIR_OpLoadKlass(LIR_Opr obj, LIR_Opr result, CodeEmitInfo* info, CodeStub* stub)
+  LIR_OpLoadKlass(LIR_Opr obj, LIR_Opr result, CodeEmitInfo* info)
     : LIR_Op(lir_load_klass, result, info)
     , _obj(obj)
-    , _stub(stub)
     {}
 
   LIR_Opr obj()        const { return _obj;  }
-  CodeStub* stub()     const { return _stub; }
 
   virtual LIR_OpLoadKlass* as_OpLoadKlass() { return this; }
   virtual void emit_code(LIR_Assembler* masm);
@@ -2378,7 +2375,7 @@ class LIR_List: public CompilationResourceObj {
   void xadd(LIR_Opr src, LIR_Opr add, LIR_Opr res, LIR_Opr tmp) { append(new LIR_Op2(lir_xadd, src, add, res, tmp)); }
   void xchg(LIR_Opr src, LIR_Opr set, LIR_Opr res, LIR_Opr tmp) { append(new LIR_Op2(lir_xchg, src, set, res, tmp)); }
 
-  void load_klass(LIR_Opr obj, LIR_Opr result, CodeEmitInfo* info, CodeStub* stub) { append(new LIR_OpLoadKlass(obj, result, info, stub)); }
+  void load_klass(LIR_Opr obj, LIR_Opr result, CodeEmitInfo* info) { append(new LIR_OpLoadKlass(obj, result, info)); }
 
 #ifdef ASSERT
   void lir_assert(LIR_Condition condition, LIR_Opr opr1, LIR_Opr opr2, const char* msg, bool halt) { append(new LIR_OpAssert(condition, opr1, opr2, msg, halt)); }

src/hotspot/share/c1/c1_LIRGenerator.cpp

@@ -1256,8 +1256,7 @@ void LIRGenerator::do_isInstance(Intrinsic* x) {
 }
 
 void LIRGenerator::load_klass(LIR_Opr obj, LIR_Opr klass, CodeEmitInfo* null_check_info) {
-  CodeStub* slow_path = UseCompactObjectHeaders ? new LoadKlassStub(klass) : nullptr;
-  __ load_klass(obj, klass, null_check_info, slow_path);
+  __ load_klass(obj, klass, null_check_info);
 }
 
 // Example: object.getClass ()

src/hotspot/share/oops/oop.hpp

@@ -80,8 +80,6 @@ class oopDesc {
   inline markWord cas_set_mark(markWord new_mark, markWord old_mark);
   inline markWord cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order);
 
-  inline markWord resolve_mark() const;
-
   // Returns the prototype mark that should be used for this object.
   inline markWord prototype_mark() const;
 

src/hotspot/share/oops/oop.inline.hpp

@@ -83,15 +83,6 @@ markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memo
   return Atomic::cmpxchg(&_mark, old_mark, new_mark, order);
 }
 
-markWord oopDesc::resolve_mark() const {
-  assert(LockingMode != LM_LEGACY, "Not safe with legacy stack-locking");
-  markWord m = mark();
-  if (m.has_displaced_mark_helper()) {
-    m = m.displaced_mark_helper();
-  }
-  return m;
-}
-
 markWord oopDesc::prototype_mark() const {
   if (UseCompactObjectHeaders) {
     return klass()->prototype_header();
@@ -111,8 +102,7 @@ void oopDesc::init_mark() {
 Klass* oopDesc::klass() const {
 #ifdef _LP64
   if (UseCompactObjectHeaders) {
-    markWord m = resolve_mark();
-    return m.klass();
+    return mark().klass();
   } else if (UseCompressedClassPointers) {
     return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);
   } else
@@ -125,8 +115,7 @@ Klass* oopDesc::klass() const {
 Klass* oopDesc::klass_or_null() const {
 #ifdef _LP64
   if (UseCompactObjectHeaders) {
-    markWord m = resolve_mark();
-    return m.klass_or_null();
+    return mark().klass_or_null();
   } else if (UseCompressedClassPointers) {
     return CompressedKlassPointers::decode(_metadata._compressed_klass);
   } else
@@ -139,11 +128,7 @@ Klass* oopDesc::klass_or_null() const {
 Klass* oopDesc::klass_or_null_acquire() const {
 #ifdef _LP64
   if (UseCompactObjectHeaders) {
-    markWord m = mark_acquire();
-    if (m.has_displaced_mark_helper()) {
-      m = m.displaced_mark_helper();
-    }
-    return m.klass_or_null();
+    return mark_acquire().klass_or_null();
   } else if (UseCompressedClassPointers) {
      narrowKlass nklass = Atomic::load_acquire(&_metadata._compressed_klass);
      return CompressedKlassPointers::decode(nklass);

src/hotspot/share/opto/c2_CodeStubs.hpp

@@ -130,16 +130,6 @@ class C2HandleAnonOMOwnerStub : public C2CodeStub {
   int max_size() const;
   void emit(C2_MacroAssembler& masm);
 };
-
-class C2LoadNKlassStub : public C2CodeStub {
-private:
-  Register _dst;
-public:
-  C2LoadNKlassStub(Register dst) : C2CodeStub(), _dst(dst) {}
-  Register dst() { return _dst; }
-  int max_size() const;
-  void emit(C2_MacroAssembler& masm);
-};
 #endif
 
 class C2FastUnlockPlaceholderStub : public C2CodeStub {