A64: Make the Decoder a template

src/a64/simulator-a64.cc

 // Copyright 2013 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 16 matching lines @@
 
 #include <stdlib.h>
 #include <cmath>
 #include <cstdarg>
 #include "v8.h"
 
 #if V8_TARGET_ARCH_A64
 
 #include "disasm.h"
 #include "assembler.h"
+#include "a64/decoder-a64-inl.h"
 #include "a64/simulator-a64.h"
 #include "macro-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 #if defined(USE_SIMULATOR)
 
 
 // This macro provides a platform independent use of sscanf. The reason for
@@ skipping 51 matching lines @@
 
 // Get the active Simulator for the current thread.
 Simulator* Simulator::current(Isolate* isolate) {
   Isolate::PerIsolateThreadData* isolate_data =
       isolate->FindOrAllocatePerThreadDataForThisThread();
   ASSERT(isolate_data != NULL);
 
   Simulator* sim = isolate_data->simulator();
   if (sim == NULL) {
     // TODO(146): delete the simulator object when a thread/isolate goes away.
-    sim = new Simulator(new Decoder(), isolate);
+    sim = new Simulator(new Decoder<DispatchingDecoderVisitor>(), isolate);
     isolate_data->set_simulator(sim);
   }
   return sim;
 }
 
 
 void Simulator::CallVoid(byte* entry, CallArgument* args) {
   int index_x = 0;
   int index_d = 0;
 
@@ skipping 207 matching lines @@
   // pushing values.
   // TODO(all): Increase the stack limit protection.
 
   // The margin was decreased to 256 bytes, because we are intensively using
   // the stack. The stack usage should decrease when our code improves. Then
   // we can set it to 1024 again.
   return reinterpret_cast<uintptr_t>(stack_limit_) + 256;
 }
 
 
-Simulator::Simulator(Decoder* decoder, Isolate* isolate, FILE* stream)
-    : decoder_(decoder), last_debugger_input_(NULL), log_parameters_(NO_PARAM),
+Simulator::Simulator(Decoder<DispatchingDecoderVisitor>* decoder,
+                     Isolate* isolate, FILE* stream)
+    : decoder_(decoder),
+      last_debugger_input_(NULL),
+      log_parameters_(NO_PARAM),
       isolate_(isolate) {
   // Setup the decoder.
   decoder_->AppendVisitor(this);
 
   ResetState();
 
   // Allocate and setup the simulator stack.
   stack_size_ = (FLAG_sim_stack_size * KB) + (2 * stack_protection_size_);
   stack_ = new byte[stack_size_];
   stack_limit_ = stack_ + stack_protection_size_;
   byte* tos = stack_ + stack_size_ - stack_protection_size_;
   // The stack pointer must be 16 bytes aligned.
   set_sp(reinterpret_cast<int64_t>(tos) & ~0xfUL);
 
   stream_ = stream;
   print_disasm_ = new PrintDisassembler(stream_);
 
   if (FLAG_trace_sim) {
     decoder_->InsertVisitorBefore(print_disasm_, this);
     log_parameters_ = LOG_ALL;
   }
 
   // The debugger needs to disassemble code without the simulator executing an
   // instruction, so we create a dedicated decoder.
-  disassembler_decoder_ = new Decoder();
+  disassembler_decoder_ = new Decoder<DispatchingDecoderVisitor>();
   disassembler_decoder_->AppendVisitor(print_disasm_);
 
   if (FLAG_log_instruction_stats) {
     instrument_ = new Instrument(FLAG_log_instruction_file,
                                  FLAG_log_instruction_period);
     decoder_->AppendVisitor(instrument_);
   }
 }
 
 
@@ skipping 3032 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64