Introduces a second temporary register for MIPS assembler macros.

runtime/vm/flow_graph_compiler_mips.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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 66 matching lines @@
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void FlowGraphCompiler::CheckClassIds(Register class_id_reg,
                                       const GrowableArray<intptr_t>& class_ids,
                                       Label* is_equal_lbl,
                                       Label* is_not_equal_lbl) {
   for (intptr_t i = 0; i < class_ids.length(); i++) {
-    __ LoadImmediate(TMP, class_ids[i]);
-    __ beq(class_id_reg, TMP, is_equal_lbl);
+    __ BranchEqual(class_id_reg, class_ids[i], is_equal_lbl);
   }
   __ b(is_not_equal_lbl);
 }
 
 
 // Testing against an instantiated type with no arguments, without
 // SubtypeTestCache.
 // A0: instance being type checked (preserved).
 // Clobbers: T0, T1, T2
 // Returns true if there is a fallthrough.
@@ skipping 15 matching lines @@
                             type_class,
                             TypeArguments::Handle(),
                             NULL)) {
     __ beq(T0, ZR, is_instance_lbl);
   } else {
     __ beq(T0, ZR, is_not_instance_lbl);
   }
   // Compare if the classes are equal.
   const Register kClassIdReg = T0;
   __ LoadClassId(kClassIdReg, kInstanceReg);
-  __ LoadImmediate(T1, type_class.id());
-  __ beq(kClassIdReg, T1, is_instance_lbl);
+  __ BranchEqual(kClassIdReg, type_class.id(), is_instance_lbl);
+
   // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
-    __ LoadImmediate(T1, kBoolCid);
-    __ beq(kClassIdReg, T1, is_instance_lbl);
+    __ BranchEqual(kClassIdReg, kBoolCid, is_instance_lbl);
     __ b(is_not_instance_lbl);
     return false;
   }
   if (type.IsFunctionType()) {
     // Check if instance is a closure.
     __ LoadClassById(T1, kClassIdReg);
     __ lw(T1, FieldAddress(T1, Class::signature_function_offset()));
-    __ LoadImmediate(T2, reinterpret_cast<int32_t>(Object::null()));
-    __ bne(T1, T2, is_instance_lbl);
+    __ BranchNotEqual(T1, reinterpret_cast<int32_t>(Object::null()),
+                      is_instance_lbl);
   }
   // Custom checking for numbers (Smi, Mint, Bigint and Double).
   // Note that instance is not Smi (checked above).
   if (type.IsSubtypeOf(Type::Handle(Type::Number()), NULL)) {
     GenerateNumberTypeCheck(
         kClassIdReg, type, is_instance_lbl, is_not_instance_lbl);
     return false;
   }
   if (type.IsStringType()) {
     GenerateStringTypeCheck(kClassIdReg, is_instance_lbl, is_not_instance_lbl);
@@ skipping 46 matching lines @@
   }
   if (TypeCheckAsClassEquality(type)) {
     const intptr_t type_cid = Class::Handle(type.type_class()).id();
     const Register kInstanceReg = A0;
     __ andi(T0, kInstanceReg, Immediate(kSmiTagMask));
     if (type_cid == kSmiCid) {
       __ beq(T0, ZR, is_instance_lbl);
     } else {
       __ beq(T0, ZR, is_not_instance_lbl);
       __ LoadClassId(T0, kInstanceReg);
-      __ LoadImmediate(T1, type_cid);
-      __ beq(T0, T1, is_instance_lbl);
+      __ BranchEqual(T0, type_cid, is_instance_lbl);
     }
     __ b(is_not_instance_lbl);
     return SubtypeTestCache::null();
   }
   if (type.IsInstantiated()) {
     const Class& type_class = Class::ZoneHandle(type.type_class());
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (type_class.HasTypeArguments()) {
@@ skipping 56 matching lines @@
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformed() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
   // Preserve instantiator and its type arguments.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(A2, Address(SP, 1 * kWordSize));
   __ sw(A1, Address(SP, 0 * kWordSize));
   // A null object is always assignable and is returned as result.
   Label is_assignable, runtime_call;
-  __ LoadImmediate(T0, reinterpret_cast<int32_t>(Object::null()));
-  __ beq(A0, T0, &is_assignable);
+  __ BranchEqual(A0, reinterpret_cast<int32_t>(Object::null()), &is_assignable);
 
   if (!FLAG_eliminate_type_checks) {
     // If type checks are not eliminated during the graph building then
     // a transition sentinel can be seen here.
-    __ LoadObject(T0, Object::transition_sentinel());
-    __ beq(A0, T0, &is_assignable);
+    __ BranchEqual(A0, Object::transition_sentinel(), &is_assignable);
   }
 
   // Generate throw new TypeError() if the type is malformed.
   if (dst_type.IsMalformed()) {
     const Error& error = Error::Handle(dst_type.malformed_error());
     const String& error_message = String::ZoneHandle(
         Symbols::New(error.ToErrorCString()));
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
     __ Push(A0);  // Push the source object.
     __ PushObject(dst_name);  // Push the name of the destination.
@@ skipping 34 matching lines @@
   __ LoadObject(A0, test_cache);
   __ Push(A0);
   GenerateCallRuntime(token_pos, deopt_id, kTypeCheckRuntimeEntry, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
   __ Pop(A0);
 
   __ Bind(&is_assignable);
   // Restore instantiator and its type arguments.
-    __ lw(A1, Address(SP, 0 * kWordSize));
-    __ lw(A2, Address(SP, 1 * kWordSize));
-    __ addiu(SP, SP, Immediate(2 * kWordSize));
+  __ lw(A1, Address(SP, 0 * kWordSize));
+  __ lw(A2, Address(SP, 1 * kWordSize));
+  __ addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) {
   if (!is_optimizing()) {
     if (FLAG_enable_type_checks && instr->IsAssertAssignable()) {
       AssertAssignableInstr* assert = instr->AsAssertAssignable();
       AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
                            assert->deopt_id(),
                            assert->token_pos());
@@ skipping 27 matching lines @@
   ASSERT(parsed_function().first_parameter_index() == kFirstLocalSlotIndex);
 
   // Check that min_num_pos_args <= num_pos_args <= max_num_pos_args,
   // where num_pos_args is the number of positional arguments passed in.
   const int min_num_pos_args = num_fixed_params;
   const int max_num_pos_args = num_fixed_params + num_opt_pos_params;
 
   __ lw(T2, FieldAddress(S4, ArgumentsDescriptor::positional_count_offset()));
   // Check that min_num_pos_args <= num_pos_args.
   Label wrong_num_arguments;
-  __ addiu(T3, T2, Immediate(-Smi::RawValue(min_num_pos_args)));
-  __ bltz(T3, &wrong_num_arguments);
+  __ BranchLess(T2, Smi::RawValue(min_num_pos_args), &wrong_num_arguments);
 
   // Check that num_pos_args <= max_num_pos_args.
-  __ addiu(T3, T2, Immediate(-Smi::RawValue(max_num_pos_args)));
-  __ bgtz(T3, &wrong_num_arguments);
+  __ BranchGreater(T2, Smi::RawValue(max_num_pos_args), &wrong_num_arguments);
 
   // Copy positional arguments.
   // Argument i passed at fp[kLastParamSlotIndex + num_args - 1 - i] is copied
   // to fp[kFirstLocalSlotIndex - i].
 
   __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
-  // Since T1 and T2 are Smi, use LSL 1 instead of LSL 2.
+  // Since T1 and T2 are Smi, use sll 1 instead of sll 2.
   // Let T1 point to the last passed positional argument, i.e. to
   // fp[kLastParamSlotIndex + num_args - 1 - (num_pos_args - 1)].
   __ subu(T1, T1, T2);
   __ sll(T1, T1, 1);
   __ addu(T1, FP, T1);
   __ addiu(T1, T1, Immediate(kLastParamSlotIndex * kWordSize));
 
   // Let T0 point to the last copied positional argument, i.e. to
   // fp[kFirstLocalSlotIndex - (num_pos_args - 1)].
   __ addiu(T0, FP, Immediate((kFirstLocalSlotIndex + 1) * kWordSize));
   __ sll(T3, T2, 1);  // T2 is a Smi.
   __ subu(T0, T0, T3);
 
   Label loop, loop_condition;
   __ b(&loop_condition);
   __ delay_slot()->SmiUntag(T2);
   // We do not use the final allocation index of the variable here, i.e.
   // scope->VariableAt(i)->index(), because captured variables still need
   // to be copied to the context that is not yet allocated.
   __ Bind(&loop);
   __ addu(T4, T1, T2);
   __ addu(T5, T0, T2);
-  __ lw(TMP, Address(T4));
-  __ sw(TMP, Address(T5));
+  __ lw(T3, Address(T4));
+  __ sw(T3, Address(T5));
   __ Bind(&loop_condition);
   __ addiu(T2, T2, Immediate(-kWordSize));
   __ bgez(T2, &loop);
 
   // Copy or initialize optional named arguments.
   Label all_arguments_processed;
   if (num_opt_named_params > 0) {
     // Start by alphabetically sorting the names of the optional parameters.
     LocalVariable** opt_param = new LocalVariable*[num_opt_named_params];
     int* opt_param_position = new int[num_opt_named_params];
@@ skipping 24 matching lines @@
     // Let T0 point to the entry of the first named argument.
     __ addiu(T0, S4, Immediate(
         ArgumentsDescriptor::first_named_entry_offset() - kHeapObjectTag));
     for (int i = 0; i < num_opt_named_params; i++) {
       Label load_default_value, assign_optional_parameter;
       const int param_pos = opt_param_position[i];
       // Check if this named parameter was passed in.
       // Load T3 with the name of the argument.
       __ lw(T3, Address(T0, ArgumentsDescriptor::name_offset()));
       ASSERT(opt_param[i]->name().IsSymbol());
-      __ LoadObject(T4, opt_param[i]->name());
-      __ bne(T3, T4, &load_default_value);
+      __ BranchNotEqual(T3, opt_param[i]->name(), &load_default_value);
 
       // Load T3 with passed-in argument at provided arg_pos, i.e. at
       // fp[kLastParamSlotIndex + num_args - 1 - arg_pos].
       __ lw(T3, Address(T0, ArgumentsDescriptor::position_offset()));
       // T3 is arg_pos as Smi.
       // Point to next named entry.
       __ addiu(T0, T0, Immediate(ArgumentsDescriptor::named_entry_size()));
       __ subu(T3, ZR, T3);
       __ sll(T3, T3, 1);
       __ addu(T3, T1, T3);
@@ skipping 11 matching lines @@
       // We do not use the final allocation index of the variable here, i.e.
       // scope->VariableAt(i)->index(), because captured variables still need
       // to be copied to the context that is not yet allocated.
       const intptr_t computed_param_pos = kFirstLocalSlotIndex - param_pos;
       __ sw(T3, Address(FP, computed_param_pos * kWordSize));
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that T0 now points to the null terminator in the array descriptor.
     __ lw(T3, Address(T0));
-    __ LoadImmediate(T4, reinterpret_cast<int32_t>(Object::null()));
-    __ beq(T3, T4, &all_arguments_processed);
+    __ BranchEqual(T3, reinterpret_cast<int32_t>(Object::null()),
+                &all_arguments_processed);
   } else {
     ASSERT(num_opt_pos_params > 0);
     __ lw(T2,
           FieldAddress(S4, ArgumentsDescriptor::positional_count_offset()));
     __ SmiUntag(T2);
     for (int i = 0; i < num_opt_pos_params; i++) {
       Label next_parameter;
       // Handle this optional positional parameter only if k or fewer positional
       // arguments have been passed, where k is param_pos, the position of this
       // optional parameter in the formal parameter list.
       const int param_pos = num_fixed_params + i;
-      __ addiu(T3, T2, Immediate(-param_pos));
-      __ bgtz(T3, &next_parameter);
+      __ BranchGreater(T2, param_pos, &next_parameter);
       // Load T3 with default argument.
       const Object& value = Object::ZoneHandle(
           parsed_function().default_parameter_values().At(i));
       __ LoadObject(T3, value);
       // Assign T3 to fp[kFirstLocalSlotIndex - param_pos].
       // We do not use the final allocation index of the variable here, i.e.
       // scope->VariableAt(i)->index(), because captured variables still need
       // to be copied to the context that is not yet allocated.
       const intptr_t computed_param_pos = kFirstLocalSlotIndex - param_pos;
       __ sw(T3, Address(FP, computed_param_pos * kWordSize));
       __ Bind(&next_parameter);
     }
     __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
     __ SmiUntag(T1);
     // Check that T2 equals T1, i.e. no named arguments passed.
-    __ beq(T2, T2, &all_arguments_processed);
+    __ beq(T2, T1, &all_arguments_processed);
   }
 
   __ Bind(&wrong_num_arguments);
   if (StackSize() != 0) {
     // We need to unwind the space we reserved for locals and copied parameters.
     // The NoSuchMethodFunction stub does not expect to see that area on the
     // stack.
     __ addiu(SP, SP, Immediate(StackSize() * kWordSize));
   }
   // The call below has an empty stackmap because we have just
@@ skipping 31 matching lines @@
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
   // This step can be skipped in case we decide that formal parameters are
   // implicitly final, since garbage collecting the unmodified value is not
   // an issue anymore.
 
   // S4 : arguments descriptor array.
   __ lw(T2, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(T2);
 
-  __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
+  __ LoadImmediate(T0, reinterpret_cast<intptr_t>(Object::null()));
   Label null_args_loop, null_args_loop_condition;
   __ b(&null_args_loop_condition);
   __ delay_slot()->addiu(T1, FP, Immediate(kLastParamSlotIndex * kWordSize));
   __ Bind(&null_args_loop);
   __ addu(T3, T1, T2);
-  __ sw(TMP, Address(T3));
+  __ sw(T0, Address(T3));
   __ Bind(&null_args_loop_condition);
   __ addiu(T2, T2, Immediate(-kWordSize));
   __ bgez(T2, &null_args_loop);
 }
 
 
 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   UNIMPLEMENTED();
 }
 
 
 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   UNIMPLEMENTED();
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   if (CanOptimizeFunction() && function.is_optimizable()) {
     const bool can_optimize = !is_optimizing() || may_reoptimize();
     const Register function_reg = T0;
     if (can_optimize) {
       Label next;
       // The pool pointer is not setup before entering the Dart frame.
 
-      __ mov(TMP, RA);  // Save RA.
+      __ mov(TMP1, RA);  // Save RA.
       __ bal(&next);  // Branch and link to next instruction to get PC in RA.
       __ delay_slot()->mov(T2, RA);  // Save PC of the following mov.
 
       // Calculate offset of pool pointer from the PC.
       const intptr_t object_pool_pc_dist =
          Instructions::HeaderSize() - Instructions::object_pool_offset() +
          assembler()->CodeSize();
 
       __ Bind(&next);
-      __ mov(RA, TMP);  // Restore RA.
+      __ mov(RA, TMP1);  // Restore RA.
 
       // Preserve PP of caller.
       __ mov(T1, PP);
 
       // Temporarily setup pool pointer for this dart function.
       __ lw(PP, Address(T2, -object_pool_pc_dist));
 
       // Load function object from object pool.
       __ LoadObject(function_reg, function);  // Uses PP.
 
@@ skipping 13 matching lines @@
         __ addiu(T1, T1, Immediate(1));
         __ sw(T1, FieldAddress(function_reg,
                                Function::usage_counter_offset()));
       } else {
         __ lw(T1, FieldAddress(function_reg,
                                Function::usage_counter_offset()));
       }
 
       // Skip Branch if T1 is less than the threshold.
       Label dont_branch;
-      __ LoadImmediate(T2, FLAG_optimization_counter_threshold);
-      __ sltu(T2, T1, T2);
-      __ bgtz(T2, &dont_branch);
+      __ BranchLess(T1, FLAG_optimization_counter_threshold, &dont_branch);
 
       ASSERT(function_reg == T0);
       __ Branch(&StubCode::OptimizeFunctionLabel());
 
       __ Bind(&dont_branch);
     }
   } else {
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
@@ skipping 40 matching lines @@
     ASSERT(!parsed_function().function().HasOptionalParameters());
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
 #endif
     if (check_arguments) {
       __ Comment("Check argument count");
       // Check that exactly num_fixed arguments are passed in.
       Label correct_num_arguments, wrong_num_arguments;
       __ lw(T0, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
-      __ LoadImmediate(T1, Smi::RawValue(num_fixed_params));
-      __ bne(T0, T1, &wrong_num_arguments);
+      __ BranchNotEqual(T0, Smi::RawValue(num_fixed_params),
+                        &wrong_num_arguments);
 
       __ lw(T1, FieldAddress(S4,
                              ArgumentsDescriptor::positional_count_offset()));
       __ beq(T0, T1, &correct_num_arguments);
       __ Bind(&wrong_num_arguments);
       if (function.IsClosureFunction()) {
         if (StackSize() != 0) {
           // We need to unwind the space we reserved for locals and copied
           // parameters. The NoSuchMethodFunction stub does not expect to see
           // that area on the stack.
@@ skipping 363 matching lines @@
 
 
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   UNIMPLEMENTED();
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS