PPC: Fix atomic load sequence.

src/ppc/code-stubs-ppc.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_PPC
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
@@ skipping 5890 matching lines @@
   {
     FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
     __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
     __ stfd(value, FieldMemOperand(r3, HeapNumber::kValueOffset));
   }
   __ blr();
 }
 
 }  // anonymous namespace
 
+#define ASSEMBLE_ATOMIC_LOAD(instr, dst, base, index) \
+  do {                                                \
+    Label dummy;                                      \
+    __ sync();                                        \
+    __ instr(dst, MemOperand(base, index));           \
+    __ cmp(dst, dst);                                 \
+    __ bne(&dummy);                                   \

[JoranSiu, 2016/04/14 17:32:09]

I'm not very familiar with sync on PPC.   What's the purpose of this bne?  
Isn't the target and fallthrough the same (i.e. dummy)?  How does one get out of
this loop?

[JoranSiu, 2016/04/14 17:39:16]

Ignore the loop part of my question..   :)   I'm still curious about why we need
to have the cmp/bne/label.

+    __ bind(&dummy);                                  \
+    __ isync();                                       \
+  } while (0)
+
 void AtomicsLoadStub::Generate(MacroAssembler* masm) {
   Register object = r4;
   Register index = r3;  // Index is an untagged word32.
   Register backing_store = r5;
   Label table, i8, u8, i16, u16, i32, u32;
 
   GetTypedArrayBackingStore(masm, backing_store, object, r6, d0);
   TypedArrayJumpTablePrologue(masm, object, r6, r7, &table);
 
   __ bind(&i8);
-  __ lbzx(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lbzx, r3, backing_store, index);
   __ extsb(r3, r3);
   __ SmiTag(r3);
   __ blr();
 
   __ bind(&u8);
-  __ lbzx(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lbzx, r3, backing_store, index);
   __ SmiTag(r3);
   __ blr();
 
   __ bind(&i16);
   __ ShiftLeftImm(index, index, Operand(1));
-  __ lhax(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lhax, r3, backing_store, index);
   __ SmiTag(r3);
   __ blr();
 
   __ bind(&u16);
   __ ShiftLeftImm(index, index, Operand(1));
-  __ lhzx(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lhzx, r3, backing_store, index);
   __ SmiTag(r3);
   __ blr();
 
   Label use_heap_number;
 
   __ bind(&i32);
   __ ShiftLeftImm(index, index, Operand(2));
-  __ lwax(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lwax, r3, backing_store, index);
 #if V8_TARGET_ARCH_PPC64
   __ SmiTag(r3);
   __ blr();
 #else
   ReturnInteger32(masm, d0, r3, &use_heap_number);
 #endif
 
   __ bind(&u32);
   __ ShiftLeftImm(index, index, Operand(2));
-  __ lwzx(r3, MemOperand(backing_store, index));
-  __ lwsync();
+  ASSEMBLE_ATOMIC_LOAD(lwzx, r3, backing_store, index);
   ReturnUnsignedInteger32(masm, d0, r3, &use_heap_number);
 
   __ bind(&use_heap_number);
   ReturnAllocatedHeapNumber(masm, d0, r4, r5, r6);
 
   TypedArrayJumpTableEpilogue(masm, &table, &i8, &u8, &i16, &u16, &i32, &u32,
                               &u8);
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_PPC