< prev index next >

src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

Print this page
*** 982,18 ***
        // ptr or a 64 bit method pointer.
        ShouldNotReachHere();
        __ ldr(dest->as_register(), as_Address(from_addr));
        break;
      case T_ADDRESS:
!       // FIXME: OMG this is a horrible kludge.  Any offset from an
-       // address that matches klass_offset_in_bytes() will be loaded
-       // as a word, not a long.
-       if (UseCompressedClassPointers && addr->disp() == oopDesc::klass_offset_in_bytes()) {
-         __ ldrw(dest->as_register(), as_Address(from_addr));
-       } else {
-         __ ldr(dest->as_register(), as_Address(from_addr));
-       }
        break;
      case T_INT:
        __ ldrw(dest->as_register(), as_Address(from_addr));
        break;
  
--- 982,11 ---
        // ptr or a 64 bit method pointer.
        ShouldNotReachHere();
        __ ldr(dest->as_register(), as_Address(from_addr));
        break;
      case T_ADDRESS:
!       __ ldr(dest->as_register(), as_Address(from_addr));
        break;
      case T_INT:
        __ ldrw(dest->as_register(), as_Address(from_addr));
        break;
  

*** 1028,14 ***
  
      if (!UseZGC) {
        // Load barrier has not yet been applied, so ZGC can't verify the oop here
        __ verify_oop(dest->as_register());
      }
-   } else if (type == T_ADDRESS && addr->disp() == oopDesc::klass_offset_in_bytes()) {
-     if (UseCompressedClassPointers) {
-       __ decode_klass_not_null(dest->as_register());
-     }
    }
  }
  
  
  int LIR_Assembler::array_element_size(BasicType type) const {
--- 1021,10 ---

*** 1247,11 ***
      }
      __ allocate_array(op->obj()->as_register(),
                        len,
                        tmp1,
                        tmp2,
!                       arrayOopDesc::header_size(op->type()),
                        array_element_size(op->type()),
                        op->klass()->as_register(),
                        *op->stub()->entry());
    }
    __ bind(*op->stub()->continuation());
--- 1236,11 ---
      }
      __ allocate_array(op->obj()->as_register(),
                        len,
                        tmp1,
                        tmp2,
!                       arrayOopDesc::base_offset_in_bytes(op->type()),
                        array_element_size(op->type()),
                        op->klass()->as_register(),
                        *op->stub()->entry());
    }
    __ bind(*op->stub()->continuation());

*** 2364,16 ***
    if (flags & LIR_OpArrayCopy::type_check) {
      // We don't know the array types are compatible
      if (basic_type != T_OBJECT) {
        // Simple test for basic type arrays
        if (UseCompressedClassPointers) {
!         __ ldrw(tmp, src_klass_addr);
!         __ ldrw(rscratch1, dst_klass_addr);
          __ cmpw(tmp, rscratch1);
        } else {
!         __ ldr(tmp, src_klass_addr);
!         __ ldr(rscratch1, dst_klass_addr);
          __ cmp(tmp, rscratch1);
        }
        __ br(Assembler::NE, *stub->entry());
      } else {
        // For object arrays, if src is a sub class of dst then we can
--- 2353,16 ---
    if (flags & LIR_OpArrayCopy::type_check) {
      // We don't know the array types are compatible
      if (basic_type != T_OBJECT) {
        // Simple test for basic type arrays
        if (UseCompressedClassPointers) {
!         __ load_nklass(tmp, src);
!         __ load_nklass(rscratch1, dst);
          __ cmpw(tmp, rscratch1);
        } else {
!         __ ldr(tmp, Address(src, oopDesc::klass_offset_in_bytes()));
!         __ ldr(rscratch1, Address(dst, oopDesc::klass_offset_in_bytes()));
          __ cmp(tmp, rscratch1);
        }
        __ br(Assembler::NE, *stub->entry());
      } else {
        // For object arrays, if src is a sub class of dst then we can

*** 2493,40 ***
      // dst type is exactly the expected type and the src type is a
      // subtype which we can't check or src is the same array as dst
      // but not necessarily exactly of type default_type.
      Label known_ok, halt;
      __ mov_metadata(tmp, default_type->constant_encoding());
-     if (UseCompressedClassPointers) {
-       __ encode_klass_not_null(tmp);
-     }
  
      if (basic_type != T_OBJECT) {
! 
-       if (UseCompressedClassPointers) {
-         __ ldrw(rscratch1, dst_klass_addr);
-         __ cmpw(tmp, rscratch1);
-       } else {
-         __ ldr(rscratch1, dst_klass_addr);
-         __ cmp(tmp, rscratch1);
-       }
        __ br(Assembler::NE, halt);
!       if (UseCompressedClassPointers) {
-         __ ldrw(rscratch1, src_klass_addr);
-         __ cmpw(tmp, rscratch1);
-       } else {
-         __ ldr(rscratch1, src_klass_addr);
-         __ cmp(tmp, rscratch1);
-       }
        __ br(Assembler::EQ, known_ok);
      } else {
!       if (UseCompressedClassPointers) {
-         __ ldrw(rscratch1, dst_klass_addr);
-         __ cmpw(tmp, rscratch1);
-       } else {
-         __ ldr(rscratch1, dst_klass_addr);
-         __ cmp(tmp, rscratch1);
-       }
        __ br(Assembler::EQ, known_ok);
        __ cmp(src, dst);
        __ br(Assembler::EQ, known_ok);
      }
      __ bind(halt);
--- 2482,18 ---
      // dst type is exactly the expected type and the src type is a
      // subtype which we can't check or src is the same array as dst
      // but not necessarily exactly of type default_type.
      Label known_ok, halt;
      __ mov_metadata(tmp, default_type->constant_encoding());
  
      if (basic_type != T_OBJECT) {
!       __ cmp_klass(dst, tmp, rscratch1);
        __ br(Assembler::NE, halt);
!       __ cmp_klass(src, tmp, rscratch1);
        __ br(Assembler::EQ, known_ok);
      } else {
!       __ cmp_klass(dst, tmp, rscratch1);
        __ br(Assembler::EQ, known_ok);
        __ cmp(src, dst);
        __ br(Assembler::EQ, known_ok);
      }
      __ bind(halt);

*** 2570,11 ***
  
  void LIR_Assembler::emit_lock(LIR_OpLock* op) {
    Register obj = op->obj_opr()->as_register();  // may not be an oop
    Register hdr = op->hdr_opr()->as_register();
    Register lock = op->lock_opr()->as_register();
!   if (!UseFastLocking) {
      __ b(*op->stub()->entry());
    } else if (op->code() == lir_lock) {
      Register scratch = noreg;
      if (UseBiasedLocking) {
        scratch = op->scratch_opr()->as_register();
--- 2537,15 ---
  
  void LIR_Assembler::emit_lock(LIR_OpLock* op) {
    Register obj = op->obj_opr()->as_register();  // may not be an oop
    Register hdr = op->hdr_opr()->as_register();
    Register lock = op->lock_opr()->as_register();
!   if (LockingMode == LM_MONITOR) {
+     if (op->info() != NULL) {
+       add_debug_info_for_null_check_here(op->info());
+       __ null_check(obj, -1);
+     }
      __ b(*op->stub()->entry());
    } else if (op->code() == lir_lock) {
      Register scratch = noreg;
      if (UseBiasedLocking) {
        scratch = op->scratch_opr()->as_register();

*** 2593,10 ***
--- 2564,37 ---
      Unimplemented();
    }
    __ bind(*op->stub()->continuation());
  }
  
+ void LIR_Assembler::emit_load_klass(LIR_OpLoadKlass* op) {
+   Register obj = op->obj()->as_pointer_register();
+   Register result = op->result_opr()->as_pointer_register();
+ 
+   CodeEmitInfo* info = op->info();
+   if (info != NULL) {
+     add_debug_info_for_null_check_here(info);
+   }
+ 
+   if (UseCompressedClassPointers) {
+     if (UseCompactObjectHeaders) {
+       // Check if we can take the (common) fast path, if obj is unlocked.
+       __ ldr(result, Address(obj, oopDesc::mark_offset_in_bytes()));
+       __ tst(result, markWord::monitor_value);
+       __ br(Assembler::NE, *op->stub()->entry());
+       __ bind(*op->stub()->continuation());
+ 
+       // Shift to get proper narrow Klass*.
+       __ lsr(result, result, markWord::klass_shift);
+     } else {
+       __ ldrw(result, Address (obj, oopDesc::klass_offset_in_bytes()));
+     }
+     __ decode_klass_not_null(result);
+   } else {
+     __ ldr(result, Address (obj, oopDesc::klass_offset_in_bytes()));
+   }
+ }
  
  void LIR_Assembler::emit_profile_call(LIR_OpProfileCall* op) {
    ciMethod* method = op->profiled_method();
    int bci          = op->profiled_bci();
    ciMethod* callee = op->profiled_callee();
< prev index next >