src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

*** 36,10 ***
--- 36,11 ---
  #include "ci/ciInstance.hpp"
  #include "code/compiledIC.hpp"
  #include "gc/shared/collectedHeap.hpp"
  #include "gc/shared/gc_globals.hpp"
  #include "nativeInst_aarch64.hpp"
+ #include "oops/compressedKlass.hpp"
  #include "oops/objArrayKlass.hpp"
  #include "runtime/frame.inline.hpp"
  #include "runtime/sharedRuntime.hpp"
  #include "runtime/stubRoutines.hpp"
  #include "utilities/powerOfTwo.hpp"

*** 1227,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());
--- 1228,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());

*** 2350,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
--- 2351,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

*** 2479,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);
--- 2480,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);

*** 2589,11 ***
    if (info != nullptr) {
      add_debug_info_for_null_check_here(info);
    }
  
    if (UseCompressedClassPointers) {
!     __ ldrw(result, Address (obj, oopDesc::klass_offset_in_bytes()));
      __ decode_klass_not_null(result);
    } else {
      __ ldr(result, Address (obj, oopDesc::klass_offset_in_bytes()));
    }
  }
--- 2568,22 ---
    if (info != nullptr) {
      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()));
    }
  }