Process a pair of registers in one instruction where possible on arm in the VM.

runtime/vm/flow_graph_compiler_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"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 190 matching lines @@
   __ CompareObject(bool_register, Object::null_object());
   __ b(&fall_through, EQ);
   __ CompareObject(bool_register, Bool::True());
   __ b(is_true, EQ);
   __ b(is_false);
   __ Bind(&fall_through);
 }
 
 
 // R0: instance (must be preserved).
-// R1: instantiator type arguments (if used).
-// R2: function type arguments (if used).
+// R2: instantiator type arguments (if used).
+// R1: function type arguments (if used).
 // R3: type test cache.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
     TypeTestStubKind test_kind,
     Register instance_reg,
     Register instantiator_type_arguments_reg,
     Register function_type_arguments_reg,
     Register temp_reg,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(instance_reg == R0);
   ASSERT(temp_reg == kNoRegister);  // Unused on ARM.
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(zone(), SubtypeTestCache::New());
   __ LoadUniqueObject(R3, type_test_cache);
   if (test_kind == kTestTypeOneArg) {
     ASSERT(instantiator_type_arguments_reg == kNoRegister);
     ASSERT(function_type_arguments_reg == kNoRegister);
     __ BranchLink(*StubCode::Subtype1TestCache_entry());
   } else if (test_kind == kTestTypeTwoArgs) {
     ASSERT(instantiator_type_arguments_reg == kNoRegister);
     ASSERT(function_type_arguments_reg == kNoRegister);
     __ BranchLink(*StubCode::Subtype2TestCache_entry());
   } else if (test_kind == kTestTypeFourArgs) {
-    ASSERT(instantiator_type_arguments_reg == R1);
-    ASSERT(function_type_arguments_reg == R2);
+    ASSERT(instantiator_type_arguments_reg == R2);
+    ASSERT(function_type_arguments_reg == R1);
     __ BranchLink(*StubCode::Subtype4TestCache_entry());
   } else {
     UNREACHABLE();
   }
   // Result is in R1: null -> not found, otherwise Bool::True or Bool::False.
   GenerateBoolToJump(R1, is_instance_lbl, is_not_instance_lbl);
   return type_test_cache.raw();
 }
 
 
@@ skipping 193 matching lines @@
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     TokenPosition token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("UninstantiatedTypeTest");
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
   if (type.IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(type);
-    __ ldr(R1, Address(SP, 1 * kWordSize));  // Get instantiator type args.
-    __ ldr(R2, Address(SP, 0 * kWordSize));  // Get function type args.
-    // TODO(regis): Renumber registers and use ldm.
-    // R1: instantiator type arguments.
-    // R2: function type arguments.
+    const Register kInstantiatorTypeArgumentsReg = R2;
+    const Register kFunctionTypeArgumentsReg = R1;
+    __ ldm(IA, SP, (1 << kFunctionTypeArgumentsReg) |
+                       (1 << kInstantiatorTypeArgumentsReg));
+    // R2: instantiator type arguments.
+    // R1: function type arguments.
     const Register kTypeArgumentsReg =
-        type_param.IsClassTypeParameter() ? R1 : R2;
+        type_param.IsClassTypeParameter() ? R2 : R1;
     // Check if type arguments are null, i.e. equivalent to vector of dynamic.
     __ CompareObject(kTypeArgumentsReg, Object::null_object());
     __ b(is_instance_lbl, EQ);
     __ ldr(R3, FieldAddress(kTypeArgumentsReg,
                             TypeArguments::type_at_offset(type_param.index())));
     // R3: concrete type of type.
     // Check if type argument is dynamic.
     __ CompareObject(R3, Object::dynamic_type());
     __ b(is_instance_lbl, EQ);
     __ CompareObject(R3, Type::ZoneHandle(zone(), Type::ObjectType()));
     __ b(is_instance_lbl, EQ);
     // TODO(regis): Optimize void type as well once allowed as type argument.
 
     // For Smi check quickly against int and num interfaces.
     Label not_smi;
     __ tst(R0, Operand(kSmiTagMask));  // Value is Smi?
     __ b(&not_smi, NE);
     __ CompareObject(R3, Type::ZoneHandle(zone(), Type::IntType()));
     __ b(is_instance_lbl, EQ);
     __ CompareObject(R3, Type::ZoneHandle(zone(), Type::Number()));
     __ b(is_instance_lbl, EQ);
     // Smi must be handled in runtime.
     Label fall_through;
     __ b(&fall_through);
 
     __ Bind(&not_smi);
     // R0: instance.
-    // R1: instantiator type arguments.
-    // R2: function type arguments.
+    // R2: instantiator type arguments.
+    // R1: function type arguments.
     const Register kInstanceReg = R0;
-    const Register kInstantiatorTypeArgumentsReg = R1;
-    const Register kFunctionTypeArgumentsReg = R2;
     const Register kTempReg = kNoRegister;
     const SubtypeTestCache& type_test_cache = SubtypeTestCache::ZoneHandle(
         zone(), GenerateCallSubtypeTestStub(
                     kTestTypeFourArgs, kInstanceReg,
                     kInstantiatorTypeArgumentsReg, kFunctionTypeArgumentsReg,
                     kTempReg, is_instance_lbl, is_not_instance_lbl));
     __ Bind(&fall_through);
     return type_test_cache.raw();
   }
   if (type.IsType()) {
     const Register kInstanceReg = R0;
-    const Register kInstantiatorTypeArgumentsReg = R1;
-    const Register kFunctionTypeArgumentsReg = R2;
+    const Register kInstantiatorTypeArgumentsReg = R2;
+    const Register kFunctionTypeArgumentsReg = R1;
     __ tst(kInstanceReg, Operand(kSmiTagMask));  // Is instance Smi?
     __ b(is_not_instance_lbl, EQ);
-    __ ldr(kInstantiatorTypeArgumentsReg, Address(SP, 1 * kWordSize));
-    __ ldr(kFunctionTypeArgumentsReg, Address(SP, 0 * kWordSize));
-    // TODO(regis): Renumber registers and use ldm.
+    __ ldm(IA, SP, (1 << kFunctionTypeArgumentsReg) |
+                       (1 << kInstantiatorTypeArgumentsReg));
     // Uninstantiated type class is known at compile time, but the type
     // arguments are determined at runtime by the instantiator(s).
     const Register kTempReg = kNoRegister;
     return GenerateCallSubtypeTestStub(kTestTypeFourArgs, kInstanceReg,
                                        kInstantiatorTypeArgumentsReg,
                                        kFunctionTypeArgumentsReg, kTempReg,
                                        is_instance_lbl, is_not_instance_lbl);
   }
   return SubtypeTestCache::null();
 }
 
 
 // Inputs:
 // - R0: instance being type checked (preserved).
-// - R1: optional instantiator type arguments (preserved).
-// - R2: optional function type arguments (preserved).
+// - R2: optional instantiator type arguments (preserved).
+// - R1: optional function type arguments (preserved).
 // Clobbers R3, R4, R8, R9.
 // Returns:
-// - preserved instance in R0, optional instantiator type arguments in R1, and
-//   optional function type arguments in R2.
+// - preserved instance in R0, optional instantiator type arguments in R2, and
+//   optional function type arguments in R1.
 // Note that this inlined code must be followed by the runtime_call code, as it
 // may fall through to it. Otherwise, this inline code will jump to the label
 // is_instance or to the label is_not_instance.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
     TokenPosition token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("InlineInstanceof");
   if (type.IsVoidType()) {
@@ skipping 27 matching lines @@
 }
 
 
 // If instanceof type test cannot be performed successfully at compile time and
 // therefore eliminated, optimize it by adding inlined tests for:
 // - NULL -> return type == Null (type is not Object or dynamic).
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - R0: object.
-// - R1: instantiator type arguments or raw_null.
-// - R2: function type arguments or raw_null.
+// - R2: instantiator type arguments or raw_null.
+// - R1: function type arguments or raw_null.
 // Returns:
 // - true or false in R0.
 void FlowGraphCompiler::GenerateInstanceOf(TokenPosition token_pos,
                                            intptr_t deopt_id,
                                            const AbstractType& type,
                                            LocationSummary* locs) {
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
   ASSERT(!type.IsObjectType() && !type.IsDynamicType());
-
-  __ Push(R1);  // Store instantiator type arguments.
-  __ Push(R2);  // Store function type arguments.
-  // TODO(regis): Renumber registers and use PushList.
-
+  const Register kInstantiatorTypeArgumentsReg = R2;
+  const Register kFunctionTypeArgumentsReg = R1;
+  __ PushList((1 << kInstantiatorTypeArgumentsReg) |
+              (1 << kFunctionTypeArgumentsReg));
   Label is_instance, is_not_instance;
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     // A null object is only an instance of Null, Object, and dynamic.
     // Object and dynamic have already been checked above (if the type is
     // instantiated). So we can return false here if the instance is null,
     // unless the type is Null (and if the type is instantiated).
     // We can only inline this null check if the type is instantiated at compile
     // time, since an uninstantiated type at compile time could be Null, Object,
     // or dynamic at run time.
     __ CompareObject(R0, Object::null_object());
     __ b(type.IsNullType() ? &is_instance : &is_not_instance, EQ);
   }
 
   // Generate inline instanceof test.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
   test_cache =
       GenerateInlineInstanceof(token_pos, type, &is_instance, &is_not_instance);
 
   // test_cache is null if there is no fall-through.
   Label done;
   if (!test_cache.IsNull()) {
     // Generate runtime call.
-    __ ldr(R1, Address(SP, 1 * kWordSize));  // Get instantiator type args.
-    __ ldr(R2, Address(SP, 0 * kWordSize));  // Get function type args.
-    // TODO(regis): Renumber registers and use ldm.
+    __ ldm(IA, SP, (1 << kFunctionTypeArgumentsReg) |
+                       (1 << kInstantiatorTypeArgumentsReg));
     __ PushObject(Object::null_object());  // Make room for the result.
     __ Push(R0);                           // Push the instance.
     __ PushObject(type);                   // Push the type.
-    __ Push(R1);                           // Instantiator type arguments.
-    __ Push(R2);                           // Function type arguments.
-    // TODO(regis): Renumber registers and use PushList.
+    __ PushList((1 << kInstantiatorTypeArgumentsReg) |
+                (1 << kFunctionTypeArgumentsReg));
     __ LoadUniqueObject(R0, test_cache);
     __ Push(R0);
     GenerateRuntimeCall(token_pos, deopt_id, kInstanceofRuntimeEntry, 5, locs);
     // Pop the parameters supplied to the runtime entry. The result of the
     // instanceof runtime call will be left as the result of the operation.
     __ Drop(5);
     __ Pop(R0);
     __ b(&done);
   }
   __ Bind(&is_not_instance);
   __ LoadObject(R0, Bool::Get(false));
   __ b(&done);
 
   __ Bind(&is_instance);
   __ LoadObject(R0, Bool::Get(true));
   __ Bind(&done);
   // Remove instantiator type arguments and function type arguments.
   __ Drop(2);
 }
 
 
 // Optimize assignable type check by adding inlined tests for:
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - R0: instance being type checked.
-// - R1: instantiator type arguments or raw_null.
-// - R2: function type arguments or raw_null.
+// - R2: instantiator type arguments or raw_null.
+// - R1: function type arguments or raw_null.
 // Returns:
 // - object in R0 for successful assignable check (or throws TypeError).
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
 void FlowGraphCompiler::GenerateAssertAssignable(TokenPosition token_pos,
                                                  intptr_t deopt_id,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name,
                                                  LocationSummary* locs) {
   ASSERT(!token_pos.IsClassifying());
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformedOrMalbounded() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
-  __ Push(R1);  // Store instantiator type arguments.
-  __ Push(R2);  // Store function type arguments.
-  // TODO(regis): Renumber registers and use PushList.
+  const Register kInstantiatorTypeArgumentsReg = R2;
+  const Register kFunctionTypeArgumentsReg = R1;
+  __ PushList((1 << kInstantiatorTypeArgumentsReg) |
+              (1 << kFunctionTypeArgumentsReg));
   // A null object is always assignable and is returned as result.
   Label is_assignable, runtime_call;
   __ CompareObject(R0, Object::null_object());
   __ b(&is_assignable, EQ);
 
   // Generate throw new TypeError() if the type is malformed or malbounded.
   if (dst_type.IsMalformedOrMalbounded()) {
     __ PushObject(Object::null_object());  // Make room for the result.
     __ Push(R0);                           // Push the source object.
     __ PushObject(dst_name);               // Push the name of the destination.
     __ PushObject(dst_type);               // Push the type of the destination.
     GenerateRuntimeCall(token_pos, deopt_id, kBadTypeErrorRuntimeEntry, 3,
                         locs);
     // We should never return here.
     __ bkpt(0);
 
     __ Bind(&is_assignable);  // For a null object.
-    __ Pop(R2);               // Remove pushed function type arguments.
-    __ Pop(R1);               // Remove pushed instantiator type arguments.
-    // TODO(regis): Renumber registers and use PopList.
+    __ PopList((1 << kFunctionTypeArgumentsReg) |
+               (1 << kInstantiatorTypeArgumentsReg));
     return;
   }
 
   // Generate inline type check, linking to runtime call if not assignable.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
   test_cache = GenerateInlineInstanceof(token_pos, dst_type, &is_assignable,
                                         &runtime_call);
 
   __ Bind(&runtime_call);
-  __ ldr(R1, Address(SP, 1 * kWordSize));  // Get instantiator type args.
-  __ ldr(R2, Address(SP, 0 * kWordSize));  // Get function type args.
-  // TODO(regis): Renumber registers and use ldm.
+  __ ldm(IA, SP, (1 << kFunctionTypeArgumentsReg) |
+                     (1 << kInstantiatorTypeArgumentsReg));
   __ PushObject(Object::null_object());  // Make room for the result.
   __ Push(R0);                           // Push the source object.
   __ PushObject(dst_type);               // Push the type of the destination.
-  __ Push(R1);                           // Instantiator type arguments.
-  __ Push(R2);                           // Function type arguments.
-  // TODO(regis): Renumber registers and use PushList.
+  __ PushList((1 << kInstantiatorTypeArgumentsReg) |
+              (1 << kFunctionTypeArgumentsReg));
   __ PushObject(dst_name);  // Push the name of the destination.
   __ LoadUniqueObject(R0, test_cache);
   __ Push(R0);
   GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 6, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
   __ Pop(R0);
 
   __ Bind(&is_assignable);
-  __ Pop(R2);  // Remove pushed function type arguments.
-  __ Pop(R1);  // Remove pushed instantiator type arguments.
-  // TODO(regis): Renumber registers and use PopList.
+  __ PopList((1 << kFunctionTypeArgumentsReg) |
+             (1 << kInstantiatorTypeArgumentsReg));
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (is_optimizing()) {
     return;
   }
   Definition* defn = instr->AsDefinition();
   if ((defn != NULL) && defn->HasTemp()) {
     __ Push(defn->locs()->out(0).reg());
@@ skipping 698 matching lines @@
   ClobberDeadTempRegisters(locs);
 #endif
 
   // TODO(vegorov): consider saving only caller save (volatile) registers.
   const intptr_t fpu_regs_count = locs->live_registers()->FpuRegisterCount();
   if (fpu_regs_count > 0) {
     __ AddImmediate(SP, -(fpu_regs_count * kFpuRegisterSize));
     // Store fpu registers with the lowest register number at the lowest
     // address.
     intptr_t offset = 0;
+    __ mov(IP, Operand(SP));
     for (intptr_t i = 0; i < kNumberOfFpuRegisters; ++i) {
       QRegister fpu_reg = static_cast<QRegister>(i);
       if (locs->live_registers()->ContainsFpuRegister(fpu_reg)) {
-        DRegister d1 = EvenDRegisterOf(fpu_reg);
-        DRegister d2 = OddDRegisterOf(fpu_reg);
-        // TODO(regis): merge stores using vstmd instruction.
-        __ vstrd(d1, Address(SP, offset));
-        __ vstrd(d2, Address(SP, offset + 2 * kWordSize));
+        DRegister d = EvenDRegisterOf(fpu_reg);
+        ASSERT(d + 1 == OddDRegisterOf(fpu_reg));
+        __ vstmd(IA_W, IP, d, 2);
         offset += kFpuRegisterSize;
       }
     }
     ASSERT(offset == (fpu_regs_count * kFpuRegisterSize));
   }
 
   // The order in which the registers are pushed must match the order
   // in which the registers are encoded in the safe point's stack map.
   // NOTE: This matches the order of ARM's multi-register push.
   RegList reg_list = 0;
@@ skipping 21 matching lines @@
     __ PopList(reg_list);
   }
 
   const intptr_t fpu_regs_count = locs->live_registers()->FpuRegisterCount();
   if (fpu_regs_count > 0) {
     // Fpu registers have the lowest register number at the lowest address.
     intptr_t offset = 0;
     for (intptr_t i = 0; i < kNumberOfFpuRegisters; ++i) {
       QRegister fpu_reg = static_cast<QRegister>(i);
       if (locs->live_registers()->ContainsFpuRegister(fpu_reg)) {
-        DRegister d1 = EvenDRegisterOf(fpu_reg);
-        DRegister d2 = OddDRegisterOf(fpu_reg);
-        // TODO(regis): merge loads using vldmd instruction.
-        __ vldrd(d1, Address(SP, offset));
-        __ vldrd(d2, Address(SP, offset + 2 * kWordSize));
+        DRegister d = EvenDRegisterOf(fpu_reg);
+        ASSERT(d + 1 == OddDRegisterOf(fpu_reg));
+        __ vldmd(IA_W, SP, d, 2);
         offset += kFpuRegisterSize;
       }
     }
     ASSERT(offset == (fpu_regs_count * kFpuRegisterSize));
-    __ AddImmediate(SP, offset);
   }
 }
 
 
 #if defined(DEBUG)
 void FlowGraphCompiler::ClobberDeadTempRegisters(LocationSummary* locs) {
   // Clobber temporaries that have not been manually preserved.
   for (intptr_t i = 0; i < locs->temp_count(); ++i) {
     Location tmp = locs->temp(i);
     // TODO(zerny): clobber non-live temporary FPU registers.
@@ skipping 415 matching lines @@
   DRegister dreg = EvenDRegisterOf(reg);
   __ vldrd(dreg, Address(SP, kDoubleSize, Address::PostIndex));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM