clang-format runtime/vm

runtime/vm/intrinsifier_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/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 11 matching lines @@
 // S4: Arguments descriptor
 // RA: Return address
 // The S4 register can be destroyed only if there is no slow-path, i.e.
 // if the intrinsified method always executes a return.
 // The FP register should not be modified, because it is used by the profiler.
 // The PP and THR registers (see constants_mips.h) must be preserved.
 
 #define __ assembler->
 
 
-intptr_t Intrinsifier::ParameterSlotFromSp() { return -1; }
+intptr_t Intrinsifier::ParameterSlotFromSp() {
+  return -1;
+}
 
 
 static bool IsABIPreservedRegister(Register reg) {
   return ((1 << reg) & kAbiPreservedCpuRegs) != 0;
 }
 
 void Intrinsifier::IntrinsicCallPrologue(Assembler* assembler) {
   ASSERT(IsABIPreservedRegister(CODE_REG));
   ASSERT(IsABIPreservedRegister(ARGS_DESC_REG));
   ASSERT(IsABIPreservedRegister(CALLEE_SAVED_TEMP));
@@ skipping 26 matching lines @@
 
   __ lw(T0, Address(SP, 2 * kWordSize));  // Array.
   // Range check.
   __ lw(T3, FieldAddress(T0, Array::length_offset()));  // Array length.
   // Runtime throws exception.
   __ BranchUnsignedGreaterEqual(T1, T3, &fall_through);
 
   // Note that T1 is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ lw(T2, Address(SP, 0 * kWordSize));  // Value.
-  __ sll(T1, T1, 1);  // T1 is Smi.
+  __ sll(T1, T1, 1);                      // T1 is Smi.
   __ addu(T1, T0, T1);
-  __ StoreIntoObject(T0,
-                     FieldAddress(T1, Array::data_offset()),
-                     T2);
+  __ StoreIntoObject(T0, FieldAddress(T1, Array::data_offset()), T2);
   // Caller is responsible for preserving the value if necessary.
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 // Allocate a GrowableObjectArray using the backing array specified.
 // On stack: type argument (+1), data (+0).
 void Intrinsifier::GrowableArray_Allocate(Assembler* assembler) {
   // The newly allocated object is returned in V0.
   const intptr_t kTypeArgumentsOffset = 1 * kWordSize;
   const intptr_t kArrayOffset = 0 * kWordSize;
   Label fall_through;
 
   // Try allocating in new space.
   const Class& cls = Class::Handle(
       Isolate::Current()->object_store()->growable_object_array_class());
   __ TryAllocate(cls, &fall_through, V0, T1);
 
   // Store backing array object in growable array object.
   __ lw(T1, Address(SP, kArrayOffset));  // Data argument.
   // V0 is new, no barrier needed.
   __ StoreIntoObjectNoBarrier(
-      V0,
-      FieldAddress(V0, GrowableObjectArray::data_offset()),
-      T1);
+      V0, FieldAddress(V0, GrowableObjectArray::data_offset()), T1);
 
   // V0: new growable array object start as a tagged pointer.
   // Store the type argument field in the growable array object.
   __ lw(T1, Address(SP, kTypeArgumentsOffset));  // Type argument.
   __ StoreIntoObjectNoBarrier(
-      V0,
-      FieldAddress(V0, GrowableObjectArray::type_arguments_offset()),
-      T1);
+      V0, FieldAddress(V0, GrowableObjectArray::type_arguments_offset()), T1);
   // Set the length field in the growable array object to 0.
   __ Ret();  // Returns the newly allocated object in V0.
   __ delay_slot()->sw(ZR,
-      FieldAddress(V0, GrowableObjectArray::length_offset()));
+                      FieldAddress(V0, GrowableObjectArray::length_offset()));
 
   __ Bind(&fall_through);
 }
 
 
 // Add an element to growable array if it doesn't need to grow, otherwise
 // call into regular code.
 // On stack: growable array (+1), value (+0).
 void Intrinsifier::GrowableArray_add(Assembler* assembler) {
   // In checked mode we need to type-check the incoming argument.
   if (Isolate::Current()->type_checks()) return;
   Label fall_through;
   __ lw(T0, Address(SP, 1 * kWordSize));  // Array.
   __ lw(T1, FieldAddress(T0, GrowableObjectArray::length_offset()));
   // T1: length.
   __ lw(T2, FieldAddress(T0, GrowableObjectArray::data_offset()));
   // T2: data.
   __ lw(T3, FieldAddress(T2, Array::length_offset()));
   // Compare length with capacity.
   // T3: capacity.
   __ beq(T1, T3, &fall_through);  // Must grow data.
   const int32_t value_one = reinterpret_cast<int32_t>(Smi::New(1));
   // len = len + 1;
   __ addiu(T3, T1, Immediate(value_one));
   __ sw(T3, FieldAddress(T0, GrowableObjectArray::length_offset()));
   __ lw(T0, Address(SP, 0 * kWordSize));  // Value.
   ASSERT(kSmiTagShift == 1);
   __ sll(T1, T1, 1);
   __ addu(T1, T2, T1);
-  __ StoreIntoObject(T2,
-                     FieldAddress(T1, Array::data_offset()),
-                     T0);
+  __ StoreIntoObject(T2, FieldAddress(T1, Array::data_offset()), T0);
   __ LoadObject(T7, Object::null_object());
   __ Ret();
   __ delay_slot()->mov(V0, T7);
   __ Bind(&fall_through);
 }
 
 
 #define TYPED_ARRAY_ALLOCATION(type_name, cid, max_len, scale_shift)           \
   Label fall_through;                                                          \
   const intptr_t kArrayLengthStackOffset = 0 * kWordSize;                      \
   NOT_IN_PRODUCT(__ MaybeTraceAllocation(cid, T2, &fall_through));             \
-  __ lw(T2, Address(SP, kArrayLengthStackOffset));  /* Array length. */        \
+  __ lw(T2, Address(SP, kArrayLengthStackOffset)); /* Array length. */         \
   /* Check that length is a positive Smi. */                                   \
   /* T2: requested array length argument. */                                   \
   __ andi(CMPRES1, T2, Immediate(kSmiTagMask));                                \
   __ bne(CMPRES1, ZR, &fall_through);                                          \
   __ BranchSignedLess(T2, Immediate(0), &fall_through);                        \
   __ SmiUntag(T2);                                                             \
   /* Check for maximum allowed length. */                                      \
   /* T2: untagged array length. */                                             \
   __ BranchSignedGreater(T2, Immediate(max_len), &fall_through);               \
   __ sll(T2, T2, scale_shift);                                                 \
@@ skipping 26 matching lines @@
   /* Initialize the tags. */                                                   \
   /* V0: new object start as a tagged pointer. */                              \
   /* T1: new object end address. */                                            \
   /* T2: allocation size. */                                                   \
   {                                                                            \
     Label size_tag_overflow, done;                                             \
     __ BranchUnsignedGreater(T2, Immediate(RawObject::SizeTag::kMaxSizeTag),   \
                              &size_tag_overflow);                              \
     __ b(&done);                                                               \
     __ delay_slot()->sll(T2, T2,                                               \
-        RawObject::kSizeTagPos - kObjectAlignmentLog2);                        \
+                         RawObject::kSizeTagPos - kObjectAlignmentLog2);       \
                                                                                \
     __ Bind(&size_tag_overflow);                                               \
     __ mov(T2, ZR);                                                            \
     __ Bind(&done);                                                            \
                                                                                \
     /* Get the class index and insert it into the tags. */                     \
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));                 \
     __ or_(T2, T2, TMP);                                                       \
-    __ sw(T2, FieldAddress(V0, type_name::tags_offset()));  /* Tags. */        \
+    __ sw(T2, FieldAddress(V0, type_name::tags_offset())); /* Tags. */         \
   }                                                                            \
   /* Set the length field. */                                                  \
   /* V0: new object start as a tagged pointer. */                              \
   /* T1: new object end address. */                                            \
-  __ lw(T2, Address(SP, kArrayLengthStackOffset));  /* Array length. */        \
-  __ StoreIntoObjectNoBarrier(V0,                                              \
-                              FieldAddress(V0, type_name::length_offset()),    \
-                              T2);                                             \
+  __ lw(T2, Address(SP, kArrayLengthStackOffset)); /* Array length. */         \
+  __ StoreIntoObjectNoBarrier(                                                 \
+      V0, FieldAddress(V0, type_name::length_offset()), T2);                   \
   /* Initialize all array elements to 0. */                                    \
   /* V0: new object start as a tagged pointer. */                              \
   /* T1: new object end address. */                                            \
   /* T2: iterator which initially points to the start of the variable */       \
   /* data area to be initialized. */                                           \
   __ AddImmediate(T2, V0, sizeof(Raw##type_name) - 1);                         \
   Label done, init_loop;                                                       \
   __ Bind(&init_loop);                                                         \
   __ BranchUnsignedGreaterEqual(T2, T1, &done);                                \
   __ sw(ZR, Address(T2, 0));                                                   \
   __ b(&init_loop);                                                            \
   __ delay_slot()->addiu(T2, T2, Immediate(kWordSize));                        \
   __ Bind(&done);                                                              \
                                                                                \
   __ Ret();                                                                    \
-  __ Bind(&fall_through);                                                      \
+  __ Bind(&fall_through);
 
 
 static int GetScaleFactor(intptr_t size) {
   switch (size) {
-    case 1: return 0;
-    case 2: return 1;
-    case 4: return 2;
-    case 8: return 3;
-    case 16: return 4;
+    case 1:
+      return 0;
+    case 2:
+      return 1;
+    case 4:
+      return 2;
+    case 8:
+      return 3;
+    case 16:
+      return 4;
   }
   UNREACHABLE();
   return -1;
 }
 
 
 #define TYPED_DATA_ALLOCATOR(clazz)                                            \
-void Intrinsifier::TypedData_##clazz##_factory(Assembler* assembler) {         \
-  intptr_t size = TypedData::ElementSizeInBytes(kTypedData##clazz##Cid);       \
-  intptr_t max_len = TypedData::MaxElements(kTypedData##clazz##Cid);           \
-  int shift = GetScaleFactor(size);                                            \
-  TYPED_ARRAY_ALLOCATION(TypedData, kTypedData##clazz##Cid, max_len, shift);   \
-}
+  void Intrinsifier::TypedData_##clazz##_factory(Assembler* assembler) {       \
+    intptr_t size = TypedData::ElementSizeInBytes(kTypedData##clazz##Cid);     \
+    intptr_t max_len = TypedData::MaxElements(kTypedData##clazz##Cid);         \
+    int shift = GetScaleFactor(size);                                          \
+    TYPED_ARRAY_ALLOCATION(TypedData, kTypedData##clazz##Cid, max_len, shift); \
+  }
 CLASS_LIST_TYPED_DATA(TYPED_DATA_ALLOCATOR)
 #undef TYPED_DATA_ALLOCATOR
 
 
 // Loads args from stack into T0 and T1
 // Tests if they are smis, jumps to label not_smi if not.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(T1, Address(SP, 1 * kWordSize));
   __ or_(CMPRES1, T0, T1);
   __ andi(CMPRES1, CMPRES1, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, not_smi);
   return;
 }
 
 
 void Intrinsifier::Integer_addFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // Checks two Smis.
-  __ AdduDetectOverflow(V0, T0, T1, CMPRES1);  // Add.
-  __ bltz(CMPRES1, &fall_through);  // Fall through on overflow.
+  __ AdduDetectOverflow(V0, T0, T1, CMPRES1);       // Add.
+  __ bltz(CMPRES1, &fall_through);                  // Fall through on overflow.
   __ Ret();  // Nothing in branch delay slot.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_add(Assembler* assembler) {
   Integer_addFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_subFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ SubuDetectOverflow(V0, T0, T1, CMPRES1);  // Subtract.
-  __ bltz(CMPRES1, &fall_through);  // Fall through on overflow.
+  __ bltz(CMPRES1, &fall_through);             // Fall through on overflow.
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_sub(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ SubuDetectOverflow(V0, T1, T0, CMPRES1);  // Subtract.
-  __ bltz(CMPRES1, &fall_through);  // Fall through on overflow.
-  __ Ret();  // Nothing in branch delay slot.
+  __ bltz(CMPRES1, &fall_through);             // Fall through on overflow.
+  __ Ret();                                    // Nothing in branch delay slot.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_mulFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ SmiUntag(T0);  // untags T0. only want result shifted by one
 
-  __ mult(T0, T1);  // HI:LO <- T0 * T1.
-  __ mflo(V0);  // V0 <- LO.
-  __ mfhi(T2);  // T2 <- HI.
-  __ sra(T3, V0, 31);  // T3 <- V0 >> 31.
+  __ mult(T0, T1);                // HI:LO <- T0 * T1.
+  __ mflo(V0);                    // V0 <- LO.
+  __ mfhi(T2);                    // T2 <- HI.
+  __ sra(T3, V0, 31);             // T3 <- V0 >> 31.
   __ bne(T2, T3, &fall_through);  // Fall through on overflow.
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_mul(Assembler* assembler) {
   Integer_mulFromInteger(assembler);
 }
 
@@ skipping 26 matching lines @@
   __ delay_slot()->mov(result, left);
 
   __ Bind(&return_zero);
   __ Ret();
   __ delay_slot()->mov(result, ZR);
 
   __ Bind(&modulo);
   __ SmiUntag(right);
   __ SmiUntag(left);
   __ div(left, right);  // Divide, remainder goes in HI.
-  __ mfhi(result);  // result <- HI.
+  __ mfhi(result);      // result <- HI.
   return;
 }
 
 
 // Implementation:
 //  res = left % right;
 //  if (res < 0) {
 //    if (right < 0) {
 //      res = res - right;
 //    } else {
@@ skipping 37 matching lines @@
 
 void Intrinsifier::Integer_truncDivide(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ beq(T0, ZR, &fall_through);  // If b is 0, fall through.
 
   __ SmiUntag(T0);
   __ SmiUntag(T1);
   __ div(T1, T0);  // LO <- T1 / T0
-  __ mflo(V0);  // V0 <- LO
+  __ mflo(V0);     // V0 <- LO
   // Check the corner case of dividing the 'MIN_SMI' with -1, in which case we
   // cannot tag the result.
   __ BranchEqual(V0, Immediate(0x40000000), &fall_through);
   __ Ret();
   __ delay_slot()->SmiTag(V0);
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_negate(Assembler* assembler) {
   Label fall_through;
 
-  __ lw(T0, Address(SP, + 0 * kWordSize));  // Grabs first argument.
+  __ lw(T0, Address(SP, +0 * kWordSize));        // Grabs first argument.
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));  // Test for Smi.
-  __ bne(CMPRES1, ZR, &fall_through);  // Fall through if not a Smi.
+  __ bne(CMPRES1, ZR, &fall_through);            // Fall through if not a Smi.
   __ SubuDetectOverflow(V0, ZR, T0, CMPRES1);
   __ bltz(CMPRES1, &fall_through);  // There was overflow.
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_bitAndFromInteger(Assembler* assembler) {
   Label fall_through;
 
@@ skipping 38 matching lines @@
   Integer_bitXorFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through, overflow;
 
   TestBothArgumentsSmis(assembler, &fall_through);
-  __ BranchUnsignedGreater(
-      T0, Immediate(Smi::RawValue(Smi::kBits)), &fall_through);
+  __ BranchUnsignedGreater(T0, Immediate(Smi::RawValue(Smi::kBits)),
+                           &fall_through);
   __ SmiUntag(T0);
 
   // Check for overflow by shifting left and shifting back arithmetically.
   // If the result is different from the original, there was overflow.
   __ sllv(TMP, T1, T0);
   __ srav(CMPRES1, TMP, T0);
   __ bne(CMPRES1, T1, &overflow);
 
   // No overflow, result in V0.
   __ Ret();
   __ delay_slot()->sllv(V0, T1, T0);
 
   __ Bind(&overflow);
   // Arguments are Smi but the shift produced an overflow to Mint.
   __ bltz(T1, &fall_through);
   __ SmiUntag(T1);
 
   // Pull off high bits that will be shifted off of T1 by making a mask
   // ((1 << T0) - 1), shifting it to the right, masking T1, then shifting back.
   // high bits = (((1 << T0) - 1) << (32 - T0)) & T1) >> (32 - T0)
   // lo bits = T1 << T0
   __ LoadImmediate(T3, 1);
-  __ sllv(T3, T3, T0);  // T3 <- T3 << T0
+  __ sllv(T3, T3, T0);              // T3 <- T3 << T0
   __ addiu(T3, T3, Immediate(-1));  // T3 <- T3 - 1
-  __ subu(T4, ZR, T0);  // T4 <- -T0
+  __ subu(T4, ZR, T0);              // T4 <- -T0
   __ addiu(T4, T4, Immediate(32));  // T4 <- 32 - T0
-  __ sllv(T3, T3, T4);  // T3 <- T3 << T4
-  __ and_(T3, T3, T1);  // T3 <- T3 & T1
-  __ srlv(T3, T3, T4);  // T3 <- T3 >> T4
+  __ sllv(T3, T3, T4);              // T3 <- T3 << T4
+  __ and_(T3, T3, T1);              // T3 <- T3 & T1
+  __ srlv(T3, T3, T4);              // T3 <- T3 >> T4
   // Now T3 has the bits that fall off of T1 on a left shift.
   __ sllv(T0, T1, T0);  // T0 gets low bits.
 
-  const Class& mint_class = Class::Handle(
-      Isolate::Current()->object_store()->mint_class());
+  const Class& mint_class =
+      Class::Handle(Isolate::Current()->object_store()->mint_class());
   __ TryAllocate(mint_class, &fall_through, V0, T1);
 
   __ sw(T0, FieldAddress(V0, Mint::value_offset()));
   __ Ret();
   __ delay_slot()->sw(T3, FieldAddress(V0, Mint::value_offset() + kWordSize));
   __ Bind(&fall_through);
 }
 
 
 static void Get64SmiOrMint(Assembler* assembler,
@@ skipping 22 matching lines @@
   return;
 }
 
 
 static void CompareIntegers(Assembler* assembler, RelationOperator rel_op) {
   Label try_mint_smi, is_true, is_false, drop_two_fall_through, fall_through;
   TestBothArgumentsSmis(assembler, &try_mint_smi);
   // T0 contains the right argument. T1 contains left argument
 
   switch (rel_op) {
-    case LT: __ BranchSignedLess(T1, T0, &is_true); break;
-    case LE: __ BranchSignedLessEqual(T1, T0, &is_true); break;
-    case GT: __ BranchSignedGreater(T1, T0, &is_true); break;
-    case GE: __ BranchSignedGreaterEqual(T1, T0, &is_true); break;
+    case LT:
+      __ BranchSignedLess(T1, T0, &is_true);
+      break;
+    case LE:
+      __ BranchSignedLessEqual(T1, T0, &is_true);
+      break;
+    case GT:
+      __ BranchSignedGreater(T1, T0, &is_true);
+      break;
+    case GE:
+      __ BranchSignedGreaterEqual(T1, T0, &is_true);
+      break;
     default:
       UNREACHABLE();
       break;
   }
 
   __ Bind(&is_false);
   __ LoadObject(V0, Bool::False());
   __ Ret();
   __ Bind(&is_true);
   __ LoadObject(V0, Bool::True());
@@ skipping 134 matching lines @@
 void Intrinsifier::Integer_sar(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   // Shift amount in T0. Value to shift in T1.
 
   __ SmiUntag(T0);
   __ bltz(T0, &fall_through);
 
   __ LoadImmediate(T2, 0x1F);
-  __ slt(CMPRES1, T2, T0);  // CMPRES1 <- 0x1F < T0 ? 1 : 0
+  __ slt(CMPRES1, T2, T0);   // CMPRES1 <- 0x1F < T0 ? 1 : 0
   __ movn(T0, T2, CMPRES1);  // T0 <- 0x1F < T0 ? 0x1F : T0
 
   __ SmiUntag(T1);
   __ srav(V0, T1, T0);
   __ Ret();
   __ delay_slot()->SmiTag(V0);
   __ Bind(&fall_through);
 }
 
 
@@ skipping 414 matching lines @@
   __ addiu(T4, T3, Immediate(TypedData::data_offset() - kHeapObjectTag));
 
   // T3 = x = *xip++, return if x == 0
   Label x_zero;
   __ lw(T3, Address(T4, 0));
   __ beq(T3, ZR, &x_zero);
   __ delay_slot()->addiu(T4, T4, Immediate(Bigint::kBytesPerDigit));
 
   // T5 = ajp = &a_digits[i]
   __ lw(T1, Address(SP, 1 * kWordSize));  // a_digits
-  __ sll(T0, T2, 2);  // j == 2*i, i is Smi.
+  __ sll(T0, T2, 2);                      // j == 2*i, i is Smi.
   __ addu(T1, T0, T1);
   __ addiu(T5, T1, Immediate(TypedData::data_offset() - kHeapObjectTag));
 
   // T6:T0 = t = x*x + *ajp
   __ lw(T0, Address(T5, 0));  // *ajp.
   __ mthi(ZR);
   __ mtlo(T0);
   __ maddu(T3, T3);  // HI:LO = T3*T3 + *ajp.
   __ mfhi(T6);
   __ mflo(T0);
@@ skipping 40 matching lines @@
   __ srl(T1, A0, 31);
   __ or_(A1, A1, T1);
   __ sll(A0, A0, 1);  // A2:A1:A0 = 2*x*xi.
   __ addu(A0, A0, T0);
   __ sltu(T1, A0, T0);
   __ addu(A1, A1, T1);  // No carry out possible; A2:A1:A0 = 2*x*xi + aj.
   __ addu(T0, A0, T6);
   __ sltu(T1, T0, T6);
   __ addu(T6, A1, T1);  // No carry out; A2:T6:T0 = 2*x*xi + aj + low32(c).
   __ addu(T6, T6, T7);  // No carry out; A2:T6:T0 = 2*x*xi + aj + c.
-  __ mov(T7, A2);  // T7:T6:T0 = 2*x*xi + aj + c.
+  __ mov(T7, A2);       // T7:T6:T0 = 2*x*xi + aj + c.
 
   // *ajp++ = low32(t) = T0
   __ sw(T0, Address(T5, 0));
   __ addiu(T5, T5, Immediate(Bigint::kBytesPerDigit));
 
   // while (n-- > 0)
   __ bgtz(V0, &loop);
   __ delay_slot()->addiu(V0, V0, Immediate(-1));  // --n
 
   __ Bind(&done);
@@ skipping 28 matching lines @@
   //   uint32_t d = digits[i >> 1];  // i is Smi.
   //   uint64_t t = rho*d;
   //   args[_MU] = t mod DIGIT_BASE;  // _MU == 4.
   //   return 1;
   // }
 
   // T4 = args
   __ lw(T4, Address(SP, 2 * kWordSize));  // args
 
   // T3 = rho = args[2]
-  __ lw(T3,
-        FieldAddress(T4, TypedData::data_offset() + 2*Bigint::kBytesPerDigit));
+  __ lw(T3, FieldAddress(
+                T4, TypedData::data_offset() + 2 * Bigint::kBytesPerDigit));
 
   // T2 = d = digits[i >> 1]
   __ lw(T0, Address(SP, 0 * kWordSize));  // T0 = i as Smi.
   __ lw(T1, Address(SP, 1 * kWordSize));  // T1 = digits.
   __ sll(T0, T0, 1);
   __ addu(T1, T0, T1);
   __ lw(T2, FieldAddress(T1, TypedData::data_offset()));
 
   // HI:LO = t = rho*d
   __ multu(T2, T3);
 
   // args[4] = t mod DIGIT_BASE = low32(t)
   __ mflo(T0);
-  __ sw(T0,
-        FieldAddress(T4, TypedData::data_offset() + 4*Bigint::kBytesPerDigit));
+  __ sw(T0, FieldAddress(
+                T4, TypedData::data_offset() + 4 * Bigint::kBytesPerDigit));
 
   __ addiu(V0, ZR, Immediate(Smi::RawValue(1)));  // One digit processed.
   __ Ret();
 }
 
 
 // Check if the last argument is a double, jump to label 'is_smi' if smi
 // (easy to convert to double), otherwise jump to label 'not_double_smi',
 // Returns the last argument in T0.
 static void TestLastArgumentIsDouble(Assembler* assembler,
@@ skipping 24 matching lines @@
   __ LoadDFromOffset(D0, T0, Double::value_offset() - kHeapObjectTag);
   // Now, left is in D0, right is in D1.
 
   __ cund(D0, D1);  // Check for NaN.
   __ bc1f(&no_NaN);
   __ LoadObject(V0, Bool::False());  // Return false if either is NaN.
   __ Ret();
   __ Bind(&no_NaN);
 
   switch (rel_op) {
-    case EQ: __ ceqd(D0, D1); break;
-    case LT: __ coltd(D0, D1); break;
-    case LE: __ coled(D0, D1); break;
-    case GT: __ coltd(D1, D0); break;
-    case GE: __ coled(D1, D0); break;
+    case EQ:
+      __ ceqd(D0, D1);
+      break;
+    case LT:
+      __ coltd(D0, D1);
+      break;
+    case LE:
+      __ coled(D0, D1);
+      break;
+    case GT:
+      __ coltd(D1, D0);
+      break;
+    case GE:
+      __ coled(D1, D0);
+      break;
     default: {
       // Only passing the above conditions to this function.
       UNREACHABLE();
       break;
     }
   }
 
   Label is_true;
   __ bc1t(&is_true);
   __ LoadObject(V0, Bool::False());
@@ skipping 46 matching lines @@
 
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Both arguments are double, right operand is in T0.
   __ lwc1(F2, FieldAddress(T0, Double::value_offset()));
   __ lwc1(F3, FieldAddress(T0, Double::value_offset() + kWordSize));
   __ Bind(&double_op);
   __ lw(T0, Address(SP, 1 * kWordSize));  // Left argument.
   __ lwc1(F0, FieldAddress(T0, Double::value_offset()));
   __ lwc1(F1, FieldAddress(T0, Double::value_offset() + kWordSize));
   switch (kind) {
-    case Token::kADD: __ addd(D0, D0, D1); break;
-    case Token::kSUB: __ subd(D0, D0, D1); break;
-    case Token::kMUL: __ muld(D0, D0, D1); break;
-    case Token::kDIV: __ divd(D0, D0, D1); break;
-    default: UNREACHABLE();
+    case Token::kADD:
+      __ addd(D0, D0, D1);
+      break;
+    case Token::kSUB:
+      __ subd(D0, D0, D1);
+      break;
+    case Token::kMUL:
+      __ muld(D0, D0, D1);
+      break;
+    case Token::kDIV:
+      __ divd(D0, D0, D1);
+      break;
+    default:
+      UNREACHABLE();
   }
-  const Class& double_class = Class::Handle(
-      Isolate::Current()->object_store()->double_class());
+  const Class& double_class =
+      Class::Handle(Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, V0, T1);  // Result register.
   __ swc1(F0, FieldAddress(V0, Double::value_offset()));
   __ Ret();
   __ delay_slot()->swc1(F1,
                         FieldAddress(V0, Double::value_offset() + kWordSize));
 
   __ Bind(&is_smi);
   __ SmiUntag(T0);
   __ mtc1(T0, STMP1);
   __ b(&double_op);
@@ skipping 33 matching lines @@
 
   // Is Smi.
   __ SmiUntag(T0);
   __ mtc1(T0, F4);
   __ cvtdw(D1, F4);
 
   __ lw(T0, Address(SP, 1 * kWordSize));
   __ lwc1(F0, FieldAddress(T0, Double::value_offset()));
   __ lwc1(F1, FieldAddress(T0, Double::value_offset() + kWordSize));
   __ muld(D0, D0, D1);
-  const Class& double_class = Class::Handle(
-      Isolate::Current()->object_store()->double_class());
+  const Class& double_class =
+      Class::Handle(Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, V0, T1);  // Result register.
   __ swc1(F0, FieldAddress(V0, Double::value_offset()));
   __ Ret();
   __ delay_slot()->swc1(F1,
                         FieldAddress(V0, Double::value_offset() + kWordSize));
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::DoubleFromInteger(Assembler* assembler) {
   Label fall_through;
 
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &fall_through);
 
   // Is Smi.
   __ SmiUntag(T0);
   __ mtc1(T0, F4);
   __ cvtdw(D0, F4);
-  const Class& double_class = Class::Handle(
-      Isolate::Current()->object_store()->double_class());
+  const Class& double_class =
+      Class::Handle(Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, V0, T1);  // Result register.
   __ swc1(F0, FieldAddress(V0, Double::value_offset()));
   __ Ret();
   __ delay_slot()->swc1(F1,
                         FieldAddress(V0, Double::value_offset() + kWordSize));
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_getIsNaN(Assembler* assembler) {
@@ skipping 51 matching lines @@
   __ Bind(&is_true);
   __ LoadObject(V0, Bool::True());
   __ Ret();
 
   __ Bind(&is_false);
   __ LoadObject(V0, Bool::False());
   __ Ret();
 
   __ Bind(&is_zero);
   // Check for negative zero by looking at the sign bit.
-  __ mfc1(T0, F1);  // Moves bits 32...63 of D0 to T0.
-  __ srl(T0, T0, 31);  // Get the sign bit down to bit 0 of T0.
+  __ mfc1(T0, F1);                     // Moves bits 32...63 of D0 to T0.
+  __ srl(T0, T0, 31);                  // Get the sign bit down to bit 0 of T0.
   __ andi(CMPRES1, T0, Immediate(1));  // Check if the bit is set.
-  __ bne(T0, ZR, &is_true);  // Sign bit set. True.
+  __ bne(T0, ZR, &is_true);            // Sign bit set. True.
   __ b(&is_false);
 }
 
 
 void Intrinsifier::DoubleToInteger(Assembler* assembler) {
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ LoadDFromOffset(D0, T0, Double::value_offset() - kHeapObjectTag);
 
   __ truncwd(F2, D0);
   __ mfc1(V0, F2);
@@ skipping 10 matching lines @@
 }
 
 
 void Intrinsifier::MathSqrt(Assembler* assembler) {
   Label fall_through, is_smi, double_op;
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Argument is double and is in T0.
   __ LoadDFromOffset(D1, T0, Double::value_offset() - kHeapObjectTag);
   __ Bind(&double_op);
   __ sqrtd(D0, D1);
-  const Class& double_class = Class::Handle(
-      Isolate::Current()->object_store()->double_class());
+  const Class& double_class =
+      Class::Handle(Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, V0, T1);  // Result register.
   __ swc1(F0, FieldAddress(V0, Double::value_offset()));
   __ Ret();
   __ delay_slot()->swc1(F1,
                         FieldAddress(V0, Double::value_offset() + kWordSize));
 
   __ Bind(&is_smi);
   __ SmiUntag(T0);
   __ mtc1(T0, F2);
   __ b(&double_op);
   __ delay_slot()->cvtdw(D1, F2);
   __ Bind(&fall_through);
 }
 
 
 //    var state = ((_A * (_state[kSTATE_LO])) + _state[kSTATE_HI]) & _MASK_64;
 //    _state[kSTATE_LO] = state & _MASK_32;
 //    _state[kSTATE_HI] = state >> 32;
 void Intrinsifier::Random_nextState(Assembler* assembler) {
   const Library& math_lib = Library::Handle(Library::MathLibrary());
   ASSERT(!math_lib.IsNull());
-  const Class& random_class = Class::Handle(
-      math_lib.LookupClassAllowPrivate(Symbols::_Random()));
+  const Class& random_class =
+      Class::Handle(math_lib.LookupClassAllowPrivate(Symbols::_Random()));
   ASSERT(!random_class.IsNull());
   const Field& state_field = Field::ZoneHandle(
       random_class.LookupInstanceFieldAllowPrivate(Symbols::_state()));
   ASSERT(!state_field.IsNull());
   const Field& random_A_field = Field::ZoneHandle(
       random_class.LookupStaticFieldAllowPrivate(Symbols::_A()));
   ASSERT(!random_A_field.IsNull());
   ASSERT(random_A_field.is_const());
   const Instance& a_value = Instance::Handle(random_A_field.StaticValue());
   const int64_t a_int_value = Integer::Cast(a_value).AsInt64Value();
@@ skipping 34 matching lines @@
   __ lw(T1, Address(SP, 1 * kWordSize));
   __ beq(T0, T1, &is_true);
   __ LoadObject(V0, Bool::False());
   __ Ret();
   __ Bind(&is_true);
   __ LoadObject(V0, Bool::True());
   __ Ret();
 }
 
 
-enum RangeCheckCondition {
-  kIfNotInRange, kIfInRange
-};
+enum RangeCheckCondition { kIfNotInRange, kIfInRange };
 
 
 static void RangeCheck(Assembler* assembler,
                        Register val,
                        Register tmp,
                        intptr_t low,
                        intptr_t high,
                        RangeCheckCondition cc,
                        Label* target) {
   __ AddImmediate(tmp, val, -low);
@@ skipping 16 matching lines @@
 
 static void JumpIfNotInteger(Assembler* assembler,
                              Register cid,
                              Register tmp,
                              Label* target) {
   RangeCheck(assembler, cid, tmp, kSmiCid, kBigintCid, kIfNotInRange, target);
 }
 
 
 static void JumpIfString(Assembler* assembler,
-                          Register cid,
-                          Register tmp,
-                          Label* target) {
-  RangeCheck(assembler,
-             cid,
-             tmp,
-             kOneByteStringCid,
-             kExternalTwoByteStringCid,
-             kIfInRange,
-             target);
+                         Register cid,
+                         Register tmp,
+                         Label* target) {
+  RangeCheck(assembler, cid, tmp, kOneByteStringCid, kExternalTwoByteStringCid,
+             kIfInRange, target);
 }
 
 
 static void JumpIfNotString(Assembler* assembler,
                             Register cid,
                             Register tmp,
                             Label* target) {
-  RangeCheck(assembler,
-             cid,
-             tmp,
-             kOneByteStringCid,
-             kExternalTwoByteStringCid,
-             kIfNotInRange,
-             target);
+  RangeCheck(assembler, cid, tmp, kOneByteStringCid, kExternalTwoByteStringCid,
+             kIfNotInRange, target);
 }
 
 
 // Return type quickly for simple types (not parameterized and not signature).
 void Intrinsifier::ObjectRuntimeType(Assembler* assembler) {
   Label fall_through, use_canonical_type, not_integer, not_double;
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ LoadClassIdMayBeSmi(T1, T0);
 
   // Closures are handled in the runtime.
   __ BranchEqual(T1, Immediate(kClosureCid), &fall_through);
 
-  __ BranchUnsignedGreaterEqual(
-      T1, Immediate(kNumPredefinedCids), &use_canonical_type);
+  __ BranchUnsignedGreaterEqual(T1, Immediate(kNumPredefinedCids),
+                                &use_canonical_type);
 
   __ BranchNotEqual(T1, Immediate(kDoubleCid), &not_double);
   // Object is a double.
   __ LoadIsolate(T1);
   __ LoadFromOffset(T1, T1, Isolate::object_store_offset());
   __ LoadFromOffset(V0, T1, ObjectStore::double_type_offset());
   __ Ret();
 
   __ Bind(&not_double);
   JumpIfNotInteger(assembler, T1, T2, &not_integer);
@@ skipping 48 matching lines @@
   __ lhu(T1, FieldAddress(T2, Class::num_type_arguments_offset()));
   __ BranchNotEqual(T1, Immediate(0), &fall_through);
 
   __ Bind(&equal);
   __ LoadObject(V0, Bool::True());
   __ Ret();
 
   // Class ids are different. Check if we are comparing runtime types of
   // two strings (with different representations) or two integers.
   __ Bind(&different_cids);
-  __ BranchUnsignedGreaterEqual(
-      T1, Immediate(kNumPredefinedCids), &not_equal);
+  __ BranchUnsignedGreaterEqual(T1, Immediate(kNumPredefinedCids), &not_equal);
 
   // Check if both are integers.
   JumpIfNotInteger(assembler, T1, T0, &not_integer);
   JumpIfInteger(assembler, T2, T0, &equal);
   __ b(&not_equal);
 
   __ Bind(&not_integer);
   // Check if both are strings.
   JumpIfNotString(assembler, T1, T0, &not_equal);
   JumpIfString(assembler, T2, T0, &equal);
@@ skipping 94 matching lines @@
 
   __ andi(CMPRES1, A1, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &fall_through);  // 'start' is not a Smi.
 
   __ LoadClassId(CMPRES1, A2);
   __ BranchNotEqual(CMPRES1, Immediate(kOneByteStringCid), &fall_through);
 
   __ LoadClassId(CMPRES1, A0);
   __ BranchNotEqual(CMPRES1, Immediate(kOneByteStringCid), &try_two_byte);
 
-  GenerateSubstringMatchesSpecialization(assembler,
-                                         kOneByteStringCid,
-                                         kOneByteStringCid,
-                                         &return_true,
+  GenerateSubstringMatchesSpecialization(assembler, kOneByteStringCid,
+                                         kOneByteStringCid, &return_true,
                                          &return_false);
 
   __ Bind(&try_two_byte);
   __ LoadClassId(CMPRES1, A0);
   __ BranchNotEqual(CMPRES1, Immediate(kTwoByteStringCid), &fall_through);
 
-  GenerateSubstringMatchesSpecialization(assembler,
-                                         kTwoByteStringCid,
-                                         kOneByteStringCid,
-                                         &return_true,
+  GenerateSubstringMatchesSpecialization(assembler, kTwoByteStringCid,
+                                         kOneByteStringCid, &return_true,
                                          &return_false);
 
   __ Bind(&return_true);
   __ LoadObject(V0, Bool::True());
   __ Ret();
 
   __ Bind(&return_false);
   __ LoadObject(V0, Bool::False());
   __ Ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::StringBaseCharAt(Assembler* assembler) {
   Label fall_through, try_two_byte_string;
 
   __ lw(T1, Address(SP, 0 * kWordSize));  // Index.
   __ lw(T0, Address(SP, 1 * kWordSize));  // String.
 
   // Checks.
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
-  __ bne(CMPRES1, ZR, &fall_through);  // Index is not a Smi.
+  __ bne(CMPRES1, ZR, &fall_through);                    // Index is not a Smi.
   __ lw(T2, FieldAddress(T0, String::length_offset()));  // Range check.
   // Runtime throws exception.
   __ BranchUnsignedGreaterEqual(T1, T2, &fall_through);
   __ LoadClassId(CMPRES1, T0);  // Class ID check.
-  __ BranchNotEqual(
-      CMPRES1, Immediate(kOneByteStringCid), &try_two_byte_string);
+  __ BranchNotEqual(CMPRES1, Immediate(kOneByteStringCid),
+                    &try_two_byte_string);
 
   // Grab byte and return.
   __ SmiUntag(T1);
   __ addu(T2, T0, T1);
   __ lbu(T2, FieldAddress(T2, OneByteString::data_offset()));
   __ BranchUnsignedGreaterEqual(
       T2, Immediate(Symbols::kNumberOfOneCharCodeSymbols), &fall_through);
   __ lw(V0, Address(THR, Thread::predefined_symbols_address_offset()));
   __ AddImmediate(V0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ sll(T2, T2, 2);
@@ skipping 142 matching lines @@
   NOT_IN_PRODUCT(__ UpdateAllocationStatsWithSize(cid, T2, T3, space));
 
   // Initialize the tags.
   // V0: new object start as a tagged pointer.
   // T1: new object end address.
   // T2: allocation size.
   {
     Label overflow, done;
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
-    __ BranchUnsignedGreater(
-        T2, Immediate(RawObject::SizeTag::kMaxSizeTag), &overflow);
+    __ BranchUnsignedGreater(T2, Immediate(RawObject::SizeTag::kMaxSizeTag),
+                             &overflow);
     __ b(&done);
     __ delay_slot()->sll(T2, T2, shift);
     __ Bind(&overflow);
     __ mov(T2, ZR);
     __ Bind(&done);
 
     // Get the class index and insert it into the tags.
     // T2: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ or_(T2, T2, TMP);
     __ sw(T2, FieldAddress(V0, String::tags_offset()));  // Store tags.
   }
 
   // Set the length field using the saved length (T6).
-  __ StoreIntoObjectNoBarrier(V0,
-                              FieldAddress(V0, String::length_offset()),
+  __ StoreIntoObjectNoBarrier(V0, FieldAddress(V0, String::length_offset()),
                               T6);
   // Clear hash.
   __ b(ok);
   __ delay_slot()->sw(ZR, FieldAddress(V0, String::hash_offset()));
 }
 
 
 // Arg0: OneByteString (receiver).
 // Arg1: Start index as Smi.
 // Arg2: End index as Smi.
@@ skipping 82 matching lines @@
   Label fall_through, is_true, is_false, loop;
   __ lw(T0, Address(SP, 1 * kWordSize));  // This.
   __ lw(T1, Address(SP, 0 * kWordSize));  // Other.
 
   // Are identical?
   __ beq(T0, T1, &is_true);
 
   // Is other OneByteString?
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ beq(CMPRES1, ZR, &fall_through);  // Other is Smi.
-  __ LoadClassId(CMPRES1, T1);  // Class ID check.
+  __ LoadClassId(CMPRES1, T1);         // Class ID check.
   __ BranchNotEqual(CMPRES1, Immediate(string_cid), &fall_through);
 
   // Have same length?
   __ lw(T2, FieldAddress(T0, String::length_offset()));
   __ lw(T3, FieldAddress(T1, String::length_offset()));
   __ bne(T2, T3, &is_false);
 
   // Check contents, no fall-through possible.
   ASSERT((string_cid == kOneByteStringCid) ||
          (string_cid == kTwoByteStringCid));
@@ skipping 71 matching lines @@
 }
 
 
 // On stack: user tag (+0).
 void Intrinsifier::UserTag_makeCurrent(Assembler* assembler) {
   // T1: Isolate.
   __ LoadIsolate(T1);
   // V0: Current user tag.
   __ lw(V0, Address(T1, Isolate::current_tag_offset()));
   // T2: UserTag.
-  __ lw(T2, Address(SP, + 0 * kWordSize));
+  __ lw(T2, Address(SP, +0 * kWordSize));
   // Set Isolate::current_tag_.
   __ sw(T2, Address(T1, Isolate::current_tag_offset()));
   // T2: UserTag's tag.
   __ lw(T2, FieldAddress(T2, UserTag::tag_offset()));
   // Set Isolate::user_tag_.
   __ sw(T2, Address(T1, Isolate::user_tag_offset()));
   __ Ret();
   __ delay_slot()->sw(T2, Address(T1, Isolate::user_tag_offset()));
 }
 
@@ skipping 24 matching lines @@
   __ lw(T0, Address(V0, TimelineStream::enabled_offset()));
   __ LoadObject(V0, Bool::True());
   __ LoadObject(V1, Bool::False());
   __ Ret();
   __ delay_slot()->movz(V0, V1, T0);  // V0 = (T0 == 0) ? V1 : V0.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS