clang-format runtime/vm

runtime/vm/intrinsifier_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 11 matching lines @@
 // R4: Arguments descriptor
 // LR: Return address
 // The R4 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_arm64.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));
@@ skipping 33 matching lines @@
 
   // Range check.
   __ ldr(R3, FieldAddress(R0, Array::length_offset()));  // Array length.
   __ cmp(R1, Operand(R3));
   // Runtime throws exception.
   __ b(&fall_through, CS);
 
   // Note that R1 is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ ldr(R2, Address(SP, 0 * kWordSize));  // Value.
-  __ add(R1, R0, Operand(R1, LSL, 2));  // R1 is Smi.
-  __ StoreIntoObject(R0,
-                     FieldAddress(R1, Array::data_offset()),
-                     R2);
+  __ add(R1, R0, Operand(R1, LSL, 2));     // R1 is Smi.
+  __ StoreIntoObject(R0, FieldAddress(R1, Array::data_offset()), R2);
   // 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 R0.
   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, R0, R1);
 
   // Store backing array object in growable array object.
   __ ldr(R1, Address(SP, kArrayOffset));  // Data argument.
   // R0 is new, no barrier needed.
   __ StoreIntoObjectNoBarrier(
-      R0,
-      FieldAddress(R0, GrowableObjectArray::data_offset()),
-      R1);
+      R0, FieldAddress(R0, GrowableObjectArray::data_offset()), R1);
 
   // R0: new growable array object start as a tagged pointer.
   // Store the type argument field in the growable array object.
   __ ldr(R1, Address(SP, kTypeArgumentsOffset));  // Type argument.
   __ StoreIntoObjectNoBarrier(
-      R0,
-      FieldAddress(R0, GrowableObjectArray::type_arguments_offset()),
-      R1);
+      R0, FieldAddress(R0, GrowableObjectArray::type_arguments_offset()), R1);
 
   // Set the length field in the growable array object to 0.
   __ LoadImmediate(R1, 0);
   __ str(R1, FieldAddress(R0, GrowableObjectArray::length_offset()));
   __ ret();  // Returns the newly allocated object in R0.
 
   __ Bind(&fall_through);
 }
 
 
@@ skipping 17 matching lines @@
   // Compare length with capacity.
   __ cmp(R1, Operand(R3));
   __ b(&fall_through, EQ);  // Must grow data.
   const int64_t value_one = reinterpret_cast<int64_t>(Smi::New(1));
   // len = len + 1;
   __ add(R3, R1, Operand(value_one));
   __ str(R3, FieldAddress(R0, GrowableObjectArray::length_offset()));
   __ ldr(R0, Address(SP, 0 * kWordSize));  // Value.
   ASSERT(kSmiTagShift == 1);
   __ add(R1, R2, Operand(R1, LSL, 2));
-  __ StoreIntoObject(R2,
-                     FieldAddress(R1, Array::data_offset()),
-                     R0);
+  __ StoreIntoObject(R2, FieldAddress(R1, Array::data_offset()), R0);
   __ LoadObject(R0, Object::null_object());
   __ ret();
   __ 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_ARRAY_ALLOCATION(type_name, cid, max_len, scale_shift)           \
   Label fall_through;                                                          \
   const intptr_t kArrayLengthStackOffset = 0 * kWordSize;                      \
   NOT_IN_PRODUCT(__ MaybeTraceAllocation(cid, R2, &fall_through));             \
-  __ ldr(R2, Address(SP, kArrayLengthStackOffset));  /* Array length. */       \
+  __ ldr(R2, Address(SP, kArrayLengthStackOffset)); /* Array length. */        \
   /* Check that length is a positive Smi. */                                   \
   /* R2: requested array length argument. */                                   \
   __ tsti(R2, Immediate(kSmiTagMask));                                         \
   __ b(&fall_through, NE);                                                     \
   __ CompareRegisters(R2, ZR);                                                 \
   __ b(&fall_through, LT);                                                     \
   __ SmiUntag(R2);                                                             \
   /* Check for maximum allowed length. */                                      \
   /* R2: untagged array length. */                                             \
   __ CompareImmediate(R2, max_len);                                            \
   __ b(&fall_through, GT);                                                     \
   __ LslImmediate(R2, R2, scale_shift);                                        \
   const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
   __ AddImmediate(R2, R2, fixed_size);                                         \
   __ andi(R2, R2, Immediate(~(kObjectAlignment - 1)));                         \
   Heap::Space space = Heap::kNew;                                              \
   __ ldr(R3, Address(THR, Thread::heap_offset()));                             \
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));                             \
                                                                                \
   /* R2: allocation size. */                                                   \
   __ adds(R1, R0, Operand(R2));                                                \
-  __ b(&fall_through, CS);  /* Fail on unsigned overflow. */                   \
+  __ b(&fall_through, CS); /* Fail on unsigned overflow. */                    \
                                                                                \
   /* Check if the allocation fits into the remaining space. */                 \
   /* R0: potential new object start. */                                        \
   /* R1: potential next object start. */                                       \
   /* R2: allocation size. */                                                   \
   /* R3: heap. */                                                              \
   __ ldr(R6, Address(R3, Heap::EndOffset(space)));                             \
   __ cmp(R1, Operand(R6));                                                     \
   __ b(&fall_through, CS);                                                     \
                                                                                \
   /* Successfully allocated the object(s), now update top to point to */       \
   /* next object start and initialize the object. */                           \
   __ str(R1, Address(R3, Heap::TopOffset(space)));                             \
   __ AddImmediate(R0, R0, kHeapObjectTag);                                     \
   NOT_IN_PRODUCT(__ UpdateAllocationStatsWithSize(cid, R2, space));            \
   /* Initialize the tags. */                                                   \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
   /* R2: allocation size. */                                                   \
   {                                                                            \
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);                  \
     __ LslImmediate(R2, R2, RawObject::kSizeTagPos - kObjectAlignmentLog2);    \
     __ csel(R2, ZR, R2, HI);                                                   \
                                                                                \
     /* Get the class index and insert it into the tags. */                     \
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));                 \
     __ orr(R2, R2, Operand(TMP));                                              \
-    __ str(R2, FieldAddress(R0, type_name::tags_offset()));  /* Tags. */       \
+    __ str(R2, FieldAddress(R0, type_name::tags_offset())); /* Tags. */        \
   }                                                                            \
   /* Set the length field. */                                                  \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
-  __ ldr(R2, Address(SP, kArrayLengthStackOffset));  /* Array length. */       \
-  __ StoreIntoObjectNoBarrier(R0,                                              \
-                              FieldAddress(R0, type_name::length_offset()),    \
-                              R2);                                             \
+  __ ldr(R2, Address(SP, kArrayLengthStackOffset)); /* Array length. */        \
+  __ StoreIntoObjectNoBarrier(                                                 \
+      R0, FieldAddress(R0, type_name::length_offset()), R2);                   \
   /* Initialize all array elements to 0. */                                    \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
   /* R2: iterator which initially points to the start of the variable */       \
   /* R3: scratch register. */                                                  \
   /* data area to be initialized. */                                           \
   __ mov(R3, ZR);                                                              \
   __ AddImmediate(R2, R0, sizeof(Raw##type_name) - 1);                         \
   Label init_loop, done;                                                       \
   __ Bind(&init_loop);                                                         \
   __ cmp(R2, Operand(R1));                                                     \
   __ b(&done, CS);                                                             \
   __ str(R3, Address(R2, 0));                                                  \
   __ add(R2, R2, Operand(kWordSize));                                          \
   __ b(&init_loop);                                                            \
   __ Bind(&done);                                                              \
                                                                                \
   __ ret();                                                                    \
-  __ Bind(&fall_through);                                                      \
+  __ Bind(&fall_through);
 
 
 #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 R0 and R1
 // Tests if they are smis, jumps to label not_smi if not.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
-  __ ldr(R0, Address(SP, + 0 * kWordSize));
-  __ ldr(R1, Address(SP, + 1 * kWordSize));
+  __ ldr(R0, Address(SP, +0 * kWordSize));
+  __ ldr(R1, Address(SP, +1 * kWordSize));
   __ orr(TMP, R0, Operand(R1));
   __ tsti(TMP, Immediate(kSmiTagMask));
   __ b(not_smi, NE);
 }
 
 
 void Intrinsifier::Integer_addFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);  // Checks two smis.
-  __ adds(R0, R0, Operand(R1));  // Adds.
-  __ b(&fall_through, VS);  // Fall-through on overflow.
+  __ adds(R0, R0, Operand(R1));                     // Adds.
+  __ b(&fall_through, VS);                          // Fall-through on overflow.
   __ ret();
   __ 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);
   __ subs(R0, R0, Operand(R1));  // Subtract.
-  __ b(&fall_through, VS);  // Fall-through on overflow.
+  __ b(&fall_through, VS);       // Fall-through on overflow.
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_sub(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ subs(R0, R1, Operand(R0));  // Subtract.
-  __ b(&fall_through, VS);  // Fall-through on overflow.
+  __ b(&fall_through, VS);       // Fall-through on overflow.
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_mulFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ SmiUntag(R0);  // Untags R6. We only want result shifted by one.
@@ skipping 68 matching lines @@
 //  if (res < 0) {
 //    if (right < 0) {
 //      res = res - right;
 //    } else {
 //      res = res + right;
 //    }
 //  }
 void Intrinsifier::Integer_moduloFromInteger(Assembler* assembler) {
   // Check to see if we have integer division
   Label neg_remainder, fall_through;
-  __ ldr(R1, Address(SP, + 0 * kWordSize));
-  __ ldr(R0, Address(SP, + 1 * kWordSize));
+  __ ldr(R1, Address(SP, +0 * kWordSize));
+  __ ldr(R0, Address(SP, +1 * kWordSize));
   __ orr(TMP, R0, Operand(R1));
   __ tsti(TMP, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);
   // R1: Tagged left (dividend).
   // R0: Tagged right (divisor).
   // Check if modulo by zero -> exception thrown in main function.
   __ CompareRegisters(R0, ZR);
   __ b(&fall_through, EQ);
   EmitRemainderOperation(assembler);
   // Untagged right in R0. Untagged remainder result in R1.
@@ skipping 27 matching lines @@
   __ SmiUntag(R0);
   __ SmiUntag(R1);
 
   __ sdiv(R0, R1, R0);
 
   // Check the corner case of dividing the 'MIN_SMI' with -1, in which case we
   // cannot tag the result.
   __ CompareImmediate(R0, 0x4000000000000000);
   __ b(&fall_through, EQ);
   __ SmiTag(R0);  // Not equal. Okay to tag and return.
-  __ ret();  // Return.
+  __ ret();       // Return.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_negate(Assembler* assembler) {
   Label fall_through;
-  __ ldr(R0, Address(SP, + 0 * kWordSize));  // Grab first argument.
-  __ tsti(R0, Immediate(kSmiTagMask));  // Test for Smi.
+  __ ldr(R0, Address(SP, +0 * kWordSize));  // Grab first argument.
+  __ tsti(R0, Immediate(kSmiTagMask));      // Test for Smi.
   __ b(&fall_through, NE);
   __ negs(R0, R0);
   __ b(&fall_through, VS);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_bitAndFromInteger(Assembler* assembler) {
   Label fall_through;
@@ skipping 41 matching lines @@
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   const Register right = R0;
   const Register left = R1;
   const Register temp = R2;
   const Register result = R0;
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
-  __ CompareImmediate(
-      right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)));
+  __ CompareImmediate(right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)));
   __ b(&fall_through, CS);
 
   // Left is not a constant.
   // Check if count too large for handling it inlined.
   __ SmiUntag(TMP, right);  // SmiUntag right into TMP.
   // Overflow test (preserve left, right, and TMP);
   __ lslv(temp, left, TMP);
   __ asrv(TMP2, temp, TMP);
   __ CompareRegisters(left, TMP2);
   __ b(&fall_through, NE);  // Overflow.
@@ skipping 268 matching lines @@
   // R7 = &digits[a_used rounded up to even number].
   __ add(R7, R3, Operand(R4, LSL, 3));
 
   // R8 = &digits[a_used rounded up to even number].
   __ add(R8, R3, Operand(R2, LSL, 3));
 
   __ adds(R0, R0, Operand(0));  // carry flag = 0
   Label add_loop;
   __ Bind(&add_loop);
   // Loop (a_used+1)/2 times, a_used > 0.
-  __ ldr(R0, Address(R3, 2*Bigint::kBytesPerDigit, Address::PostIndex));
-  __ ldr(R1, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R0, Address(R3, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R1, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ adcs(R0, R0, R1);
   __ sub(R9, R3, Operand(R7));  // Does not affect carry flag.
-  __ str(R0, Address(R6, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R6, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ cbnz(&add_loop, R9);  // Does not affect carry flag.
 
   Label last_carry;
   __ sub(R9, R3, Operand(R8));  // Does not affect carry flag.
-  __ cbz(&last_carry, R9);  // If used - a_used == 0.
+  __ cbz(&last_carry, R9);      // If used - a_used == 0.
 
   Label carry_loop;
   __ Bind(&carry_loop);
   // Loop (used+1)/2 - (a_used+1)/2 times, used - a_used > 0.
-  __ ldr(R0, Address(R3, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R0, Address(R3, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ adcs(R0, R0, ZR);
   __ sub(R9, R3, Operand(R8));  // Does not affect carry flag.
-  __ str(R0, Address(R6, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R6, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ cbnz(&carry_loop, R9);
 
   __ Bind(&last_carry);
   Label done;
   __ b(&done, CC);
   __ LoadImmediate(R0, 1);
   __ str(R0, Address(R6, 0));
 
   __ Bind(&done);
   // Returning Object::null() is not required, since this method is private.
@@ skipping 28 matching lines @@
   // R7 = &digits[a_used rounded up to even number].
   __ add(R7, R3, Operand(R4, LSL, 3));
 
   // R8 = &digits[a_used rounded up to even number].
   __ add(R8, R3, Operand(R2, LSL, 3));
 
   __ subs(R0, R0, Operand(0));  // carry flag = 1
   Label sub_loop;
   __ Bind(&sub_loop);
   // Loop (a_used+1)/2 times, a_used > 0.
-  __ ldr(R0, Address(R3, 2*Bigint::kBytesPerDigit, Address::PostIndex));
-  __ ldr(R1, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R0, Address(R3, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R1, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ sbcs(R0, R0, R1);
   __ sub(R9, R3, Operand(R7));  // Does not affect carry flag.
-  __ str(R0, Address(R6, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R6, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ cbnz(&sub_loop, R9);  // Does not affect carry flag.
 
   Label done;
   __ sub(R9, R3, Operand(R8));  // Does not affect carry flag.
-  __ cbz(&done, R9);  // If used - a_used == 0.
+  __ cbz(&done, R9);            // If used - a_used == 0.
 
   Label carry_loop;
   __ Bind(&carry_loop);
   // Loop (used+1)/2 - (a_used+1)/2 times, used - a_used > 0.
-  __ ldr(R0, Address(R3, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R0, Address(R3, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ sbcs(R0, R0, ZR);
   __ sub(R9, R3, Operand(R8));  // Does not affect carry flag.
-  __ str(R0, Address(R6, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R6, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ cbnz(&carry_loop, R9);
 
   __ Bind(&done);
   // Returning Object::null() is not required, since this method is private.
   __ ret();
 }
 
 
 void Intrinsifier::Bigint_mulAdd(Assembler* assembler) {
   // Pseudo code:
@@ skipping 57 matching lines @@
   Label muladd_loop;
   __ Bind(&muladd_loop);
   // x:   R3
   // mip: R4
   // ajp: R5
   // c:   R1
   // n:   R6
   // t:   R7:R8 (not live at loop entry)
 
   // uint64_t mi = *mip++
-  __ ldr(R2, Address(R4, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R2, Address(R4, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
 
   // uint64_t aj = *ajp
   __ ldr(R0, Address(R5, 0));
 
   // uint128_t t = x*mi + aj + c
-  __ mul(R7, R2, R3);  // R7 = low64(R2*R3).
+  __ mul(R7, R2, R3);    // R7 = low64(R2*R3).
   __ umulh(R8, R2, R3);  // R8 = high64(R2*R3), t = R8:R7 = x*mi.
   __ adds(R7, R7, Operand(R0));
-  __ adc(R8, R8, ZR);  // t += aj.
+  __ adc(R8, R8, ZR);            // t += aj.
   __ adds(R0, R7, Operand(R1));  // t += c, R0 = low64(t).
-  __ adc(R1, R8, ZR);  // c = R1 = high64(t).
+  __ adc(R1, R8, ZR);            // c = R1 = high64(t).
 
   // *ajp++ = low64(t) = R0
-  __ str(R0, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
 
   // while (--n > 0)
   __ subs(R6, R6, Operand(1));  // --n
   __ b(&muladd_loop, NE);
 
   __ tst(R1, Operand(R1));
   __ b(&done, EQ);
 
   // *ajp++ += c
   __ ldr(R0, Address(R5, 0));
   __ adds(R0, R0, Operand(R1));
-  __ str(R0, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&done, CC);
 
   Label propagate_carry_loop;
   __ Bind(&propagate_carry_loop);
   __ ldr(R0, Address(R5, 0));
   __ adds(R0, R0, Operand(1));
-  __ str(R0, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&propagate_carry_loop, CS);
 
   __ Bind(&done);
   __ LoadImmediate(R0, Smi::RawValue(2));  // Two digits processed.
   __ ret();
 }
 
 
 void Intrinsifier::Bigint_sqrAdd(Assembler* assembler) {
   // Pseudo code:
@@ skipping 23 matching lines @@
   // }
 
   // R4 = xip = &x_digits[i >> 1]
   // R2 = i as Smi, R3 = x_digits
   __ ldp(R2, R3, Address(SP, 2 * kWordSize, Address::PairOffset));
   __ add(R3, R3, Operand(R2, LSL, 1));
   __ add(R4, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R3 = x = *xip++, return if x == 0
   Label x_zero;
-  __ ldr(R3, Address(R4, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R3, Address(R4, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
   __ tst(R3, Operand(R3));
   __ b(&x_zero, EQ);
 
   // R5 = ajp = &a_digits[i]
   __ ldr(R1, Address(SP, 1 * kWordSize));  // a_digits
-  __ add(R1, R1, Operand(R2, LSL, 2));  // j == 2*i, i is Smi.
+  __ add(R1, R1, Operand(R2, LSL, 2));     // j == 2*i, i is Smi.
   __ add(R5, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R6:R1 = t = x*x + *ajp
   __ ldr(R0, Address(R5, 0));
-  __ mul(R1, R3, R3);  // R1 = low64(R3*R3).
-  __ umulh(R6, R3, R3);  // R6 = high64(R3*R3).
+  __ mul(R1, R3, R3);            // R1 = low64(R3*R3).
+  __ umulh(R6, R3, R3);          // R6 = high64(R3*R3).
   __ adds(R1, R1, Operand(R0));  // R6:R1 += *ajp.
-  __ adc(R6, R6, ZR);  // R6 = low64(c) = high64(t).
-  __ mov(R7, ZR);  // R7 = high64(c) = 0.
+  __ adc(R6, R6, ZR);            // R6 = low64(c) = high64(t).
+  __ mov(R7, ZR);                // R7 = high64(c) = 0.
 
   // *ajp++ = low64(t) = R1
-  __ str(R1, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R1, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
 
   // int n = (used - i + 1)/2 - 1
   __ ldr(R0, Address(SP, 0 * kWordSize));  // used is Smi
   __ sub(R8, R0, Operand(R2));
   __ add(R8, R8, Operand(2));
-  __ movn(R0, Immediate(1), 0);  // R0 = ~1 = -2.
+  __ movn(R0, Immediate(1), 0);          // R0 = ~1 = -2.
   __ adds(R8, R0, Operand(R8, ASR, 2));  // while (--n >= 0)
 
   Label loop, done;
   __ b(&done, MI);
 
   __ Bind(&loop);
   // x:   R3
   // xip: R4
   // ajp: R5
   // c:   R7:R6
   // t:   R2:R1:R0 (not live at loop entry)
   // n:   R8
 
   // uint64_t xi = *xip++
-  __ ldr(R2, Address(R4, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R2, Address(R4, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
 
   // uint192_t t = R2:R1:R0 = 2*x*xi + aj + c
-  __ mul(R0, R2, R3);  // R0 = low64(R2*R3) = low64(x*xi).
+  __ mul(R0, R2, R3);    // R0 = low64(R2*R3) = low64(x*xi).
   __ umulh(R1, R2, R3);  // R1 = high64(R2*R3) = high64(x*xi).
   __ adds(R0, R0, Operand(R0));
   __ adcs(R1, R1, R1);
   __ adc(R2, ZR, ZR);  // R2:R1:R0 = R1:R0 + R1:R0 = 2*x*xi.
   __ adds(R0, R0, Operand(R6));
   __ adcs(R1, R1, R7);
-  __ adc(R2, R2, ZR);  // R2:R1:R0 += c.
+  __ adc(R2, R2, ZR);          // R2:R1:R0 += c.
   __ ldr(R7, Address(R5, 0));  // R7 = aj = *ajp.
   __ adds(R0, R0, Operand(R7));
   __ adcs(R6, R1, ZR);
   __ adc(R7, R2, ZR);  // R7:R6:R0 = 2*x*xi + aj + c.
 
   // *ajp++ = low64(t) = R0
-  __ str(R0, Address(R5, 2*Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R5, 2 * Bigint::kBytesPerDigit, Address::PostIndex));
 
   // while (--n >= 0)
   __ subs(R8, R8, Operand(1));  // --n
   __ b(&loop, PL);
 
   __ Bind(&done);
   // uint64_t aj = *ajp
   __ ldr(R0, Address(R5, 0));
 
   // uint128_t t = aj + c
@@ skipping 70 matching lines @@
 
   // R0 = qd = (DIGIT_MASK << 32) | DIGIT_MASK = -1
   __ movn(R0, Immediate(0), 0);
 
   // Return qd if dh == yt
   Label return_qd;
   __ cmp(R2, Operand(R3));
   __ b(&return_qd, EQ);
 
   // R1 = dl = digits[(i >> 1) - 3 .. (i >> 1) - 2]
-  __ ldr(R1,
-         FieldAddress(R1, TypedData::data_offset() - 3*Bigint::kBytesPerDigit));
+  __ ldr(R1, FieldAddress(
+                 R1, TypedData::data_offset() - 3 * Bigint::kBytesPerDigit));
 
   // R5 = yth = yt >> 32
   __ orr(R5, ZR, Operand(R3, LSR, 32));
 
   // R6 = qh = dh / yth
   __ udiv(R6, R2, R5);
 
   // R8:R7 = ph:pl = yt*qh
   __ mul(R7, R3, R6);
   __ umulh(R8, R3, R6);
@@ skipping 77 matching lines @@
 
   // --ql
   __ sub(R6, R6, Operand(1));
 
   __ Bind(&ql_ok);
   // qd |= ql;
   __ orr(R0, R0, Operand(R6));
 
   __ Bind(&return_qd);
   // args[2..3] = qd
-  __ str(R0,
-         FieldAddress(R4, TypedData::data_offset() + 2*Bigint::kBytesPerDigit));
+  __ str(R0, FieldAddress(
+                 R4, TypedData::data_offset() + 2 * Bigint::kBytesPerDigit));
 
   __ LoadImmediate(R0, Smi::RawValue(2));  // Two digits processed.
   __ ret();
 }
 
 
 void Intrinsifier::Montgomery_mulMod(Assembler* assembler) {
   // Pseudo code:
   // static int _mulMod(Uint32List args, Uint32List digits, int i) {
   //   uint64_t rho = args[_RHO .. _RHO_HI];  // _RHO == 2, _RHO_HI == 3.
   //   uint64_t d = digits[i >> 1 .. (i >> 1) + 1];  // i is Smi and even.
   //   uint128_t t = rho*d;
   //   args[_MU .. _MU_HI] = t mod DIGIT_BASE^2;  // _MU == 4, _MU_HI == 5.
   //   return 2;
   // }
 
   // R4 = args
   __ ldr(R4, Address(SP, 2 * kWordSize));  // args
 
   // R3 = rho = args[2..3]
-  __ ldr(R3,
-         FieldAddress(R4, TypedData::data_offset() + 2*Bigint::kBytesPerDigit));
+  __ ldr(R3, FieldAddress(
+                 R4, TypedData::data_offset() + 2 * Bigint::kBytesPerDigit));
 
   // R2 = digits[i >> 1 .. (i >> 1) + 1]
   // R0 = i as Smi, R1 = digits
   __ ldp(R0, R1, Address(SP, 0 * kWordSize, Address::PairOffset));
   __ add(R1, R1, Operand(R0, LSL, 1));
   __ ldr(R2, FieldAddress(R1, TypedData::data_offset()));
 
   // R0 = rho*d mod DIGIT_BASE
   __ mul(R0, R2, R3);  // R0 = low64(R2*R3).
 
   // args[4 .. 5] = R0
-  __ str(R0,
-         FieldAddress(R4, TypedData::data_offset() + 4*Bigint::kBytesPerDigit));
+  __ str(R0, FieldAddress(
+                 R4, TypedData::data_offset() + 4 * Bigint::kBytesPerDigit));
 
   __ LoadImmediate(R0, Smi::RawValue(2));  // Two digits 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 R0.
 static void TestLastArgumentIsDouble(Assembler* assembler,
@@ skipping 71 matching lines @@
 static void DoubleArithmeticOperations(Assembler* assembler, Token::Kind kind) {
   Label fall_through, is_smi, double_op;
 
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Both arguments are double, right operand is in R0.
   __ LoadDFieldFromOffset(V1, R0, Double::value_offset());
   __ Bind(&double_op);
   __ ldr(R0, Address(SP, 1 * kWordSize));  // Left argument.
   __ LoadDFieldFromOffset(V0, R0, Double::value_offset());
   switch (kind) {
-    case Token::kADD: __ faddd(V0, V0, V1); break;
-    case Token::kSUB: __ fsubd(V0, V0, V1); break;
-    case Token::kMUL: __ fmuld(V0, V0, V1); break;
-    case Token::kDIV: __ fdivd(V0, V0, V1); break;
-    default: UNREACHABLE();
+    case Token::kADD:
+      __ faddd(V0, V0, V1);
+      break;
+    case Token::kSUB:
+      __ fsubd(V0, V0, V1);
+      break;
+    case Token::kMUL:
+      __ fmuld(V0, V0, V1);
+      break;
+    case Token::kDIV:
+      __ fdivd(V0, V0, V1);
+      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, R0, R1);
   __ StoreDFieldToOffset(V0, R0, Double::value_offset());
   __ ret();
 
   __ Bind(&is_smi);  // Convert R0 to a double.
   __ SmiUntag(R0);
   __ scvtfdx(V1, R0);
   __ b(&double_op);
 
   __ Bind(&fall_through);
@@ skipping 26 matching lines @@
   // Only smis allowed.
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ tsti(R0, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);
   // Is Smi.
   __ SmiUntag(R0);
   __ scvtfdx(V1, R0);
   __ ldr(R0, Address(SP, 1 * kWordSize));
   __ LoadDFieldFromOffset(V0, R0, Double::value_offset());
   __ fmuld(V0, V0, V1);
-  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, R0, R1);
   __ StoreDFieldToOffset(V0, R0, Double::value_offset());
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::DoubleFromInteger(Assembler* assembler) {
   Label fall_through;
 
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ tsti(R0, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);
   // Is Smi.
   __ SmiUntag(R0);
   __ scvtfdx(V0, R0);
-  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, R0, R1);
   __ StoreDFieldToOffset(V0, R0, Double::value_offset());
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_getIsNaN(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ LoadDFieldFromOffset(V0, R0, Double::value_offset());
@@ skipping 23 matching lines @@
   const Register false_reg = R0;
   const Register true_reg = R2;
   Label is_false, is_true, is_zero;
 
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ LoadDFieldFromOffset(V0, R0, Double::value_offset());
   __ fcmpdz(V0);
   __ LoadObject(true_reg, Bool::True());
   __ LoadObject(false_reg, Bool::False());
   __ b(&is_false, VS);  // NaN -> false.
-  __ b(&is_zero, EQ);  // Check for negative zero.
+  __ b(&is_zero, EQ);   // Check for negative zero.
   __ b(&is_false, CS);  // >= 0 -> false.
 
   __ Bind(&is_true);
   __ mov(R0, true_reg);
 
   __ Bind(&is_false);
   __ ret();
 
   __ Bind(&is_zero);
   // Check for negative zero by looking at the sign bit.
@@ skipping 27 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 R0.
   __ LoadDFieldFromOffset(V1, R0, Double::value_offset());
   __ Bind(&double_op);
   __ fsqrtd(V0, V1);
-  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, R0, R1);
   __ StoreDFieldToOffset(V0, R0, Double::value_offset());
   __ ret();
   __ Bind(&is_smi);
   __ SmiUntag(R0);
   __ scvtfdx(V1, R0);
   __ b(&double_op);
   __ 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 56 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_double, not_integer;
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ LoadClassIdMayBeSmi(R1, R0);
 
   __ CompareImmediate(R1, kClosureCid);
@@ skipping 184 matching lines @@
 
   __ tsti(R1, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);  // 'start' is not a Smi.
 
   __ CompareClassId(R2, kOneByteStringCid);
   __ b(&fall_through, NE);
 
   __ CompareClassId(R0, kOneByteStringCid);
   __ b(&fall_through, NE);
 
-  GenerateSubstringMatchesSpecialization(assembler,
-                                         kOneByteStringCid,
-                                         kOneByteStringCid,
-                                         &return_true,
+  GenerateSubstringMatchesSpecialization(assembler, kOneByteStringCid,
+                                         kOneByteStringCid, &return_true,
                                          &return_false);
 
   __ Bind(&try_two_byte);
   __ CompareClassId(R0, kTwoByteStringCid);
   __ b(&fall_through, NE);
 
-  GenerateSubstringMatchesSpecialization(assembler,
-                                         kTwoByteStringCid,
-                                         kOneByteStringCid,
-                                         &return_true,
+  GenerateSubstringMatchesSpecialization(assembler, kTwoByteStringCid,
+                                         kOneByteStringCid, &return_true,
                                          &return_false);
 
   __ Bind(&return_true);
   __ LoadObject(R0, Bool::True());
   __ ret();
 
   __ Bind(&return_false);
   __ LoadObject(R0, Bool::False());
   __ ret();
 
@@ skipping 14 matching lines @@
   __ b(&fall_through, CS);  // Runtime throws exception.
 
   __ CompareClassId(R0, kOneByteStringCid);
   __ b(&try_two_byte_string, NE);
   __ SmiUntag(R1);
   __ AddImmediate(R0, R0, OneByteString::data_offset() - kHeapObjectTag);
   __ ldr(R1, Address(R0, R1), kUnsignedByte);
   __ CompareImmediate(R1, Symbols::kNumberOfOneCharCodeSymbols);
   __ b(&fall_through, GE);
   __ ldr(R0, Address(THR, Thread::predefined_symbols_address_offset()));
-  __ AddImmediate(
-      R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ AddImmediate(R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ ldr(R0, Address(R0, R1, UXTX, Address::Scaled));
   __ ret();
 
   __ Bind(&try_two_byte_string);
   __ CompareClassId(R0, kTwoByteStringCid);
   __ b(&fall_through, NE);
   ASSERT(kSmiTagShift == 1);
   __ AddImmediate(R0, R0, TwoByteString::data_offset() - kHeapObjectTag);
   __ ldr(R1, Address(R0, R1), kUnsignedHalfword);
   __ CompareImmediate(R1, Symbols::kNumberOfOneCharCodeSymbols);
   __ b(&fall_through, GE);
   __ ldr(R0, Address(THR, Thread::predefined_symbols_address_offset()));
-  __ AddImmediate(
-      R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ AddImmediate(R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ ldr(R0, Address(R0, R1, UXTX, Address::Scaled));
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::StringBaseIsEmpty(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, String::length_offset()));
@@ skipping 47 matching lines @@
   __ b(&loop, NE);
 
   // Finalize.
   // hash_ += hash_ << 3;
   // hash_ ^= hash_ >> 11;
   // hash_ += hash_ << 15;
   __ addw(R0, R0, Operand(R0, LSL, 3));
   __ eorw(R0, R0, Operand(R0, LSR, 11));
   __ addw(R0, R0, Operand(R0, LSL, 15));
   // hash_ = hash_ & ((static_cast<intptr_t>(1) << bits) - 1);
-  __ AndImmediate(
-      R0, R0, (static_cast<intptr_t>(1) << String::kHashBits) - 1);
+  __ AndImmediate(R0, R0, (static_cast<intptr_t>(1) << String::kHashBits) - 1);
   __ CompareRegisters(R0, ZR);
   // return hash_ == 0 ? 1 : hash_;
   __ Bind(&done);
   __ csinc(R0, R0, ZR, NE);  // R0 <- (R0 != 0) ? R0 : (ZR + 1).
   __ SmiTag(R0);
   __ str(R0, FieldAddress(R1, String::hash_offset()));
   __ ret();
 }
 
 
@@ skipping 50 matching lines @@
     __ csel(R2, R2, ZR, LS);
 
     // Get the class index and insert it into the tags.
     // R2: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ orr(R2, R2, Operand(TMP));
     __ str(R2, FieldAddress(R0, String::tags_offset()));  // Store tags.
   }
 
   // Set the length field using the saved length (R6).
-  __ StoreIntoObjectNoBarrier(R0,
-                              FieldAddress(R0, String::length_offset()),
+  __ StoreIntoObjectNoBarrier(R0, FieldAddress(R0, String::length_offset()),
                               R6);
   // Clear hash.
   __ mov(TMP, ZR);
   __ str(TMP, FieldAddress(R0, String::hash_offset()));
   __ b(ok);
 
   __ Bind(&fail);
   __ b(failure);
 }
 
 
 // Arg0: OneByteString (receiver).
 // Arg1: Start index as Smi.
 // Arg2: End index as Smi.
 // The indexes must be valid.
 void Intrinsifier::OneByteString_substringUnchecked(Assembler* assembler) {
   const intptr_t kStringOffset = 2 * kWordSize;
   const intptr_t kStartIndexOffset = 1 * kWordSize;
   const intptr_t kEndIndexOffset = 0 * kWordSize;
   Label fall_through, ok;
 
   __ ldr(R2, Address(SP, kEndIndexOffset));
   __ ldr(TMP, Address(SP, kStartIndexOffset));
-  __ orr(R3, R2,  Operand(TMP));
+  __ orr(R3, R2, Operand(TMP));
   __ tsti(R3, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);  // 'start', 'end' not Smi.
 
   __ sub(R2, R2, Operand(TMP));
   TryAllocateOnebyteString(assembler, &ok, &fall_through);
   __ Bind(&ok);
   // R0: new string as tagged pointer.
   // Copy string.
   __ ldr(R3, Address(SP, kStringOffset));
   __ ldr(R1, Address(SP, kStartIndexOffset));
@@ skipping 78 matching lines @@
   // Have same length?
   __ ldr(R2, FieldAddress(R0, String::length_offset()));
   __ ldr(R3, FieldAddress(R1, String::length_offset()));
   __ cmp(R2, Operand(R3));
   __ b(&is_false, NE);
 
   // Check contents, no fall-through possible.
   // TODO(zra): try out other sequences.
   ASSERT((string_cid == kOneByteStringCid) ||
          (string_cid == kTwoByteStringCid));
-  const intptr_t offset = (string_cid == kOneByteStringCid) ?
-      OneByteString::data_offset() : TwoByteString::data_offset();
+  const intptr_t offset = (string_cid == kOneByteStringCid)
+                              ? OneByteString::data_offset()
+                              : TwoByteString::data_offset();
   __ AddImmediate(R0, R0, offset - kHeapObjectTag);
   __ AddImmediate(R1, R1, offset - kHeapObjectTag);
   __ SmiUntag(R2);
   __ Bind(&loop);
   __ AddImmediate(R2, R2, -1);
   __ CompareRegisters(R2, ZR);
   __ b(&is_true, LT);
   if (string_cid == kOneByteStringCid) {
     __ ldr(R3, Address(R0), kUnsignedByte);
     __ ldr(R4, Address(R1), kUnsignedByte);
@@ skipping 65 matching lines @@
 }
 
 
 // On stack: user tag (+0).
 void Intrinsifier::UserTag_makeCurrent(Assembler* assembler) {
   // R1: Isolate.
   __ LoadIsolate(R1);
   // R0: Current user tag.
   __ ldr(R0, Address(R1, Isolate::current_tag_offset()));
   // R2: UserTag.
-  __ ldr(R2, Address(SP, + 0 * kWordSize));
+  __ ldr(R2, Address(SP, +0 * kWordSize));
   // Set Isolate::current_tag_.
   __ str(R2, Address(R1, Isolate::current_tag_offset()));
   // R2: UserTag's tag.
   __ ldr(R2, FieldAddress(R2, UserTag::tag_offset()));
   // Set Isolate::user_tag_.
   __ str(R2, Address(R1, Isolate::user_tag_offset()));
   __ ret();
 }
 
 
@@ skipping 24 matching lines @@
   __ cmp(R0, Operand(0));
   __ LoadObject(R0, Bool::False());
   __ LoadObject(TMP, Bool::True());
   __ csel(R0, TMP, R0, NE);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64