Expands the use of Immediate and Operand wrappers.

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 "vm/ast_printer.h"
@@ skipping 177 matching lines @@
 
 #define __ assembler()->
 
 
 // Fall through if bool_register contains null.
 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
                                            Label* is_true,
                                            Label* is_false) {
   __ TraceSimMsg("BoolToJump");
   Label fall_through;
-  __ BranchEqual(bool_register, reinterpret_cast<int32_t>(Object::null()),
-                 &fall_through);
+  __ BranchEqual(bool_register, Object::null_object(), &fall_through);
   __ BranchEqual(bool_register, Bool::True(), is_true);
   __ b(is_false);
   __ Bind(&fall_through);
 }
 
 
 // A0: instance (must be preserved).
 // A1: instantiator type arguments (if used).
 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
     TypeTestStubKind test_kind,
@@ skipping 62 matching lines @@
   const TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(type.arguments());
   const bool is_raw_type = type_arguments.IsNull() ||
       type_arguments.IsRaw(from_index, num_type_params);
   // Signature class is an instantiated parameterized type.
   if (!type_class.IsSignatureClass()) {
     if (is_raw_type) {
       const Register kClassIdReg = T0;
       // dynamic type argument, check only classes.
       __ LoadClassId(kClassIdReg, kInstanceReg);
-      __ BranchEqual(kClassIdReg, type_class.id(), is_instance_lbl);
+      __ BranchEqual(kClassIdReg, Immediate(type_class.id()), is_instance_lbl);
       // List is a very common case.
       if (IsListClass(type_class)) {
         GenerateListTypeCheck(kClassIdReg, is_instance_lbl);
       }
       return GenerateSubtype1TestCacheLookup(
           token_pos, type_class, is_instance_lbl, is_not_instance_lbl);
     }
     // If one type argument only, check if type argument is Object or dynamic.
     if (type_arguments.Length() == 1) {
       const AbstractType& tp_argument = AbstractType::ZoneHandle(
@@ skipping 23 matching lines @@
                                      is_not_instance_lbl);
 }
 
 
 void FlowGraphCompiler::CheckClassIds(Register class_id_reg,
                                       const GrowableArray<intptr_t>& class_ids,
                                       Label* is_equal_lbl,
                                       Label* is_not_equal_lbl) {
   __ TraceSimMsg("CheckClassIds");
   for (intptr_t i = 0; i < class_ids.length(); i++) {
-    __ BranchEqual(class_id_reg, class_ids[i], is_equal_lbl);
+    __ BranchEqual(class_id_reg, Immediate(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 16 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);
-  __ BranchEqual(kClassIdReg, type_class.id(), is_instance_lbl);
+  __ BranchEqual(kClassIdReg, Immediate(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()) {
-    __ BranchEqual(kClassIdReg, kBoolCid, is_instance_lbl);
+    __ BranchEqual(kClassIdReg, Immediate(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()));
-    __ BranchNotEqual(T1, reinterpret_cast<int32_t>(Object::null()),
-                      is_instance_lbl);
+    __ BranchNotEqual(T1, Object::null_object(), 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 191 matching lines @@
   // 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 Object and dynamic, which has
     // already been checked above (if the type is instantiated). So we can
     // return false here if the instance 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 Object or
     // dynamic at run time.
-    __ BranchEqual(A0, reinterpret_cast<int32_t>(Object::null()),
-                   &is_not_instance);
+    __ BranchEqual(A0, Object::null_object(), &is_not_instance);
   }
 
   // Generate inline instanceof test.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
   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()) {
@@ skipping 63 matching lines @@
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformedOrMalbounded() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
   // Preserve instantiator and its type arguments.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(A2, Address(SP, 1 * kWordSize));
 
   // A null object is always assignable and is returned as result.
   Label is_assignable, runtime_call;
 
-  __ BranchEqual(A0, reinterpret_cast<int32_t>(Object::null()), &is_assignable);
+  __ BranchEqual(A0, Object::null_object(), &is_assignable);
   __ delay_slot()->sw(A1, Address(SP, 0 * kWordSize));
 
   // Generate throw new TypeError() if the type is malformed or malbounded.
   if (dst_type.IsMalformedOrMalbounded()) {
     __ addiu(SP, SP, Immediate(-4 * kWordSize));
     __ LoadObject(TMP, Object::null_object());
     __ sw(TMP, Address(SP, 3 * kWordSize));  // Make room for the result.
     __ sw(A0, Address(SP, 2 * kWordSize));  // Push the source object.
     __ LoadObject(TMP, dst_name);
     __ sw(TMP, Address(SP, 1 * kWordSize));  // Push the destination name.
@@ skipping 78 matching lines @@
   ASSERT(parsed_function().first_parameter_index() == kFirstLocalSlotFromFp);
 
   // 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;
-  __ BranchSignedLess(T2, Smi::RawValue(min_num_pos_args),
+  __ BranchSignedLess(T2, Immediate(Smi::RawValue(min_num_pos_args)),
                       &wrong_num_arguments);
 
   // Check that num_pos_args <= max_num_pos_args.
-  __ BranchSignedGreater(T2, Smi::RawValue(max_num_pos_args),
+  __ BranchSignedGreater(T2, Immediate(Smi::RawValue(max_num_pos_args)),
                          &wrong_num_arguments);
 
   // Copy positional arguments.
   // Argument i passed at fp[kParamEndSlotFromFp + num_args - i] is copied
   // to fp[kFirstLocalSlotFromFp - i].
 
   __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   // 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[kParamEndSlotFromFp + num_args - (num_pos_args - 1)].
@@ skipping 93 matching lines @@
       // to be copied to the context that is not yet allocated.
       const intptr_t computed_param_pos = kFirstLocalSlotFromFp - param_pos;
       __ sw(T3, Address(FP, computed_param_pos * kWordSize));
     }
     delete[] opt_param;
     delete[] opt_param_position;
     if (check_correct_named_args) {
       // Check that T0 now points to the null terminator in the arguments
       // descriptor.
       __ lw(T3, Address(T0));
-      __ BranchEqual(T3, reinterpret_cast<int32_t>(Object::null()),
-                     &all_arguments_processed);
+      __ BranchEqual(T3, Object::null_object(), &all_arguments_processed);
     }
   } else {
     ASSERT(num_opt_pos_params > 0);
     __ Comment("There are optional positional parameters");
     __ 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;
-      __ BranchSignedGreater(T2, param_pos, &next_parameter);
+      __ BranchSignedGreater(T2, Immediate(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[kFirstLocalSlotFromFp - 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 = kFirstLocalSlotFromFp - param_pos;
       __ sw(T3, Address(FP, computed_param_pos * kWordSize));
@@ skipping 97 matching lines @@
     __ lw(T1, FieldAddress(function_reg, Function::usage_counter_offset()));
     // Reoptimization of an optimized function is triggered by counting in
     // IC stubs, but not at the entry of the function.
     if (!is_optimizing()) {
       __ addiu(T1, T1, Immediate(1));
       __ sw(T1, FieldAddress(function_reg, Function::usage_counter_offset()));
     }
 
     // Skip Branch if T1 is less than the threshold.
     Label dont_branch;
-    __ BranchSignedLess(T1, GetOptimizationThreshold(), &dont_branch);
+    __ BranchSignedLess(
+        T1, Immediate(GetOptimizationThreshold()), &dont_branch);
 
     ASSERT(function_reg == T0);
     __ Branch(&stub_code->OptimizeFunctionLabel());
 
     __ Bind(&dont_branch);
 
   } else if (!flow_graph().IsCompiledForOsr()) {
     entry_patch_pc_offset_ = assembler()->CodeSize();
   }
   __ Comment("Enter frame");
@@ skipping 42 matching lines @@
 #else
     const bool check_arguments =
         function.IsClosureFunction() && !flow_graph().IsCompiledForOsr();
 #endif
     if (check_arguments) {
       __ TraceSimMsg("Check argument count");
       __ 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()));
-      __ BranchNotEqual(T0, Smi::RawValue(num_fixed_params),
+      __ BranchNotEqual(T0, Immediate(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()) {
         __ LeaveDartFrame();  // The arguments are still on the stack.
         __ Branch(&isolate()->stub_code()->CallClosureNoSuchMethodLabel());
         // The noSuchMethod call may return to the caller, but not here.
@@ skipping 442 matching lines @@
                                                  argument_names));
   StubCode* stub_code = isolate()->stub_code();
 
   __ TraceSimMsg("EmitTestAndCall");
   __ Comment("EmitTestAndCall");
   __ LoadObject(S4, arguments_descriptor);
   for (intptr_t i = 0; i < len; i++) {
     const bool is_last_check = (i == (len - 1));
     Label next_test;
     if (is_last_check) {
-      __ BranchNotEqual(class_id_reg, sorted[i].cid, deopt);
+      __ BranchNotEqual(class_id_reg, Immediate(sorted[i].cid), deopt);
     } else {
-      __ BranchNotEqual(class_id_reg, sorted[i].cid, &next_test);
+      __ BranchNotEqual(class_id_reg, Immediate(sorted[i].cid), &next_test);
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     GenerateDartCall(deopt_id,
                      token_index,
                      &stub_code->CallStaticFunctionLabel(),
                      RawPcDescriptors::kOptStaticCall,
                      locs);
     const Function& function = *sorted[i].target;
     AddStaticCallTarget(function);
@@ skipping 235 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS