Expands the use of Immediate and Operand wrappers.

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 86 matching lines @@
 
 #if defined(DEBUG)
   Label stack_ok;
   __ Comment("Stack Check");
   __ TraceSimMsg("Stack Check");
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ subu(CMPRES1, SP, FP);
 
-  __ BranchEqual(CMPRES1, fp_sp_dist, &stack_ok);
+  __ BranchEqual(CMPRES1, Immediate(fp_sp_dist), &stack_ok);
   __ break_(0);
 
   __ Bind(&stack_ok);
 #endif
   __ LeaveDartFrameAndReturn();
 }
 
 
 static Condition NegateCondition(Condition condition) {
   switch (condition) {
@@ skipping 633 matching lines @@
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
   __ andi(CMPRES1, val_reg, Immediate(kSmiTagMask));
   __ beq(CMPRES1, ZR, result ? labels.true_label : labels.false_label);
 
   __ LoadClassId(cid_reg, val_reg);
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
     ASSERT(test_cid != kSmiCid);
     result = data[i + 1] == true_result;
-    __ BranchEqual(cid_reg, test_cid,
+    __ BranchEqual(cid_reg, Immediate(test_cid),
                    result ? labels.true_label : labels.false_label);
   }
   // No match found, deoptimize or false.
   if (deopt == NULL) {
     Label* target = result ? labels.false_label : labels.true_label;
     if (target != labels.fall_through) {
       __ b(target);
     }
   } else {
     __ b(deopt);
@@ skipping 206 matching lines @@
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("StringToCharCodeInstr");
 
   ASSERT(cid_ == kOneByteStringCid);
   Register str = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   Label done, is_one;
   __ lw(result, FieldAddress(str, String::length_offset()));
-  __ BranchEqual(result, Smi::RawValue(1), &is_one);
+  __ BranchEqual(result, Immediate(Smi::RawValue(1)), &is_one);
   __ LoadImmediate(result, Smi::RawValue(-1));
   __ b(&done);
   __ Bind(&is_one);
   __ lbu(result, FieldAddress(str, OneByteString::data_offset()));
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
 LocationSummary* StringInterpolateInstr::MakeLocationSummary(Isolate* isolate,
@@ skipping 231 matching lines @@
     case kTypedDataUint16ArrayCid:
     case kTwoByteStringCid:
       __ lhu(result, element_address);
       __ SmiTag(result);
       break;
     case kTypedDataInt32ArrayCid: {
         Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                               ICData::kDeoptInt32Load);
         __ lw(result, element_address);
         // Verify that the signed value in 'result' can fit inside a Smi.
-        __ BranchSignedLess(result, 0xC0000000, deopt);
+        __ BranchSignedLess(result, Immediate(0xC0000000), deopt);
         __ SmiTag(result);
       }
       break;
     case kTypedDataUint32ArrayCid: {
         Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                               ICData::kDeoptUint32Load);
         __ lw(result, element_address);
         // Verify that the unsigned value in 'result' can fit inside a Smi.
         __ LoadImmediate(TMP, 0xC0000000);
         __ and_(CMPRES1, result, TMP);
@@ skipping 140 matching lines @@
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
         __ LoadImmediate(TMP, static_cast<int8_t>(value));
         __ sb(TMP, element_address);
       } else {
         Register value = locs()->in(2).reg();
         Label store_value, bigger, smaller;
         __ SmiUntag(TMP, value);
-        __ BranchUnsignedLess(TMP, 0xFF + 1, &store_value);
+        __ BranchUnsignedLess(TMP, Immediate(0xFF + 1), &store_value);
         __ LoadImmediate(TMP, 0xFF);
         __ slti(CMPRES1, value, Immediate(1));
         __ movn(TMP, ZR, CMPRES1);
         __ Bind(&store_value);
         __ sb(TMP, element_address);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
@@ skipping 121 matching lines @@
     // Check if the tracked state of the guarded field can be initialized
     // inline. If the field needs length check we fall through to runtime
     // which is responsible for computing offset of the length field
     // based on the class id.
     // Length guard will be emitted separately when needed via GuardFieldLength
     // instruction after GuardFieldClass.
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
       __ lw(CMPRES1, field_cid_operand);
-      __ BranchNotEqual(CMPRES1, kIllegalCid, fail);
+      __ BranchNotEqual(CMPRES1, Immediate(kIllegalCid), fail);
 
       if (value_cid == kDynamicCid) {
         __ sw(value_cid_reg, field_cid_operand);
         __ sw(value_cid_reg, field_nullability_operand);
       } else {
         __ LoadImmediate(TMP, value_cid);
         __ sw(TMP, field_cid_operand);
         __ sw(TMP, field_nullability_operand);
       }
 
       if (deopt == NULL) {
         ASSERT(!compiler->is_optimizing());
         __ b(&ok);
       }
     }
 
     if (deopt == NULL) {
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
       __ lw(CMPRES1, FieldAddress(field_reg, Field::guarded_cid_offset()));
-      __ BranchEqual(CMPRES1, kDynamicCid, &ok);
+      __ BranchEqual(CMPRES1, Immediate(kDynamicCid), &ok);
 
       __ addiu(SP, SP, Immediate(-2 * kWordSize));
       __ sw(field_reg, Address(SP, 1 * kWordSize));
       __ sw(value_reg, Address(SP, 0 * kWordSize));
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(deopt != NULL);
@@ skipping 220 matching lines @@
 
 static void EnsureMutableBox(FlowGraphCompiler* compiler,
                              StoreInstanceFieldInstr* instruction,
                              Register box_reg,
                              const Class& cls,
                              Register instance_reg,
                              intptr_t offset,
                              Register temp) {
   Label done;
   __ lw(box_reg, FieldAddress(instance_reg, offset));
-  __ BranchNotEqual(box_reg, reinterpret_cast<int32_t>(Object::null()),
-                    &done);
+  __ BranchNotEqual(box_reg, Object::null_object(), &done);
   BoxAllocationSlowPath::Allocate(compiler, instruction, cls, box_reg, temp);
   __ mov(temp, box_reg);
   __ StoreIntoObjectOffset(instance_reg, offset, temp);
   __ Bind(&done);
 }
 
 
 void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label skip_store;
 
@@ skipping 42 matching lines @@
       // across allocation slow-path.
       locs()->live_registers()->Add(locs()->in(1), kTagged);
     }
 
     Label store_pointer;
     Label store_double;
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()));
 
     __ lw(temp2, FieldAddress(temp, Field::is_nullable_offset()));
-    __ BranchEqual(temp2, kNullCid, &store_pointer);
+    __ BranchEqual(temp2, Immediate(kNullCid), &store_pointer);
 
     __ lbu(temp2, FieldAddress(temp, Field::kind_bits_offset()));
     __ andi(CMPRES1, temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ beq(CMPRES1, ZR, &store_pointer);
 
     __ lw(temp2, FieldAddress(temp, Field::guarded_cid_offset()));
-    __ BranchEqual(temp2, kDoubleCid, &store_double);
+    __ BranchEqual(temp2, Immediate(kDoubleCid), &store_double);
 
     // Fall through.
     __ b(&store_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
       locs()->live_registers()->Add(locs()->in(1));
     }
 
     {
@@ skipping 275 matching lines @@
     Label load_pointer;
     Label load_double;
 
     __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()));
 
     FieldAddress field_cid_operand(result_reg, Field::guarded_cid_offset());
     FieldAddress field_nullability_operand(result_reg,
                                            Field::is_nullable_offset());
 
     __ lw(temp, field_nullability_operand);
-    __ BranchEqual(temp, kNullCid, &load_pointer);
+    __ BranchEqual(temp, Immediate(kNullCid), &load_pointer);
 
     __ lw(temp, field_cid_operand);
-    __ BranchEqual(temp, kDoubleCid, &load_double);
+    __ BranchEqual(temp, Immediate(kDoubleCid), &load_double);
 
     // Fall through.
     __ b(&load_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
     }
 
     {
       __ Bind(&load_double);
@@ skipping 78 matching lines @@
   // 'instantiator_reg' is the instantiator TypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    __ BranchEqual(instantiator_reg, reinterpret_cast<int32_t>(Object::null()),
+    __ BranchEqual(instantiator_reg, Object::null_object(),
                    &type_arguments_instantiated);
   }
 
   __ LoadObject(T2, type_arguments());
   __ lw(T2, FieldAddress(T2, TypeArguments::instantiations_offset()));
   __ AddImmediate(T2, Array::data_offset() - kHeapObjectTag);
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, found, slow_case;
   __ Bind(&loop);
   __ lw(T1, Address(T2, 0 * kWordSize));  // Cached instantiator.
   __ beq(T1, T0, &found);
-  __ BranchNotEqual(T1, Smi::RawValue(StubCode::kNoInstantiator), &loop);
+  __ BranchNotEqual(
+      T1, Immediate(Smi::RawValue(StubCode::kNoInstantiator)), &loop);
   __ delay_slot()->addiu(T2, T2, Immediate(2 * kWordSize));
   __ b(&slow_case);
   __ Bind(&found);
   __ lw(T0, Address(T2, 1 * kWordSize));  // Cached instantiated args.
   __ b(&type_arguments_instantiated);
 
   __ Bind(&slow_case);
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
@@ skipping 312 matching lines @@
   __ BranchUnsignedLessEqual(SP, CMPRES1, slow_path->entry_label());
   if (compiler->CanOSRFunction() && in_loop()) {
     Register temp = locs()->temp(0).reg();
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function());
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ lw(temp, FieldAddress(temp, Function::usage_counter_offset()));
-    __ BranchSignedGreaterEqual(temp, threshold, slow_path->osr_entry_label());
+    __ BranchSignedGreaterEqual(
+        temp, Immediate(threshold), slow_path->osr_entry_label());
   }
   if (compiler->ForceSlowPathForStackOverflow()) {
     __ b(slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
@@ skipping 35 matching lines @@
       const intptr_t left_int = Smi::Cast(obj).Value();
       if (left_int == 0) {
         __ bltz(right, deopt);
         __ mov(result, ZR);
         return;
       }
       const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
       const bool right_needs_check =
           !RangeUtils::IsWithin(right_range, 0, max_right - 1);
       if (right_needs_check) {
-        __ BranchUnsignedGreaterEqual(
-            right, reinterpret_cast<int32_t>(Smi::New(max_right)), deopt);
+        const Immediate& max_right_imm =
+            Immediate(reinterpret_cast<int32_t>(Smi::New(max_right)));
+        __ BranchUnsignedGreaterEqual(right, max_right_imm, deopt);
       }
       __ SmiUntag(TMP, right);
       __ sllv(result, left, TMP);
     }
     return;
   }
 
   const bool right_needs_check =
       !RangeUtils::IsWithin(right_range, 0, (Smi::kBits - 1));
   if (!shift_left->can_overflow()) {
@@ skipping 12 matching lines @@
       __ sra(TMP, right, kSmiTagSize);
       __ sllv(TMP, left, TMP);
       // result = right < kBits ? left << right : result.
       __ movn(result, TMP, CMPRES1);
     } else {
       __ sra(TMP, right, kSmiTagSize);
       __ sllv(result, left, TMP);
     }
   } else {
     if (right_needs_check) {
+      const Immediate& bits_imm =
+          Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits)));
       ASSERT(shift_left->CanDeoptimize());
-      __ BranchUnsignedGreaterEqual(
-          right, reinterpret_cast<int32_t>(Smi::New(Smi::kBits)), deopt);
+      __ BranchUnsignedGreaterEqual(right, bits_imm, deopt);
     }
     // Left is not a constant.
     Register temp = locs.temp(0).reg();
     // Check if count too large for handling it inlined.
     __ SmiUntag(temp, right);
     // Overflow test (preserve left, right, and temp);
     __ sllv(CMPRES1, left, temp);
     __ srav(CMPRES1, CMPRES1, temp);
     __ bne(CMPRES1, left, deopt);  // Overflow.
     // Shift for result now we know there is no overflow.
@@ skipping 221 matching lines @@
         // Handle divide by zero in runtime.
         __ beq(right, ZR, deopt);
       }
       Register temp = locs()->temp(0).reg();
       __ SmiUntag(temp, left);
       __ SmiUntag(TMP, right);
       __ div(temp, TMP);
       __ mflo(result);
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
-      __ BranchEqual(result, 0x40000000, deopt);
+      __ BranchEqual(result, Immediate(0x40000000), deopt);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ beq(right, ZR, deopt);
       }
       Register temp = locs()->temp(0).reg();
       __ SmiUntag(temp, left);
@@ skipping 32 matching lines @@
       Register temp = locs()->temp(0).reg();
       if (CanDeoptimize()) {
         __ bltz(right, deopt);
       }
       __ SmiUntag(temp, right);
       // sra operation masks the count to 5 bits.
       const intptr_t kCountLimit = 0x1F;
       if ((right_range == NULL) ||
           !right_range->OnlyLessThanOrEqualTo(kCountLimit)) {
         Label ok;
-        __ BranchSignedLessEqual(temp, kCountLimit, &ok);
+        __ BranchSignedLessEqual(temp, Immediate(kCountLimit), &ok);
         __ LoadImmediate(temp, kCountLimit);
         __ Bind(&ok);
       }
 
       __ SmiUntag(CMPRES1, left);
       __ srav(result, CMPRES1, temp);
       __ SmiTag(result);
       break;
     }
     case Token::kDIV: {
@@ skipping 99 matching lines @@
     __ LoadDFromOffset(result, value, Double::value_offset() - kHeapObjectTag);
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(TMP, value);
     __ mtc1(TMP, STMP1);
     __ cvtdw(result, STMP1);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
-      __ BranchEqual(value, reinterpret_cast<int32_t>(Object::null()), deopt);
+      __ BranchEqual(value, Object::null_object(), deopt);
       // It must be double now.
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
     } else {
       Label is_smi, done;
 
       __ andi(CMPRES1, value, Immediate(kSmiTagMask));
       __ beq(CMPRES1, ZR, &is_smi);
       __ LoadClassId(CMPRES1, value);
-      __ BranchNotEqual(CMPRES1, kDoubleCid, deopt);
+      __ BranchNotEqual(CMPRES1, Immediate(kDoubleCid), deopt);
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
       __ b(&done);
       __ Bind(&is_smi);
       __ SmiUntag(TMP, value);
       __ mtc1(TMP, STMP1);
       __ cvtdw(result, STMP1);
       __ Bind(&done);
     }
   }
@@ skipping 1049 matching lines @@
       // Handle divide by zero in runtime.
       __ beq(right, ZR, deopt);
     }
     __ SmiUntag(temp, left);
     __ SmiUntag(TMP, right);
     __ div(temp, TMP);
     __ mflo(result_div);
     __ mfhi(result_mod);
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
-    __ BranchEqual(result_div, 0x40000000, deopt);
+    __ BranchEqual(result_div, Immediate(0x40000000), deopt);
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
     //    } else {
     //      res = res + right;
     //    }
     //  }
     Label done;
     __ bgez(result_mod, &done);
@@ skipping 93 matching lines @@
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData::DeoptReasonId deopt_reason = licm_hoisted_ ?
       ICData::kDeoptHoistedCheckClass : ICData::kDeoptCheckClass;
   if (IsNullCheck()) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(), deopt_reason);
-    __ BranchEqual(locs()->in(0).reg(),
-        reinterpret_cast<int32_t>(Object::null()), deopt);
+    __ BranchEqual(locs()->in(0).reg(), Object::null_object(), deopt);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), deopt_reason);
   Label is_ok;
   intptr_t cix = 0;
@@ skipping 68 matching lines @@
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass);
-  __ BranchNotEqual(value, Smi::RawValue(cid_), deopt);
+  __ BranchNotEqual(value, Immediate(Smi::RawValue(cid_)), deopt);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(kLengthPos, Location::RegisterOrSmiConstant(length()));
@@ skipping 16 matching lines @@
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ b(deopt);
     return;
   }
 
   if (index_loc.IsConstant()) {
     Register length = length_loc.reg();
     const Smi& index = Smi::Cast(index_loc.constant());
     __ BranchUnsignedLessEqual(
-        length, reinterpret_cast<int32_t>(index.raw()), deopt);
+        length, Immediate(reinterpret_cast<int32_t>(index.raw())), deopt);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     Register index = index_loc.reg();
     __ BranchUnsignedGreaterEqual(
-        index, reinterpret_cast<int32_t>(length.raw()), deopt);
+        index, Immediate(reinterpret_cast<int32_t>(length.raw())), deopt);
   } else {
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ BranchUnsignedGreaterEqual(index, length, deopt);
   }
 }
 
 
 LocationSummary* UnboxIntegerInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
@@ skipping 182 matching lines @@
   if (value_cid == kSmiCid) {
     __ SmiUntag(out, value);
   } else if (value_cid == kMintCid) {
     LoadInt32FromMint(compiler, value, out, out_of_range);
   } else {
     Label done;
     __ SmiUntag(out, value);
     __ andi(CMPRES1, value, Immediate(kSmiTagMask));
     __ beq(CMPRES1, ZR, &done);
     __ LoadClassId(CMPRES1, value);
-    __ BranchNotEqual(CMPRES1, kMintCid, deopt);
+    __ BranchNotEqual(CMPRES1, Immediate(kMintCid), deopt);
     LoadInt32FromMint(compiler, value, out, out_of_range);
     __ Bind(&done);
   }
 }
 
 
 LocationSummary* UnboxedIntConverterInstr::MakeLocationSummary(Isolate* isolate,
                                                                bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 18 matching lines @@
     const Register out = locs()->out(0).reg();
     // Representations are bitwise equivalent.
     ASSERT(out == locs()->in(0).reg());
   } else if (from() == kUnboxedUint32 && to() == kUnboxedInt32) {
     const Register out = locs()->out(0).reg();
     // Representations are bitwise equivalent.
     ASSERT(out == locs()->in(0).reg());
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
-      __ BranchSignedLess(out, 0, deopt);
+      __ BranchSignedLess(out, Immediate(0), deopt);
     }
   } else if (from() == kUnboxedMint) {
     UNREACHABLE();
   } else if (to() == kUnboxedMint) {
     ASSERT(from() == kUnboxedUint32 || from() == kUnboxedInt32);
     UNREACHABLE();
   } else {
     UNREACHABLE();
   }
 }
@@ skipping 219 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(S4, kInvalidObjectPointer);
   __ LoadImmediate(S5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS