Bugfix for r9690.

src/arm/code-stubs-arm.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 6914 matching lines @@
   // Used in KeyedStoreStubCompiler::CompileStoreField via GenerateStoreField.
   { r2, r1, r3, EMIT_REMEMBERED_SET },
   { r3, r1, r2, EMIT_REMEMBERED_SET },
   // KeyedStoreStubCompiler::GenerateStoreFastElement.
   { r4, r2, r3, EMIT_REMEMBERED_SET },
   // FastElementsConversionStub::GenerateSmiOnlyToObject
   // and FastElementsConversionStub::GenerateSmiOnlyToDouble
   // and FastElementsConversionStub::GenerateDoubleToObject
   { r2, r3, r9, EMIT_REMEMBERED_SET },
   // FastElementsConversionStub::GenerateDoubleToObject
-  { r6, r0, r3, EMIT_REMEMBERED_SET },
+  { r6, r0, r2, EMIT_REMEMBERED_SET },
   { r2, r6, r9, EMIT_REMEMBERED_SET },
   // Null termination.
   { no_reg, no_reg, no_reg, EMIT_REMEMBERED_SET}
 };
 
 
 bool RecordWriteStub::IsPregenerated() {
   for (AheadOfTimeWriteBarrierStubList* entry = kAheadOfTime;
        !entry->object.is(no_reg);
        entry++) {
@@ skipping 383 matching lines @@
   __ add(r0, r0, Operand(r5, LSL, 1));
   __ AllocateInNewSpace(r0, r6, r7, r9, &gc_required, NO_ALLOCATION_FLAGS);
   // r6: destination FixedArray, not tagged as heap object
   __ LoadRoot(r9, Heap::kFixedArrayMapRootIndex);
   __ str(r9, MemOperand(r6, HeapObject::kMapOffset));
   // Set destination FixedDoubleArray's length.
   __ str(r5, MemOperand(r6, FixedDoubleArray::kLengthOffset));
 
   // Prepare for conversion loop.
   __ add(r4, r4, Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag + 4));
-  __ add(r3, r6, Operand(FixedArray::kHeaderSize - 4));
+  __ add(r3, r6, Operand(FixedArray::kHeaderSize));
   __ add(r6, r6, Operand(kHeapObjectTag));
   __ add(r5, r3, Operand(r5, LSL, 1));
   __ LoadRoot(r7, Heap::kTheHoleValueRootIndex);
   __ LoadRoot(r9, Heap::kHeapNumberMapRootIndex);
-  // Using offsetted addresses to fully take advantage of pre/post-indexing
-  // r3: begin of destination FixedArray element fields, not tagged, -4
+  // Using offsetted addresses in r4 to fully take advantage of post-indexing.
+  // r3: begin of destination FixedArray element fields, not tagged
   // r4: begin of source FixedDoubleArray element fields, not tagged, +4
-  // r5: end of destination FixedArray, not tagged, -4
+  // r5: end of destination FixedArray, not tagged
   // r6: destination FixedArray
   // r7: the-hole pointer
   // r9: heap number map
   __ b(&entry);
 
   // Call into runtime if GC is required.
   __ bind(&gc_required);
   __ Pop(r2, r3);
   __ Pop(r0, r1);
   __ pop(lr);
   KeyedStoreIC::GenerateRuntimeSetProperty(masm, strict_mode);
 
   __ bind(&loop);
   __ ldr(lr, MemOperand(r4, 8, PostIndex));
   // lr: current element's upper 32 bit
   // r4: address of next element's upper 32 bit
   __ cmp(lr, Operand(kHoleNanUpper32));
   __ b(eq, &convert_hole);
 
   // Non-hole double, copy value into a heap number.
   __ AllocateHeapNumber(r0, r1, r2, r9, &gc_required);
   __ str(lr, FieldMemOperand(r0, HeapNumber::kExponentOffset));
   __ ldr(lr, MemOperand(r4, 12, NegOffset));
   __ str(lr, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
-  __ str(r0, MemOperand(r3, 4, PreIndex));
+  __ mov(r2, r3);
+  __ str(r0, MemOperand(r3, 4, PostIndex));
   __ RecordWrite(r6,
-                 r3,
+                 r2,
                  r0,
                  kLRHasBeenSaved,
                  kDontSaveFPRegs,
                  EMIT_REMEMBERED_SET,
                  OMIT_SMI_CHECK);
   __ b(&entry);
 
   // Replace the-hole NaN with the-hole pointer.
   __ bind(&convert_hole);
-  __ str(r7, MemOperand(r3, 4, PreIndex));
+  __ str(r7, MemOperand(r3, 4, PostIndex));
 
   __ bind(&entry);
   __ cmp(r3, r5);
   __ b(lt, &loop);
 
   __ Pop(r2, r3);

[Sven Panne, 2011/10/19 10:43:34]

Not introduced by this CL, but anyway: Our ARM macro-assembler should really
have symmetrical push/pop instructions. Currently, we are able to push e.g. 4
registers in a single instruction, but pop only 2. Note that we have to be
careful with the argument order to get good code.

   __ Pop(r0, r1);
   // Update receiver's map.
   __ str(r3, FieldMemOperand(r2, HeapObject::kMapOffset));
   __ RecordWriteField(r2,
                       HeapObject::kMapOffset,
                       r3,
                       r9,
                       kLRHasBeenSaved,
                       kDontSaveFPRegs,
                       EMIT_REMEMBERED_SET,
@@ skipping 10 matching lines @@
                       OMIT_SMI_CHECK);
   __ pop(lr);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM