Merges ARM load/store type enums into one enum.

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/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 29 matching lines @@
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to Dart VM C++ code.
-  __ StoreToOffset(kStoreWord, SP, R0, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, SP, R0, Isolate::top_exit_frame_info_offset());
 
   // Save current Context pointer into Isolate structure.
-  __ StoreToOffset(kStoreWord, CTX, R0, Isolate::top_context_offset());
+  __ StoreToOffset(kWord, CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing runtime code.
   __ mov(CTX, ShifterOperand(R0));
 
   // Reserve space for arguments and align frame before entering C++ world.
   // NativeArguments are passed in registers.
   ASSERT(sizeof(NativeArguments) == 4 * kWordSize);
   __ ReserveAlignedFrameSpace(0);
 
   // Pass NativeArguments structure by value and call runtime.
@@ skipping 12 matching lines @@
   __ AddImmediate(R2, kWordSize);  // Set argv in NativeArguments.
 
   ASSERT(retval_offset == 3 * kWordSize);
   __ add(R3, R2, ShifterOperand(kWordSize));  // Retval is next to 1st argument.
 
   // Call runtime or redirection via simulator.
   __ blx(R5);
 
   // Reset exit frame information in Isolate structure.
   __ LoadImmediate(R2, 0);
-  __ StoreToOffset(kStoreWord, R2, CTX, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
-  __ LoadFromOffset(kLoadWord, R2, CTX, Isolate::top_context_offset());
+  __ LoadFromOffset(kWord, R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
-  __ StoreToOffset(kStoreWord, R3, CTX, Isolate::top_context_offset());
+  __ StoreToOffset(kWord, R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, ShifterOperand(R2));
 
   __ LeaveFrame((1 << FP) | (1 << LR));
   __ Ret();
 }
 
 
 // Print the stop message.
@@ skipping 27 matching lines @@
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
-  __ StoreToOffset(kStoreWord, SP, R0, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, SP, R0, Isolate::top_exit_frame_info_offset());
 
   // Save current Context pointer into Isolate structure.
-  __ StoreToOffset(kStoreWord, CTX, R0, Isolate::top_context_offset());
+  __ StoreToOffset(kWord, CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing native code.
   __ mov(CTX, ShifterOperand(R0));
 
   // Reserve space for the native arguments structure passed on the stack (the
   // outgoing pointer parameter to the native arguments structure is passed in
   // R0) and align frame before entering the C++ world.
   __ ReserveAlignedFrameSpace(sizeof(NativeArguments));
 
   // Initialize NativeArguments structure and call native function.
@@ skipping 17 matching lines @@
   // It would require changing Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ stm(IA, SP,  (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3));
   __ mov(R0, ShifterOperand(SP));  // Pass the pointer to the NativeArguments.
 
   // Call native function or redirection via simulator.
   __ blx(R5);
 
   // Reset exit frame information in Isolate structure.
   __ LoadImmediate(R2, 0);
-  __ StoreToOffset(kStoreWord, R2, CTX, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
-  __ LoadFromOffset(kLoadWord, R2, CTX, Isolate::top_context_offset());
+  __ LoadFromOffset(kWord, R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
-  __ StoreToOffset(kStoreWord, R3, CTX, Isolate::top_context_offset());
+  __ StoreToOffset(kWord, R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, ShifterOperand(R2));
 
   __ LeaveFrame((1 << FP) | (1 << LR));
   __ Ret();
 }
 
 
 // Input parameters:
@@ skipping 268 matching lines @@
     // and is computed as:
     // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
     // Assert that length is a Smi.
     __ tst(R2, ShifterOperand(kSmiTagMask));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, NE);
     }
     __ ldr(R8, FieldAddress(CTX, Context::isolate_offset()));
-    __ LoadFromOffset(kLoadWord, R8, R8, Isolate::heap_offset());
-    __ LoadFromOffset(kLoadWord, R8, R8, Heap::new_space_offset());
+    __ LoadFromOffset(kWord, R8, R8, Isolate::heap_offset());
+    __ LoadFromOffset(kWord, R8, R8, Heap::new_space_offset());
 
     // Calculate and align allocation size.
     // Load new object start and calculate next object start.
     // R1: array element type.
     // R2: array length as Smi.
     // R8: points to new space object.
-    __ LoadFromOffset(kLoadWord, R0, R8, Scavenger::top_offset());
+    __ LoadFromOffset(kWord, R0, R8, Scavenger::top_offset());
     intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
     __ LoadImmediate(R3, fixed_size);
     __ add(R3, R3, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
     ASSERT(kSmiTagShift == 1);
     __ bic(R3, R3, ShifterOperand(kObjectAlignment - 1));
     __ add(R7, R3, ShifterOperand(R0));
 
     // Check if the allocation fits into the remaining space.
     // R0: potential new object start.
     // R1: array element type.
     // R2: array length as Smi.
     // R3: array size.
     // R7: potential next object start.
     // R8: points to new space object.
-    __ LoadFromOffset(kLoadWord, IP, R8, Scavenger::end_offset());
+    __ LoadFromOffset(kWord, IP, R8, Scavenger::end_offset());
     __ cmp(R7, ShifterOperand(IP));
     __ b(&slow_case, CS);  // Branch if unsigned higher or equal.
 
     // Successfully allocated the object(s), now update top to point to
     // next object start and initialize the object.
     // R0: potential new object start.
     // R7: potential next object start.
     // R8: Points to new space object.
-    __ StoreToOffset(kStoreWord, R7, R8, Scavenger::top_offset());
+    __ StoreToOffset(kWord, R7, R8, Scavenger::top_offset());
     __ add(R0, R0, ShifterOperand(kHeapObjectTag));
 
     // R0: new object start as a tagged pointer.
     // R1: array element type.
     // R2: array length as Smi.
     // R3: array size.
     // R7: new object end address.
 
     // Store the type argument field.
     __ StoreIntoObjectNoBarrier(
@@ skipping 181 matching lines @@
   // compiled or runtime stub code.
 
   // Cache the new Context pointer into CTX while executing Dart code.
   __ ldr(CTX, Address(R3, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load Isolate pointer from Context structure into temporary register R8.
   __ ldr(R8, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save the top exit frame info. Use R5 as a temporary register.
   // StackFrameIterator reads the top exit frame info saved in this frame.
-  __ LoadFromOffset(kLoadWord, R5, R8, Isolate::top_exit_frame_info_offset());
+  __ LoadFromOffset(kWord, R5, R8, Isolate::top_exit_frame_info_offset());
   __ LoadImmediate(R6, 0);
-  __ StoreToOffset(kStoreWord, R6, R8, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, R6, R8, Isolate::top_exit_frame_info_offset());
 
   // Save the old Context pointer. Use R4 as a temporary register.
   // Note that VisitObjectPointers will find this saved Context pointer during
   // GC marking, since it traverses any information between SP and
   // FP - kExitLinkSlotFromEntryFp.
   // EntryFrame::SavedContext reads the context saved in this frame.
-  __ LoadFromOffset(kLoadWord, R4, R8, Isolate::top_context_offset());
+  __ LoadFromOffset(kWord, R4, R8, Isolate::top_context_offset());
 
   // The constants kSavedContextSlotFromEntryFp and
   // kExitLinkSlotFromEntryFp must be kept in sync with the code below.
   ASSERT(kExitLinkSlotFromEntryFp == -9);
   ASSERT(kSavedContextSlotFromEntryFp == -10);
   __ PushList((1 << R4) | (1 << R5));
 
   // The stack pointer is restored after the call to this location.
   const intptr_t kSavedContextSlotFromEntryFp = -10 * kWordSize;
 
@@ skipping 34 matching lines @@
   __ AddImmediate(SP, FP, kSavedContextSlotFromEntryFp);
 
   // Load Isolate pointer from Context structure into CTX. Drop Context.
   __ ldr(CTX, FieldAddress(CTX, Context::isolate_offset()));
 
   // Restore the saved Context pointer into the Isolate structure.
   // Uses R4 as a temporary register for this.
   // Restore the saved top exit frame info back into the Isolate structure.
   // Uses R5 as a temporary register for this.
   __ PopList((1 << R4) | (1 << R5));
-  __ StoreToOffset(kStoreWord, R4, CTX, Isolate::top_context_offset());
-  __ StoreToOffset(kStoreWord, R5, CTX, Isolate::top_exit_frame_info_offset());
+  __ StoreToOffset(kWord, R4, CTX, Isolate::top_context_offset());
+  __ StoreToOffset(kWord, R5, CTX, Isolate::top_exit_frame_info_offset());
 
   // Restore C++ ABI callee-saved registers.
   __ PopList((1 << R3) | kAbiPreservedCpuRegs);  // Ignore restored R3.
 
   // Restore the frame pointer and return.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
@@ skipping 275 matching lines @@
     // R2: new object start.
     // R3: next object start.
     // R1: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = sizeof(RawObject);
            current_offset < instance_size;
            current_offset += kWordSize) {
-        __ StoreToOffset(kStoreWord, R0, R2, current_offset);
+        __ StoreToOffset(kWord, R0, R2, current_offset);
       }
     } else {
       __ add(R4, R2, ShifterOperand(sizeof(RawObject)));
       // Loop until the whole object is initialized.
       // R0: raw null.
       // R2: new object.
       // R3: next object start.
       // R4: next word to be initialized.
       // R1: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
       __ cmp(R4, ShifterOperand(R3));
       __ b(&done, CS);
       __ str(R0, Address(R4, 0));
       __ AddImmediate(R4, kWordSize);
       __ b(&init_loop);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
       // R1: new object type arguments.
       // Set the type arguments in the new object.
-      __ StoreToOffset(kStoreWord, R1, R2, cls.type_arguments_field_offset());
+      __ StoreToOffset(kWord, R1, R2, cls.type_arguments_field_offset());
     }
     // Done allocating and initializing the instance.
     // R2: new object still missing its heap tag.
     __ add(R0, R2, ShifterOperand(kHeapObjectTag));
     // R0: new object.
     __ Ret();
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
@@ skipping 307 matching lines @@
   __ b(&test);
 
   __ Bind(&loop);
   for (int i = 0; i < num_args; i++) {
     if (i > 0) {
       // If not the first, load the next argument's class ID.
       __ AddImmediate(R0, R7, Smi::RawValue(-i));
       __ ldr(R0, Address(SP, R0, LSL, 1));
       __ bl(&get_class_id_as_smi);
       // R0: next argument class ID (smi).
-      __ LoadFromOffset(kLoadWord, R1, R6, i * kWordSize);
+      __ LoadFromOffset(kWord, R1, R6, i * kWordSize);
       // R1: next class ID to check (smi).
     }
     __ cmp(R0, ShifterOperand(R1));  // Class id match?
     if (i < (num_args - 1)) {
       __ b(&update, NE);  // Continue.
     } else {
       // Last check, all checks before matched.
       __ mov(LR, ShifterOperand(R8), EQ);  // Restore return address if found.
       __ b(&found, EQ);  // Break.
     }
@@ skipping 23 matching lines @@
   // R7: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
   __ PushList((1 << R0) | (1 << R4) | (1 << R5));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
-    __ LoadFromOffset(kLoadWord, IP, R7, -i * kWordSize);
+    __ LoadFromOffset(kWord, IP, R7, -i * kWordSize);
     __ Push(IP);
   }
   // Pass IC data object and arguments descriptor array.
   __ PushList((1 << R4) | (1 << R5));
 
   if (num_args == 1) {
     __ CallRuntime(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
     __ CallRuntime(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
   } else if (num_args == 3) {
@@ skipping 15 matching lines @@
   // Mark IC call that it may be a closure call that does not collect
   // type feedback.
   __ mov(IP, ShifterOperand(1));
   __ strb(IP, FieldAddress(R5, ICData::is_closure_call_offset()));
   __ Branch(&StubCode::InstanceFunctionLookupLabel());
 
   __ Bind(&found);
   // R6: pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
-  __ LoadFromOffset(kLoadWord, R0, R6, target_offset);
-  __ LoadFromOffset(kLoadWord, R1, R6, count_offset);
+  __ LoadFromOffset(kWord, R0, R6, target_offset);
+  __ LoadFromOffset(kWord, R1, R6, count_offset);
   __ adds(R1, R1, ShifterOperand(Smi::RawValue(1)));
-  __ StoreToOffset(kStoreWord, R1, R6, count_offset);
+  __ StoreToOffset(kWord, R1, R6, count_offset);
   __ b(&call_target_function, VC);  // No overflow.
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue));
-  __ StoreToOffset(kStoreWord, R1, R6, count_offset);
+  __ StoreToOffset(kWord, R1, R6, count_offset);
 
   __ Bind(&call_target_function);
   // R0: target function.
   __ ldr(R0, FieldAddress(R0, Function::code_offset()));
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R0);
 
   // Instance in R0, return its class-id in R0 as Smi.
   __ Bind(&get_class_id_as_smi);
@@ skipping 100 matching lines @@
   // R5: IC data object (preserved).
   __ ldr(R6, FieldAddress(R5, ICData::ic_data_offset()));
   // R6: ic_data_array with entries: target functions and count.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
   // R6: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
 
   // Increment count for this call.
   Label increment_done;
-  __ LoadFromOffset(kLoadWord, R1, R6, count_offset);
+  __ LoadFromOffset(kWord, R1, R6, count_offset);
   __ adds(R1, R1, ShifterOperand(Smi::RawValue(1)));
-  __ StoreToOffset(kStoreWord, R1, R6, count_offset);
+  __ StoreToOffset(kWord, R1, R6, count_offset);
   __ b(&increment_done, VC);  // No overflow.
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue));
-  __ StoreToOffset(kStoreWord, R1, R6, count_offset);
+  __ StoreToOffset(kWord, R1, R6, count_offset);
   __ Bind(&increment_done);
 
   Label target_is_compiled;
   // Get function and call it, if possible.
-  __ LoadFromOffset(kLoadWord, R1, R6, target_offset);
+  __ LoadFromOffset(kWord, R1, R6, target_offset);
   __ ldr(R0, FieldAddress(R1, Function::code_offset()));
   __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&target_is_compiled, NE);
   // R1: function.
 
   __ EnterStubFrame();
   // Preserve target function and IC data object.
   __ PushList((1 << R1) | (1 << R5));
   __ Push(R1);  // Pass function.
   __ CallRuntime(kCompileFunctionRuntimeEntry);
@@ skipping 439 matching lines @@
   __ ldr(left, Address(SP, 4 * kWordSize));
   __ ldr(right, Address(SP, 3 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ PopList((1 << R0) | (1 << R1) | (1 << R2));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM