Class Memory

g2all/900/module/mem.js:432–691

}*/

export class Memory {
    constructor(main, worker, obj, addr_addr)  {
        this._main = main;
        this._worker = worker;
        this._obj = obj;
        this._addr_low = addr_addr.lo;
        this._addr_high = addr_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