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

runtime/vm/simulator_arm.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_ARM)
 
 // Only build the simulator if not compiling for real ARM hardware.
 #if !defined(HOST_ARCH_ARM)
 
 #include "vm/simulator.h"
 
 #include "vm/assembler.h"
 #include "vm/constants_arm.h"
 #include "vm/cpu.h"
 #include "vm/disassembler.h"
 #include "vm/lockers.h"
 #include "vm/native_arguments.h"
 #include "vm/stack_frame.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_sim, false, "Trace simulator execution.");
-DEFINE_FLAG(int, stop_sim_at, 0, "Address to stop simulator at.");
+DEFINE_FLAG(int, stop_sim_at, 0,
+            "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
 
 
-// Unimplemented counter class for debugging and measurement purposes.
-class StatsCounter {
- public:
-  explicit StatsCounter(const char* name) {
-    // UNIMPLEMENTED();
-  }
-
-  void Increment() {
-    // UNIMPLEMENTED();
-  }
-};
-
-
 // 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.
 class SimulatorSetjmpBuffer {
  public:
   int Setjmp() { return setjmp(buffer_); }
   void Longjmp() {
     // "This" is now the last setjmp buffer.
@@ skipping 32 matching lines @@
 
 // The SimulatorDebugger class is used by the simulator while debugging
 // simulated ARM code.
 class SimulatorDebugger {
  public:
   explicit SimulatorDebugger(Simulator* sim);
   ~SimulatorDebugger();
 
   void Stop(Instr* instr, const char* message);
   void Debug();
-
   char* ReadLine(const char* prompt);
 
  private:
-  static const int32_t kSimulatorBreakpointInstr =  // svc #kBreakpointSvcCode
-    ((AL << kConditionShift) | (0xf << 24) | kBreakpointSvcCode);
-  static const int32_t kNopInstr =  // nop
-    ((AL << kConditionShift) | (0x32 << 20) | (0xf << 12));
-
   Simulator* sim_;
 
   bool GetValue(char* desc, uint32_t* value);
   bool GetFValue(char* desc, float* value);
   bool GetDValue(char* desc, double* value);
 
   static intptr_t GetApproximateTokenIndex(const Code& code, uword pc);
 
   static void PrintDartFrame(uword pc, uword fp, uword sp,
                              const Function& function,
@@ skipping 88 matching lines @@
   if (desc[0] == '*') {
     uint32_t addr;
     if (GetValue(desc + 1, &addr)) {
       if (Simulator::IsIllegalAddress(addr)) {
         return false;
       }
       *value = *(reinterpret_cast<uint32_t*>(addr));
       return true;
     }
   }
+  if (strcmp("icount", desc) == 0) {
+    *value = sim_->get_icount();
+    return true;
+  }
   bool retval = SScanF(desc, "0x%x", value) == 1;
   if (!retval) {
     retval = SScanF(desc, "%x", value) == 1;
   }
   return retval;
 }
 
 
 bool SimulatorDebugger::GetFValue(char* desc, float* value) {
   SRegister sreg = LookupSRegisterByName(desc);
@@ skipping 155 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(kSimulatorBreakpointInstr);
+    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 39 matching lines @@
                   "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"
                   "flags -- print flag values\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 value or *addr> -- print integer value\n"
+                  "p/print <reg or icount or value or *addr> -- print integer\n"
                   "ps/printsingle <sreg or *addr> -- print float value\n"
                   "pd/printdouble <dreg or *addr> -- print double 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");
@@ skipping 67 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.
+              OS::Print("First argument yields invalid address: 0x%x\n", start);
+              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.
+              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 16 matching lines @@
         OS::Print("V flag: %d\n", sim_->v_flag_);
         OS::Print("FPSCR: ");
         OS::Print("N flag: %d; ", sim_->fp_n_flag_);
         OS::Print("Z flag: %d; ", sim_->fp_z_flag_);
         OS::Print("C flag: %d; ", sim_->fp_c_flag_);
         OS::Print("V flag: %d\n", sim_->fp_v_flag_);
       } else if (strcmp(cmd, "unstop") == 0) {
         intptr_t stop_pc = sim_->get_pc() - Instr::kInstrSize;
         Instr* stop_instr = reinterpret_cast<Instr*>(stop_pc);
         if (stop_instr->IsSvc() || stop_instr->IsBkpt()) {
-          stop_instr->SetInstructionBits(kNopInstr);
+          stop_instr->SetInstructionBits(Instr::kNopInstruction);
         } else {
           OS::Print("Not at debugger stop.\n");
         }
       } else if (strcmp(cmd, "trace") == 0) {
         FLAG_trace_sim = !FLAG_trace_sim;
         OS::Print("execution tracing %s\n", FLAG_trace_sim ? "on" : "off");
       } else if (strcmp(cmd, "bt") == 0) {
         PrintBacktrace();
       } else {
         OS::Print("Unknown command: %s\n", cmd);
@@ skipping 10 matching lines @@
 #undef ARG_SIZE
 
 #undef STR
 #undef XSTR
 }
 
 
 char* SimulatorDebugger::ReadLine(const char* prompt) {
   char* result = NULL;
   char line_buf[256];
-  int offset = 0;
+  intptr_t offset = 0;
   bool keep_going = true;
   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;
     }
-    int len = strlen(line_buf);
+    intptr_t len = strlen(line_buf);
     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;
     }
     if (result == NULL) {
       // Allocate the initial result and make room for the terminating '\0'
       result = new char[len + 1];
       if (result == NULL) {
         // OOM, so cannot readline anymore.
         return NULL;
       }
     } else {
       // Allocate a new result with enough room for the new addition.
-      int new_len = offset + len + 1;
+      intptr_t new_len = offset + len + 1;
       char* new_result = new char[new_len];
       if (new_result == NULL) {
         // OOM, free the buffer allocated so far and return NULL.
         delete[] result;
         return NULL;
       } else {
         // Copy the existing input into the new array and set the new
         // array as the result.
         memmove(new_result, result, offset);
         delete[] result;
@@ skipping 124 matching lines @@
     Redirection* current;
     for (current = list_; current != NULL; current = current->next_) {
       if (current->address_of_svc_instruction() == address_of_svc) {
         return current->external_function_;
       }
     }
     return 0;
   }
 
  private:
-  static const int32_t kRedirectSvcInstruction =
-    ((AL << kConditionShift) | (0xf << 24) | kRedirectionSvcCode);
   Redirection(uword external_function,
               Simulator::CallKind call_kind,
               int argument_count)
       : external_function_(external_function),
         call_kind_(call_kind),
         argument_count_(argument_count),
-        svc_instruction_(kRedirectSvcInstruction),
+        svc_instruction_(Instr::kSimulatorRedirectInstruction),
         next_(list_) {
     list_ = this;
   }
 
   uword external_function_;
   Simulator::CallKind call_kind_;
   int argument_count_;
   uint32_t svc_instruction_;
   Redirection* next_;
   static Redirection* list_;
@@ skipping 176 matching lines @@
 void Simulator::UnimplementedInstruction(Instr* instr) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer), "Unimplemented instruction: pc=%p\n", instr);
   SimulatorDebugger dbg(this);
   dbg.Stop(instr, buffer);
   FATAL("Cannot continue execution after unimplemented instruction.");
 }
 
 
 intptr_t Simulator::ReadW(uword addr, Instr* instr) {
-  static StatsCounter counter_read_w("Simulated word reads");
-  counter_read_w.Increment();
   if ((addr & 3) == 0) {
     intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
     return *ptr;
   }
   UnalignedAccess("read", addr, instr);
   return 0;
 }
 
 
 void Simulator::WriteW(uword addr, intptr_t value, Instr* instr) {
-  static StatsCounter counter_write_w("Simulated word writes");
-  counter_write_w.Increment();
   if ((addr & 3) == 0) {
     intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
     *ptr = value;
     return;
   }
   UnalignedAccess("write", addr, instr);
 }
 
 
 uint16_t Simulator::ReadHU(uword addr, Instr* instr) {
-  static StatsCounter counter_read_hu("Simulated unsigned halfword reads");
-  counter_read_hu.Increment();
   if ((addr & 1) == 0) {
     uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
     return *ptr;
   }
   UnalignedAccess("unsigned halfword read", addr, instr);
   return 0;
 }
 
 
 int16_t Simulator::ReadH(uword addr, Instr* instr) {
-  static StatsCounter counter_read_h("Simulated signed halfword reads");
-  counter_read_h.Increment();
   if ((addr & 1) == 0) {
     int16_t* ptr = reinterpret_cast<int16_t*>(addr);
     return *ptr;
   }
   UnalignedAccess("signed halfword read", addr, instr);
   return 0;
 }
 
 
 void Simulator::WriteH(uword addr, uint16_t value, Instr* instr) {
-  static StatsCounter counter_write_h("Simulated halfword writes");
-  counter_write_h.Increment();
   if ((addr & 1) == 0) {
     uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
     *ptr = value;
     return;
   }
   UnalignedAccess("halfword write", addr, instr);
 }
 
 
 uint8_t Simulator::ReadBU(uword addr) {
-  static StatsCounter counter_read_bu("Simulated unsigned byte reads");
-  counter_read_bu.Increment();
   uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
   return *ptr;
 }
 
 
 int8_t Simulator::ReadB(uword addr) {
-  static StatsCounter counter_read_b("Simulated signed byte reads");
-  counter_read_b.Increment();
   int8_t* ptr = reinterpret_cast<int8_t*>(addr);
   return *ptr;
 }
 
 
 void Simulator::WriteB(uword addr, uint8_t value) {
-  static StatsCounter counter_write_b("Simulated byte writes");
-  counter_write_b.Increment();
   uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
   *ptr = value;
 }
 
 
 // Synchronization primitives support.
 void Simulator::SetExclusiveAccess(uword addr) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   DEBUG_ASSERT(exclusive_access_lock_->Owner() == isolate);
@@ skipping 540 matching lines @@
       break;
     }
     case kStopMessageSvcCode: {
       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);
       break;
     }
-    case kWordSpillMarkerSvcCode: {
-      static StatsCounter counter_spill_w("Simulated word spills");
-      counter_spill_w.Increment();
-      break;
-    }
-    case kDWordSpillMarkerSvcCode: {
-      static StatsCounter counter_spill_d("Simulated double word spills");
-      counter_spill_d.Increment();
-      break;
-    }
     default: {
       UNREACHABLE();
       break;
     }
   }
 }
 
 
 // Handle execution based on instruction types.
 
@@ skipping 1984 matching lines @@
       }
     }
   }
   if (!pc_modified_) {
     set_register(PC, reinterpret_cast<int32_t>(instr) + Instr::kInstrSize);
   }
 }
 
 
 void Simulator::Execute() {
-  static StatsCounter counter_instructions("Simulated instructions");
-
   // Get the PC to simulate. Cannot use the accessor here as we need the
   // raw PC value and not the one used as input to arithmetic instructions.
   uword program_counter = get_pc();
 
   if (FLAG_stop_sim_at == 0) {
     // Fast version of the dispatch loop without checking whether the simulator
     // should be stopping at a particular executed instruction.
     while (program_counter != kEndSimulatingPC) {
       Instr* instr = reinterpret_cast<Instr*>(program_counter);
       icount_++;
-      counter_instructions.Increment();
       if (IsIllegalAddress(program_counter)) {
         HandleIllegalAccess(program_counter, instr);
       } else {
         InstructionDecode(instr);
       }
       program_counter = get_pc();
     }
   } else {
     // FLAG_stop_sim_at is at the non-default value. Stop in the debugger when
-    // we reach the particular instruction count.
+    // we reach the particular instruction count or address.
     while (program_counter != kEndSimulatingPC) {
       Instr* instr = reinterpret_cast<Instr*>(program_counter);
       icount_++;
-      counter_instructions.Increment();
-      if (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<intptr_t>(instr) == FLAG_stop_sim_at) {
+        SimulatorDebugger dbg(this);
+        dbg.Stop(instr, "Instruction address reached");
       } else if (IsIllegalAddress(program_counter)) {
         HandleIllegalAccess(program_counter, instr);
       } else {
         InstructionDecode(instr);
       }
       program_counter = get_pc();
     }
   }
 }
 
@@ skipping 188 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_ARM)
 
 #endif  // defined TARGET_ARCH_ARM