clang-format runtime/vm

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, 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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 14 matching lines @@
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os_thread.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-DEFINE_FLAG(uint64_t, trace_sim_after, ULLONG_MAX,
+DEFINE_FLAG(uint64_t,
+            trace_sim_after,
+            ULLONG_MAX,
             "Trace simulator execution after instruction count reached.");
-DEFINE_FLAG(uint64_t, stop_sim_at, ULLONG_MAX,
+DEFINE_FLAG(uint64_t,
+            stop_sim_at,
+            ULLONG_MAX,
             "Instruction address or instruction count to stop simulator at.");
 
 #define LIKELY(cond) __builtin_expect((cond), 1)
 #define UNLIKELY(cond) __builtin_expect((cond), 0)
 
 // SimulatorSetjmpBuffer are linked together, and the last created one
 // is referenced by the Simulator. When an exception is thrown, the exception
 // runtime looks at where to jump and finds the corresponding
 // SimulatorSetjmpBuffer based on the stack pointer of the exception handler.
 // The runtime then does a Longjmp on that buffer to return to the simulator.
@@ skipping 42 matching lines @@
   return reinterpret_cast<RawObject**>(FP[kSavedCallerFpSlotFromFp]);
 }
 
 
 DART_FORCE_INLINE static RawObject** FrameArguments(RawObject** FP,
                                                     intptr_t argc) {
   return FP - (kDartFrameFixedSize + argc);
 }
 
 
-#define RAW_CAST(Type, val)  (SimulatorHelpers::CastTo##Type(val))
+#define RAW_CAST(Type, val) (SimulatorHelpers::CastTo##Type(val))
 
 
 class SimulatorHelpers {
  public:
-#define DEFINE_CASTS(Type)                                              \
-    DART_FORCE_INLINE static Raw##Type* CastTo##Type(RawObject* obj) {  \
-      ASSERT((k##Type##Cid == kSmiCid) ? !obj->IsHeapObject()           \
-                                       : obj->Is##Type());              \
-      return reinterpret_cast<Raw##Type*>(obj);                         \
-    }
+#define DEFINE_CASTS(Type)                                                     \
+  DART_FORCE_INLINE static Raw##Type* CastTo##Type(RawObject* obj) {           \
+    ASSERT((k##Type##Cid == kSmiCid) ? !obj->IsHeapObject()                    \
+                                     : obj->Is##Type());                       \
+    return reinterpret_cast<Raw##Type*>(obj);                                  \
+  }
   CLASS_LIST(DEFINE_CASTS)
 #undef DEFINE_CASTS
 
   DART_FORCE_INLINE static RawSmi* GetClassIdAsSmi(RawObject* obj) {
     return Smi::New(obj->IsHeapObject() ? obj->GetClassId()
                                         : static_cast<intptr_t>(kSmiCid));
   }
 
   DART_FORCE_INLINE static intptr_t GetClassId(RawObject* obj) {
     return obj->IsHeapObject() ? obj->GetClassId()
                                : static_cast<intptr_t>(kSmiCid);
   }
 
   DART_FORCE_INLINE static void IncrementUsageCounter(RawFunction* f) {
     f->ptr()->usage_counter_++;
   }
 
   DART_FORCE_INLINE static void IncrementICUsageCount(RawObject** entries,
                                                       intptr_t offset,
                                                       intptr_t args_tested) {
     const intptr_t count_offset = ICData::CountIndexFor(args_tested);
     const intptr_t raw_smi_old =
         reinterpret_cast<intptr_t>(entries[offset + count_offset]);
     const intptr_t raw_smi_new = raw_smi_old + Smi::RawValue(1);
-    *reinterpret_cast<intptr_t*>(&entries[offset + count_offset]) =
-        raw_smi_new;
+    *reinterpret_cast<intptr_t*>(&entries[offset + count_offset]) = raw_smi_new;
   }
 
   DART_FORCE_INLINE static bool IsStrictEqualWithNumberCheck(RawObject* lhs,
                                                              RawObject* rhs) {
     if (lhs == rhs) {
       return true;
     }
 
     if (lhs->IsHeapObject() && rhs->IsHeapObject()) {
       const intptr_t lhs_cid = lhs->GetClassId();
@@ skipping 19 matching lines @@
 
     return false;
   }
 
   template <typename T>
   DART_FORCE_INLINE static T* Untag(T* tagged) {
     return tagged->ptr();
   }
 
   DART_FORCE_INLINE static bool CheckIndex(RawSmi* index, RawSmi* length) {
-    return !index->IsHeapObject() &&
-           (reinterpret_cast<intptr_t>(index) >= 0) &&
+    return !index->IsHeapObject() && (reinterpret_cast<intptr_t>(index) >= 0) &&
            (reinterpret_cast<intptr_t>(index) <
-                reinterpret_cast<intptr_t>(length));
+            reinterpret_cast<intptr_t>(length));
   }
 
   static bool ObjectArraySetIndexed(Thread* thread,
                                     RawObject** FP,
                                     RawObject** result) {
     if (thread->isolate()->type_checks()) {
       return false;
     }
 
     RawObject** args = FrameArguments(FP, 3);
@@ skipping 50 matching lines @@
       return true;
     }
     return false;
   }
 
   static bool Double_getIsNan(Thread* thread,
                               RawObject** FP,
                               RawObject** result) {
     RawObject** args = FrameArguments(FP, 1);
     RawDouble* d = static_cast<RawDouble*>(args[0]);
-    *result = isnan(d->ptr()->value_)
-            ? Bool::True().raw()
-            : Bool::False().raw();
+    *result =
+        isnan(d->ptr()->value_) ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   static bool Double_getIsInfinite(Thread* thread,
                                    RawObject** FP,
                                    RawObject** result) {
     RawObject** args = FrameArguments(FP, 1);
     RawDouble* d = static_cast<RawDouble*>(args[0]);
-    *result = isinf(d->ptr()->value_)
-            ? Bool::True().raw()
-            : Bool::False().raw();
+    *result =
+        isinf(d->ptr()->value_) ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
-  static bool ObjectEquals(Thread* thread,
-                           RawObject** FP,
-                           RawObject** result) {
+  static bool ObjectEquals(Thread* thread, RawObject** FP, RawObject** result) {
     RawObject** args = FrameArguments(FP, 2);
     *result = args[0] == args[1] ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   static bool ObjectRuntimeType(Thread* thread,
                                 RawObject** FP,
                                 RawObject** result) {
     RawObject** args = FrameArguments(FP, 1);
     const intptr_t cid = GetClassId(args[0]);
@@ skipping 20 matching lines @@
     if (typ == Object::null()) {
       return false;
     }
     *result = static_cast<RawObject*>(typ);
     return true;
   }
 
   static bool GetDoubleOperands(RawObject** args, double* d1, double* d2) {
     RawObject* obj2 = args[1];
     if (!obj2->IsHeapObject()) {
-      *d2 = static_cast<double>(
-          reinterpret_cast<intptr_t>(obj2) >> kSmiTagSize);
+      *d2 =
+          static_cast<double>(reinterpret_cast<intptr_t>(obj2) >> kSmiTagSize);
     } else if (obj2->GetClassId() == kDoubleCid) {
       RawDouble* obj2d = static_cast<RawDouble*>(obj2);
       *d2 = obj2d->ptr()->value_;
     } else {
       return false;
     }
     RawDouble* obj1 = static_cast<RawDouble*>(args[0]);
     *d1 = obj1->ptr()->value_;
     return true;
   }
 
   static RawObject* AllocateDouble(Thread* thread, double value) {
     const intptr_t instance_size = Double::InstanceSize();
-    const uword start =
-        thread->heap()->new_space()->TryAllocate(instance_size);
+    const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       uword tags = 0;
       tags = RawObject::ClassIdTag::update(kDoubleCid, tags);
       tags = RawObject::SizeTag::update(instance_size, tags);
       *reinterpret_cast<uword*>(start + Double::tags_offset()) = tags;
       *reinterpret_cast<double*>(start + Double::value_offset()) = value;
       return reinterpret_cast<RawObject*>(start + kHeapObjectTag);
     }
     return NULL;
   }
 
-  static bool Double_add(Thread* thread,
-                         RawObject** FP,
-                         RawObject** result) {
+  static bool Double_add(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     RawObject* new_double = AllocateDouble(thread, d1 + d2);
     if (new_double != NULL) {
       *result = new_double;
       return true;
     }
     return false;
   }
 
-  static bool Double_mul(Thread* thread,
-                         RawObject** FP,
-                         RawObject** result) {
+  static bool Double_mul(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     RawObject* new_double = AllocateDouble(thread, d1 * d2);
     if (new_double != NULL) {
       *result = new_double;
       return true;
     }
     return false;
   }
 
-  static bool Double_sub(Thread* thread,
-                         RawObject** FP,
-                         RawObject** result) {
+  static bool Double_sub(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     RawObject* new_double = AllocateDouble(thread, d1 - d2);
     if (new_double != NULL) {
       *result = new_double;
       return true;
     }
     return false;
   }
 
-  static bool Double_div(Thread* thread,
-                         RawObject** FP,
-                         RawObject** result) {
+  static bool Double_div(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     RawObject* new_double = AllocateDouble(thread, d1 / d2);
     if (new_double != NULL) {
       *result = new_double;
       return true;
     }
     return false;
   }
 
   static bool Double_greaterThan(Thread* thread,
                                  RawObject** FP,
                                  RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     *result = d1 > d2 ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   static bool Double_greaterEqualThan(Thread* thread,
-                                 RawObject** FP,
-                                 RawObject** result) {
+                                      RawObject** FP,
+                                      RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     *result = d1 >= d2 ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   static bool Double_lessThan(Thread* thread,
-                                 RawObject** FP,
-                                 RawObject** result) {
+                              RawObject** FP,
+                              RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     *result = d1 < d2 ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
-  static bool Double_equal(Thread* thread,
-                                 RawObject** FP,
-                                 RawObject** result) {
+  static bool Double_equal(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     *result = d1 == d2 ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   static bool Double_lessEqualThan(Thread* thread,
-                                 RawObject** FP,
-                                 RawObject** result) {
+                                   RawObject** FP,
+                                   RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
       return false;
     }
     *result = d1 <= d2 ? Bool::True().raw() : Bool::False().raw();
     return true;
   }
 
   DART_FORCE_INLINE static RawCode* FrameCode(RawObject** FP) {
     ASSERT(GetClassId(FP[kPcMarkerSlotFromFp]) == kCodeCid);
     return static_cast<RawCode*>(FP[kPcMarkerSlotFromFp]);
   }
 
 
   DART_FORCE_INLINE static void SetFrameCode(RawObject** FP, RawCode* code) {
     ASSERT(GetClassId(code) == kCodeCid);
     FP[kPcMarkerSlotFromFp] = code;
   }
 
-  DART_FORCE_INLINE static uint8_t* GetTypedData(
-      RawObject* obj, RawObject* index) {
+  DART_FORCE_INLINE static uint8_t* GetTypedData(RawObject* obj,
+                                                 RawObject* index) {
     ASSERT(RawObject::IsTypedDataClassId(obj->GetClassId()));
     RawTypedData* array = reinterpret_cast<RawTypedData*>(obj);
     const intptr_t byte_offset = Smi::Value(RAW_CAST(Smi, index));
     ASSERT(byte_offset >= 0);
     return array->ptr()->data() + byte_offset;
   }
 };
 
 
 DART_FORCE_INLINE static uint32_t* SavedCallerPC(RawObject** FP) {
@@ skipping 18 matching lines @@
   }
 
   intrinsics_[kObjectArraySetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArraySetIndexed;
   intrinsics_[kObjectArrayGetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArrayGetIndexed;
   intrinsics_[kGrowableArraySetIndexedIntrinsic] =
       SimulatorHelpers::GrowableArraySetIndexed;
   intrinsics_[kGrowableArrayGetIndexedIntrinsic] =
       SimulatorHelpers::GrowableArrayGetIndexed;
-  intrinsics_[kObjectEqualsIntrinsic] =
-      SimulatorHelpers::ObjectEquals;
+  intrinsics_[kObjectEqualsIntrinsic] = SimulatorHelpers::ObjectEquals;
   intrinsics_[kObjectRuntimeTypeIntrinsic] =
       SimulatorHelpers::ObjectRuntimeType;
 
-  intrinsics_[kDouble_getIsNaNIntrinsic] =
-      SimulatorHelpers::Double_getIsNan;
+  intrinsics_[kDouble_getIsNaNIntrinsic] = SimulatorHelpers::Double_getIsNan;
   intrinsics_[kDouble_getIsInfiniteIntrinsic] =
       SimulatorHelpers::Double_getIsInfinite;
-  intrinsics_[kDouble_addIntrinsic] =
-      SimulatorHelpers::Double_add;
-  intrinsics_[kDouble_mulIntrinsic] =
-      SimulatorHelpers::Double_mul;
-  intrinsics_[kDouble_subIntrinsic] =
-      SimulatorHelpers::Double_sub;
-  intrinsics_[kDouble_divIntrinsic] =
-      SimulatorHelpers::Double_div;
+  intrinsics_[kDouble_addIntrinsic] = SimulatorHelpers::Double_add;
+  intrinsics_[kDouble_mulIntrinsic] = SimulatorHelpers::Double_mul;
+  intrinsics_[kDouble_subIntrinsic] = SimulatorHelpers::Double_sub;
+  intrinsics_[kDouble_divIntrinsic] = SimulatorHelpers::Double_div;
   intrinsics_[kDouble_greaterThanIntrinsic] =
       SimulatorHelpers::Double_greaterThan;
   intrinsics_[kDouble_greaterEqualThanIntrinsic] =
       SimulatorHelpers::Double_greaterEqualThan;
-  intrinsics_[kDouble_lessThanIntrinsic] =
-      SimulatorHelpers::Double_lessThan;
-  intrinsics_[kDouble_equalIntrinsic] =
-      SimulatorHelpers::Double_equal;
+  intrinsics_[kDouble_lessThanIntrinsic] = SimulatorHelpers::Double_lessThan;
+  intrinsics_[kDouble_equalIntrinsic] = SimulatorHelpers::Double_equal;
   intrinsics_[kDouble_lessEqualThanIntrinsic] =
       SimulatorHelpers::Double_lessEqualThan;
 }
 
 
-Simulator::Simulator()
-    : stack_(NULL),
-      fp_(NULL),
-      sp_(NULL) {
+Simulator::Simulator() : stack_(NULL), fp_(NULL), sp_(NULL) {
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   // We allocate the stack here, the size is computed as the sum of
   // the size specified by the user and the buffer space needed for
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ = new uintptr_t[(OSThread::GetSpecifiedStackSize() +
                           OSThread::kStackSizeBuffer +
                           kSimulatorStackUnderflowSize) /
                          sizeof(uintptr_t)];
@@ skipping 171 matching lines @@
   return (res != 0);
 }
 
 
 DART_FORCE_INLINE static bool AreBothSmis(intptr_t a, intptr_t b) {
   return ((a | b) & kHeapObjectTag) == 0;
 }
 
 
 #define SMI_MUL(lhs, rhs, pres) SignedMulWithOverflow((lhs), (rhs) >> 1, pres)
-#define SMI_COND(cond, lhs, rhs, pres) \
+#define SMI_COND(cond, lhs, rhs, pres)                                         \
   ((*(pres) = ((lhs cond rhs) ? true_value : false_value)), false)
 #define SMI_EQ(lhs, rhs, pres) SMI_COND(==, lhs, rhs, pres)
 #define SMI_LT(lhs, rhs, pres) SMI_COND(<, lhs, rhs, pres)
 #define SMI_GT(lhs, rhs, pres) SMI_COND(>, lhs, rhs, pres)
 #define SMI_BITOR(lhs, rhs, pres) ((*(pres) = (lhs | rhs)), false)
 #define SMI_BITAND(lhs, rhs, pres) ((*(pres) = ((lhs) & (rhs))), false)
 #define SMI_BITXOR(lhs, rhs, pres) ((*(pres) = ((lhs) ^ (rhs))), false)
 
 
 void Simulator::CallRuntime(Thread* thread,
@@ skipping 78 matching lines @@
       handler = DRT_InlineCacheMissHandlerThreeArgs;
       break;
     default:
       UNREACHABLE();
       break;
   }
 
   // Handler arguments: arguments to check and an ICData object.
   const intptr_t miss_handler_argc = checked_args + 1;
   RawObject** exit_frame = miss_handler_args + miss_handler_argc;
-  CallRuntime(thread,
-              FP,
-              exit_frame,
-              pc,
-              miss_handler_argc,
-              miss_handler_args,
-              result,
-              reinterpret_cast<uword>(handler));
+  CallRuntime(thread, FP, exit_frame, pc, miss_handler_argc, miss_handler_args,
+              result, reinterpret_cast<uword>(handler));
 }
 
 
 DART_FORCE_INLINE void Simulator::InstanceCall1(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 1;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
   RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   intptr_t i;
-  for (i = 0;
-       i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
+  for (i = 0; i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if (cache->data()[i + 0] == receiver_cid) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
       break;
     }
   }
 
   if (found) {
     if (!optimized) {
       SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);
     }
   } else {
-    InlineCacheMiss(
-        kCheckedArgs, thread, icdata, call_base, top, *pc, *FP, *SP);
+    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
+                    *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
 
 DART_FORCE_INLINE void Simulator::InstanceCall2(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 2;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
   RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
   RawSmi* arg0_cid = SimulatorHelpers::GetClassIdAsSmi(args[1]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   intptr_t i;
-  for (i = 0;
-       i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
+  for (i = 0; i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if ((cache->data()[i + 0] == receiver_cid) &&
         (cache->data()[i + 1] == arg0_cid)) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
       break;
     }
   }
 
   if (found) {
     if (!optimized) {
       SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);
     }
   } else {
-    InlineCacheMiss(
-        kCheckedArgs, thread, icdata, call_base, top, *pc, *FP, *SP);
+    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
+                    *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
 
 // Note: functions below are marked DART_NOINLINE to recover performance on
 // ARM where inlining these functions into the interpreter loop seemed to cause
 // some code quality issues.
-static DART_NOINLINE bool InvokeRuntime(
-    Thread* thread,
-    Simulator* sim,
-    RuntimeFunction drt,
-    const NativeArguments& args) {
+static DART_NOINLINE bool InvokeRuntime(Thread* thread,
+                                        Simulator* sim,
+                                        RuntimeFunction drt,
+                                        const NativeArguments& args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(drt));
     drt(args);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 
-static DART_NOINLINE bool InvokeNative(
-    Thread* thread,
-    Simulator* sim,
-    SimulatorBootstrapNativeCall f,
-    NativeArguments* args) {
+static DART_NOINLINE bool InvokeNative(Thread* thread,
+                                       Simulator* sim,
+                                       SimulatorBootstrapNativeCall f,
+                                       NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     f(args);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 
-static DART_NOINLINE bool InvokeNativeWrapper(
-    Thread* thread,
-    Simulator* sim,
-    Dart_NativeFunction f,
-    NativeArguments* args) {
+static DART_NOINLINE bool InvokeNativeWrapper(Thread* thread,
+                                              Simulator* sim,
+                                              Dart_NativeFunction f,
+                                              NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     NativeEntry::NativeCallWrapper(reinterpret_cast<Dart_NativeArguments>(args),
                                    f);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 // Note: all macro helpers are intended to be used only inside Simulator::Call.
 
 // Decode opcode and A part of the given value and dispatch to the
 // corresponding bytecode handler.
-#define DISPATCH_OP(val)         \
-  do {                           \
-    op = (val);                \
-    rA = ((op >> 8) & 0xFF);   \
-    goto* dispatch[op & 0xFF]; \
+#define DISPATCH_OP(val)                                                       \
+  do {                                                                         \
+    op = (val);                                                                \
+    rA = ((op >> 8) & 0xFF);                                                   \
+    goto* dispatch[op & 0xFF];                                                 \
   } while (0)
 
 // Fetch next operation from PC, increment program counter and dispatch.
 #define DISPATCH() DISPATCH_OP(*pc++)
 
 // Define entry point that handles bytecode Name with the given operand format.
-#define BYTECODE(Name, Operands) \
+#define BYTECODE(Name, Operands)                                               \
   BYTECODE_HEADER(Name, DECLARE_##Operands, DECODE_##Operands)
 
-#define BYTECODE_HEADER(Name, Declare, Decode) \
-  Declare;                                     \
-  bc##Name : Decode                            \
+#define BYTECODE_HEADER(Name, Declare, Decode)                                 \
+  Declare;                                                                     \
+  bc##Name : Decode
 
 // Helpers to decode common instruction formats. Used in conjunction with
 // BYTECODE() macro.
-#define DECLARE_A_B_C uint16_t rB, rC; USE(rB); USE(rC)
-#define DECODE_A_B_C \
-  rB = ((op >> Bytecode::kBShift) & Bytecode::kBMask);    \
+#define DECLARE_A_B_C                                                          \
+  uint16_t rB, rC;                                                             \
+  USE(rB);                                                                     \
+  USE(rC)
+#define DECODE_A_B_C                                                           \
+  rB = ((op >> Bytecode::kBShift) & Bytecode::kBMask);                         \
   rC = ((op >> Bytecode::kCShift) & Bytecode::kCMask);
 
 #define DECLARE_0
 #define DECODE_0
 
 #define DECLARE_A
 #define DECODE_A
 
-#define DECLARE___D uint32_t rD; USE(rD)
+#define DECLARE___D                                                            \
+  uint32_t rD;                                                                 \
+  USE(rD)
 #define DECODE___D rD = (op >> Bytecode::kDShift);
 
 #define DECLARE_A_D DECLARE___D
 #define DECODE_A_D DECODE___D
 
-#define DECLARE_A_X int32_t rD; USE(rD)
+#define DECLARE_A_X                                                            \
+  int32_t rD;                                                                  \
+  USE(rD)
 #define DECODE_A_X rD = (static_cast<int32_t>(op) >> Bytecode::kDShift);
 
 
 #define SMI_FASTPATH_ICDATA_INC                                                \
   do {                                                                         \
     ASSERT(Bytecode::IsCallOpcode(*pc));                                       \
     const uint16_t kidx = Bytecode::DecodeD(*pc);                              \
     const RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));           \
     RawObject** entries = icdata->ptr()->ic_data_->ptr()->data();              \
     SimulatorHelpers::IncrementICUsageCount(entries, 0, 2);                    \
-  } while (0);                                                                 \
+  } while (0);
 
 // Declare bytecode handler for a smi operation (e.g. AddTOS) with the
 // given result type and the given behavior specified as a function
 // that takes left and right operands and result slot and returns
 // true if fast-path succeeds.
 #define SMI_FASTPATH_TOS(ResultT, Func)                                        \
   {                                                                            \
     const intptr_t lhs = reinterpret_cast<intptr_t>(SP[-1]);                   \
     const intptr_t rhs = reinterpret_cast<intptr_t>(SP[-0]);                   \
     ResultT* slot = reinterpret_cast<ResultT*>(SP - 1);                        \
     if (LIKELY(!thread->isolate()->single_step()) &&                           \
-        LIKELY(AreBothSmis(lhs, rhs) &&                                        \
-        !Func(lhs, rhs, slot))) {                                              \
+        LIKELY(AreBothSmis(lhs, rhs) && !Func(lhs, rhs, slot))) {              \
       SMI_FASTPATH_ICDATA_INC;                                                 \
       /* Fast path succeeded. Skip the generic call that follows. */           \
       pc++;                                                                    \
       /* We dropped 2 arguments and push result                   */           \
       SP--;                                                                    \
     }                                                                          \
   }
 
 // Skip the next instruction if there is no overflow.
 #define SMI_OP_CHECK(ResultT, Func)                                            \
   {                                                                            \
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);                   \
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);                   \
     ResultT* slot = reinterpret_cast<ResultT*>(&FP[rA]);                       \
     if (LIKELY(!Func(lhs, rhs, slot))) {                                       \
       /* Success. Skip the instruction that follows. */                        \
       pc++;                                                                    \
     }                                                                          \
   }
 
 // Do not check for overflow.
 #define SMI_OP_NOCHECK(ResultT, Func)                                          \
   {                                                                            \
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);                   \
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);                   \
     ResultT* slot = reinterpret_cast<ResultT*>(&FP[rA]);                       \
     Func(lhs, rhs, slot);                                                      \
-  }                                                                            \
+  }
 
 
 // Exception handling helper. Gets handler FP and PC from the Simulator where
 // they were stored by Simulator::Longjmp and proceeds to execute the handler.
 // Corner case: handler PC can be a fake marker that marks entry frame, which
 // means exception was not handled in the Dart code. In this case we return
 // caught exception from Simulator::Call.
 #define HANDLE_EXCEPTION                                                       \
   do {                                                                         \
     FP = reinterpret_cast<RawObject**>(fp_);                                   \
     pc = reinterpret_cast<uint32_t*>(pc_);                                     \
-    if ((reinterpret_cast<uword>(pc) & 2) != 0) {  /* Entry frame? */          \
+    if ((reinterpret_cast<uword>(pc) & 2) != 0) { /* Entry frame? */           \
       fp_ = sp_ = reinterpret_cast<RawObject**>(fp_[0]);                       \
       thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));           \
       thread->set_top_resource(top_resource);                                  \
       thread->set_vm_tag(vm_tag);                                              \
       return special_[kExceptionSpecialIndex];                                 \
     }                                                                          \
     pp = SimulatorHelpers::FrameCode(FP)->ptr()->object_pool_->ptr();          \
     goto DispatchAfterException;                                               \
-  } while (0)                                                                  \
+  } while (0)
 
 // Runtime call helpers: handle invocation and potential exception after return.
-#define INVOKE_RUNTIME(Func, Args)                \
-  if (!InvokeRuntime(thread, this, Func, Args)) { \
-    HANDLE_EXCEPTION;                             \
-  }                                               \
+#define INVOKE_RUNTIME(Func, Args)                                             \
+  if (!InvokeRuntime(thread, this, Func, Args)) {                              \
+    HANDLE_EXCEPTION;                                                          \
+  }
 
-#define INVOKE_NATIVE(Func, Args)                 \
-  if (!InvokeNative(thread, this, Func, &Args)) { \
-    HANDLE_EXCEPTION;                             \
-  }                                               \
+#define INVOKE_NATIVE(Func, Args)                                              \
+  if (!InvokeNative(thread, this, Func, &Args)) {                              \
+    HANDLE_EXCEPTION;                                                          \
+  }
 
-#define INVOKE_NATIVE_WRAPPER(Func, Args)                \
-  if (!InvokeNativeWrapper(thread, this, Func, &Args)) { \
-    HANDLE_EXCEPTION;                                    \
-  }                                                      \
+#define INVOKE_NATIVE_WRAPPER(Func, Args)                                      \
+  if (!InvokeNativeWrapper(thread, this, Func, &Args)) {                       \
+    HANDLE_EXCEPTION;                                                          \
+  }
 
 #define LOAD_CONSTANT(index) (pp->data()[(index)].raw_obj_)
 
 RawObject* Simulator::Call(const Code& code,
                            const Array& arguments_descriptor,
                            const Array& arguments,
                            Thread* thread) {
   // Dispatch used to interpret bytecode. Contains addresses of
   // labels of bytecode handlers. Handlers themselves are defined below.
   static const void* dispatch[] = {
 #define TARGET(name, fmt, fmta, fmtb, fmtc) &&bc##name,
       BYTECODES_LIST(TARGET)
 #undef TARGET
   };
 
   // Interpreter state (see constants_dbc.h for high-level overview).
-  uint32_t* pc;  // Program Counter: points to the next op to execute.
+  uint32_t* pc;       // Program Counter: points to the next op to execute.
   RawObjectPool* pp;  // Pool Pointer.
-  RawObject** FP;  // Frame Pointer.
-  RawObject** SP;  // Stack Pointer.
+  RawObject** FP;     // Frame Pointer.
+  RawObject** SP;     // Stack Pointer.
 
   RawArray* argdesc;  // Arguments Descriptor: used to pass information between
                       // call instruction and the function entry.
 
   uint32_t op;  // Currently executing op.
   uint16_t rA;  // A component of the currently executing op.
 
   if (sp_ == NULL) {
     fp_ = sp_ = reinterpret_cast<RawObject**>(stack_);
   }
@@ skipping 147 matching lines @@
     memmove(FP, first_arg, pos_count * kWordSize);
 
     if (num_opt_named_params != 0) {
       // This is a function with named parameters.
       // Walk the list of named parameters and their
       // default values encoded as pairs of LoadConstant instructions that
       // follows the entry point and find matching values via arguments
       // descriptor.
       RawObject** argdesc_data = argdesc->ptr()->data();
 
-      intptr_t i = named_count - 1;  // argument position
+      intptr_t i = named_count - 1;           // argument position
       intptr_t j = num_opt_named_params - 1;  // parameter position
       while ((j >= 0) && (i >= 0)) {
         // Fetch formal parameter information: name, default value, target slot.
         const uint32_t load_name = pc[2 * j];
         const uint32_t load_value = pc[2 * j + 1];
         ASSERT(Bytecode::DecodeOpcode(load_name) == Bytecode::kLoadConstant);
         ASSERT(Bytecode::DecodeOpcode(load_value) == Bytecode::kLoadConstant);
         const uint8_t reg = Bytecode::DecodeA(load_name);
         ASSERT(reg == Bytecode::DecodeA(load_value));
 
@@ skipping 43 matching lines @@
       if (named_count != 0) {
         // Function can't have both named and optional positional parameters.
         // This kind of mismatch can only occur if the current function
         // is a closure.
         goto ClosureNoSuchMethod;
       }
 
       // Process the list of default values encoded as a sequence of
       // LoadConstant instructions after EntryOpt bytecode.
       // Execute only those that correspond to parameters the were not passed.
-      for (intptr_t i = pos_count - num_fixed_params;
-           i < num_opt_pos_params;
+      for (intptr_t i = pos_count - num_fixed_params; i < num_opt_pos_params;
            i++) {
         const uint32_t load_value = pc[i];
         ASSERT(Bytecode::DecodeOpcode(load_value) == Bytecode::kLoadConstant);
 #if defined(DEBUG)
         const uint8_t reg = Bytecode::DecodeA(load_value);
         ASSERT((num_fixed_params + i) == reg);
 #endif
         FP[num_fixed_params + i] = LOAD_CONSTANT(Bytecode::DecodeD(load_value));
       }
 
@@ skipping 41 matching lines @@
       pc = reinterpret_cast<uint32_t*>(code->ptr()->entry_point_);
       pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
     }
     DISPATCH();
   }
 
   {
     BYTECODE(HotCheck, A_D);
     const uint8_t increment = rA;
     const uint16_t threshold = rD;
-    RawFunction* f =  FrameFunction(FP);
+    RawFunction* f = FrameFunction(FP);
     int32_t counter = f->ptr()->usage_counter_;
     // Note: we don't increment usage counter in the prologue of optimized
     // functions.
     if (increment) {
       counter += increment;
       f->ptr()->usage_counter_ = counter;
     }
     if (UNLIKELY(counter >= threshold)) {
       FP[0] = f;
       FP[1] = 0;
@@ skipping 224 matching lines @@
     }
 
     // Invoke target function.
     {
       const uint16_t argc = rA;
       // Lookup the funciton in the ICData.
       RawObject* ic_data_obj = SP[0];
       RawICData* ic_data = RAW_CAST(ICData, ic_data_obj);
       RawObject** data = ic_data->ptr()->ic_data_->ptr()->data();
       SimulatorHelpers::IncrementICUsageCount(data, 0, 0);
-      SP[0] = data[ICData::TargetIndexFor(
-          ic_data->ptr()->state_bits_ & 0x3)];
+      SP[0] = data[ICData::TargetIndexFor(ic_data->ptr()->state_bits_ & 0x3)];
       RawObject** call_base = SP - argc;
       RawObject** call_top = SP;  // *SP contains function
       argdesc = static_cast<RawArray*>(LOAD_CONSTANT(rD));
       Invoke(thread, call_base, call_top, &pp, &pc, &FP, &SP);
     }
 
     DISPATCH();
   }
 
   {
@@ skipping 19 matching lines @@
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(
           RAW_CAST(Function, icdata->ptr()->owner_));
-      InstanceCall1(thread, icdata, call_base, call_top,
-                    &argdesc, &pp, &pc, &FP, &SP,
-                    false /* optimized */);
+      InstanceCall1(thread, icdata, call_base, call_top, &argdesc, &pp, &pc,
+                    &FP, &SP, false /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall2, A_D);
     if (thread->isolate()->single_step()) {
       Exit(thread, FP, SP + 1, pc);
       NativeArguments args(thread, 0, NULL, NULL);
       INVOKE_RUNTIME(DRT_SingleStepHandler, args);
     }
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(
           RAW_CAST(Function, icdata->ptr()->owner_));
-      InstanceCall2(thread, icdata, call_base, call_top,
-                    &argdesc, &pp, &pc, &FP, &SP,
-                    false /* optimized */);
+      InstanceCall2(thread, icdata, call_base, call_top, &argdesc, &pp, &pc,
+                    &FP, &SP, false /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall1Opt, A_D);
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(FrameFunction(FP));
-      InstanceCall1(thread, icdata, call_base, call_top,
-                    &argdesc, &pp, &pc, &FP, &SP,
-                    true /* optimized */);
+      InstanceCall1(thread, icdata, call_base, call_top, &argdesc, &pp, &pc,
+                    &FP, &SP, true /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall2Opt, A_D);
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(FrameFunction(FP));
-      InstanceCall2(thread, icdata, call_base, call_top,
-                    &argdesc, &pp, &pc, &FP, &SP,
-                    true /* optimized */);
+      InstanceCall2(thread, icdata, call_base, call_top, &argdesc, &pp, &pc,
+                    &FP, &SP, true /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(PushPolymorphicInstanceCall, A_D);
     const uint8_t argc = rA;
     const intptr_t cids_length = rD;
     RawObject** args = SP - argc + 1;
     const intptr_t receiver_cid = SimulatorHelpers::GetClassId(args[0]);
-    for (intptr_t i = 0; i < 2*cids_length; i+=2) {
+    for (intptr_t i = 0; i < 2 * cids_length; i += 2) {
       const intptr_t icdata_cid = Bytecode::DecodeD(*(pc + i));
       if (receiver_cid == icdata_cid) {
         RawFunction* target =
             RAW_CAST(Function, LOAD_CONSTANT(Bytecode::DecodeD(*(pc + i + 1))));
         *++SP = target;
         pc++;
         break;
       }
     }
     pc += 2 * cids_length;
@@ skipping 165 matching lines @@
       }
     }
     DISPATCH();
   }
 
   {
     BYTECODE(Mod, A_B_C);
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);
     if (rhs != 0) {
       const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
-      const intptr_t res =
-          ((lhs >> kSmiTagSize) % (rhs >> kSmiTagSize)) << kSmiTagSize;
+      const intptr_t res = ((lhs >> kSmiTagSize) % (rhs >> kSmiTagSize))
+                           << kSmiTagSize;
       *reinterpret_cast<intptr_t*>(&FP[rA]) =
           (res < 0) ? ((rhs < 0) ? (res - rhs) : (res + rhs)) : res;
       pc++;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(Shl, A_B_C);
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]) >> kSmiTagSize;
     if (static_cast<uintptr_t>(rhs) < kBitsPerWord) {
       const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
       const intptr_t res = lhs << rhs;
       if (lhs == (res >> rhs)) {
         *reinterpret_cast<intptr_t*>(&FP[rA]) = res;
         pc++;
       }
     }
     DISPATCH();
   }
 
   {
     BYTECODE(Shr, A_B_C);
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]) >> kSmiTagSize;
     if (rhs >= 0) {
       const intptr_t shift_amount =
           (rhs >= kBitsPerWord) ? (kBitsPerWord - 1) : rhs;
       const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]) >> kSmiTagSize;
-      *reinterpret_cast<intptr_t*>(&FP[rA]) =
-          (lhs >> shift_amount) << kSmiTagSize;
+      *reinterpret_cast<intptr_t*>(&FP[rA]) = (lhs >> shift_amount)
+                                              << kSmiTagSize;
       pc++;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(ShlImm, A_B_C);
     const uint8_t shift = rC;
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
     FP[rA] = reinterpret_cast<RawObject*>(lhs << shift);
@@ skipping 333 matching lines @@
   }
 
   {
     BYTECODE(BoxUint32, A_D);
     // Casts to zero out high 32 bits.
     const uintptr_t value = reinterpret_cast<uintptr_t>(FP[rD]);
     const uint32_t value32 = static_cast<uint32_t>(value);
     FP[rA] = Smi::New(static_cast<intptr_t>(value32));
     DISPATCH();
   }
-#else  // defined(ARCH_IS_64_BIT)
+#else   // defined(ARCH_IS_64_BIT)
   {
     BYTECODE(WriteIntoDouble, A_D);
     UNIMPLEMENTED();
     DISPATCH();
   }
 
   {
     BYTECODE(UnboxDouble, A_D);
     UNIMPLEMENTED();
     DISPATCH();
@@ skipping 204 matching lines @@
       DISPATCH();
     }
     goto ReturnImpl;
 
     BYTECODE(Return, A);
     result = FP[rA];
     goto ReturnImpl;
 
     BYTECODE(ReturnTOS, 0);
     result = *SP;
-    // Fall through to the ReturnImpl.
+  // Fall through to the ReturnImpl.
 
   ReturnImpl:
     // Restore caller PC.
     pc = SavedCallerPC(FP);
     pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
 
     // Check if it is a fake PC marking the entry frame.
     if ((reinterpret_cast<uword>(pc) & 2) != 0) {
       const intptr_t argc = reinterpret_cast<uword>(pc) >> 2;
       fp_ = sp_ =
@@ skipping 121 matching lines @@
     }
     DISPATCH();
   }
 
   // TODO(vegorov) allocation bytecodes can benefit from the new-space
   // allocation fast-path that does not transition into the runtime system.
   {
     BYTECODE(AllocateUninitializedContext, A_D);
     const uint16_t num_context_variables = rD;
     const intptr_t instance_size = Context::InstanceSize(num_context_variables);
-    const uword start =
-        thread->heap()->new_space()->TryAllocate(instance_size);
+    const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       uword tags = 0;
       tags = RawObject::ClassIdTag::update(kContextCid, tags);
       tags = RawObject::SizeTag::update(instance_size, tags);
       *reinterpret_cast<uword*>(start + Array::tags_offset()) = tags;
       *reinterpret_cast<uword*>(start + Context::num_variables_offset()) =
           num_context_variables;
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       pc += 2;
     }
@@ skipping 26 matching lines @@
 
   {
     BYTECODE(AllocateOpt, A_D);
     const uword tags =
         static_cast<uword>(Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD))));
     const intptr_t instance_size = RawObject::SizeTag::decode(tags);
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
       for (intptr_t current_offset = sizeof(RawInstance);
-           current_offset < instance_size;
-           current_offset += kWordSize) {
+           current_offset < instance_size; current_offset += kWordSize) {
         *reinterpret_cast<RawObject**>(start + current_offset) = null_value;
       }
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       pc += 2;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(Allocate, A_D);
-    SP[1] = 0;  // Space for the result.
+    SP[1] = 0;                  // Space for the result.
     SP[2] = LOAD_CONSTANT(rD);  // Class object.
-    SP[3] = null_value;  // Type arguments.
+    SP[3] = null_value;         // Type arguments.
     Exit(thread, FP, SP + 4, pc);
     NativeArguments args(thread, 2, SP + 2, SP + 1);
     INVOKE_RUNTIME(DRT_AllocateObject, args);
     SP++;  // Result is in SP[1].
     DISPATCH();
   }
 
   {
     BYTECODE(AllocateTOpt, A_D);
     const uword tags = Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD)));
     const intptr_t instance_size = RawObject::SizeTag::decode(tags);
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       RawObject* type_args = SP[0];
       const intptr_t type_args_offset = Bytecode::DecodeD(*pc);
       *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
       for (intptr_t current_offset = sizeof(RawInstance);
-           current_offset < instance_size;
-           current_offset += kWordSize) {
+           current_offset < instance_size; current_offset += kWordSize) {
         *reinterpret_cast<RawObject**>(start + current_offset) = null_value;
       }
       *reinterpret_cast<RawObject**>(start + type_args_offset) = type_args;
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       SP -= 1;  // Consume the type arguments on the stack.
       pc += 4;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(AllocateT, 0);
     SP[1] = SP[-0];  // Class object.
     SP[2] = SP[-1];  // Type arguments
     Exit(thread, FP, SP + 3, pc);
     NativeArguments args(thread, 2, SP + 1, SP - 1);
     INVOKE_RUNTIME(DRT_AllocateObject, args);
     SP -= 1;  // Result is in SP - 1.
     DISPATCH();
   }
 
   {
     BYTECODE(CreateArrayOpt, A_B_C);
     const intptr_t length = Smi::Value(RAW_CAST(Smi, FP[rB]));
     if (LIKELY(length <= Array::kMaxElements)) {
       const intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
       const intptr_t instance_size =
-          (fixed_size + length*kWordSize) & ~(kObjectAlignment - 1);
+          (fixed_size + length * kWordSize) & ~(kObjectAlignment - 1);
       const uword start =
           thread->heap()->new_space()->TryAllocate(instance_size);
       if (LIKELY(start != 0)) {
         const intptr_t cid = kArrayCid;
         uword tags = 0;
         if (LIKELY(instance_size < RawObject::SizeTag::kMaxSizeTag)) {
           tags = RawObject::SizeTag::update(instance_size, tags);
         }
         tags = RawObject::ClassIdTag::update(cid, tags);
         *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
@@ skipping 37 matching lines @@
       RawTypeArguments* instance_type_arguments =
           static_cast<RawTypeArguments*>(null_value);
       RawObject* instance_cid_or_function;
       if (cid == kClosureCid) {
         RawClosure* closure = static_cast<RawClosure*>(instance);
         instance_type_arguments = closure->ptr()->type_arguments_;
         instance_cid_or_function = closure->ptr()->function_;
       } else {
         instance_cid_or_function = Smi::New(cid);
 
-        RawClass* instance_class =
-            thread->isolate()->class_table()->At(cid);
+        RawClass* instance_class = thread->isolate()->class_table()->At(cid);
         if (instance_class->ptr()->num_type_arguments_ < 0) {
           goto InstanceOfCallRuntime;
         } else if (instance_class->ptr()->num_type_arguments_ > 0) {
           instance_type_arguments = reinterpret_cast<RawTypeArguments**>(
-              instance
-                  ->ptr())[instance_class->ptr()
-                               ->type_arguments_field_offset_in_words_];
+              instance->ptr())[instance_class->ptr()
+                                   ->type_arguments_field_offset_in_words_];
         }
       }
 
       for (RawObject** entries = cache->ptr()->cache_->ptr()->data();
            entries[0] != null_value;
            entries += SubtypeTestCache::kTestEntryLength) {
         if ((entries[SubtypeTestCache::kInstanceClassIdOrFunction] ==
-                instance_cid_or_function) &&
+             instance_cid_or_function) &&
             (entries[SubtypeTestCache::kInstanceTypeArguments] ==
-                instance_type_arguments) &&
+             instance_type_arguments) &&
             (entries[SubtypeTestCache::kInstantiatorTypeArguments] ==
-                instantiator_type_arguments)) {
+             instantiator_type_arguments)) {
           SP[-3] = entries[SubtypeTestCache::kTestResult];
           goto InstanceOfOk;
         }
       }
     }
 
+  // clang-format off
   InstanceOfCallRuntime:
     {
       SP[1] = instance;
       SP[2] = type;
       SP[3] = instantiator_type_arguments;
       SP[4] = cache;
       Exit(thread, FP, SP + 5, pc);
       NativeArguments native_args(thread, 4, SP + 1, SP - 3);
       INVOKE_RUNTIME(DRT_Instanceof, native_args);
     }
+  // clang-format on
 
   InstanceOfOk:
     SP -= 3;
     if (rA) {  // Negate result.
       SP[0] = (SP[0] == true_value) ? false_value : true_value;
     }
     DISPATCH();
   }
 
   {
@@ skipping 32 matching lines @@
         RawTypeArguments* instance_type_arguments =
             static_cast<RawTypeArguments*>(null_value);
         RawObject* instance_cid_or_function;
         if (cid == kClosureCid) {
           RawClosure* closure = static_cast<RawClosure*>(instance);
           instance_type_arguments = closure->ptr()->type_arguments_;
           instance_cid_or_function = closure->ptr()->function_;
         } else {
           instance_cid_or_function = Smi::New(cid);
 
-          RawClass* instance_class =
-              thread->isolate()->class_table()->At(cid);
+          RawClass* instance_class = thread->isolate()->class_table()->At(cid);
           if (instance_class->ptr()->num_type_arguments_ < 0) {
             goto AssertAssignableCallRuntime;
           } else if (instance_class->ptr()->num_type_arguments_ > 0) {
             instance_type_arguments = reinterpret_cast<RawTypeArguments**>(
-                instance
-                    ->ptr())[instance_class->ptr()
-                                 ->type_arguments_field_offset_in_words_];
+                instance->ptr())[instance_class->ptr()
+                                     ->type_arguments_field_offset_in_words_];
           }
         }
 
         for (RawObject** entries = cache->ptr()->cache_->ptr()->data();
              entries[0] != null_value;
              entries += SubtypeTestCache::kTestEntryLength) {
           if ((entries[SubtypeTestCache::kInstanceClassIdOrFunction] ==
-                  instance_cid_or_function) &&
+               instance_cid_or_function) &&
               (entries[SubtypeTestCache::kInstanceTypeArguments] ==
-                  instance_type_arguments) &&
+               instance_type_arguments) &&
               (entries[SubtypeTestCache::kInstantiatorTypeArguments] ==
-                  instantiator_type_arguments)) {
+               instantiator_type_arguments)) {
             if (true_value == entries[SubtypeTestCache::kTestResult]) {
               goto AssertAssignableOk;
             } else {
               break;
             }
           }
         }
       }
 
     AssertAssignableCallRuntime:
@@ skipping 331 matching lines @@
     DISPATCH();
   }
 
   {
     BYTECODE(IfDGt, A_D);
     const double lhs = bit_cast<double, RawObject*>(FP[rA]);
     const double rhs = bit_cast<double, RawObject*>(FP[rD]);
     pc += (lhs > rhs) ? 0 : 1;
     DISPATCH();
   }
-#else  // defined(ARCH_IS_64_BIT)
+#else   // defined(ARCH_IS_64_BIT)
   {
     BYTECODE(IfDEq, A_D);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
     BYTECODE(IfDNe, A_D);
     UNREACHABLE();
     DISPATCH();
@@ skipping 296 matching lines @@
   ClosureNoSuchMethod:
 #if defined(DEBUG)
     function_h ^= FrameFunction(FP);
     ASSERT(function_h.IsClosureFunction());
 #endif
 
     // Restore caller context as we are going to throw NoSuchMethod.
     pc = SavedCallerPC(FP);
 
     const bool has_dart_caller = (reinterpret_cast<uword>(pc) & 2) == 0;
-    const intptr_t argc = has_dart_caller
-                              ? Bytecode::DecodeArgc(pc[-1])
-                              : (reinterpret_cast<uword>(pc) >> 2);
+    const intptr_t argc = has_dart_caller ? Bytecode::DecodeArgc(pc[-1])
+                                          : (reinterpret_cast<uword>(pc) >> 2);
 
     SP = FrameArguments(FP, 0);
     RawObject** args = SP - argc;
     FP = SavedCallerFP(FP);
     if (has_dart_caller) {
       pp = SimulatorHelpers::FrameCode(FP)->ptr()->object_pool_->ptr();
     }
 
     *++SP = null_value;
     *++SP = args[0];  // Closure object.
@@ skipping 70 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC