Minor cleanup of ARM stubs.

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 202 matching lines @@
   __ bx(R0);
 }
 
 
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   __ Unimplemented("FixCallersTarget stub");
 }
 
 
 // Input parameters:
-//   R2: Smi-tagged argument count, may be zero.
-//   FP[kLastParamSlotIndex]: Last argument.
+//   R2: smi-tagged argument count, may be zero.
+//   FP[kLastParamSlotIndex]: last argument.
 static void PushArgumentsArray(Assembler* assembler) {
   // Allocate array to store arguments of caller.
   __ LoadImmediate(R1, reinterpret_cast<intptr_t>(Object::null()));
-  // R1: Null element type for raw Array.
-  // R2: Smi-tagged argument count, may be zero.
+  // R1: null element type for raw Array.
+  // R2: smi-tagged argument count, may be zero.
   __ BranchLink(&StubCode::AllocateArrayLabel());
   // R0: newly allocated array.
-  // R2: Smi-tagged argument count, may be zero (was preserved by the stub).
+  // R2: smi-tagged argument count, may be zero (was preserved by the stub).
   __ Push(R0);  // Array is in R0 and on top of stack.
   __ add(R1, FP, ShifterOperand(R2, LSL, 1));
   __ AddImmediate(R1, (kLastParamSlotIndex - 1) * kWordSize);
   __ AddImmediate(R3, R0, Array::data_offset() - kHeapObjectTag);
-  Label loop, loop_condition;
-  __ b(&loop_condition);
+  // R1: address of first argument on stack.
+  // R3: address of first argument in array.
+  Label loop;
   __ Bind(&loop);
-  __ ldr(IP, Address(R1, 0));
-  __ str(IP, Address(R3, 0));
-  __ AddImmediate(R1, -kWordSize);
-  __ AddImmediate(R3, kWordSize);
-  __ Bind(&loop_condition);
   __ subs(R2, R2, ShifterOperand(Smi::RawValue(1)));  // R2 is Smi.
+  __ ldr(IP, Address(R1, 0), PL);
+  __ str(IP, Address(R3, 0), PL);
+  __ AddImmediate(R1, -kWordSize, PL);
+  __ AddImmediate(R3, kWordSize, PL);
   __ b(&loop, PL);
 }
 
 
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
   __ Unimplemented("InstanceFunctionLookup stub");
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   __ Unimplemented("DeoptimizeLazy stub");
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   __ Unimplemented("Deoptimize stub");
 }
 
 
 void StubCode::GenerateMegamorphicMissStub(Assembler* assembler) {
   __ Unimplemented("MegamorphicMiss stub");
 }
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   LR: return address.
-//   R2: Array length as Smi.
+//   R2: array length as Smi.
 //   R1: array element type (either NULL or an instantiated type).
 // NOTE: R2 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in R0.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
   if (FLAG_inline_alloc) {
     // Compute the size to be allocated, it is based on the array length
     // 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());
 
     // 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.
+    // R2: array length as Smi.
+    // R8: points to new space object.
     __ LoadFromOffset(kLoadWord, R0, R8, Scavenger::top_offset());
     intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
-    __ LoadImmediate(R7, fixed_size);
-    __ add(R7, R7, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
+    __ LoadImmediate(R3, fixed_size);
+    __ add(R3, R3, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
     ASSERT(kSmiTagShift == 1);
-    __ bic(R7, R7, ShifterOperand(kObjectAlignment - 1));
-    __ add(R7, R7, ShifterOperand(R0));
+    __ 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.
+    // R2: array length as Smi.
+    // R3: array size.
     // R7: potential next object start.
-    // R8: Points to new space object.
+    // R8: points to new space object.
     __ LoadFromOffset(kLoadWord, 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());
     __ add(R0, R0, ShifterOperand(kHeapObjectTag));
 
     // R0: new object start as a tagged pointer.
     // R1: array element type.
-    // R2: Array length as Smi.
+    // R2: array length as Smi.
+    // R3: array size.
     // R7: new object end address.
 
     // Store the type argument field.
     __ StoreIntoObjectNoBarrier(
         R0,
         FieldAddress(R0, Array::type_arguments_offset()),
         R1);
 
     // Set the length field.
     __ StoreIntoObjectNoBarrier(
         R0,
         FieldAddress(R0, Array::length_offset()),
         R2);
 
     // Calculate the size tag.
     // R0: new object start as a tagged pointer.
-    // R2: Array length as Smi.
+    // R2: array length as Smi.
+    // R3: array size.
     // R7: new object end address.
-    __ LoadImmediate(R1, fixed_size);
-    __ add(R1, R1, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
-    ASSERT(kSmiTagShift == 1);
-    __ bic(R1, R1, ShifterOperand(kObjectAlignment - 1));
     const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
-    __ CompareImmediate(R1, RawObject::SizeTag::kMaxSizeTag);
+    __ CompareImmediate(R3, RawObject::SizeTag::kMaxSizeTag);
     // If no size tag overflow, shift R1 left, else set R1 to zero.
-    __ mov(R1, ShifterOperand(R1, LSL, shift), LS);
+    __ mov(R1, ShifterOperand(R3, LSL, shift), LS);
     __ mov(R1, ShifterOperand(0), HI);
 
     // Get the class index and insert it into the tags.
     __ LoadImmediate(IP, RawObject::ClassIdTag::encode(kArrayCid));
     __ orr(R1, R1, ShifterOperand(IP));
     __ str(R1, FieldAddress(R0, Array::tags_offset()));
 
     // Initialize all array elements to raw_null.
     // R0: new object start as a tagged pointer.
     // R7: new object end address.
-    // R2: Array length as Smi.
+    // R2: array length as Smi.
     __ AddImmediate(R1, R0, Array::data_offset() - kHeapObjectTag);
     // R1: iterator which initially points to the start of the variable
     // data area to be initialized.
     __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
-    Label loop, test;
-    __ b(&test);
+    Label loop;
     __ Bind(&loop);
     // TODO(cshapiro): StoreIntoObjectNoBarrier
-    __ str(IP, Address(R1, 0));
-    __ AddImmediate(R1, kWordSize);
-    __ Bind(&test);
     __ cmp(R1, ShifterOperand(R7));
-    __ b(&loop, NE);
+    __ str(IP, Address(R1, 0), CC);  // Store if unsigned lower.
+    __ AddImmediate(R1, kWordSize, CC);
+    __ b(&loop, CS);
 
     // Done allocating and initializing the array.
     // R0: new object.
-    // R2: Array length as Smi (preserved for the caller.)
+    // R2: array length as Smi (preserved for the caller.)
     __ Ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ PushList((1 << R1) | (1 << R2) | (1 << IP));
   __ CallRuntime(kAllocateArrayRuntimeEntry);
   // Pop arguments; result is popped in IP.
   __ PopList((1 << R1) | (1 << R2) | (1 << IP));  // R2 is restored.
   __ mov(R0, ShifterOperand(IP));
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 // Input parameters:
 //   LR: return address.
 //   SP: address of last argument.
-//   R4: Arguments descriptor array.
+//   R4: arguments descriptor array.
 // Note: The closure object is the first argument to the function being
 //       called, the stub accesses the closure from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateCallClosureFunctionStub(Assembler* assembler) {
   // Load num_args.
   __ ldr(R0, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   __ sub(R0, R0, ShifterOperand(Smi::RawValue(1)));
   // Load closure object in R1.
   __ ldr(R1, Address(SP, R0, LSL, 1));  // R0 (num_args - 1) is a Smi.
 
@@ skipping 34 matching lines @@
   __ CallRuntime(kCompileFunctionRuntimeEntry);
   // Restore arguments descriptor array and read-only function object argument.
   __ PopList((1 << R2) | (1 << R4));
   // Restore R0.
   __ ldr(R0, FieldAddress(R2, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveStubFrame();
 
   __ Bind(&function_compiled);
-  // R0: Code.
-  // R4: Arguments descriptor array.
+  // R0: code.
+  // R4: arguments descriptor array.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R0);
 
   __ Bind(&not_closure);
   // Call runtime to attempt to resolve and invoke a call method on a
   // non-closure object, passing the non-closure object and its arguments array,
   // returning here.
   // If no call method exists, throw a NoSuchMethodError.
   // R1: non-closure object.
   // R4: arguments descriptor array.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   // Setup space on stack for result from error reporting.
   __ PushList((1 << R4) | (1 << R8));  // Arguments descriptor and raw null.
 
   // Load smi-tagged arguments array length, including the non-closure.
   __ ldr(R2, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   PushArgumentsArray(assembler);
 
   // Stack:
-  // TOS + 0: Argument array.
-  // TOS + 1: Arguments descriptor array.
-  // TOS + 2: Place for result from the call.
-  // TOS + 3: Saved FP of previous frame.
-  // TOS + 4: Dart code return address
-  // TOS + 5: PC marker (0 for stub).
-  // TOS + 6: Last argument of caller.
+  // TOS + 0: argument array.
+  // TOS + 1: arguments descriptor array.
+  // TOS + 2: place for result from the call.
+  // TOS + 3: saved FP of previous frame.
+  // TOS + 4: dart code return address
+  // TOS + 5: pc marker (0 for stub).
+  // TOS + 6: last argument of caller.
   // ....
   __ CallRuntime(kInvokeNonClosureRuntimeEntry);
   // Remove arguments.
   __ Drop(2);
   __ Pop(R0);  // Get result into R0.
 
   // Remove the stub frame as we are about to return.
   __ LeaveStubFrame();
   __ Ret();
 }
@@ skipping 169 matching lines @@
     // Setup up number of context variables field.
     // R0: new object.
     // R1: number of context variables as integer value (not object).
     __ str(R1, FieldAddress(R0, Context::num_variables_offset()));
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into R2.
     // R0: new object.
     // R1: number of context variables.
     __ ldr(R2, FieldAddress(CTX, Context::isolate_offset()));
-    // R2: Isolate, not an object.
+    // R2: isolate, not an object.
     __ str(R2, FieldAddress(R0, Context::isolate_offset()));
 
     // Setup the parent field.
     // R0: new object.
     // R1: number of context variables.
     __ LoadImmediate(R2, reinterpret_cast<intptr_t>(Object::null()));
     __ str(R2, FieldAddress(R0, Context::parent_offset()));
 
     // Initialize the context variables.
     // R0: new object.
@@ skipping 26 matching lines @@
   // Restore the frame pointer.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
 // Helper stub to implement Assembler::StoreIntoObject.
 // Input parameters:
-//   R0: Address (i.e. object) being stored into.
+//   R0: address (i.e. object) being stored into.
 void StubCode::GenerateUpdateStoreBufferStub(Assembler* assembler) {
   // Save values being destroyed.
   __ PushList((1 << R1) | (1 << R2) | (1 << R3));
 
   // Load the isolate out of the context.
   // Spilled: R1, R2, R3.
-  // R0: Address being stored.
+  // R0: address being stored.
   __ ldr(R1, FieldAddress(CTX, Context::isolate_offset()));
 
   // Load top_ out of the StoreBufferBlock and add the address to the pointers_.
-  // R1: Isolate.
+  // R1: isolate.
   intptr_t store_buffer_offset = Isolate::store_buffer_block_offset();
   __ LoadFromOffset(kLoadWord, R2, R1,
                     store_buffer_offset + StoreBufferBlock::top_offset());
   __ add(R3, R1, ShifterOperand(R2, LSL, 2));
   __ StoreToOffset(kStoreWord, R0, R3,
                    store_buffer_offset + StoreBufferBlock::pointers_offset());
 
   // Increment top_ and check for overflow.
-  // R2: top_
-  // R1: Isolate
+  // R2: top_.
+  // R1: isolate.
   Label L;
   __ add(R2, R2, ShifterOperand(1));
   __ StoreToOffset(kStoreWord, R2, R1,
                    store_buffer_offset + StoreBufferBlock::top_offset());
   __ CompareImmediate(R2, StoreBufferBlock::kSize);
   // Restore values.
   __ PopList((1 << R1) | (1 << R2) | (1 << R3));
   __ b(&L, EQ);
   __ Ret();
 
@@ skipping 357 matching lines @@
     // but only at exit so that we have collected all type feedback before
     // optimizing.
   }
   __ add(R7, R7, ShifterOperand(1));
   __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
   __ Bind(&is_hot);
 }
 
 
 // Generate inline cache check for 'num_args'.
-//  LR: return address
-//  R5: Inline cache data object.
-//  R4: Arguments descriptor array.
+//  LR: return address.
+//  R5: inline cache data object.
+//  R4: arguments descriptor array.
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(Assembler* assembler,
                                                  intptr_t num_args) {
   ASSERT(num_args > 0);
@@ skipping 108 matching lines @@
   __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&call_target_function, NE);
   // NoSuchMethod or closure.
   // 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.
+  // 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);
   __ adds(R1, R1, ShifterOperand(Smi::RawValue(1)));
   __ StoreToOffset(kStoreWord, R1, R6, count_offset);
   __ b(&call_target_function, VC);  // No overflow.
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue));
   __ StoreToOffset(kStoreWord, R1, R6, count_offset);
 
   __ Bind(&call_target_function);
-  // R0: 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);
 
   // Test if Smi -> load Smi class for comparison.
   __ tst(R0, ShifterOperand(kSmiTagMask));
   __ mov(R0, ShifterOperand(Smi::RawValue(kSmiCid)), EQ);
   __ bx(LR, EQ);
   __ LoadClassId(R0, R0);
   __ SmiTag(R0);
   __ bx(LR);
 }
 
 
 // Use inline cache data array to invoke the target or continue in inline
 // cache miss handler. Stub for 1-argument check (receiver class).
-//  LR: Return address.
-//  R5: Inline cache data object.
-//  R4: Arguments descriptor array.
+//  LR: return address.
+//  R5: inline cache data object.
+//  R4: arguments descriptor array.
 // Inline cache data object structure:
 // 0: function-name
 // 1: N, number of arguments checked.
 // 2 .. (length - 1): group of checks, each check containing:
 //   - N classes.
 //   - 1 target function.
 void StubCode::GenerateOneArgCheckInlineCacheStub(Assembler* assembler) {
   GenerateUsageCounterIncrement(assembler, R6);
   GenerateNArgsCheckInlineCacheStub(assembler, 1);
 }
@@ skipping 82 matching lines @@
   __ LoadClassId(R3, R0);
   // R0: instance.
   // R1: instantiator type arguments or NULL.
   // R2: SubtypeTestCache.
   // R3: instance class id.
   // R4: instance type arguments (null if none), used only if n > 1.
   __ ldr(R2, FieldAddress(R2, SubtypeTestCache::cache_offset()));
   __ AddImmediate(R2, Array::data_offset() - kHeapObjectTag);
 
   Label loop, found, not_found, next_iteration;
-  // R2: Entry start.
+  // R2: entry start.
   // R3: instance class id.
   // R4: instance type arguments.
   __ SmiTag(R3);
   __ Bind(&loop);
   __ ldr(R5, Address(R2, kWordSize * SubtypeTestCache::kInstanceClassId));
   __ CompareImmediate(R5, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&not_found, EQ);
   __ cmp(R5, ShifterOperand(R3));
   if (n == 1) {
     __ b(&found, EQ);
@@ skipping 187 matching lines @@
   __ Bind(&reference_compare);
   __ cmp(left, ShifterOperand(right));
   __ Bind(&done);
   __ PopList((1 << R0) | (1 << R1) | (1 << R2));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM