Refactor the register to name mapping 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_;
 
+  int32_t GetRegsiterValue(int regnum);

[iposva, 2009/09/08 21:59:57]

GetRegisterValue

[Søren Thygesen Gjesse, 2009/09/09 07:01:12]

Done.

   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 42 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(const char* name) {
-  int reg = 0;
-  while (*reg_names[reg] != 0) {
-    if (strcmp(reg_names[reg], name) == 0) {
-      return reg_nums[reg];
-    }
-    reg++;
+int32_t Debugger::GetRegsiterValue(int regnum) {
+  if (regnum == kPCRegister) {
+    return sim_->get_pc();
+  } else {
+    return sim_->get_register(regnum);
   }
-  return -1;
 }
 
 
 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);
-    }
+  int regnum = Registers::Number(desc);
+  if (regnum != kNoRegister) {
+    *value = GetRegsiterValue(regnum);
     return true;
   } else {
     return SScanF(desc, "%i", value) == 1;
   }
   return false;
 }
 
 
 bool Debugger::SetBreakpoint(Instr* breakpc) {
   // Check if a breakpoint can be set. If not return without any side-effects.
@@ skipping 84 matching lines @@
         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 (strcmp(arg1, "all") == 0) {
-            for (int i = 0; i <= 15; i++) {
-              if (GetValue(reg_names[i], &value)) {
-                if (i <= 10) {
-                  PrintF("%3s: 0x%08x %d\n", reg_names[i], value, value);
-                } else {
-                  PrintF("%3s: 0x%08x %d\n",
-                         reg_names[15 + 16 - i],
-                         value,
-                         value);
-                }
-              }
+            for (int i = 0; i < kNumRegisters; i++) {
+              value = GetRegsiterValue(i);
+              PrintF("%3s: 0x%08x %10d\n", Registers::Name(i), value, value);
             }
           } else {
             if (GetValue(arg1, &value)) {
               PrintF("%s: 0x%08x %d \n", arg1, value, value);
             } else {
               PrintF("%s unrecognized\n", arg1);
             }
           }
         } else {
           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);
             PrintF("%s: \n", arg1);
 #ifdef DEBUG
             obj->PrintLn();
 #else
             obj->ShortPrint();
             PrintF("\n");
 #endif
           } else {
             PrintF("%s unrecognized\n", arg1);
           }
@@ skipping 1636 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__)