Vortex 2.0 changes:

+ Microarchitecture optimizations
+ 64-bit support
+ Xilinx FPGA support
+ LLVM-16 support
+ Refactoring and quality control fixes

sim/common/mem.h

@@ -1,3 +1,16 @@
+// Copyright © 2019-2023
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
 
 #include <cstdint>
@@ -7,13 +20,14 @@
 
 namespace vortex {
 struct BadAddress {};
+struct OutOfRange {};
 
 class MemDevice {
 public:
   virtual ~MemDevice() {}
   virtual uint64_t size() const = 0;
-  virtual void read(void *data, uint64_t addr, uint64_t size) = 0;
-  virtual void write(const void *data, uint64_t addr, uint64_t size) = 0;
+  virtual void read(void* data, uint64_t addr, uint64_t size) = 0;
+  virtual void write(const void* data, uint64_t addr, uint64_t size) = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -21,11 +35,11 @@ public:
 class RamMemDevice : public MemDevice {
 public:
   RamMemDevice(uint64_t size, uint32_t wordSize);
-  RamMemDevice(const char *filename, uint32_t wordSize);
+  RamMemDevice(const char* filename, uint32_t wordSize);
   ~RamMemDevice() {}
 
-  void read(void *data, uint64_t addr, uint64_t size) override;  
-  void write(const void *data, uint64_t addr, uint64_t size) override;
+  void read(void* data, uint64_t addr, uint64_t size) override;  
+  void write(const void* data, uint64_t addr, uint64_t size) override;
 
   virtual uint64_t size() const {
     return contents_.size();
@@ -50,7 +64,7 @@ public:
   
   ~RomMemDevice();
 
-  void write(const void *data, uint64_t addr, uint64_t size) override;
+  void write(const void* data, uint64_t addr, uint64_t size) override;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -63,47 +77,56 @@ public:
       : faultAddr(a)
       , notFound(nf) 
     {}
-    uint64_t faultAddr;
-    bool notFound;
+    uint64_t  faultAddr;
+    bool      notFound;
   };
 
-  MemoryUnit(uint64_t pageSize, uint64_t addrBytes, bool disableVm = false);
+  MemoryUnit(uint64_t pageSize = 0);
 
   void attach(MemDevice &m, uint64_t start, uint64_t end);
 
-  void read(void *data, uint64_t addr, uint64_t size, bool sup);  
-  void write(const void *data, uint64_t addr, uint64_t size, bool sup);
+  void read(void* data, uint64_t addr, uint64_t size, bool sup);
+  void write(const void* data, uint64_t addr, uint64_t size, bool sup);
+
+  void amo_reserve(uint64_t addr);
+  bool amo_check(uint64_t addr);
 
   void tlbAdd(uint64_t virt, uint64_t phys, uint32_t flags);
-  void tlbRm(uint64_t va);
+  void tlbRm(uint64_t vaddr);
   void tlbFlush() {
     tlb_.clear();
   }
+
 private:
 
+  struct amo_reservation_t {
+    uint64_t addr;
+    bool     valid;
+  };
+
   class ADecoder {
   public:
     ADecoder() {}
     
-    void read(void *data, uint64_t addr, uint64_t size);
-    void write(const void *data, uint64_t addr, uint64_t size);
+    void read(void* data, uint64_t addr, uint64_t size);
+    void write(const void* data, uint64_t addr, uint64_t size);
     
     void map(uint64_t start, uint64_t end, MemDevice &md);
 
   private:
 
     struct mem_accessor_t {
-      MemDevice* md;
-      uint64_t addr;
+      MemDevice*  md;
+      uint64_t    addr;
     };
     
     struct entry_t {
-      MemDevice *md;
-      uint64_t      start;
-      uint64_t      end;        
+      MemDevice*  md;
+      uint64_t    start;
+      uint64_t    end;        
     };
 
-    bool lookup(uint64_t a, uint32_t wordSize, mem_accessor_t*);
+    bool lookup(uint64_t addr, uint32_t wordSize, mem_accessor_t*);
 
     std::vector<entry_t> entries_;
   };
@@ -120,11 +143,14 @@ private:
 
   TLBEntry tlbLookup(uint64_t vAddr, uint32_t flagMask);
 
+  uint64_t toPhyAddr(uint64_t vAddr, uint32_t flagMask);
+
   std::unordered_map<uint64_t, TLBEntry> tlb_;
-  uint64_t pageSize_;
-  uint64_t addrBytes_;
-  ADecoder decoder_;  
-  bool disableVM_;
+  uint64_t  pageSize_;
+  ADecoder  decoder_;  
+  bool      enableVM_;
+
+  amo_reservation_t amo_reservation_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -132,15 +158,15 @@ private:
 class RAM : public MemDevice {
 public:
   
-  RAM(uint32_t page_size);
+   RAM(uint32_t page_size, uint64_t capacity = 0);
   ~RAM();
 
   void clear();
 
   uint64_t size() const override;
 
-  void read(void *data, uint64_t addr, uint64_t size) override;  
-  void write(const void *data, uint64_t addr, uint64_t size) override;
+  void read(void* data, uint64_t addr, uint64_t size) override;  
+  void write(const void* data, uint64_t addr, uint64_t size) override;
 
   void loadBinImage(const char* filename, uint64_t destination);
   void loadHexImage(const char* filename);
@@ -157,11 +183,11 @@ private:
 
   uint8_t *get(uint64_t address) const;
 
-  uint64_t size_;
+  uint64_t capacity_;
   uint32_t page_bits_;  
   mutable std::unordered_map<uint64_t, uint8_t*> pages_;
   mutable uint8_t* last_page_;
   mutable uint64_t last_page_index_;
 };
 
-} // namespace vortex
+} // namespace vortex