Fix the debugger in the ARM simulator

src/arm/simulator-arm.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 52 matching lines @@
   void Debug();
 
  private:
   static const instr_t kBreakpointInstr =
       ((AL << 28) | (7 << 25) | (1 << 24) | break_point);
   static const instr_t kNopInstr =
       ((AL << 28) | (13 << 21));
 
   Simulator* sim_;
 
-  bool GetValue(char* desc, int32_t* value);
+  bool GetValue(const char* desc, int32_t* value);
 
   // 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 41 matching lines @@
 
 void Debugger::Stop(Instr* instr) {
   const char* str = (const char*)(instr->InstructionBits() & 0x0fffffff);
   PrintF("Simulator hit %s\n", str);
   sim_->set_pc(sim_->get_pc() + Instr::kInstrSize);
   Debug();
 }
 #endif
 
 
+// The order of these are important, see the handling of the 'print all'
+// debugger command.
 static const char* reg_names[] = {  "r0",  "r1",  "r2",  "r3",
                                     "r4",  "r5",  "r6",  "r7",
                                     "r8",  "r9", "r10", "r11",
                                    "r12", "r13", "r14", "r15",
                                     "pc",  "lr",  "sp",  "ip",
                                     "fp",  "sl", ""};
 
 static int   reg_nums[]  = {           0,     1,     2,     3,
                                        4,     5,     6,     7,
                                        8,     9,    10,    11,
                                       12,    13,    14,    15,
                                       15,    14,    13,    12,
                                       11,    10};
 
 
-static int RegNameToRegNum(char* name) {
+static int RegNameToRegNum(const char* name) {
   int reg = 0;
   while (*reg_names[reg] != 0) {
     if (strcmp(reg_names[reg], name) == 0) {
       return reg_nums[reg];
     }
     reg++;
   }
   return -1;
 }
 
 
-bool Debugger::GetValue(char* desc, int32_t* value) {
+bool Debugger::GetValue(const char* desc, int32_t* value) {
   int regnum = RegNameToRegNum(desc);
   if (regnum >= 0) {
     if (regnum == 15) {
       *value = sim_->get_pc();
     } else {
       *value = sim_->get_register(regnum);
     }
     return true;
   } else {
     return SScanF(desc, "%i", value) == 1;
@@ skipping 90 matching lines @@
       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) {
           int32_t value;
-          if (GetValue(arg1, &value)) {
-            PrintF("%s: %d 0x%x\n", arg1, value, value);
+          if (strcmp(arg1, "all") == 0) {
+            for (int i = 0; i <= 15; i++) {

[iposva, 2009/09/04 05:30:24]

Please use named constants here.

+              if (GetValue(reg_names[i], &value)) {
+                if (i <= 10) {

[iposva, 2009/09/04 05:30:24]

and here.

+                  PrintF("%s: 08x%x %d\n", reg_names[i], value, value);
+                } else {
+                  PrintF("%s: 08x%x %d\n", reg_names[15 + 16 - i], value, value);

[iposva, 2009/09/04 05:30:24]

and here.

Better yet, abstract the register to name mapping from the disassembler into
constants_arm.h and constants_arm.cc and use it here and in the disassembler.

+                }
+              }
+            }
           } else {
-            PrintF("%s unrecognized\n", arg1);
+            if (GetValue(arg1, &value)) {
+              PrintF("%s: 08x%x %d \n", arg1, value, value);
+            } else {
+              PrintF("%s unrecognized\n", arg1);
+            }
           }
         } else {
-          PrintF("print value\n");
+          PrintF("print <register>\n");
         }
       } else if ((strcmp(cmd, "po") == 0)
                  || (strcmp(cmd, "printobject") == 0)) {
         if (args == 2) {
           int32_t value;
           if (GetValue(arg1, &value)) {
             Object* obj = reinterpret_cast<Object*>(value);
             USE(obj);

[iposva, 2009/09/04 05:30:24]

This USE can be dropped now, that obj is used in DEBUG and non-DEBUG builds.

             PrintF("%s: \n", arg1);
-#if defined(DEBUG)
+#ifdef DEBUG
             obj->PrintLn();
-#endif  // defined(DEBUG)
+#else
+            obj->ShortPrint();
+            PrintF("\n");
+#endif
           } else {
             PrintF("%s unrecognized\n", arg1);
           }
         } else {
-          PrintF("printobject value\n");
+          PrintF("printobject <value>\n");
         }
       } else if (strcmp(cmd, "disasm") == 0) {
         disasm::NameConverter converter;
         disasm::Disassembler dasm(converter);
         // use a reasonably large buffer
         v8::internal::EmbeddedVector<char, 256> buffer;
 
         byte* cur = NULL;
         byte* end = NULL;
 
@@ skipping 29 matching lines @@
         if (args == 2) {
           int32_t value;
           if (GetValue(arg1, &value)) {
             if (!SetBreakpoint(reinterpret_cast<Instr*>(value))) {
               PrintF("setting breakpoint failed\n");
             }
           } else {
             PrintF("%s unrecognized\n", arg1);
           }
         } else {
-          PrintF("break addr\n");
+          PrintF("break <address>\n");
         }
       } else if (strcmp(cmd, "del") == 0) {
         if (!DeleteBreakpoint(NULL)) {
           PrintF("deleting breakpoint failed\n");
         }
       } else if (strcmp(cmd, "flags") == 0) {
         PrintF("N flag: %d; ", sim_->n_flag_);
         PrintF("Z flag: %d; ", sim_->z_flag_);
         PrintF("C flag: %d; ", sim_->c_flag_);
         PrintF("V flag: %d\n", sim_->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->ConditionField() == special_condition) {
           stop_instr->SetInstructionBits(kNopInstr);
         } else {
           PrintF("Not at debugger stop.");
         }
+      } else if ((strcmp(cmd, "h") == 0) || (strcmp(cmd, "help") == 0)) {
+        PrintF("print <register>\n");

[Erik Corry, 2009/09/02 14:22:44]

It would be nice to include si/stepi and c/cont as well as the short versions of
all these commands.

[Søren Thygesen Gjesse, 2009/09/02 14:47:19]

Added missing commands and description and alias as well.

+        PrintF("printobject <register>\n");
+        PrintF("flags\n");
+        PrintF("disasm <value>\n");
+        PrintF("gdb\n");
+        PrintF("break <address>\n");
+        PrintF("del\n");
+        PrintF("unstop\n");
       } else {
         PrintF("Unknown command: %s\n", cmd);
       }
     }
     DeleteArray(line);
   }
 
   // Add all the breakpoints back to stop execution and enter the debugger
   // shell when hit.
   RedoBreakpoints();
@@ skipping 1344 matching lines @@
       default: {
         // The PU field is a 2-bit field.
         UNREACHABLE();
         break;
       }
     }
     // Not sign extending, so load as unsigned.
     uint16_t halfword = ReadH(addr, instr);
     set_register(rd, halfword);
   } else {
-    UNIMPLEMENTED();
+    Debugger dbg(this);
+    dbg.Stop(instr);
   }
 }
 
 
 // Executes the current instruction.
 void Simulator::InstructionDecode(Instr* instr) {
   pc_modified_ = false;
   if (::v8::internal::FLAG_trace_sim) {
     disasm::NameConverter converter;
     disasm::Disassembler dasm(converter);
@@ skipping 166 matching lines @@
   CHECK_EQ(entry_stack, get_register(sp));
   set_register(sp, original_stack);
 
   int32_t result = get_register(r0);
   return result;
 }
 
 } }  // namespace assembler::arm
 
 #endif  // !defined(__arm__)