ARM64: Use templates for simulated memory accesses.

src/arm64/simulator-arm64.h

 // Copyright 2013 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.
 
 #ifndef V8_ARM64_SIMULATOR_ARM64_H_
 #define V8_ARM64_SIMULATOR_ARM64_H_
 
 #include <stdarg.h>
 #include <vector>
 
@@ skipping 464 matching lines @@
   // for the 'next' command.
   void CheckBreakNext();
 
   // Disassemble instruction at the given address.
   void PrintInstructionsAt(Instruction* pc, uint64_t count);
 
   void PrintSystemRegisters(bool print_all = false);
   void PrintRegisters(bool print_all_regs = false);
   void PrintFPRegisters(bool print_all_regs = false);
   void PrintProcessorState();
-  void PrintWrite(uint8_t* address, uint64_t value, unsigned num_bytes);
+  void PrintWrite(uintptr_t address, uint64_t value, unsigned num_bytes);
   void LogSystemRegisters() {
     if (log_parameters_ & LOG_SYS_REGS) PrintSystemRegisters();
   }
   void LogRegisters() {
     if (log_parameters_ & LOG_REGS) PrintRegisters();
   }
   void LogFPRegisters() {
     if (log_parameters_ & LOG_FP_REGS) PrintFPRegisters();
   }
   void LogProcessorState() {
     LogSystemRegisters();
     LogRegisters();
     LogFPRegisters();
   }
-  void LogWrite(uint8_t* address, uint64_t value, unsigned num_bytes) {
-    if (log_parameters_ & LOG_WRITE) PrintWrite(address, value, num_bytes);
+  template <typename T>
+  void LogWrite(uintptr_t address, T value) {
+    uint64_t raw_value = 0;
+    DCHECK(sizeof(value) <= sizeof(raw_value));
+    if (log_parameters_ & LOG_WRITE) {
+      memcpy(&raw_value, &value, sizeof(value));
+      PrintWrite(address, raw_value, sizeof(value));
+    }
   }
 
   int log_parameters() { return log_parameters_; }
   void set_log_parameters(int new_parameters) {
     log_parameters_ = new_parameters;
     if (!decoder_) {
       if (new_parameters & LOG_DISASM) {
         PrintF("Run --debug-sim to dynamically turn on disassembler\n");
       }
       return;
@@ skipping 78 matching lines @@
                        AddrMode addrmode);
   void LoadStorePairHelper(Instruction* instr, AddrMode addrmode);
   uint8_t* LoadStoreAddress(unsigned addr_reg,
                             int64_t offset,
                             AddrMode addrmode);
   void LoadStoreWriteBack(unsigned addr_reg,
                           int64_t offset,
                           AddrMode addrmode);
   void CheckMemoryAccess(uint8_t* address, uint8_t* stack);
 
-  uint64_t MemoryRead(uint8_t* address, unsigned num_bytes);
-  uint8_t MemoryRead8(uint8_t* address);
-  uint16_t MemoryRead16(uint8_t* address);
-  uint32_t MemoryRead32(uint8_t* address);
-  float MemoryReadFP32(uint8_t* address);
-  uint64_t MemoryRead64(uint8_t* address);
-  double MemoryReadFP64(uint8_t* address);
+  template <typename T, typename A>
+  T MemoryRead(A address) {
+    T value;
+    STATIC_ASSERT((sizeof(value) == 1) || (sizeof(value) == 2) ||
+                  (sizeof(value) == 4) || (sizeof(value) == 8));
+    memcpy(&value, reinterpret_cast<const void*>(address), sizeof(value));
+    return value;
+  }
 
-  void MemoryWrite(uint8_t* address, uint64_t value, unsigned num_bytes);
-  void MemoryWrite32(uint8_t* address, uint32_t value);
-  void MemoryWriteFP32(uint8_t* address, float value);
-  void MemoryWrite64(uint8_t* address, uint64_t value);
-  void MemoryWriteFP64(uint8_t* address, double value);
-
+  template <typename T, typename A>
+  void MemoryWrite(A address, T value) {
+    STATIC_ASSERT((sizeof(value) == 1) || (sizeof(value) == 2) ||
+                  (sizeof(value) == 4) || (sizeof(value) == 8));
+    LogWrite(reinterpret_cast<uintptr_t>(address), value);
+    memcpy(reinterpret_cast<void*>(address), &value, sizeof(value));
+  }
 
   template <typename T>
   T ShiftOperand(T value,
                  Shift shift_type,
                  unsigned amount);
   template <typename T>
   T ExtendValue(T value,
                 Extend extend_type,
                 unsigned left_shift = 0);
   template <typename T>
@@ skipping 205 matching lines @@
   static void UnregisterCTryCatch() {
     Simulator::current(Isolate::Current())->PopAddress();
   }
 };
 
 #endif  // !defined(USE_SIMULATOR)
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_SIMULATOR_ARM64_H_