@aptre/v86 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aptre/v86",
-    "version": "0.6.0",
+    "version": "0.6.2",
     "license": "BSD-2-Clause",
     "description": "x86 PC emulator and x86-to-wasm JIT, running in the browser",
     "homepage": "https://github.com/aperturerobotics/v86",

package/src/browser/starter.ts

@@ -1,7 +1,12 @@
 declare let DEBUG: boolean
 
 import { v86 } from '../main.js'
-import { LOG_CPU, WASM_TABLE_OFFSET, WASM_TABLE_SIZE } from '../const.js'
+import {
+    LOG_CPU,
+    WASM_PAGE_SIZE,
+    WASM_TABLE_OFFSET,
+    WASM_TABLE_SIZE,
+} from '../const.js'
 import { get_rand_int, load_file, read_sized_string_from_mem } from '../lib.js'
 import { dbg_assert, dbg_trace, dbg_log, set_log_level } from '../log.js'
 import * as print_stats from './print_stats.js'
@@ -105,7 +110,22 @@ export class V86 {
 
         let cpu: any
 
-        let wasm_memory: any
+        // Reserve VA upfront so memory.grow() is fast (no realloc+copy).
+        // Without maximum, engines must reallocate on every grow which
+        // is expensive and can OOM for large guest memories.
+        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',
@@ -113,6 +133,7 @@ export class V86 {
         })
 
         const wasm_shared_funcs: Record<string, any> = {
+            memory: wasm_memory,
             cpu_exception_hook: (n: number) => this.cpu_exception_hook(n),
 
             run_hardware_timers: function (a: any, t: any) {
@@ -280,7 +301,6 @@ export class V86 {
         }
 
         wasm_fn({ env: wasm_shared_funcs }).then((exports: WasmExports) => {
-            wasm_memory = exports.memory
             exports['rust_init']()
 
             const emulator = (this.v86 = new v86(this.emulator_bus, {
@@ -957,6 +977,30 @@ export class V86 {
         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: number): Promise<void> {
+        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.
      */

package/src/cpu.ts

@@ -359,32 +359,26 @@ export class CPU {
         this.segment_limits = view(Uint32Array, memory, 768, 8)
         this.segment_access_bytes = view(Uint8Array, memory, 512, 8)
 
-        // Whether or not in protected mode
         this.protected_mode = view(Int32Array, memory, 800, 1)
 
         this.idtr_size = view(Int32Array, memory, 564, 1)
         this.idtr_offset = view(Int32Array, memory, 568, 1)
 
-        // global descriptor table register
         this.gdtr_size = view(Int32Array, memory, 572, 1)
         this.gdtr_offset = view(Int32Array, memory, 576, 1)
 
         this.tss_size_32 = view(Int32Array, memory, 1128, 1)
 
-        // whether or not a page fault occured
         this.page_fault = view(Uint32Array, memory, 540, 8)
 
         this.cr = view(Int32Array, memory, 580, 8)
 
-        // current privilege level
         this.cpl = view(Uint8Array, memory, 612, 1)
 
-        // current operand/address size
         this.is_32 = view(Int32Array, memory, 804, 1)
 
         this.stack_size_32 = view(Int32Array, memory, 808, 1)
 
-        // Was the last instruction a hlt?
         this.in_hlt = view(Uint8Array, memory, 616, 1)
 
         this.last_virt_eip = view(Int32Array, memory, 620, 1)
@@ -400,16 +394,13 @@ export class CPU {
 
         this.flags = view(Int32Array, memory, 120, 1)
 
-        // bitmap of flags which are not updated in the flags variable
-        // changed by arithmetic instructions, so only relevant to arithmetic flags
         this.flags_changed = view(Int32Array, memory, 100, 1)
 
-        // enough infos about the last arithmetic operation to compute eflags
         this.last_op_size = view(Int32Array, memory, 96, 1)
         this.last_op1 = view(Int32Array, memory, 104, 1)
         this.last_result = view(Int32Array, memory, 112, 1)
 
-        this.current_tsc = view(Uint32Array, memory, 960, 2) // 64 bit
+        this.current_tsc = view(Uint32Array, memory, 960, 2)
 
         // @ts-expect-error Devices are populated during init()
         this.devices = {}
@@ -417,9 +408,7 @@ export class CPU {
         this.instruction_pointer = view(Int32Array, memory, 556, 1)
         this.previous_ip = view(Int32Array, memory, 560, 1)
 
-        // configured by guest
         this.apic_enabled = view(Uint8Array, memory, 548, 1)
-        // configured when the emulator starts (changes bios initialisation)
         this.acpi_enabled = view(Uint8Array, memory, 552, 1)
 
         // managed in io.js
@@ -435,7 +424,6 @@ export class CPU {
 
         this.instruction_counter = view(Uint32Array, memory, 664, 1)
 
-        // registers
         this.reg32 = view(Int32Array, memory, 64, 8)
 
         this.fpu_st = view(Int32Array, memory, 1152, 4 * 8)
@@ -464,10 +452,8 @@ export class CPU {
 
         this.mxcsr = view(Int32Array, memory, 824, 1)
 
-        // segment registers, tr and ldtr
         this.sreg = view(Uint16Array, memory, 668, 8)
 
-        // debug registers
         this.dreg = view(Int32Array, memory, 684, 8)
 
         this.reg_pdpte = view(Int32Array, memory, 968, 8)
@@ -887,27 +873,25 @@ export class CPU {
     }
 
     resize_memory(new_size: number): void {
-        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: any[]): void {
-        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(