PSFree/module/mem.mjs

/* Copyright (C) 2023-2025 anonymous

This file is part of PSFree.

PSFree is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

PSFree is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

import { Int, lohi_from_one } from './int64.mjs';
import { view_m_vector, view_m_length } from './offset.mjs';

export let mem = null;

// cache some constants
const off_vector = view_m_vector / 4;
const off_vector2 = (view_m_vector + 4) / 4;
const isInteger = Number.isInteger;

function init_module(memory) {
    mem = memory;
}

function add_and_set_addr(mem, offset, base_lo, base_hi) {
    const values = lohi_from_one(offset);
    const main = mem._main;

    const low = base_lo + values[0];

    // no need to use ">>> 0" to convert to unsigned here
    main[off_vector] = low;
    main[off_vector2] = base_hi + values[1] + (low > 0xffffffff);
}

export class Addr extends Int {
    read8(offset) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        return m.read8_at(offset);
    }

    read16(offset) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        return m.read16_at(offset);
    }

    read32(offset) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        return m.read32_at(offset);
    }

    read64(offset) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        return m.read64_at(offset);
    }

    readp(offset) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        return m.readp_at(offset);
    }

    write8(offset, value) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        m.write8_at(offset, value);
    }

    write16(offset, value) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        m.write16_at(offset, value);
    }

    write32(offset, value) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        m.write32_at(offset, value);
    }

    write64(offset, value) {
        const m = mem;
        if (isInteger(offset) && 0 <= offset && offset <= 0xffffffff) {
            m._set_addr_direct(this);
        } else {
            add_and_set_addr(m, offset, this.lo, this.hi);
            offset = 0;
        }

        m.write64_at(offset, value);
    }
}

// expected:
// * main - Uint32Array whose m_vector points to worker
// * worker - DataView
//
// addrof()/fakeobj() expectations:
// * obj - has a "addr" property and a 0 index.
// * addr_addr - Int, the address of the slot of obj.addr
// * fake_addr - Int, the address of the slot of obj[0]
//
// a valid example for "obj" is "{addr: null, 0: 0}". note that this example
// has [0] be 0 so that the butterfly's indexing type is ArrayWithInt32. this
// prevents the garbage collector from incorrectly treating the slot's value as
// a JSObject and then crash
//
// the relative read/write methods expect the offset to be a unsigned 32-bit
// integer
export class Memory {
    constructor(main, worker, obj, addr_addr, fake_addr)  {
        this._main = main;
        this._worker = worker;
        this._obj = obj;
        this._addr_low = addr_addr.lo;
        this._addr_high = addr_addr.hi;
        this._fake_low = fake_addr.lo;
        this._fake_high = fake_addr.hi;

        main[view_m_length / 4] = 0xffffffff;

        init_module(this);

        const off_mvec = view_m_vector;
        // use this to create WastefulTypedArrays to avoid a GC crash
        const buf = new ArrayBuffer(0);

        const src = new Uint8Array(buf);
        const sset = new Uint32Array(buf);
        const sset_p = this.addrof(sset);
        sset_p.write64(off_mvec, this.addrof(src).add(off_mvec));
        sset_p.write32(view_m_length, 3);
        this._cpysrc = src;
        this._src_setter = sset;

        const dst = new Uint8Array(buf);
        const dset = new Uint32Array(buf);
        const dset_p = this.addrof(dset);
        dset_p.write64(off_mvec, this.addrof(dst).add(off_mvec));
        dset_p.write32(view_m_length, 3);
        dset[2] = 0xffffffff;
        this._cpydst = dst;
        this._dst_setter = dset;
    }

    // dst and src may overlap
    cpy(dst, src, len) {
        if (!(isInteger(len) && 0 <= len && len <= 0xffffffff)) {
            throw TypeError('len not a unsigned 32-bit integer');
        }

        const dvals = lohi_from_one(dst);
        const svals = lohi_from_one(src);
        const dset = this._dst_setter;
        const sset = this._src_setter;

        dset[0] = dvals[0];
        dset[1] = dvals[1];
        sset[0] = svals[0];
        sset[1] = svals[1];
        sset[2] = len;

        this._cpydst.set(this._cpysrc);
    }

    // allocate Garbage Collector managed memory. returns [address_of_memory,
    // backer]. backer is the JSCell that is keeping the returned memory alive,
    // you can drop it once you have another GC object reference the address.
    // the backer is an implementation detail. don't use it to mutate the
    // memory
    gc_alloc(size) {
        if (!isInteger(size)) {
            throw TypeError('size not a integer');
        }
        if (size < 0) {
            throw RangeError('size is negative');
        }

        const fastLimit = 1000;
        size = (size + 7 & ~7) >> 3;
        if (size > fastLimit) {
            throw RangeError('size is too large');
        }

        const backer = new Float64Array(size);
        return [mem.addrof(backer).readp(view_m_vector), backer];
    }

    fakeobj(addr) {
        const values = lohi_from_one(addr);
        const worker = this._worker;
        const main = this._main;

        main[off_vector] = this._fake_low;
        main[off_vector2] = this._fake_high;
        worker.setUint32(0, values[0], true);
        worker.setUint32(4, values[1], true);
        return this._obj[0];
    }

    addrof(object) {
        // typeof considers null as a object. blacklist it as it isn't a
        // JSObject
        if (object === null
            || (typeof object !== 'object' && typeof object !== 'function')
        ) {
            throw TypeError('argument not a JS object');
        }

        const obj = this._obj;
        const worker = this._worker;
        const main = this._main;

        obj.addr = object;

        main[off_vector] = this._addr_low;
        main[off_vector2] = this._addr_high;

        const res = new Addr(
            worker.getUint32(0, true),
            worker.getUint32(4, true),
        );
        obj.addr = null;

        return res;
    }

    // expects addr to be a Int
    _set_addr_direct(addr) {
        const main = this._main;
        main[off_vector] = addr.lo;
        main[off_vector2] = addr.hi;
    }

    set_addr(addr) {
        const values = lohi_from_one(addr);
        const main = this._main;
        main[off_vector] = values[0];
        main[off_vector2] = values[1];
    }

    get_addr() {
        const main = this._main;
        return new Addr(main[off_vector], main[off_vector2]);
    }

    read8(addr) {
        this.set_addr(addr);
        return this._worker.getUint8(0);
    }

    read16(addr) {
        this.set_addr(addr);
        return this._worker.getUint16(0, true);
    }

    read32(addr) {
        this.set_addr(addr);
        return this._worker.getUint32(0, true);
    }

    read64(addr) {
        this.set_addr(addr);
        const worker = this._worker;
        return new Int(worker.getUint32(0, true), worker.getUint32(4, true));
    }

    // returns a pointer instead of an Int
    readp(addr) {
        this.set_addr(addr);
        const worker = this._worker;
        return new Addr(worker.getUint32(0, true), worker.getUint32(4, true));
    }

    read8_at(offset) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        return this._worker.getUint8(offset);
    }

    read16_at(offset) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        return this._worker.getUint16(offset, true);
    }

    read32_at(offset) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        return this._worker.getUint32(offset, true);
    }

    read64_at(offset) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        const worker = this._worker;
        return new Int(
            worker.getUint32(offset, true),
            worker.getUint32(offset + 4, true),
        );
    }

    readp_at(offset) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        const worker = this._worker;
        return new Addr(
            worker.getUint32(offset, true),
            worker.getUint32(offset + 4, true),
        );
    }

    write8(addr, value) {
        this.set_addr(addr);
        this._worker.setUint8(0, value);
    }

    write16(addr, value) {
        this.set_addr(addr);
        this._worker.setUint16(0, value, true);
    }

    write32(addr, value) {
        this.set_addr(addr);
        this._worker.setUint32(0, value, true);
    }

    write64(addr, value) {
        const values = lohi_from_one(value);
        this.set_addr(addr);
        const worker = this._worker;
        worker.setUint32(0, values[0], true);
        worker.setUint32(4, values[1], true);
    }

    write8_at(offset, value) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        this._worker.setUint8(offset, value);
    }

    write16_at(offset, value) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        this._worker.setUint16(offset, value, true);
    }

    write32_at(offset, value) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        this._worker.setUint32(offset, value, true);
    }

    write64_at(offset, value) {
        if (!isInteger(offset)) {
            throw TypeError('offset not a integer');
        }
        const values = lohi_from_one(value);
        const worker = this._worker;
        worker.setUint32(offset, values[0], true);
        worker.setUint32(offset + 4, values[1], true);
    }
}