clang-format runtime/vm

runtime/vm/simulator_mips.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
 
 // Only build the simulator if not compiling for real MIPS hardware.
 #if defined(USING_SIMULATOR)
 
 #include "vm/simulator.h"
 
 #include "vm/assembler.h"
 #include "vm/constants_mips.h"
 #include "vm/disassembler.h"
 #include "vm/lockers.h"
 #include "vm/native_arguments.h"
 #include "vm/stack_frame.h"
 #include "vm/os_thread.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.");
 
 
 // This macro provides a platform independent use of sscanf. The reason for
 // SScanF not being implemented in a platform independent way through
 // OS in the same way as SNPrint is that the Windows C Run-Time
 // Library does not provide vsscanf.
 #define SScanF sscanf  // NOLINT
 
 
@@ skipping 49 matching lines @@
 
  private:
   Simulator* sim_;
 
   bool GetValue(char* desc, uint32_t* value);
   bool GetFValue(char* desc, double* value);
   bool GetDValue(char* desc, double* value);
 
   static TokenPosition GetApproximateTokenIndex(const Code& code, uword pc);
 
-  static void PrintDartFrame(uword pc, uword fp, uword sp,
+  static void PrintDartFrame(uword pc,
+                             uword fp,
+                             uword sp,
                              const Function& function,
                              TokenPosition token_pos,
                              bool is_optimized,
                              bool is_inlined);
   void PrintBacktrace();
 
   // Set or delete a breakpoint. Returns true if successful.
   bool SetBreakpoint(Instr* breakpc);
   bool DeleteBreakpoint(Instr* breakpc);
 
   // Undo and redo all breakpoints. This is needed to bracket disassembly and
   // execution to skip past breakpoints when run from the debugger.
   void UndoBreakpoints();
   void RedoBreakpoints();
 };
 
 
 SimulatorDebugger::SimulatorDebugger(Simulator* sim) {
   sim_ = sim;
 }
 
 
-SimulatorDebugger::~SimulatorDebugger() {
-}
+SimulatorDebugger::~SimulatorDebugger() {}
 
 
 void SimulatorDebugger::Stop(Instr* instr, const char* message) {
   OS::Print("Simulator hit %s\n", message);
   Debug();
 }
 
 
 static Register LookupCpuRegisterByName(const char* name) {
   static const char* kNames[] = {
-      "r0",  "r1",  "r2",  "r3",
-      "r4",  "r5",  "r6",  "r7",
-      "r8",  "r9",  "r10", "r11",
-      "r12", "r13", "r14", "r15",
-      "r16", "r17", "r18", "r19",
-      "r20", "r21", "r22", "r23",
-      "r24", "r25", "r26", "r27",
-      "r28", "r29", "r30", "r31",
+      "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
+      "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
+      "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+      "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 
-      "zr",  "at",  "v0",  "v1",
-      "a0",  "a1",  "a2",  "a3",
-      "t0",  "t1",  "t2",  "t3",
-      "t4",  "t5",  "t6",  "t7",
-      "s0",  "s1",  "s2",  "s3",
-      "s4",  "s5",  "s6",  "s7",
-      "t8",  "t9",  "k0",  "k1",
-      "gp",  "sp",  "fp",  "ra"
-  };
+      "zr",  "at",  "v0",  "v1",  "a0",  "a1",  "a2",  "a3",
+      "t0",  "t1",  "t2",  "t3",  "t4",  "t5",  "t6",  "t7",
+      "s0",  "s1",  "s2",  "s3",  "s4",  "s5",  "s6",  "s7",
+      "t8",  "t9",  "k0",  "k1",  "gp",  "sp",  "fp",  "ra"};
   static const Register kRegisters[] = {
-      R0,  R1,  R2,  R3,
-      R4,  R5,  R6,  R7,
-      R8,  R9,  R10, R11,
-      R12, R13, R14, R15,
-      R16, R17, R18, R19,
-      R20, R21, R22, R23,
-      R24, R25, R26, R27,
-      R28, R29, R30, R31,
+      R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10,
+      R11, R12, R13, R14, R15, R16, R17, R18, R19, R20, R21,
+      R22, R23, R24, R25, R26, R27, R28, R29, R30, R31,
 
-      ZR,  AT,  V0,  V1,
-      A0,  A1,  A2,  A3,
-      T0,  T1,  T2,  T3,
-      T4,  T5,  T6,  T7,
-      S0,  S1,  S2,  S3,
-      S4,  S5,  S6,  S7,
-      T8,  T9,  K0,  K1,
-      GP,  SP,  FP,  RA
-  };
+      ZR,  AT,  V0,  V1,  A0,  A1,  A2,  A3,  T0,  T1,  T2,
+      T3,  T4,  T5,  T6,  T7,  S0,  S1,  S2,  S3,  S4,  S5,
+      S6,  S7,  T8,  T9,  K0,  K1,  GP,  SP,  FP,  RA};
   ASSERT(ARRAY_SIZE(kNames) == ARRAY_SIZE(kRegisters));
   for (unsigned i = 0; i < ARRAY_SIZE(kNames); i++) {
     if (strcmp(kNames[i], name) == 0) {
       return kRegisters[i];
     }
   }
   return kNoRegister;
 }
 
 
@@ skipping 69 matching lines @@
       }
       *value = *(reinterpret_cast<double*>(addr));
       return true;
     }
   }
   return false;
 }
 
 
 TokenPosition SimulatorDebugger::GetApproximateTokenIndex(const Code& code,
-                                                     uword pc) {
+                                                          uword pc) {
   TokenPosition token_pos = TokenPosition::kNoSource;
   uword pc_offset = pc - code.PayloadStart();
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kAnyKind);
   while (iter.MoveNext()) {
     if (iter.PcOffset() == pc_offset) {
       return iter.TokenPos();
     } else if (!token_pos.IsReal() && (iter.PcOffset() > pc_offset)) {
       token_pos = iter.TokenPos();
     }
   }
   return token_pos;
 }
 
 
-void SimulatorDebugger::PrintDartFrame(uword pc, uword fp, uword sp,
+void SimulatorDebugger::PrintDartFrame(uword pc,
+                                       uword fp,
+                                       uword sp,
                                        const Function& function,
                                        TokenPosition token_pos,
                                        bool is_optimized,
                                        bool is_inlined) {
   const Script& script = Script::Handle(function.script());
   const String& func_name = String::Handle(function.QualifiedScrubbedName());
   const String& url = String::Handle(script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (token_pos.IsReal()) {
     script.GetTokenLocation(token_pos, &line, &column);
   }
-  OS::Print("pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s%s (%s:%" Pd
-            ":%" Pd ")\n",
-            pc, fp, sp,
-            is_optimized ? (is_inlined ? "inlined " : "optimized ") : "",
-            func_name.ToCString(),
-            url.ToCString(),
-            line, column);
+  OS::Print(
+      "pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s%s (%s:%" Pd ":%" Pd ")\n", pc,
+      fp, sp, is_optimized ? (is_inlined ? "inlined " : "optimized ") : "",
+      func_name.ToCString(), url.ToCString(), line, column);
 }
 
 
 void SimulatorDebugger::PrintBacktrace() {
-  StackFrameIterator frames(sim_->get_register(FP),
-                            sim_->get_register(SP),
+  StackFrameIterator frames(sim_->get_register(FP), sim_->get_register(SP),
                             sim_->get_pc(),
                             StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
   Function& function = Function::Handle();
   Function& inlined_function = Function::Handle();
   Code& code = Code::Handle();
   Code& unoptimized_code = Code::Handle();
   while (frame != NULL) {
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       function = code.function();
       if (code.is_optimized()) {
         // For optimized frames, extract all the inlined functions if any
         // into the stack trace.
         InlinedFunctionsIterator it(code, frame->pc());
         while (!it.Done()) {
           // Print each inlined frame with its pc in the corresponding
           // unoptimized frame.
           inlined_function = it.function();
           unoptimized_code = it.code();
           uword unoptimized_pc = it.pc();
           it.Advance();
           if (!it.Done()) {
-            PrintDartFrame(unoptimized_pc, frame->fp(), frame->sp(),
-                           inlined_function,
-                           GetApproximateTokenIndex(unoptimized_code,
-                                                    unoptimized_pc),
-                           true, true);
+            PrintDartFrame(
+                unoptimized_pc, frame->fp(), frame->sp(), inlined_function,
+                GetApproximateTokenIndex(unoptimized_code, unoptimized_pc),
+                true, true);
           }
         }
         // Print the optimized inlining frame below.
       }
-      PrintDartFrame(frame->pc(), frame->fp(), frame->sp(),
-                     function,
+      PrintDartFrame(frame->pc(), frame->fp(), frame->sp(), function,
                      GetApproximateTokenIndex(code, frame->pc()),
                      code.is_optimized(), false);
     } else {
       OS::Print("pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s frame\n",
                 frame->pc(), frame->fp(), frame->sp(),
-                frame->IsEntryFrame() ? "entry" :
-                    frame->IsExitFrame() ? "exit" :
-                        frame->IsStubFrame() ? "stub" : "invalid");
+                frame->IsEntryFrame()
+                    ? "entry"
+                    : frame->IsExitFrame()
+                          ? "exit"
+                          : frame->IsStubFrame() ? "stub" : "invalid");
     }
     frame = frames.NextFrame();
   }
 }
 
 
 bool SimulatorDebugger::SetBreakpoint(Instr* breakpc) {
   // Check if a breakpoint can be set. If not return without any side-effects.
   if (sim_->break_pc_ != NULL) {
     return false;
@@ skipping 74 matching lines @@
       FATAL("ReadLine failed");
     } else {
       // Use sscanf to parse the individual parts of the command line. At the
       // moment no command expects more than two parameters.
       int args = SScanF(line,
                         "%" XSTR(COMMAND_SIZE) "s "
                         "%" XSTR(ARG_SIZE) "s "
                         "%" XSTR(ARG_SIZE) "s",
                         cmd, arg1, arg2);
       if ((strcmp(cmd, "h") == 0) || (strcmp(cmd, "help") == 0)) {
-        OS::Print("c/cont -- continue execution\n"
-                  "disasm -- disassemble instrs at current pc location\n"
-                  "  other variants are:\n"
-                  "    disasm <address>\n"
-                  "    disasm <address> <number_of_instructions>\n"
-                  "  by default 10 instrs are disassembled\n"
-                  "del -- delete breakpoints\n"
-                  "gdb -- transfer control to gdb\n"
-                  "h/help -- print this help string\n"
-                  "break <address> -- set break point at specified address\n"
-                  "p/print <reg or icount or value or *addr> -- print integer\n"
-                  "pf/printfloat <freg or *addr> -- print float value\n"
-                  "po/printobject <*reg or *addr> -- print object\n"
-                  "si/stepi -- single step an instruction\n"
-                  "trace -- toggle execution tracing mode\n"
-                  "bt -- print backtrace\n"
-                  "unstop -- if current pc is a stop instr make it a nop\n"
-                  "q/quit -- Quit the debugger and exit the program\n");
+        OS::Print(
+            "c/cont -- continue execution\n"
+            "disasm -- disassemble instrs at current pc location\n"
+            "  other variants are:\n"
+            "    disasm <address>\n"
+            "    disasm <address> <number_of_instructions>\n"
+            "  by default 10 instrs are disassembled\n"
+            "del -- delete breakpoints\n"
+            "gdb -- transfer control to gdb\n"
+            "h/help -- print this help string\n"
+            "break <address> -- set break point at specified address\n"
+            "p/print <reg or icount or value or *addr> -- print integer\n"
+            "pf/printfloat <freg or *addr> -- print float value\n"
+            "po/printobject <*reg or *addr> -- print object\n"
+            "si/stepi -- single step an instruction\n"
+            "trace -- toggle execution tracing mode\n"
+            "bt -- print backtrace\n"
+            "unstop -- if current pc is a stop instr make it a nop\n"
+            "q/quit -- Quit the debugger and exit the program\n");
       } else if ((strcmp(cmd, "quit") == 0) || (strcmp(cmd, "q") == 0)) {
         OS::Print("Quitting\n");
         OS::Exit(0);
       } else if ((strcmp(cmd, "si") == 0) || (strcmp(cmd, "stepi") == 0)) {
         sim_->InstructionDecode(reinterpret_cast<Instr*>(sim_->get_pc()));
       } else if ((strcmp(cmd, "c") == 0) || (strcmp(cmd, "cont") == 0)) {
         // Execute the one instruction we broke at with breakpoints disabled.
         sim_->InstructionDecode(reinterpret_cast<Instr*>(sim_->get_pc()));
         // Leave the debugger shell.
         done = true;
       } else if ((strcmp(cmd, "p") == 0) || (strcmp(cmd, "print") == 0)) {
         if (args == 2) {
           uint32_t value;
           if (strcmp(arg1, "icount") == 0) {
             const uint64_t icount = sim_->get_icount();
             OS::Print("icount: %" Pu64 " 0x%" Px64 "\n", icount, icount);
           } else if (GetValue(arg1, &value)) {
             OS::Print("%s: %u 0x%x\n", arg1, value, value);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("print <reg or icount or value or *addr>\n");
         }
-      } else if ((strcmp(cmd, "pf") == 0) ||
-                 (strcmp(cmd, "printfloat") == 0)) {
+      } else if ((strcmp(cmd, "pf") == 0) || (strcmp(cmd, "printfloat") == 0)) {
         if (args == 2) {
           double dvalue;
           if (GetFValue(arg1, &dvalue)) {
             uint64_t long_value = bit_cast<uint64_t, double>(dvalue);
-            OS::Print("%s: %llu 0x%llx %.8g\n",
-                arg1, long_value, long_value, dvalue);
+            OS::Print("%s: %llu 0x%llx %.8g\n", arg1, long_value, long_value,
+                      dvalue);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printfloat <dreg or *addr>\n");
         }
       } else if ((strcmp(cmd, "pd") == 0) ||
                  (strcmp(cmd, "printdouble") == 0)) {
         if (args == 2) {
           double dvalue;
           if (GetDValue(arg1, &dvalue)) {
             uint64_t long_value = bit_cast<uint64_t, double>(dvalue);
-            OS::Print("%s: %llu 0x%llx %.8g\n",
-                arg1, long_value, long_value, dvalue);
+            OS::Print("%s: %llu 0x%llx %.8g\n", arg1, long_value, long_value,
+                      dvalue);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printfloat <dreg or *addr>\n");
         }
       } else if ((strcmp(cmd, "po") == 0) ||
                  (strcmp(cmd, "printobject") == 0)) {
         if (args == 2) {
           uint32_t value;
           // Make the dereferencing '*' optional.
           if (((arg1[0] == '*') && GetValue(arg1 + 1, &value)) ||
               GetValue(arg1, &value)) {
             if (Isolate::Current()->heap()->Contains(value)) {
               OS::Print("%s: \n", arg1);
 #if defined(DEBUG)
-              const Object& obj = Object::Handle(
-                  reinterpret_cast<RawObject*>(value));
+              const Object& obj =
+                  Object::Handle(reinterpret_cast<RawObject*>(value));
               obj.Print();
 #endif  // defined(DEBUG)
             } else {
               OS::Print("0x%x is not an object reference\n", value);
             }
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printobject <*reg or *addr>\n");
@@ skipping 102 matching lines @@
   OS::Print("%s", prompt);
   while (keep_going) {
     if (fgets(line_buf, sizeof(line_buf), stdin) == NULL) {
       // fgets got an error. Just give up.
       if (result != NULL) {
         delete[] result;
       }
       return NULL;
     }
     intptr_t len = strlen(line_buf);
-    if (len > 1 &&
-        line_buf[len - 2] == '\\' &&
-        line_buf[len - 1] == '\n') {
+    if (len > 1 && line_buf[len - 2] == '\\' && line_buf[len - 1] == '\n') {
       // When we read a line that ends with a "\" we remove the escape and
       // append the remainder.
       line_buf[len - 2] = '\n';
       line_buf[len - 1] = 0;
       len -= 1;
     } else if ((len > 0) && (line_buf[len - 1] == '\n')) {
       // Since we read a new line we are done reading the line. This
       // will exit the loop after copying this buffer into the result.
       keep_going = false;
     }
@@ skipping 25 matching lines @@
     offset += len;
   }
   ASSERT(result != NULL);
   result[offset] = '\0';
   return result;
 }
 
 
 // Synchronization primitives support.
 Mutex* Simulator::exclusive_access_lock_ = NULL;
-Simulator::AddressTag Simulator::exclusive_access_state_[kNumAddressTags] =
-    {{NULL, 0}};
+Simulator::AddressTag Simulator::exclusive_access_state_[kNumAddressTags] = {
+    {NULL, 0}};
 int Simulator::next_address_tag_ = 0;
 
 
 void Simulator::InitOnce() {
   // Setup exclusive access state lock.
   exclusive_access_lock_ = new Mutex();
 }
 
 
 Simulator::Simulator() {
   // 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 char[(OSThread::GetSpecifiedStackSize() +
-                     OSThread::kStackSizeBuffer +
-                     kSimulatorStackUnderflowSize)];
+  stack_ =
+      new char[(OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer +
+                kSimulatorStackUnderflowSize)];
   icount_ = 0;
   delay_slot_ = false;
   break_pc_ = NULL;
   break_instr_ = 0;
   last_setjmp_buffer_ = NULL;
   top_exit_frame_info_ = 0;
 
   // Setup architecture state.
   // All registers are initialized to zero to start with.
   for (int i = 0; i < kNumberOfCpuRegisters; i++) {
@@ skipping 74 matching lines @@
       : external_function_(external_function),
         call_kind_(call_kind),
         argument_count_(argument_count),
         break_instruction_(Instr::kSimulatorRedirectInstruction),
         next_(list_) {
     // Atomically prepend this element to the front of the global list.
     // Note: Since elements are never removed, there is no ABA issue.
     Redirection* list_head = list_;
     do {
       next_ = list_head;
-      list_head = reinterpret_cast<Redirection*>(
-          AtomicOperations::CompareAndSwapWord(
-              reinterpret_cast<uword*>(&list_),
-              reinterpret_cast<uword>(next_),
+      list_head =
+          reinterpret_cast<Redirection*>(AtomicOperations::CompareAndSwapWord(
+              reinterpret_cast<uword*>(&list_), reinterpret_cast<uword>(next_),
               reinterpret_cast<uword>(this)));
     } while (list_head != next_);
   }
 
   uword external_function_;
   Simulator::CallKind call_kind_;
   int argument_count_;
   uint32_t break_instruction_;
   Redirection* next_;
   static Redirection* list_;
@@ skipping 149 matching lines @@
   FATAL("Cannot continue execution after unimplemented instruction.");
 }
 
 
 void Simulator::HandleIllegalAccess(uword addr, Instr* instr) {
   uword fault_pc = get_pc();
   // The debugger will not be able to single step past this instruction, but
   // it will be possible to disassemble the code and inspect registers.
   char buffer[128];
   snprintf(buffer, sizeof(buffer),
-           "illegal memory access at 0x%" Px ", pc=0x%" Px "\n",
-           addr, fault_pc);
+           "illegal memory access at 0x%" Px ", pc=0x%" Px "\n", addr,
+           fault_pc);
   SimulatorDebugger dbg(this);
   dbg.Stop(instr, buffer);
   // The debugger will return control in non-interactive mode.
   FATAL("Cannot continue execution after illegal memory access.");
 }
 
 
 void Simulator::UnalignedAccess(const char* msg, uword addr, Instr* instr) {
   // The debugger will not be able to single step past this instruction, but
   // it will be possible to disassemble the code and inspect registers.
   char buffer[128];
-  snprintf(buffer, sizeof(buffer),
-           "pc=%p, unaligned %s at 0x%" Px "\n",  instr, msg, addr);
+  snprintf(buffer, sizeof(buffer), "pc=%p, unaligned %s at 0x%" Px "\n", instr,
+           msg, addr);
   SimulatorDebugger dbg(this);
   dbg.Stop(instr, buffer);
   // The debugger will return control in non-interactive mode.
   FATAL("Cannot continue execution after unaligned access.");
 }
 
 
 // Returns the top of the stack area to enable checking for stack pointer
 // validity.
 uword Simulator::StackTop() const {
   // To be safe in potential stack underflows we leave some buffer above and
   // set the stack top.
   return StackBase() +
-      (OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer);
+         (OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer);
 }
 
 
 bool Simulator::IsTracingExecution() const {
   return icount_ > FLAG_trace_sim_after;
 }
 
 
 void Simulator::Format(Instr* instr, const char* format) {
   OS::PrintErr("Simulator - unknown instruction: %s\n", format);
@@ skipping 187 matching lines @@
   return CompareExchange(reinterpret_cast<uword*>(address),
                          static_cast<uword>(compare_value),
                          static_cast<uword>(new_value));
 }
 
 
 // Calls into the Dart runtime are based on this interface.
 typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
 
 // Calls to leaf Dart runtime functions are based on this interface.
-typedef int32_t (*SimulatorLeafRuntimeCall)(
-    int32_t r0, int32_t r1, int32_t r2, int32_t r3);
+typedef int32_t (*SimulatorLeafRuntimeCall)(int32_t r0,
+                                            int32_t r1,
+                                            int32_t r2,
+                                            int32_t r3);
 
 // Calls to leaf float Dart runtime functions are based on this interface.
 typedef double (*SimulatorLeafFloatRuntimeCall)(double d0, double d1);
 
 // Calls to native Dart functions are based on this interface.
 typedef void (*SimulatorBootstrapNativeCall)(NativeArguments* arguments);
 typedef void (*SimulatorNativeCall)(NativeArguments* arguments, uword target);
 
 
-void Simulator::DoBreak(Instr *instr) {
+void Simulator::DoBreak(Instr* instr) {
   ASSERT(instr->OpcodeField() == SPECIAL);
   ASSERT(instr->FunctionField() == BREAK);
   if (instr->BreakCodeField() == Instr::kStopMessageCode) {
     SimulatorDebugger dbg(this);
     const char* message = *reinterpret_cast<const char**>(
         reinterpret_cast<intptr_t>(instr) - Instr::kInstrSize);
     set_pc(get_pc() + Instr::kInstrSize);
     dbg.Stop(instr, message);
     // Adjust for extra pc increment.
     set_pc(get_pc() - Instr::kInstrSize);
   } else if (instr->BreakCodeField() == Instr::kSimulatorRedirectCode) {
     SimulatorSetjmpBuffer buffer(this);
 
     if (!setjmp(buffer.buffer_)) {
       int32_t saved_ra = get_register(RA);
       Redirection* redirection = Redirection::FromBreakInstruction(instr);
       uword external = redirection->external_function();
       if (IsTracingExecution()) {
         THR_Print("Call to host function at 0x%" Pd "\n", external);
       }
 
       if ((redirection->call_kind() == kRuntimeCall) ||
           (redirection->call_kind() == kBootstrapNativeCall) ||
           (redirection->call_kind() == kNativeCall)) {
         // Set the top_exit_frame_info of this simulator to the native stack.
         set_top_exit_frame_info(Thread::GetCurrentStackPointer());
       }
       if (redirection->call_kind() == kRuntimeCall) {
         NativeArguments arguments;
-        ASSERT(sizeof(NativeArguments) == 4*kWordSize);
+        ASSERT(sizeof(NativeArguments) == 4 * kWordSize);
         arguments.thread_ = reinterpret_cast<Thread*>(get_register(A0));
         arguments.argc_tag_ = get_register(A1);
         arguments.argv_ = reinterpret_cast<RawObject**>(get_register(A2));
         arguments.retval_ = reinterpret_cast<RawObject**>(get_register(A3));
         SimulatorRuntimeCall target =
             reinterpret_cast<SimulatorRuntimeCall>(external);
         target(arguments);
         set_register(V0, icount_);  // Zap result registers from void function.
         set_register(V1, icount_);
       } else if (redirection->call_kind() == kLeafRuntimeCall) {
         int32_t a0 = get_register(A0);
         int32_t a1 = get_register(A1);
         int32_t a2 = get_register(A2);
         int32_t a3 = get_register(A3);
         SimulatorLeafRuntimeCall target =
             reinterpret_cast<SimulatorLeafRuntimeCall>(external);
         a0 = target(a0, a1, a2, a3);
-        set_register(V0, a0);  // Set returned result from function.
+        set_register(V0, a0);       // Set returned result from function.
         set_register(V1, icount_);  // Zap second result register.
       } else if (redirection->call_kind() == kLeafFloatRuntimeCall) {
         ASSERT((0 <= redirection->argument_count()) &&
                (redirection->argument_count() <= 2));
         // double values are passed and returned in floating point registers.
         SimulatorLeafFloatRuntimeCall target =
             reinterpret_cast<SimulatorLeafFloatRuntimeCall>(external);
         double d0 = 0.0;
         double d6 = get_fregister_double(F12);
         double d7 = get_fregister_double(F14);
@@ skipping 132 matching lines @@
       }
       set_lo_register(rs_val / rt_val);
       set_hi_register(rs_val % rt_val);
       break;
     }
     case JALR: {
       ASSERT(instr->RtField() == R0);
       ASSERT(instr->RsField() != instr->RdField());
       ASSERT(!delay_slot_);
       // Format(instr, "jalr'hint 'rd, rs");
-      set_register(instr->RdField(), pc_ + 2*Instr::kInstrSize);
+      set_register(instr->RdField(), pc_ + 2 * Instr::kInstrSize);
       uword next_pc = get_register(instr->RsField());
       ExecuteDelaySlot();
       // Set return address to be the instruction after the delay slot.
       pc_ = next_pc - Instr::kInstrSize;  // Account for regular PC increment.
       break;
     }
     case JR: {
       ASSERT(instr->RtField() == R0);
       ASSERT(instr->RdField() == R0);
       ASSERT(!delay_slot_);
@@ skipping 102 matching lines @@
     case OR: {
       ASSERT(instr->SaField() == 0);
       // Format(instr, "or 'rd, 'rs, 'rt");
       int32_t rs_val = get_register(instr->RsField());
       int32_t rt_val = get_register(instr->RtField());
       set_register(instr->RdField(), rs_val | rt_val);
       break;
     }
     case SLL: {
       ASSERT(instr->RsField() == 0);
-      if ((instr->RdField() == R0) &&
-          (instr->RtField() == R0) &&
+      if ((instr->RdField() == R0) && (instr->RtField() == R0) &&
           (instr->SaField() == 0)) {
         // Format(instr, "nop");
         // Nothing to be done for NOP.
       } else {
         int32_t rt_val = get_register(instr->RtField());
         int sa = instr->SaField();
         set_register(instr->RdField(), rt_val << sa);
       }
       break;
     }
@@ skipping 176 matching lines @@
   switch (instr->RegImmFnField()) {
     case BGEZ: {
       // Format(instr, "bgez 'rs, 'dest");
       int32_t rs_val = get_register(instr->RsField());
       DoBranch(instr, rs_val >= 0, false);
       break;
     }
     case BGEZAL: {
       int32_t rs_val = get_register(instr->RsField());
       // Return address is one after the delay slot.
-      set_register(RA, pc_ + (2*Instr::kInstrSize));
+      set_register(RA, pc_ + (2 * Instr::kInstrSize));
       DoBranch(instr, rs_val >= 0, false);
       break;
     }
     case BLTZAL: {
       int32_t rs_val = get_register(instr->RsField());
       // Return address is one after the delay slot.
-      set_register(RA, pc_ + (2*Instr::kInstrSize));
+      set_register(RA, pc_ + (2 * Instr::kInstrSize));
       DoBranch(instr, rs_val < 0, false);
       break;
     }
     case BGEZL: {
       // Format(instr, "bgezl 'rs, 'dest");
       int32_t rs_val = get_register(instr->RsField());
       DoBranch(instr, rs_val >= 0, true);
       break;
     }
     case BLTZ: {
@@ skipping 85 matching lines @@
       case COP1_C_EQ: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc, (fs_val == ft_val));
         break;
       }
       case COP1_C_UEQ: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc,
-            (fs_val == ft_val) || isnan(fs_val) || isnan(ft_val));
+                     (fs_val == ft_val) || isnan(fs_val) || isnan(ft_val));
         break;
       }
       case COP1_C_OLT: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc, (fs_val < ft_val));
         break;
       }
       case COP1_C_ULT: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc,
-            (fs_val < ft_val) || isnan(fs_val) || isnan(ft_val));
+                     (fs_val < ft_val) || isnan(fs_val) || isnan(ft_val));
         break;
       }
       case COP1_C_OLE: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc, (fs_val <= ft_val));
         break;
       }
       case COP1_C_ULE: {
         ASSERT(instr->FormatField() == FMT_D);  // Only D supported.
         ASSERT(instr->FdField() == F0);
         set_fcsr_bit(fcsr_cc,
-            (fs_val <= ft_val) || isnan(fs_val) || isnan(ft_val));
+                     (fs_val <= ft_val) || isnan(fs_val) || isnan(ft_val));
         break;
       }
       case COP1_TRUNC_W: {
         switch (instr->FormatField()) {
           case FMT_D: {
             double fs_dbl = get_fregister_double(instr->FsField());
             int32_t fs_int;
             if (isnan(fs_dbl) || isinf(fs_dbl) || (fs_dbl > kMaxInt32) ||
                 (fs_dbl < kMinInt32)) {
               fs_int = kMaxInt32;
@@ skipping 405 matching lines @@
     }
     case XORI: {
       // Format(instr, "xori 'rt, 'rs, 'immu");
       int32_t rs_val = get_register(instr->RsField());
       set_register(instr->RtField(), rs_val ^ instr->UImmField());
       break;
       break;
     }
     default: {
       OS::PrintErr("Undecoded instruction: 0x%x at %p\n",
-                    instr->InstructionBits(), instr);
+                   instr->InstructionBits(), instr);
       UnimplementedInstruction(instr);
       break;
     }
   }
   pc_ += Instr::kInstrSize;
 }
 
 
 void Simulator::ExecuteDelaySlot() {
   ASSERT(pc_ != kEndSimulatingPC);
@@ skipping 200 matching lines @@
   set_register(THR, reinterpret_cast<int32_t>(thread));
   // Set the tag.
   thread->set_vm_tag(VMTag::kDartTagId);
   // Clear top exit frame.
   thread->set_top_exit_frame_info(0);
 
   ASSERT(raw_exception != Object::null());
   set_register(kExceptionObjectReg, bit_cast<int32_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   // Restore pool pointer.
-  int32_t code = *reinterpret_cast<int32_t*>(
-      fp + kPcMarkerSlotFromFp * kWordSize);
-  int32_t pp = *reinterpret_cast<int32_t*>(
-      code + Code::object_pool_offset() - kHeapObjectTag);
+  int32_t code =
+      *reinterpret_cast<int32_t*>(fp + kPcMarkerSlotFromFp * kWordSize);
+  int32_t pp = *reinterpret_cast<int32_t*>(code + Code::object_pool_offset() -
+                                           kHeapObjectTag);
   set_register(CODE_REG, code);
   set_register(PP, pp);
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // defined(USING_SIMULATOR)
 
 #endif  // defined TARGET_ARCH_MIPS