memcheck.ljs

extern undefined;
extern print;
extern console;
extern snarf;
extern process;
extern newGlobal;
extern setDebug;
extern ArrayBuffer;
extern Uint8Array;
extern Uint32Array;

let NODE_JS = 1;
let JS_SHELL = 2;
let BROWSER = 3;

let enabled = false;


let mode;
if (typeof process !== "undefined") {
  mode = NODE_JS;
} else if (typeof snarf !== "undefined") {
  mode = JS_SHELL;
} else {
  mode = BROWSER;
}

let ck, root, dbg;
if (mode === NODE_JS) {
  print = console.log;
} 

let memcheck = {}; 

// The shadow memory (SM) is a typed array with a corresponding U1
// view that holds a addresssable/defined flag (FLAG_ACC and FLAG_DEF)
// for each byte of main memory.
let u8 FLAG_ACC = 0x1;
let u8 FLAG_DEF = 0x2;
let u8 FLAG_MAL = 0x4

let SM;
let viewSM;

function reset(memSize) {
  SM = new ArrayBuffer(memSize);
  viewSM = new Uint8Array(SM);
  exports.enabled = enabled = true;
  
  memcheck = {
    // {byte* => [str]}
    used: [],
    errors: {
      // [byte*]
      double_free: [],
      // [{membyte: byte*, trace: [str]]
      bad_access: [],
      // [{membyte: byte*, trace: [str]]
      undef_access: []
    }
  };
}

function setFlag(byte *idx, uint size, uint mask) {
  for (let uint i = 0; i < size; i++) {
    viewSM[idx + i] |= mask;
  }
}

function clearFlag(byte *idx, uint size, uint mask) {
  for (let uint i = 0; i < size; i++) {
    viewSM[idx + i] &= ~mask;
  }
}

function isSet(byte *bt, flag) {
  if(viewSM[bt] & flag) {
    return true;
  } else {
    return false;
  }
}


// (byte, uint, bool) -> unit
function setAddressable(byte *bt, uint size, on) {
  if(on) {
    setFlag(bt, size, FLAG_ACC);
  } else {
    clearFlag(bt, size, FLAG_ACC);
  }
}

// (byte) -> bool
function isAddressable(byte *bt) {
  return isSet(bt, FLAG_ACC);
}

// (byte, uint, bool) -> unit
function setDefined(byte *bt, uint size, on) {
  if(on) {
    setFlag(bt, size, FLAG_DEF);
  } else {
    clearFlag(bt, size, FLAG_DEF);
  }
}

// (byte) -> bool
function isDefined(byte *bt) {
  return isSet(bt, FLAG_DEF);
}

// (byte, bool) -> unit
function setAlloc(byte *bt, value) {
  if(value) {
    setFlag(bt, 1, FLAG_MAL);
    memcheck.used[bt] = callstack.slice(0);
  } else {
    clearFlag(bt, 1, FLAG_MAL);
    memcheck.used[bt] = undefined;
  }
}

           

// (byte) -> bool
function isAlloc(byte *bt) {
  return isSet(bt, FLAG_MAL);
}


// (str, str) -> unit
function addError(kind, msg) {
  if(memcheck.errors[kind] === undefined) {
    memcheck.errors[kind] = [];
  }
  memcheck.errors[kind].push(msg);
}

function addDoubleFreeError(byte *bt) {
  memcheck.errors.double_free.push({membyte: bt, trace: callstack.slice(0)});
} 

function addBadAccessError(byte *bt) {
  memcheck.errors.bad_access.push({membyte: bt, trace: callstack.slice(0) });
}

function addUndefinedError(byte *bt) {
  memcheck.errors.undef_access.push({membyte: bt, trace: callstack.slice(0)});
}

// unit -> [byte*]
function getBadAccesses() {
  return memcheck.errors.bad_access;
}

// unit -> [byte*]
function getBadUndefined() {
  return memcheck.errors.undef_access;
}

// unit -> [byte*]
function getBadFrees() {
  return memcheck.errors.double_free;
}

// unit -> [byte, [str]]
function getLeaks() {
  return memcheck.used.map(function(val, idx) {
    if(val) {
      return {membyte: idx, trace: val};
    }
  }).filter(function (val, idx) {
    if(val) {
      return val;
    }
  });
}

let callstack = [];

function call_push(name, fname, line, col) {
  callstack.push(name + " (" + fname + ".ljs:" + line + ":" + col + ")")
}
function call_pop() {
  callstack.pop()
}

function call_reset(name, line, col) {
  let fn = name + ":" + line + ":" + col;
  let idx = callstack.lastIndexOf(fn)
  if(idx !== -1) {
    callstack = callstack.slice(0, idx+1);
  }
}

function getCallstack() {
  return callstack;
}

// uint -> str
function report(limit) {
  function fmtErrors(err) {
    let errors;
    if(limit >= 0) {
      errors = err.slice(0, limit);
    } else {
      errors = err;
    }
    return errors.map(function(val, idx) {
      let stack;
      if(val.trace.length === 0) {
        stack = "at <empty stack>";
      } else {
        stack = val.trace.reverse().join("\n\tat ");
      }
      return "address " + val.membyte + "\n\t" + stack;
    }).join("\n")
  }
  
  let leaks = "== Memory Leaks ==\n" + fmtErrors(getLeaks());
  let access = "== Access of unallocated memory ==\n" + fmtErrors(getBadAccesses());
  let undef = "== Access of uninitialized memory ==\n" + fmtErrors(getBadUndefined());
  let frees = "== Free of unallocated memory ==\n" + fmtErrors(getBadFrees());
  return [access, undef, frees, leaks].join("\n\n");
}

exports.setAddressable = setAddressable;
exports.isAddressable = isAddressable;
exports.setDefined = setDefined;
exports.isDefined = isDefined;
exports.setAlloc = setAlloc;
exports.isAlloc = isAlloc;

exports.addDoubleFreeError = addDoubleFreeError;
exports.addBadAccessError = addBadAccessError;
exports.addUndefinedError = addUndefinedError;

exports.getBadAccesses = getBadAccesses;
exports.getBadUndefined = getBadUndefined;
exports.getBadFrees = getBadFrees;
exports.getLeaks = getLeaks;

exports.report = report;
exports.reset = reset;
exports.enabled = enabled;

exports.memcheck_call_pop = call_pop;
exports.memcheck_call_push = call_push;
exports.memcheck_call_reset = call_reset;
exports.getCallstack = getCallstack;