@aptre/v86 0.6.0 → 0.6.1

package/dist/v86.browser.js

@@ -18822,6 +18822,7 @@ var V86Starter = (() => {
     wasm_memory;
     memory_size;
     mem8;
+    mem8_offset = 0;
     mem32s;
     segment_is_null;
     segment_offsets;
@@ -18951,10 +18952,46 @@ var V86Starter = (() => {
       this.wasm_memory = wm.wasm_memory;
       this.wasm_patch();
       this.create_jit_imports();
-      const memory = this.wasm_memory;
-      this.memory_size = view(Uint32Array, memory, 812, 1);
       this.mem8 = new Uint8Array(0);
       this.mem32s = new Int32Array(this.mem8.buffer);
+      this.rebuild_wasm_views();
+      this.devices = {};
+      this.memory_map_read8 = [];
+      this.memory_map_write8 = [];
+      this.memory_map_read32 = [];
+      this.memory_map_write32 = [];
+      this.bios = {
+        main: null,
+        vga: null
+      };
+      this.fpu_stack_empty[0] = 255;
+      this.fpu_stack_ptr[0] = 0;
+      this.fpu_control_word[0] = 895;
+      this.fpu_status_word[0] = 0;
+      this.fpu_ip[0] = 0;
+      this.fpu_ip_selector[0] = 0;
+      this.fpu_opcode[0] = 0;
+      this.fpu_dp[0] = 0;
+      this.fpu_dp_selector[0] = 0;
+      this.fw_value = [];
+      this.fw_pointer = 0;
+      this.option_roms = [];
+      this.io = void 0;
+      this.bus = bus;
+      this.set_tsc(0, 0);
+      if (false) {
+        this.seen_code = {};
+        this.seen_code_uncompiled = {};
+      }
+    }
+    /**
+     * Rebuild all TypedArray views into WASM linear memory.
+     * Must be called after any wasm_memory.grow() since growth
+     * detaches the old ArrayBuffer, invalidating all views.
+     */
+    rebuild_wasm_views() {
+      const memory = this.wasm_memory;
+      this.memory_size = view(Uint32Array, memory, 812, 1);
       this.segment_is_null = view(Uint8Array, memory, 724, 8);
       this.segment_offsets = view(Int32Array, memory, 736, 8);
       this.segment_limits = view(Uint32Array, memory, 768, 8);
@@ -18983,40 +19020,22 @@ var V86Starter = (() => {
       this.last_op1 = view(Int32Array, memory, 104, 1);
       this.last_result = view(Int32Array, memory, 112, 1);
       this.current_tsc = view(Uint32Array, memory, 960, 2);
-      this.devices = {};
       this.instruction_pointer = view(Int32Array, memory, 556, 1);
       this.previous_ip = view(Int32Array, memory, 560, 1);
       this.apic_enabled = view(Uint8Array, memory, 548, 1);
       this.acpi_enabled = view(Uint8Array, memory, 552, 1);
-      this.memory_map_read8 = [];
-      this.memory_map_write8 = [];
-      this.memory_map_read32 = [];
-      this.memory_map_write32 = [];
-      this.bios = {
-        main: null,
-        vga: null
-      };
       this.instruction_counter = view(Uint32Array, memory, 664, 1);
       this.reg32 = view(Int32Array, memory, 64, 8);
       this.fpu_st = view(Int32Array, memory, 1152, 4 * 8);
       this.fpu_stack_empty = view(Uint8Array, memory, 816, 1);
-      this.fpu_stack_empty[0] = 255;
       this.fpu_stack_ptr = view(Uint8Array, memory, 1032, 1);
-      this.fpu_stack_ptr[0] = 0;
       this.fpu_control_word = view(Uint16Array, memory, 1036, 1);
-      this.fpu_control_word[0] = 895;
       this.fpu_status_word = view(Uint16Array, memory, 1040, 1);
-      this.fpu_status_word[0] = 0;
       this.fpu_ip = view(Int32Array, memory, 1048, 1);
-      this.fpu_ip[0] = 0;
       this.fpu_ip_selector = view(Int32Array, memory, 1052, 1);
-      this.fpu_ip_selector[0] = 0;
       this.fpu_opcode = view(Int32Array, memory, 1044, 1);
-      this.fpu_opcode[0] = 0;
       this.fpu_dp = view(Int32Array, memory, 1056, 1);
-      this.fpu_dp[0] = 0;
       this.fpu_dp_selector = view(Int32Array, memory, 1060, 1);
-      this.fpu_dp_selector[0] = 0;
       this.reg_xmm32s = view(Int32Array, memory, 832, 8 * 4);
       this.mxcsr = view(Int32Array, memory, 824, 1);
       this.sreg = view(Uint16Array, memory, 668, 8);
@@ -19024,16 +19043,6 @@ var V86Starter = (() => {
       this.reg_pdpte = view(Int32Array, memory, 968, 8);
       this.svga_dirty_bitmap_min_offset = view(Uint32Array, memory, 716, 1);
       this.svga_dirty_bitmap_max_offset = view(Uint32Array, memory, 720, 1);
-      this.fw_value = [];
-      this.fw_pointer = 0;
-      this.option_roms = [];
-      this.io = void 0;
-      this.bus = bus;
-      this.set_tsc(0, 0);
-      if (false) {
-        this.seen_code = {};
-        this.seen_code_uncompiled = {};
-      }
     }
     mmap_read8(addr) {
       const value = this.memory_map_read8[addr >>> MMAP_BLOCK_BITS](addr);
@@ -19336,7 +19345,7 @@ var V86Starter = (() => {
       );
     }
     resize_memory(new_size) {
-      const mem8_offset = this.mem8.byteOffset;
+      const mem8_offset = this.mem8_offset;
       const needed_total = mem8_offset + new_size;
       const current_buffer = this.wasm_memory.buffer.byteLength;
       if (needed_total > current_buffer) {
@@ -19344,6 +19353,7 @@ var V86Starter = (() => {
           (needed_total - current_buffer) / WASM_PAGE_SIZE
         );
         this.wasm_memory.grow(grow_pages);
+        this.rebuild_wasm_views();
       }
       this.mem8 = view(Uint8Array, this.wasm_memory, mem8_offset, new_size);
       this.mem32s = view(
@@ -19355,7 +19365,12 @@ var V86Starter = (() => {
       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]
@@ -19655,8 +19670,10 @@ var V86Starter = (() => {
         this.memory_size[0] === 0,
         "Expected uninitialised memory"
       );
-      this.memory_size[0] = size;
       const memory_offset = this.allocate_memory(size);
+      this.rebuild_wasm_views();
+      this.memory_size[0] = size;
+      this.mem8_offset = memory_offset;
       this.mem8 = view(Uint8Array, this.wasm_memory, memory_offset, size);
       this.mem32s = view(
         Uint32Array,
@@ -19900,6 +19917,21 @@ var V86Starter = (() => {
         }
       }
       this.debug_init();
+      this.rebuild_wasm_views();
+      if (this.mem8_offset > 0) {
+        this.mem8 = view(
+          Uint8Array,
+          this.wasm_memory,
+          this.mem8_offset,
+          this.memory_size[0]
+        );
+        this.mem32s = view(
+          Uint32Array,
+          this.wasm_memory,
+          this.mem8_offset,
+          this.memory_size[0] >> 2
+        );
+      }
     }
     load_multiboot(buffer) {
       if (this.bios.main) {
@@ -26211,12 +26243,25 @@ ${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_PAGE_SIZE2 = 65536;
+      const wasm_initial_pages = 256;
+      const wasm_max_pages = Math.max(
+        wasm_initial_pages,
+        Math.min(Math.ceil(memory_max / WASM_PAGE_SIZE2), 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 +26396,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 +26922,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.
      */