@aptre/v86 0.6.0 → 0.6.2

package/dist/v86.browser.js

@@ -19336,26 +19336,24 @@ var V86Starter = (() => {
       );
     }
     resize_memory(new_size) {
-      const mem8_offset = this.mem8.byteOffset;
-      const needed_total = mem8_offset + new_size;
-      const current_buffer = this.wasm_memory.buffer.byteLength;
-      if (needed_total > current_buffer) {
-        const grow_pages = Math.ceil(
-          (needed_total - current_buffer) / WASM_PAGE_SIZE
-        );
-        this.wasm_memory.grow(grow_pages);
-      }
-      this.mem8 = view(Uint8Array, this.wasm_memory, mem8_offset, new_size);
-      this.mem32s = view(
-        Int32Array,
-        this.wasm_memory,
-        mem8_offset,
-        new_size >> 2
-      );
+      const offset = this.mem8.byteOffset;
+      const needed = offset + new_size;
+      const current = this.wasm_memory.buffer.byteLength;
+      if (needed > current) {
+        const pages = Math.ceil((needed - current) / WASM_PAGE_SIZE);
+        this.wasm_memory.grow(pages);
+      }
+      this.mem8 = view(Uint8Array, this.wasm_memory, offset, new_size);
+      this.mem32s = view(Uint32Array, this.wasm_memory, offset, new_size >> 2);
       this.memory_size[0] = new_size;
     }
     set_state(state) {
-      this.memory_size[0] = state[0];
+      const saved_memory_size = state[0];
+      if (saved_memory_size > this.memory_size[0]) {
+        this.resize_memory(saved_memory_size);
+      } else {
+        this.memory_size[0] = saved_memory_size;
+      }
       if (this.mem8.length !== this.memory_size[0]) {
         console.warn(
           "Note: Memory size mismatch. we=" + this.mem8.length + " state=" + this.memory_size[0]
@@ -26211,12 +26209,24 @@ ${e.stack || e.message}`
       this.bus = bus[0];
       this.emulator_bus = bus[1];
       let cpu;
-      let wasm_memory;
+      const memory_size = options.memory_size || 64 * 1024 * 1024;
+      const vga_memory_size = options.vga_memory_size || 8 * 1024 * 1024;
+      const memory_max = options.memory_max || (memory_size + vga_memory_size) * 4;
+      const wasm_initial_pages = 256;
+      const wasm_max_pages = Math.max(
+        wasm_initial_pages,
+        Math.min(Math.ceil(memory_max / WASM_PAGE_SIZE), 65536)
+      );
+      const wasm_memory = new WebAssembly.Memory({
+        initial: wasm_initial_pages,
+        maximum: wasm_max_pages
+      });
       const wasm_table = new WebAssembly.Table({
         element: "anyfunc",
         initial: WASM_TABLE_SIZE + WASM_TABLE_OFFSET
       });
       const wasm_shared_funcs = {
+        memory: wasm_memory,
         cpu_exception_hook: (n) => this.cpu_exception_hook(n),
         run_hardware_timers: function(a, t) {
           return cpu.run_hardware_timers(a, t);
@@ -26351,7 +26361,6 @@ ${e.stack || e.message}`
         };
       }
       wasm_fn({ env: wasm_shared_funcs }).then((exports) => {
-        wasm_memory = exports.memory;
         exports["rust_init"]();
         const emulator = this.v86 = new v86(this.emulator_bus, {
           exports,
@@ -26878,6 +26887,26 @@ ${e.stack || e.message}`
     async run() {
       this.v86.run();
     }
+    /**
+     * Grow guest memory to the specified size in bytes. Stops the VM,
+     * grows WASM linear memory, updates memory_size, clears the TLB,
+     * and resumes execution.
+     */
+    async growMemory(newSizeBytes) {
+      const cpu = this.v86.cpu;
+      if (newSizeBytes <= cpu.memory_size[0]) {
+        return;
+      }
+      const wasRunning = this.cpu_is_running;
+      if (wasRunning) {
+        await this.stop();
+      }
+      cpu.resize_memory(newSizeBytes);
+      cpu.full_clear_tlb();
+      if (wasRunning) {
+        await this.run();
+      }
+    }
     /**
      * Stop emulation. Do nothing if emulator is not running. Can be asynchronous.
      */