@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
178 lines (148 loc) • 16.3 kB
JavaScript
import { APPEND_OPCODES } from '../opcodes';
import { $pc, $ra, $fp, $sp } from '@glimmer/vm';
import { assert } from '@glimmer/util';
export function initializeRegisters() {
return [0, -1, 0, 0];
}
export function initializeRegistersWithSP(sp) {
return [0, -1, sp, 0];
}
export function initializeRegistersWithPC(pc) {
return [pc, -1, 0, 0];
}
var LowLevelVM = /*#__PURE__*/function () {
function LowLevelVM(stack, heap, program, externs, registers) {
this.stack = stack;
this.heap = heap;
this.program = program;
this.externs = externs;
this.registers = registers;
this.currentOpSize = 0;
}
var _proto = LowLevelVM.prototype;
_proto.fetchRegister = function fetchRegister(register) {
return this.registers[register];
};
_proto.loadRegister = function loadRegister(register, value) {
this.registers[register] = value;
};
_proto.setPc = function setPc(pc) {
false && assert(typeof pc === 'number' && !isNaN(pc), 'pc is set to a number');
this.registers[$pc] = pc;
} // Start a new frame and save $ra and $fp on the stack
;
_proto.pushFrame = function pushFrame() {
this.stack.push(this.registers[$ra]);
this.stack.push(this.registers[$fp]);
this.registers[$fp] = this.registers[$sp] - 1;
} // Restore $ra, $sp and $fp
;
_proto.popFrame = function popFrame() {
this.registers[$sp] = this.registers[$fp] - 1;
this.registers[$ra] = this.stack.get(0);
this.registers[$fp] = this.stack.get(1);
};
_proto.pushSmallFrame = function pushSmallFrame() {
this.stack.push(this.registers[$ra]);
};
_proto.popSmallFrame = function popSmallFrame() {
this.registers[$ra] = this.stack.pop();
} // Jump to an address in `program`
;
_proto["goto"] = function goto(offset) {
this.setPc(this.target(offset));
};
_proto.target = function target(offset) {
return this.registers[$pc] + offset - this.currentOpSize;
} // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)
;
_proto.call = function call(handle) {
false && assert(handle < 0xffffffff, "Jumping to placeholder address");
this.registers[$ra] = this.registers[$pc];
this.setPc(this.heap.getaddr(handle));
} // Put a specific `program` address in $ra
;
_proto.returnTo = function returnTo(offset) {
this.registers[$ra] = this.target(offset);
} // Return to the `program` address stored in $ra
;
_proto["return"] = function _return() {
this.setPc(this.registers[$ra]);
};
_proto.nextStatement = function nextStatement() {
var registers = this.registers,
program = this.program;
var pc = registers[$pc];
false && assert(typeof pc === 'number', 'pc is a number');
if (pc === -1) {
return null;
} // We have to save off the current operations size so that
// when we do a jump we can calculate the correct offset
// to where we are going. We can't simply ask for the size
// in a jump because we have have already incremented the
// program counter to the next instruction prior to executing.
var opcode = program.opcode(pc);
var operationSize = this.currentOpSize = opcode.size;
this.registers[$pc] += operationSize;
return opcode;
};
_proto.evaluateOuter = function evaluateOuter(opcode, vm) {
if (false
/* LOCAL_DEBUG */
) {
var _this$externs = this.externs,
debugBefore = _this$externs.debugBefore,
debugAfter = _this$externs.debugAfter;
var state = debugBefore(opcode);
this.evaluateInner(opcode, vm);
debugAfter(state);
} else {
this.evaluateInner(opcode, vm);
}
};
_proto.evaluateInner = function evaluateInner(opcode, vm) {
if (opcode.isMachine) {
this.evaluateMachine(opcode);
} else {
this.evaluateSyscall(opcode, vm);
}
};
_proto.evaluateMachine = function evaluateMachine(opcode) {
switch (opcode.type) {
case 0
/* PushFrame */
:
return this.pushFrame();
case 1
/* PopFrame */
:
return this.popFrame();
case 3
/* InvokeStatic */
:
return this.call(opcode.op1);
case 2
/* InvokeVirtual */
:
return this.call(this.stack.pop());
case 4
/* Jump */
:
return this["goto"](opcode.op1);
case 5
/* Return */
:
return this["return"]();
case 6
/* ReturnTo */
:
return this.returnTo(opcode.op1);
}
};
_proto.evaluateSyscall = function evaluateSyscall(opcode, vm) {
APPEND_OPCODES.evaluate(vm, opcode, opcode.type);
};
return LowLevelVM;
}();
export { LowLevelVM as default };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/runtime/lib/vm/low-level.ts"],"names":[],"mappings":"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","sourcesContent":["import { Option, RuntimeHeap, MachineOp, RuntimeProgram, RuntimeOp } from '@glimmer/interfaces';\nimport { APPEND_OPCODES } from '../opcodes';\nimport VM from './append';\nimport { LOCAL_DEBUG } from '@glimmer/local-debug-flags';\nimport { MachineRegister, $pc, $ra, $fp, $sp } from '@glimmer/vm';\nimport { assert } from '@glimmer/util';\n\nexport interface LowLevelRegisters {\n  [MachineRegister.pc]: number;\n  [MachineRegister.ra]: number;\n  [MachineRegister.sp]: number;\n  [MachineRegister.fp]: number;\n}\n\nexport function initializeRegisters(): LowLevelRegisters {\n  return [0, -1, 0, 0];\n}\n\nexport function initializeRegistersWithSP(sp: number): LowLevelRegisters {\n  return [0, -1, sp, 0];\n}\n\nexport function initializeRegistersWithPC(pc: number): LowLevelRegisters {\n  return [pc, -1, 0, 0];\n}\n\nexport interface Stack {\n  push(value: unknown): void;\n  get(position: number): number;\n  pop<T>(): T;\n}\n\nexport interface Externs {\n  debugBefore(opcode: RuntimeOp): unknown;\n  debugAfter(state: unknown): void;\n}\n\nexport default class LowLevelVM {\n  public currentOpSize = 0;\n\n  constructor(\n    public stack: Stack,\n    public heap: RuntimeHeap,\n    public program: RuntimeProgram,\n    public externs: Externs,\n    readonly registers: LowLevelRegisters\n  ) {}\n\n  fetchRegister(register: MachineRegister): number {\n    return this.registers[register];\n  }\n\n  loadRegister(register: MachineRegister, value: number) {\n    this.registers[register] = value;\n  }\n\n  setPc(pc: number): void {\n    assert(typeof pc === 'number' && !isNaN(pc), 'pc is set to a number');\n    this.registers[$pc] = pc;\n  }\n\n  // Start a new frame and save $ra and $fp on the stack\n  pushFrame() {\n    this.stack.push(this.registers[$ra]);\n    this.stack.push(this.registers[$fp]);\n    this.registers[$fp] = this.registers[$sp] - 1;\n  }\n\n  // Restore $ra, $sp and $fp\n  popFrame() {\n    this.registers[$sp] = this.registers[$fp] - 1;\n    this.registers[$ra] = this.stack.get(0);\n    this.registers[$fp] = this.stack.get(1);\n  }\n\n  pushSmallFrame() {\n    this.stack.push(this.registers[$ra]);\n  }\n\n  popSmallFrame() {\n    this.registers[$ra] = this.stack.pop();\n  }\n\n  // Jump to an address in `program`\n  goto(offset: number) {\n    this.setPc(this.target(offset));\n  }\n\n  target(offset: number) {\n    return this.registers[$pc] + offset - this.currentOpSize;\n  }\n\n  // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)\n  call(handle: number) {\n    assert(handle < 0xffffffff, `Jumping to placeholder address`);\n\n    this.registers[$ra] = this.registers[$pc];\n    this.setPc(this.heap.getaddr(handle));\n  }\n\n  // Put a specific `program` address in $ra\n  returnTo(offset: number) {\n    this.registers[$ra] = this.target(offset);\n  }\n\n  // Return to the `program` address stored in $ra\n  return() {\n    this.setPc(this.registers[$ra]);\n  }\n\n  nextStatement(): Option<RuntimeOp> {\n    let { registers, program } = this;\n\n    let pc = registers[$pc];\n\n    assert(typeof pc === 'number', 'pc is a number');\n\n    if (pc === -1) {\n      return null;\n    }\n\n    // We have to save off the current operations size so that\n    // when we do a jump we can calculate the correct offset\n    // to where we are going. We can't simply ask for the size\n    // in a jump because we have have already incremented the\n    // program counter to the next instruction prior to executing.\n    let opcode = program.opcode(pc);\n    let operationSize = (this.currentOpSize = opcode.size);\n    this.registers[$pc] += operationSize;\n\n    return opcode;\n  }\n\n  evaluateOuter(opcode: RuntimeOp, vm: VM) {\n    if (LOCAL_DEBUG) {\n      let {\n        externs: { debugBefore, debugAfter },\n      } = this;\n      let state = debugBefore(opcode);\n      this.evaluateInner(opcode, vm);\n      debugAfter(state);\n    } else {\n      this.evaluateInner(opcode, vm);\n    }\n  }\n\n  evaluateInner(opcode: RuntimeOp, vm: VM) {\n    if (opcode.isMachine) {\n      this.evaluateMachine(opcode);\n    } else {\n      this.evaluateSyscall(opcode, vm);\n    }\n  }\n\n  evaluateMachine(opcode: RuntimeOp) {\n    switch (opcode.type) {\n      case MachineOp.PushFrame:\n        return this.pushFrame();\n      case MachineOp.PopFrame:\n        return this.popFrame();\n      case MachineOp.InvokeStatic:\n        return this.call(opcode.op1);\n      case MachineOp.InvokeVirtual:\n        return this.call(this.stack.pop());\n      case MachineOp.Jump:\n        return this.goto(opcode.op1);\n      case MachineOp.Return:\n        return this.return();\n      case MachineOp.ReturnTo:\n        return this.returnTo(opcode.op1);\n    }\n  }\n\n  evaluateSyscall(opcode: RuntimeOp, vm: VM) {\n    APPEND_OPCODES.evaluate(vm, opcode, opcode.type);\n  }\n}\n"],"sourceRoot":""}