memory.ljs

extern ArrayBuffer;
extern Uint8Array;
extern Int8Array;
extern Uint16Array;
extern Int16Array;
extern Uint32Array;
extern Int32Array;
extern Float32Array;
extern Float64Array;

const MB = 1024 * 1024;
const WORD_SIZE = sizeof(word);
const SIZE = (32 * MB) / WORD_SIZE;
const STACK_SIZE = (2 * MB) / WORD_SIZE;
const HEAP_SIZE = SIZE - STACK_SIZE;

// let I4, U4;

/*
   +---------------+ -
 0 | Heap  Pointer |
 1 | Stack Pointer |
   +---------------+ <- Heap Pointer (HP)
   |               |
   |               | |
   |     HEAP      | | Malloc Region
   |               | v
   |               |
   +---------------+
   |               |
   |               | ^
   |     STACK     | |
   |               | |
   |               |
   +---------------+ <- Stack Pointer (SP)
*/

function byte *memcpy(byte *dst, byte *src, uint length) {
  for (let int i = 0; i < length; ++i) {
    *dst++ = *src++;
  }
  return dst;
}

function u16 *memcpy2(u16 *dst, u16 *src, uint length) {
  for (let int i = 0; i < length; ++i) {
    *dst++ = *src++;
  }
  return dst;
}

function u32 *memcpy4(u32 *dst, u32 *src, uint length) {
  for (let int i = 0; i < length; ++i) {
    *dst++ = *src++;
  }
  return dst;
}

function void memset(byte *s, byte b, uint length) {
  for (let int i = 0; i < length; ++i) {
    *s = b;
  }
}

function void memset2(u16 *s, u16 b, uint length) {
  for (let int i = 0; i < length; ++i) {
    *s = b;
  }
}

function void memset4(u32 *s, u32 b, uint length) {
  for (let int i = 0; i < length; ++i) {
    *s = b;
  }
}

/* K&R Malloc */

struct Header {
  Header *next;
  uint size;
};

let Header *base = null;
let Header *freep = null;

function reset() {
  let M = exports.M = new ArrayBuffer(SIZE * WORD_SIZE);
  exports.U1 = new Uint8Array(M);
  exports.I1 = new Int8Array(M);
  exports.U2 = new Uint16Array(M);
  exports.I2 = new Int16Array(M);
  exports.U4 = new Uint32Array(M);
  exports.I4 = new Int32Array(M);
  exports.F4 = new Float32Array(M);
  exports.F8 = new Float64Array(M);

  exports.U4[0] = 4;
  exports.U4[1] = SIZE;

  base = (Header *)(2);
  freep = null;
}

reset();

function word *sbrk(int nBytes) {
  let U4 = exports.U4;
  let int nWords = nBytes / sizeof(word);
  if (U4[0] + nWords > HEAP_SIZE) {
    return null;
  }
  let word *address = (word *)(U4[0]);
  U4[0] += nWords;
  return address;
}

let uint nUnitsMin = 1024;

function Header *morecore(uint nUnits) {
  if (nUnits < nUnitsMin) {
    nUnits = nUnitsMin;
  }
  let word *buffer = sbrk(nUnits * sizeof(Header));

  if (buffer === null) {
    return null;
  }
  let Header *header = (Header *)(buffer);
  header->size = nUnits;
  free(header + 1);
  return freep;
}

function byte *malloc(int nBytes) {
  let Header *p, *prevp;
  let uint nUnits = ((nBytes + sizeof(Header) - 1) / sizeof(Header)) + 1;

  if ((prevp = freep) === null) {
    base->next = freep = prevp = base;
    base->size = 0;
  }

  for (p = prevp->next; true; prevp = p, p = p->next) {
    if (p->size >= nUnits) {
      if (p->size === nUnits) {
        prevp->next = p->next;
      } else {
        p->size -= nUnits;
        p += p->size;
        p->size = nUnits;
      }
      freep = prevp;
      return p + 1;
    }
    if (p === freep) {
      if ((p = morecore(nUnits)) === null) {
        return null;
      }
    }
  }
  return null;
}

function void free(byte *ap) {
  let Header *bp = (Header *)(ap) - 1, *p;
  for (p = freep; !(bp > p && bp < p->next); p = p->next) {
    if (p >= p->next && (bp > p || bp < p->next)) {
      break;
    }
  }
  if (bp + bp->size === p->next) {
    bp->size += p->next->size;
    bp->next = p->next->next;
  } else {
    bp->next = p->next;
  }
  if (p + p->size == bp) {
    p->size += bp->size;
    p->next = bp->next;
  } else {
    p->next = bp;
  }
  freep = p;
}

exports.reset = reset;

exports.memcpy = memcpy;
exports.memcpy2 = memcpy2;
exports.memcpy4 = memcpy4;
exports.memset = memset;
exports.memset2 = memset2;
exports.memset4 = memset4;

exports.malloc = malloc;
exports.free = free;