Complete and clean up breakpoint support in all 3 debuggers embedded in MIPS,

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>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
 
@@ skipping 87 matching lines @@
 
   static intptr_t GetApproximateTokenIndex(const Code& code, uword pc);
 
   static void PrintDartFrame(uword pc, uword fp, uword sp,
                              const Function& function,
                              intptr_t token_pos,
                              bool is_optimized,
                              bool is_inlined);
   void PrintBacktrace();
 
-  static const int32_t kSimulatorBreakpointInstruction =
-      Instr::kBreakPointInstruction |
-      (Instr::kSimulatorBreakCode << kBreakCodeShift);
-
   // 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();
 };
 
@@ skipping 264 matching lines @@
 
 void SimulatorDebugger::UndoBreakpoints() {
   if (sim_->break_pc_ != NULL) {
     sim_->break_pc_->SetInstructionBits(sim_->break_instr_);
   }
 }
 
 
 void SimulatorDebugger::RedoBreakpoints() {
   if (sim_->break_pc_ != NULL) {
-    sim_->break_pc_->SetInstructionBits(kSimulatorBreakpointInstruction);
+    sim_->break_pc_->SetInstructionBits(Instr::kSimulatorBreakpointInstruction);
   }
 }
 
 
 void SimulatorDebugger::Debug() {
   intptr_t last_pc = -1;
   bool done = false;
 
 #define COMMAND_SIZE 63
 #define ARG_SIZE 255
@@ skipping 126 matching lines @@
           OS::Print("printobject <*reg or *addr>\n");
         }
       } else if (strcmp(cmd, "disasm") == 0) {
         uint32_t start = 0;
         uint32_t end = 0;
         if (args == 1) {
           start = sim_->get_pc();
           end = start + (10 * Instr::kInstrSize);
         } else if (args == 2) {
           if (GetValue(arg1, &start)) {
-            // no length parameter passed, assume 10 instructions
+            // No length parameter passed, assume 10 instructions.
             if (Simulator::IsIllegalAddress(start)) {
-              // If start isn't a valid address, warn and use PC instead
+              // If start isn't a valid address, warn and use PC instead.
               OS::Print("First argument yields invalid address: 0x%x\n", start);
-              OS::Print("Using PC instead");
+              OS::Print("Using PC instead\n");
               start = sim_->get_pc();
             }
             end = start + (10 * Instr::kInstrSize);
           }
         } else {
           uint32_t length;
           if (GetValue(arg1, &start) && GetValue(arg2, &length)) {
             if (Simulator::IsIllegalAddress(start)) {
-              // If start isn't a valid address, warn and use PC instead
+              // If start isn't a valid address, warn and use PC instead.
               OS::Print("First argument yields invalid address: 0x%x\n", start);
               OS::Print("Using PC instead\n");
               start = sim_->get_pc();
             }
             end = start + (length * Instr::kInstrSize);
           }
         }
-
-        Disassembler::Disassemble(start, end);
+        if ((start > 0) && (end > start)) {
+          Disassembler::Disassemble(start, end);
+        } else {
+          OS::Print("disasm [<address> [<number_of_instructions>]]\n");
+        }
       } else if (strcmp(cmd, "gdb") == 0) {
         OS::Print("relinquishing control to gdb\n");
         OS::DebugBreak();
         OS::Print("regaining control from gdb\n");
       } else if (strcmp(cmd, "break") == 0) {
         if (args == 2) {
           uint32_t addr;
           if (GetValue(arg1, &addr)) {
             if (!SetBreakpoint(reinterpret_cast<Instr*>(addr))) {
               OS::Print("setting breakpoint failed\n");
@@ skipping 198 matching lines @@
     Redirection* current;
     for (current = list_; current != NULL; current = current->next_) {
       if (current->address_of_break_instruction() == address_of_break) {
         return current->external_function_;
       }
     }
     return 0;
   }
 
  private:
-  static const int32_t kRedirectInstruction =
-    Instr::kBreakPointInstruction | (Instr::kRedirectCode << kBreakCodeShift);
-
   Redirection(uword external_function,
               Simulator::CallKind call_kind,
               int argument_count)
       : external_function_(external_function),
         call_kind_(call_kind),
         argument_count_(argument_count),
-        break_instruction_(kRedirectInstruction),
+        break_instruction_(Instr::kSimulatorRedirectInstruction),
         next_(list_) {
     list_ = this;
   }
 
   uword external_function_;
   Simulator::CallKind call_kind_;
   int argument_count_;
   uint32_t break_instruction_;
   Redirection* next_;
   static Redirection* list_;
@@ skipping 307 matching lines @@
 
 
 bool Simulator::HasExclusiveAccessAndOpen(uword addr) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ASSERT(addr != 0);
   DEBUG_ASSERT(exclusive_access_lock_->Owner() == isolate);
   bool result = false;
   for (int i = 0; i < kNumAddressTags; i++) {
     if (exclusive_access_state_[i].isolate == isolate) {
-      // Check whether the current isolates address reservation matches.
+      // Check whether the current isolate's address reservation matches.
       if (exclusive_access_state_[i].addr == addr) {
         result = true;
       }
       exclusive_access_state_[i].addr = 0;
     } else if (exclusive_access_state_[i].addr == addr) {
       // Other isolates with matching address lose their reservations.
       exclusive_access_state_[i].addr = 0;
     }
   }
   return result;
@@ skipping 64 matching lines @@
   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::kMsgMessageCode) {
+  } else if (instr->BreakCodeField() == Instr::kSimulatorMessageCode) {
     const char* message = *reinterpret_cast<const char**>(
         reinterpret_cast<intptr_t>(instr) - Instr::kInstrSize);
     if (FLAG_trace_sim) {
       OS::Print("Message: %s\n", message);
     } else {
       OS::PrintErr("Bad break code: 0x%x\n", instr->InstructionBits());
       UnimplementedInstruction(instr);
     }
-  } else if (instr->BreakCodeField() == Instr::kRedirectCode) {
+  } 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 (FLAG_trace_sim) {
         OS::Print("Call to host function at 0x%" Pd "\n", external);
       }
 
@@ skipping 1066 matching lines @@
       if (IsIllegalAddress(pc_)) {
         HandleIllegalAccess(pc_, instr);
       } else {
         InstructionDecode(instr);
       }
     }
   } else {
     // FLAG_stop_sim_at is at the non-default value. Stop in the debugger when
     // we reach the particular instruction count or address.
     while (pc_ != kEndSimulatingPC) {
+      Instr* instr = Instr::At(pc_);
       icount_++;
-      Instr* instr = Instr::At(pc_);
-      if (static_cast<int>(icount_) == FLAG_stop_sim_at) {
+      if (static_cast<intptr_t>(icount_) == FLAG_stop_sim_at) {
         SimulatorDebugger dbg(this);
         dbg.Stop(instr, "Instruction count reached");
-      } else if (reinterpret_cast<int>(instr) == FLAG_stop_sim_at) {
+      } else if (reinterpret_cast<intptr_t>(instr) == FLAG_stop_sim_at) {
         SimulatorDebugger dbg(this);
         dbg.Stop(instr, "Instruction address reached");
+      } else if (IsIllegalAddress(pc_)) {
+        HandleIllegalAccess(pc_, instr);
       } else {
-        if (IsIllegalAddress(pc_)) {
-          HandleIllegalAccess(pc_, instr);
-        } else {
-          InstructionDecode(instr);
-        }
+        InstructionDecode(instr);
       }
     }
   }
 }
 
 
 int64_t Simulator::Call(int32_t entry,
                         int32_t parameter0,
                         int32_t parameter1,
                         int32_t parameter2,
@@ skipping 154 matching lines @@
   set_register(kExceptionObjectReg, bit_cast<int32_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_MIPS)
 
 #endif  // defined TARGET_ARCH_MIPS