Moves the top_ and end_ words of the Scavenger into mutator thread.

runtime/vm/stub_code_arm.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
@@ skipping 685 matching lines @@
 
   const intptr_t fixed_size_plus_alignment_padding =
       sizeof(RawArray) + kObjectAlignment - 1;
   __ LoadImmediate(R9, fixed_size_plus_alignment_padding);
   __ add(R9, R9, Operand(R3, LSL, 1));  // R3 is a Smi.
   ASSERT(kSmiTagShift == 1);
   __ bic(R9, R9, Operand(kObjectAlignment - 1));
 
   // R9: Allocation size.
   Heap::Space space = Heap::kNew;
-  __ ldr(R8, Address(THR, Thread::heap_offset()));
   // Potential new object start.
-  __ ldr(R0, Address(R8, Heap::TopOffset(space)));
+  __ ldr(R0, Address(THR, Thread::top_offset()));
   __ adds(NOTFP, R0, Operand(R9));  // Potential next object start.
   __ b(&slow_case, CS);             // Branch if unsigned overflow.
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
   // NOTFP: potential next object start.
   // R9: allocation size.
-  __ ldr(R3, Address(R8, Heap::EndOffset(space)));
+  __ ldr(R3, Address(THR, Thread::end_offset()));
   __ cmp(NOTFP, Operand(R3));
   __ b(&slow_case, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   NOT_IN_PRODUCT(__ LoadAllocationStatsAddress(R3, cid));
-  __ str(NOTFP, Address(R8, Heap::TopOffset(space)));
+  __ str(R7, Address(THR, Thread::top_offset()));
   __ add(R0, R0, Operand(kHeapObjectTag));
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R3: allocation stats address.
   // NOTFP: new object end address.
   // R9: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
@@ skipping 189 matching lines @@
     __ add(R2, R2, Operand(R1, LSL, 2));
     ASSERT(kSmiTagShift == 1);
     __ bic(R2, R2, Operand(kObjectAlignment - 1));
 
     NOT_IN_PRODUCT(__ MaybeTraceAllocation(kContextCid, R8, &slow_case));
     // Now allocate the object.
     // R1: number of context variables.
     // R2: object size.
     const intptr_t cid = kContextCid;
     Heap::Space space = Heap::kNew;
-    __ ldr(R9, Address(THR, Thread::heap_offset()));
-    __ ldr(R0, Address(R9, Heap::TopOffset(space)));
+    __ ldr(R0, Address(THR, Thread::top_offset()));
     __ add(R3, R2, Operand(R0));
     // Check if the allocation fits into the remaining space.
     // R0: potential new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: potential next object start.
     // R9: heap.
-    __ ldr(IP, Address(R9, Heap::EndOffset(space)));
+    __ ldr(IP, Address(THR, Thread::end_offset()));
     __ cmp(R3, Operand(IP));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, CS);  // Branch if unsigned higher or equal.
     }
 
     // Successfully allocated the object, now update top to point to
     // next object start and initialize the object.
     // R0: new object start (untagged).
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     // R9: heap.
     NOT_IN_PRODUCT(__ LoadAllocationStatsAddress(R4, cid));
-    __ str(R3, Address(R9, Heap::TopOffset(space)));
+    __ str(R3, Address(THR, Thread::top_offset()));
     __ add(R0, R0, Operand(kHeapObjectTag));
 
     // Calculate the size tag.
     // R0: new object (tagged).
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     // R4: allocation stats address.
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
@@ skipping 152 matching lines @@
   const int kInlineInstanceSize = 12;
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
   Isolate* isolate = Isolate::Current();
   if (FLAG_inline_alloc && Heap::IsAllocatableInNewSpace(instance_size) &&
       !cls.TraceAllocation(isolate)) {
     Label slow_case;
     // Allocate the object and update top to point to
     // next object start and initialize the allocated object.
     Heap::Space space = Heap::kNew;
-    __ ldr(R9, Address(THR, Thread::heap_offset()));
-    __ ldr(R0, Address(R9, Heap::TopOffset(space)));
+    __ ldr(R0, Address(THR, Thread::top_offset()));
     __ AddImmediate(R1, R0, instance_size);
     // Check if the allocation fits into the remaining space.
     // R0: potential new object start.
     // R1: potential next object start.
     // R9: heap.
-    __ ldr(IP, Address(R9, Heap::EndOffset(space)));
+    __ ldr(IP, Address(THR, Thread::end_offset()));
     __ cmp(R1, Operand(IP));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, CS);  // Unsigned higher or equal.
     }
-    __ str(R1, Address(R9, Heap::TopOffset(space)));
+    __ str(R1, Address(THR, Thread::top_offset()));
 
     // Load the address of the allocation stats table. We split up the load
     // and the increment so that the dependent load is not too nearby.
     NOT_IN_PRODUCT(__ LoadAllocationStatsAddress(R9, cls.id()));
 
     // R0: new object start.
     // R1: next object start.
     // R9: allocation stats table.
     // Set the tags.
     uword tags = 0;
@@ skipping 1171 matching lines @@
 }
 
 
 void StubCode::GenerateAsynchronousGapMarkerStub(Assembler* assembler) {
   __ bkpt(0);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM