As a first step towards implementing thumb2, add code for...

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 403 matching lines @@
 
 
 Simulator::Simulator() {
   Initialize();
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   size_t stack_size = 1 * 1024*1024;  // allocate 1MB for stack
   stack_ = reinterpret_cast<char*>(malloc(stack_size));
   pc_modified_ = false;
   icount_ = 0;
+  thumb_mode_ = false;
   break_pc_ = NULL;
   break_instr_ = 0;
 
   // Setup architecture state.
   // All registers are initialized to zero to start with.
   for (int i = 0; i < num_registers; i++) {
     registers_[i] = 0;
   }
   n_flag_ = false;
   z_flag_ = false;
@@ skipping 1633 matching lines @@
   pc_modified_ = false;
   if (::v8::internal::FLAG_trace_sim) {
     disasm::NameConverter converter;
     disasm::Disassembler dasm(converter);
     // use a reasonably large buffer
     v8::internal::EmbeddedVector<char, 256> buffer;
     dasm.InstructionDecode(buffer,
                            reinterpret_cast<byte*>(instr));
     PrintF("  0x%08x  %s\n", instr, buffer.start());
   }
+  // Temporary special-casing of our particular ARM/THUMB switch

[Erik Corry, 2009/12/17 14:05:50]

I think this can be moved to where it fits (in the sub instruction somewhere).

+  if ((unsigned)instr->InstructionBits() == 0xe24ff003) {
+    thumb_mode_ = true;
+    set_register(pc, reinterpret_cast<int32_t>(instr) + Instr::kInstrSize);
+    return;
+  }
   if (instr->ConditionField() == special_condition) {
     DecodeUnconditional(instr);
   } else if (ConditionallyExecute(instr)) {
     switch (instr->TypeField()) {
       case 0:
       case 1: {
         DecodeType01(instr);
         break;
       }
       case 2: {
@@ skipping 24 matching lines @@
         UNIMPLEMENTED();
         break;
       }
     }
   }
   if (!pc_modified_) {
     set_register(pc, reinterpret_cast<int32_t>(instr) + Instr::kInstrSize);
   }
 }
 
+void Simulator::InstructionDecode(ThumbInstr* instr) {
+  // For now, assume all thumb instructions are an aligned switch back to ARM

[Erik Corry, 2009/12/17 14:05:50]

Please assert this is true.

+  set_register(pc, reinterpret_cast<int32_t>(instr) + Instr::kInstrSize);
+  thumb_mode_ = false;
+}
 
 void Simulator::Execute() {
   // 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.
   int program_counter = get_pc();
 
   if (::v8::internal::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 != end_sim_pc) {
-      Instr* instr = reinterpret_cast<Instr*>(program_counter);
+      if (thumb_mode_) {
+        ThumbInstr* instr = reinterpret_cast<ThumbInstr*>(program_counter);
+        InstructionDecode(instr);
+      } else {
+        Instr* instr = reinterpret_cast<Instr*>(program_counter);
+        InstructionDecode(instr);
+      }
       icount_++;
-      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 instuction count.
     while (program_counter != end_sim_pc) {
       Instr* instr = reinterpret_cast<Instr*>(program_counter);
       icount_++;
       if (icount_ == ::v8::internal::FLAG_stop_sim_at) {
         Debugger dbg(this);
@@ skipping 111 matching lines @@
   uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(current_sp);
   uintptr_t address = *stack_slot;
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 
 } }  // namespace assembler::arm
 
 #endif  // !defined(__arm__)