PPC: Fix constant pool overflow access in Get/SetRelocatedValue.

src/ppc/macro-assembler-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.
 
 #include <assert.h>  // For assert
 #include <limits.h>  // For LONG_MIN, LONG_MAX.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_PPC
@@ skipping 3224 matching lines @@
 
   dcbf(r0, scratch);
   sync();
   icbi(r0, scratch);
   isync();
 
   bind(&done);
 }
 
 
+void MacroAssembler::DecodeConstantPoolOffset(Register result,
+                                              Register location) {
+  Label overflow_access, done;
+  DCHECK(!AreAliased(result, location, r0));
+
+  // Determine constant pool access type
+  // Caller has already placed the instruction word at location in result.
+  ExtractBitRange(r0, result, 31, 26);
+  cmpi(r0, Operand(ADDIS >> 26));
+  beq(&overflow_access);
+
+  // Regular constant pool access
+  // extract the load offset
+  andi(result, result, Operand(kImm16Mask));
+  b(&done);
+
+  bind(&overflow_access);
+  // Overflow constant pool access
+  // shift addis immediate
+  slwi(r0, result, Operand(16));
+  // sign-extend and add the load offset
+  lwz(result, MemOperand(location, kInstrSize));
+  extsh(result, result);
+  add(result, r0, result);
+
+  bind(&done);
+}
+
+
 void MacroAssembler::SetRelocatedValue(Register location, Register scratch,
                                        Register new_value) {
   lwz(scratch, MemOperand(location));
 
   if (FLAG_enable_embedded_constant_pool) {
     if (emit_debug_code()) {
       // Check that the instruction sequence is a load from the constant pool
       ExtractBitMask(scratch, scratch, 0x1f * B16);
       cmpi(scratch, Operand(kConstantPoolRegister.code()));
       Check(eq, kTheInstructionToPatchShouldBeALoadFromConstantPool);
       // Scratch was clobbered. Restore it.
       lwz(scratch, MemOperand(location));
     }
-    // Get the address of the constant and patch it.
-    andi(scratch, scratch, Operand(kImm16Mask));
+    DecodeConstantPoolOffset(scratch, location);
     StorePX(new_value, MemOperand(kConstantPoolRegister, scratch));
     return;
   }
 
   // This code assumes a FIXED_SEQUENCE for lis/ori
 
   // At this point scratch is a lis instruction.
   if (emit_debug_code()) {
     And(scratch, scratch, Operand(kOpcodeMask | (0x1f * B16)));
     Cmpi(scratch, Operand(ADDIS), r0);
@@ skipping 75 matching lines @@
   lwz(result, MemOperand(location));
 
   if (FLAG_enable_embedded_constant_pool) {
     if (emit_debug_code()) {
       // Check that the instruction sequence is a load from the constant pool
       ExtractBitMask(result, result, 0x1f * B16);
       cmpi(result, Operand(kConstantPoolRegister.code()));
       Check(eq, kTheInstructionToPatchShouldBeALoadFromConstantPool);
       lwz(result, MemOperand(location));
     }
-    // Get the address of the constant and retrieve it.
-    andi(result, result, Operand(kImm16Mask));
+    DecodeConstantPoolOffset(result, location);
     LoadPX(result, MemOperand(kConstantPoolRegister, result));
     return;
   }
 
   // This code assumes a FIXED_SEQUENCE for lis/ori
   if (emit_debug_code()) {
     And(result, result, Operand(kOpcodeMask | (0x1f * B16)));
     Cmpi(result, Operand(ADDIS), r0);
     Check(eq, kTheInstructionShouldBeALis);
     lwz(result, MemOperand(location));
@@ skipping 1268 matching lines @@
   }
   if (mag.shift > 0) srawi(result, result, mag.shift);
   ExtractBit(r0, dividend, 31);
   add(result, result, r0);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_PPC