Shrinking alloy memory interface so that alloy-sandbox doesn't need xe.

src/alloy/backend/ivm/ivm_intcode.cc

@@ -1499,7 +1499,9 @@ int Translate_LOAD(TranslationContext& ctx, Instr* i) {
 
 void MarkPageDirty(IntCodeState& ics, uint32_t address) {
   // 16KB pages.
-  ics.page_table[(address >> 14) & 0x7FFF] = 1;
+  if (ics.page_table) {
+    ics.page_table[(address >> 14) & 0x7FFF] = 1;
+  }
 }
 uint32_t IntCode_STORE_I8(IntCodeState& ics, const IntCode* i) {
   uint32_t address = ics.rf[i->src1_reg].u32;

src/alloy/backend/x64/x64_sequences.cc

@@ -1557,9 +1557,12 @@ EMITTER_OPCODE_TABLE(
 // Note: most *should* be aligned, but needs to be checked!
 void EmitMarkPageDirty(X64Emitter& e, RegExp& addr) {
   // 16KB pages.
-  e.shr(e.eax, 14);
-  e.and(e.eax, 0x7FFF);
-  e.mov(e.byte[e.rdx + e.rax + e.page_table_address()], 1);
+  auto page_table_address = e.page_table_address();
+  if (page_table_address) {
+    e.shr(e.eax, 14);
+    e.and(e.eax, 0x7FFF);
+    e.mov(e.byte[e.rdx + e.rax + page_table_address], 1);
+  }
 }
 EMITTER(STORE_I8, MATCH(I<OPCODE_STORE, VoidOp, I64<>, I8<>>)) {
   static void Emit(X64Emitter& e, const EmitArgType& i) {

src/alloy/frontend/ppc/ppc_context.h

@@ -172,7 +172,7 @@ typedef struct alignas(64) PPCContext_s {
   uint32_t thread_id;
 
   // Reserve address for load acquire/store release. Shared.
-  uint32_t* reserve_address;
+  uint64_t* reserve_address;
 
   // Runtime-specific data pointer. Used on callbacks to get access to the
   // current runtime and its data.

src/alloy/memory.cc

@@ -61,4 +61,43 @@ uint64_t Memory::SearchAligned(uint64_t start, uint64_t end,
   return 0;
 }
 
+SimpleMemory::SimpleMemory(size_t capacity) : memory_(capacity) {
+  membase_ = reinterpret_cast<uint8_t*>(memory_.data());
+  reserve_address_ = capacity - 8;
+}
+
+SimpleMemory::~SimpleMemory() = default;
+
+uint8_t SimpleMemory::LoadI8(uint64_t address) {
+  return poly::load<uint8_t>(membase_ + address);
+}
+
+uint16_t SimpleMemory::LoadI16(uint64_t address) {
+  return poly::load<uint16_t>(membase_ + address);
+}
+
+uint32_t SimpleMemory::LoadI32(uint64_t address) {
+  return poly::load<uint32_t>(membase_ + address);
+}
+
+uint64_t SimpleMemory::LoadI64(uint64_t address) {
+  return poly::load<uint64_t>(membase_ + address);
+}
+
+void SimpleMemory::StoreI8(uint64_t address, uint8_t value) {
+  poly::store<uint8_t>(membase_ + address, value);
+}
+
+void SimpleMemory::StoreI16(uint64_t address, uint16_t value) {
+  poly::store<uint16_t>(membase_ + address, value);
+}
+
+void SimpleMemory::StoreI32(uint64_t address, uint32_t value) {
+  poly::store<uint32_t>(membase_ + address, value);
+}
+
+void SimpleMemory::StoreI64(uint64_t address, uint64_t value) {
+  poly::store<uint64_t>(membase_ + address, value);
+}
+
 }  // namespace alloy

src/alloy/memory.h

@@ -14,23 +14,6 @@
 
 namespace alloy {
 
-enum {
-  MEMORY_FLAG_64KB_PAGES = (1 << 1),
-  MEMORY_FLAG_ZERO = (1 << 2),
-  MEMORY_FLAG_PHYSICAL = (1 << 3),
-};
-
-// Equivalent to the Win32 MEMORY_BASIC_INFORMATION struct.
-struct AllocationInfo {
-  uint64_t base_address;
-  uint64_t allocation_base;
-  uint32_t allocation_protect;  // TBD
-  size_t region_size;
-  uint32_t state;    // TBD
-  uint32_t protect;  // TBD
-  uint32_t type;     // TBD
-};
-
 class Memory {
  public:
   Memory();
@@ -40,8 +23,9 @@ class Memory {
   inline uint8_t* Translate(uint64_t guest_address) const {
     return membase_ + guest_address;
   };
-  inline uint32_t* reserve_address() { return &reserve_address_; }
+  inline uint64_t* reserve_address() { return &reserve_address_; }
 
+  // TODO(benvanik): remove with GPU refactor.
   virtual uint64_t page_table() const = 0;
 
   uint64_t trace_base() const { return trace_base_; }
@@ -49,6 +33,7 @@ class Memory {
 
   virtual int Initialize();
 
+  // TODO(benvanik): make poly memory utils for these.
   void Zero(uint64_t address, size_t size);
   void Fill(uint64_t address, size_t size, uint8_t value);
   void Copy(uint64_t dest, uint64_t src, size_t size);
@@ -56,6 +41,7 @@ class Memory {
   uint64_t SearchAligned(uint64_t start, uint64_t end, const uint32_t* values,
                          size_t value_count);
 
+  // TODO(benvanik): remove with IVM.
   virtual uint8_t LoadI8(uint64_t address) = 0;
   virtual uint16_t LoadI16(uint64_t address) = 0;
   virtual uint32_t LoadI32(uint64_t address) = 0;
@@ -65,24 +51,34 @@ class Memory {
   virtual void StoreI32(uint64_t address, uint32_t value) = 0;
   virtual void StoreI64(uint64_t address, uint64_t value) = 0;
 
-  virtual uint64_t HeapAlloc(uint64_t base_address, size_t size, uint32_t flags,
-                             uint32_t alignment = 0x20) = 0;
-  virtual int HeapFree(uint64_t address, size_t size) = 0;
-
-  virtual bool QueryInformation(uint64_t base_address,
-                                AllocationInfo* mem_info) = 0;
-  virtual size_t QuerySize(uint64_t base_address) = 0;
-
-  virtual int Protect(uint64_t address, size_t size, uint32_t access) = 0;
-  virtual uint32_t QueryProtect(uint64_t address) = 0;
-
  protected:
   size_t system_page_size_;
   uint8_t* membase_;
-  uint32_t reserve_address_;
+  uint64_t reserve_address_;
   uint64_t trace_base_;
 };
 
+class SimpleMemory : public Memory {
+ public:
+  SimpleMemory(size_t capacity);
+  ~SimpleMemory() override;
+
+  uint64_t page_table() const override { return 0; }
+
+  // TODO(benvanik): remove with IVM.
+  uint8_t LoadI8(uint64_t address) override;
+  uint16_t LoadI16(uint64_t address) override;
+  uint32_t LoadI32(uint64_t address) override;
+  uint64_t LoadI64(uint64_t address) override;
+  void StoreI8(uint64_t address, uint8_t value) override;
+  void StoreI16(uint64_t address, uint16_t value) override;
+  void StoreI32(uint64_t address, uint32_t value) override;
+  void StoreI64(uint64_t address, uint64_t value) override;
+
+ private:
+  std::vector<uint8_t> memory_;
+};
+
 }  // namespace alloy
 
 #endif  // ALLOY_MEMORY_H_

src/alloy/runtime/raw_module.cc

@@ -15,11 +15,7 @@ namespace runtime {
 RawModule::RawModule(Runtime* runtime)
     : Module(runtime), base_address_(0), low_address_(0), high_address_(0) {}
 
-RawModule::~RawModule() {
-  if (base_address_) {
-    memory_->HeapFree(base_address_, high_address_ - low_address_);
-  }
-}
+RawModule::~RawModule() {}
 
 int RawModule::LoadFile(uint64_t base_address, const std::string& path) {
   FILE* file = fopen(path.c_str(), "rb");
@@ -28,15 +24,12 @@ int RawModule::LoadFile(uint64_t base_address, const std::string& path) {
   fseek(file, 0, SEEK_SET);
 
   // Allocate memory.
-  base_address_ =
-      memory_->HeapAlloc(base_address, file_length, MEMORY_FLAG_ZERO);
-  if (!base_address_) {
-    fclose(file);
-    return 1;
-  }
+  // Since we have no real heap just load it wherever.
+  base_address_ = base_address;
+  uint8_t* p = memory_->Translate(base_address_);
+  memset(p, 0, file_length);
 
   // Read into memory.
-  uint8_t* p = memory_->Translate(base_address_);
   fread(p, file_length, 1, file);
 
   fclose(file);