src/hotspot/cpu/ppc/c1_MacroAssembler_ppc.cpp

@@ -176,13 +176,10 @@
    // Load object.
    ld(Roop, in_bytes(BasicObjectLock::obj_offset()), Rbox);
    verify_oop(Roop, FILE_AND_LINE);
  
    if (LockingMode == LM_LIGHTWEIGHT) {
-     ld(Rmark, oopDesc::mark_offset_in_bytes(), Roop);
-     andi_(R0, Rmark, markWord::monitor_value);
-     bne(CCR0, slow_int);
      lightweight_unlock(Roop, Rmark, slow_int);
    } else if (LockingMode == LM_LEGACY) {
      // Check if it is still a light weight lock, this is is true if we see
      // the stack address of the basicLock in the markWord of the object.
      cmpxchgd(/*flag=*/CCR0,

@@ -331,11 +328,11 @@
    Register obj,                        // result: pointer to array after successful allocation
    Register len,                        // array length
    Register t1,                         // temp register
    Register t2,                         // temp register
    Register t3,                         // temp register
-   int      hdr_size,                   // object header size in words
+   int      base_offset_in_bytes,       // elements offset in bytes
    int      elt_size,                   // element size in bytes
    Register klass,                      // object klass
    Label&   slow_case                   // continuation point if fast allocation fails
  ) {
    assert_different_registers(obj, len, t1, t2, t3, klass);

@@ -363,22 +360,32 @@
    Register arr_len_in_bytes = len;
    if (elt_size != 1) {
      sldi(t1, len, log2_elt_size);
      arr_len_in_bytes = t1;
    }
-   addi(arr_size, arr_len_in_bytes, hdr_size * wordSize + MinObjAlignmentInBytesMask); // Add space for header & alignment.
+   addi(arr_size, arr_len_in_bytes, base_offset_in_bytes + MinObjAlignmentInBytesMask); // Add space for header & alignment.
    clrrdi(arr_size, arr_size, LogMinObjAlignmentInBytes);                              // Align array size.
  
    // Allocate space & initialize header.
    try_allocate(obj, arr_size, 0, t2, t3, slow_case);
    initialize_header(obj, klass, len, t2, t3);
  
    // Initialize body.
    const Register base  = t2;
    const Register index = t3;
-   addi(base, obj, hdr_size * wordSize);               // compute address of first element
-   addi(index, arr_size, -(hdr_size * wordSize));      // compute index = number of bytes to clear
+   addi(base, obj, base_offset_in_bytes);               // compute address of first element
+   addi(index, arr_size, -(base_offset_in_bytes));      // compute index = number of bytes to clear
+ 
+   // Zero first 4 bytes, if start offset is not word aligned.
+   if (!is_aligned(base_offset_in_bytes, BytesPerWord)) {
+     assert(is_aligned(base_offset_in_bytes, BytesPerInt), "must be 4-byte aligned");
+     li(t1, 0);
+     stw(t1, 0, base);
+     addi(base, base, BytesPerInt);
+     // Note: initialize_body will align index down, no need to correct it here.
+   }
+ 
    initialize_body(base, index);
  
    if (CURRENT_ENV->dtrace_alloc_probes()) {
      Unimplemented();
      //assert(obj == O0, "must be");