Class Memory

g2all/700/module/mem.js:169–419

// 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,