MIPS: Optimize simulator.

src/mips/simulator-mips.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // Declares a Simulator for MIPS instructions if we are not generating a native
 // MIPS binary. This Simulator allows us to run and debug MIPS code generation
 // on regular desktop machines.
 // V8 calls into generated code by "calling" the CALL_GENERATED_CODE macro,
 // which will start execution in the Simulator or forwards to the real entry
@@ skipping 275 matching lines @@
   // Get Double Higher / Lower word.
   inline int32_t GetDoubleHIW(double* addr);
   inline int32_t GetDoubleLOW(double* addr);
   // Set Double Higher / Lower word.
   inline int32_t SetDoubleHIW(double* addr);
   inline int32_t SetDoubleLOW(double* addr);
 
   // Executing is handled based on the instruction type.
   void DecodeTypeRegister(Instruction* instr);
 
-  // Called from DecodeTypeRegisterCOP1
-  void DecodeTypeRegisterDRsType(Instruction* instr, const int32_t& fr_reg,
-                                 const int32_t& fs_reg, const int32_t& ft_reg,
-                                 const int32_t& fd_reg);
-  void DecodeTypeRegisterWRsType(Instruction* instr, int32_t& alu_out,
-                                 const int32_t& fd_reg, const int32_t& fs_reg,
-                                 const int32_t& ft_reg);
-  void DecodeTypeRegisterSRsType(Instruction* instr, const int32_t& ft_reg,
-                                 const int32_t& fs_reg, const int32_t& fd_reg);
-  void DecodeTypeRegisterLRsType(Instruction* instr, const int32_t& ft_reg,
-                                 const int32_t& fs_reg, const int32_t& fd_reg);
+  // Functions called from DecodeTypeRegister.
+  void DecodeTypeRegisterCOP1();
 
-  // Functions called from DeocodeTypeRegister
-  void DecodeTypeRegisterCOP1(
-      Instruction* instr, const int32_t& rs_reg, const int32_t& rs,
-      const uint32_t& rs_u, const int32_t& rt_reg, const int32_t& rt,
-      const uint32_t& rt_u, const int32_t& rd_reg, const int32_t& fr_reg,
-      const int32_t& fs_reg, const int32_t& ft_reg, const int32_t& fd_reg,
-      int64_t& i64hilo, uint64_t& u64hilo, int32_t& alu_out, bool& do_interrupt,
-      int32_t& current_pc, int32_t& next_pc, int32_t& return_addr_reg);
+  void DecodeTypeRegisterCOP1X();
 
+  void DecodeTypeRegisterSPECIAL();
 
-  void DecodeTypeRegisterCOP1X(Instruction* instr, const int32_t& fr_reg,
-                               const int32_t& fs_reg, const int32_t& ft_reg,
-                               const int32_t& fd_reg);
+  void DecodeTypeRegisterSPECIAL2();
 
+  void DecodeTypeRegisterSPECIAL3();
 
-  void DecodeTypeRegisterSPECIAL(
-      Instruction* instr, const int32_t& rs_reg, const int32_t& rs,
-      const uint32_t& rs_u, const int32_t& rt_reg, const int32_t& rt,
-      const uint32_t& rt_u, const int32_t& rd_reg, const int32_t& fr_reg,
-      const int32_t& fs_reg, const int32_t& ft_reg, const int32_t& fd_reg,
-      int64_t& i64hilo, uint64_t& u64hilo, int32_t& alu_out, bool& do_interrupt,
-      int32_t& current_pc, int32_t& next_pc, int32_t& return_addr_reg);
+  // Called from DecodeTypeRegisterCOP1.
+  void DecodeTypeRegisterSRsType();
 
+  void DecodeTypeRegisterDRsType();
 
-  void DecodeTypeRegisterSPECIAL2(Instruction* instr, const int32_t& rd_reg,
-                                  int32_t& alu_out);
+  void DecodeTypeRegisterWRsType();
 
-  void DecodeTypeRegisterSPECIAL3(Instruction* instr, const int32_t& rt_reg,
-                                  const int32_t& rd_reg, int32_t& alu_out);
+  void DecodeTypeRegisterLRsType();
 
-  // Helper function for DecodeTypeRegister.
-  void ConfigureTypeRegister(Instruction* instr,
-                             int32_t* alu_out,
-                             int64_t* i64hilo,
-                             uint64_t* u64hilo,
-                             int32_t* next_pc,
-                             int32_t* return_addr_reg,
-                             bool* do_interrupt);
+  Instruction* currentInstr_;
+  inline Instruction* get_instr() const { return currentInstr_; }
+  inline void set_instr(Instruction* instr) { currentInstr_ = instr; }
+
+  inline int32_t rs_reg() const { return currentInstr_->RsValue(); }
+  inline int32_t rs() const { return get_register(rs_reg()); }
+  inline uint32_t rs_u() const {
+    return static_cast<uint32_t>(get_register(rs_reg()));
+  }
+  inline int32_t rt_reg() const { return currentInstr_->RtValue(); }
+  inline int32_t rt() const { return get_register(rt_reg()); }
+  inline uint32_t rt_u() const {
+    return static_cast<uint32_t>(get_register(rt_reg()));
+  }
+  inline int32_t rd_reg() const { return currentInstr_->RdValue(); }
+  inline int32_t fr_reg() const { return currentInstr_->FrValue(); }
+  inline int32_t fs_reg() const { return currentInstr_->FsValue(); }
+  inline int32_t ft_reg() const { return currentInstr_->FtValue(); }
+  inline int32_t fd_reg() const { return currentInstr_->FdValue(); }
+  inline int32_t sa() const { return currentInstr_->SaValue(); }
+
+  inline void SetResult(int32_t rd_reg, int32_t alu_out) {
+    set_register(rd_reg, alu_out);
+    TraceRegWr(alu_out);
+  }
 
   void DecodeTypeImmediate(Instruction* instr);
   void DecodeTypeJump(Instruction* instr);
 
   // Used for breakpoints and traps.
   void SoftwareInterrupt(Instruction* instr);
 
   // Stop helper functions.
   bool IsWatchpoint(uint32_t code);
   void PrintWatchpoint(uint32_t code);
@@ skipping 31 matching lines @@
                            int size);
   static CachePage* GetCachePage(v8::internal::HashMap* i_cache, void* page);
 
   enum Exception {
     none,
     kIntegerOverflow,
     kIntegerUnderflow,
     kDivideByZero,
     kNumExceptions
   };
-  int16_t exceptions[kNumExceptions];
 
   // Exceptions.
-  void SignalExceptions();
+  void SignalException(Exception e);
 
   // Runtime call support.
   static void* RedirectExternalReference(void* external_function,
                                          ExternalReference::Type type);
 
   // Handle arguments and return value for runtime FP functions.
   void GetFpArgs(double* x, double* y, int32_t* z);
   void SetFpResult(const double& result);
 
   void CallInternal(byte* entry);
 
   // Architecture state.
   // Registers.
   int32_t registers_[kNumSimuRegisters];
   // Coprocessor Registers.
   // Note: FP32 mode uses only the lower 32-bit part of each element,
   // the upper 32-bit is unpredictable.
   int64_t FPUregisters_[kNumFPURegisters];
   // FPU control register.
   uint32_t FCSR_;
 
   // Simulator support.
   // Allocate 1MB for stack.
   static const size_t stack_size_ = 1 * 1024*1024;
   char* stack_;
   bool pc_modified_;
-  int icount_;
+  uint64_t icount_;
   int break_count_;
 
   // Debugger input.
   char* last_debugger_input_;
 
   // Icache simulation.
   v8::internal::HashMap* i_cache_;
 
   v8::internal::Isolate* isolate_;
 
@@ skipping 45 matching lines @@
 
   static inline void UnregisterCTryCatch() {
     Simulator::current(Isolate::Current())->PopAddress();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // !defined(USE_SIMULATOR)
 #endif  // V8_MIPS_SIMULATOR_MIPS_H_