first steps to a new evaluation engine
This commit is contained in:
Araq
parent
84534ce4b8
commit
b30e237a37
4 changed files with 1768 additions and 0 deletions
584
compiler/vm.nim
Normal file
584
compiler/vm.nim
Normal file
|
|
@ -0,0 +1,584 @@
|
|||
#
|
||||
#
|
||||
# The Nimrod Compiler
|
||||
# (c) Copyright 2013 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
## This file implements the new evaluation engine for Nimrod code.
|
||||
## An instruction is 1-2 int32s in memory, it is a register based VM.
|
||||
|
||||
import ast, astalgo, msgs, vmdef, vmgen, nimsets, types, passes, unsigned
|
||||
|
||||
type
|
||||
PStackFrame* = ref TStackFrame
|
||||
TStackFrame* = object
|
||||
prc: PSym # current prc; proc that is evaluated
|
||||
slots: TNodeSeq # parameters passed to the proc + locals;
|
||||
# parameters come first
|
||||
next: PStackFrame # for stacking
|
||||
comesFrom: int
|
||||
safePoints: seq[int] # used for exception handling
|
||||
# XXX 'break' should perform cleanup actions
|
||||
# What does the C backend do for it?
|
||||
|
||||
proc stackTraceAux(c: PCtx; x: PStackFrame; pc: int) =
|
||||
if x != nil:
|
||||
stackTraceAux(c, x.next, x.comesFrom)
|
||||
var info = c.debug[pc]
|
||||
# we now use the same format as in system/except.nim
|
||||
var s = toFilename(info)
|
||||
var line = toLineNumber(info)
|
||||
if line > 0:
|
||||
add(s, '(')
|
||||
add(s, $line)
|
||||
add(s, ')')
|
||||
if x.prc != nil:
|
||||
for k in 1..max(1, 25-s.len): add(s, ' ')
|
||||
add(s, x.prc.name.s)
|
||||
MsgWriteln(s)
|
||||
|
||||
proc stackTrace(c: PCtx, tos: PStackFrame, pc: int,
|
||||
msg: TMsgKind, arg = "") =
|
||||
MsgWriteln("stack trace: (most recent call last)")
|
||||
stackTraceAux(c, tos, pc)
|
||||
LocalError(c.debug[pc], msg, arg)
|
||||
|
||||
proc bailOut(c: PCtx; tos: PStackFrame) =
|
||||
stackTrace(c, tos, c.exceptionInstr, errUnhandledExceptionX,
|
||||
c.currentExceptionA.sons[2].strVal)
|
||||
|
||||
when not defined(nimHasInterpreterLoop):
|
||||
{.pragma: interpreterLoop.}
|
||||
|
||||
template inc(pc: ptr TInstr, diff = 1) =
|
||||
inc cast[TAddress](pc), TInstr.sizeof * diff
|
||||
|
||||
template ensureKind(k: expr) {.immediate, dirty.} =
|
||||
if regs[ra].kind != k:
|
||||
myreset(regs[ra])
|
||||
regs[ra].kind = k
|
||||
|
||||
template decodeB(k: expr) {.immediate, dirty.} =
|
||||
let rb = instr.regB
|
||||
ensureKind(k)
|
||||
|
||||
template decodeBC(k: expr) {.immediate, dirty.} =
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
ensureKind(k)
|
||||
|
||||
template decodeBImm(k: expr) {.immediate, dirty.} =
|
||||
let rb = instr.regB
|
||||
let imm = instr.regC - byteExcess
|
||||
ensureKind(k)
|
||||
|
||||
template decodeBx(k: expr) {.immediate, dirty.} =
|
||||
let rbx = instr.regBx - wordExcess
|
||||
ensureKind(k)
|
||||
|
||||
proc compile(c: PCtx, s: PSym): int = vmgen.genProc(c, s)
|
||||
|
||||
proc myreset(n: PNode) =
|
||||
when defined(system.reset):
|
||||
var oldInfo = n.info
|
||||
reset(n[])
|
||||
n.info = oldInfo
|
||||
|
||||
template move(a, b: expr) = system.shallowCopy(a, b)
|
||||
# XXX fix minor 'shallowCopy' overloading bug in compiler
|
||||
|
||||
proc asgnRef(x, y: PNode) =
|
||||
myreset(x)
|
||||
x.kind = y.kind
|
||||
x.typ = y.typ
|
||||
case x.kind
|
||||
of nkCharLit..nkInt64Lit: x.intVal = y.intVal
|
||||
of nkFloatLit..nkFloat64Lit: x.floatVal = y.floatVal
|
||||
of nkStrLit..nkTripleStrLit: x.strVal = y.strVal
|
||||
of nkIdent: x.ident = y.ident
|
||||
of nkSym: x.sym = y.sym
|
||||
else:
|
||||
if x.kind notin {nkEmpty..nkNilLit}:
|
||||
move(x.sons, y.sons)
|
||||
|
||||
proc asgnComplex(x, y: PNode) =
|
||||
myreset(x)
|
||||
x.kind = y.kind
|
||||
x.typ = y.typ
|
||||
case x.kind
|
||||
of nkCharLit..nkInt64Lit: x.intVal = y.intVal
|
||||
of nkFloatLit..nkFloat64Lit: x.floatVal = y.floatVal
|
||||
of nkStrLit..nkTripleStrLit: x.strVal = y.strVal
|
||||
of nkIdent: x.ident = y.ident
|
||||
of nkSym: x.sym = y.sym
|
||||
else:
|
||||
if x.kind notin {nkEmpty..nkNilLit}:
|
||||
let y = y.copyTree
|
||||
for i in countup(0, sonsLen(y) - 1): addSon(x, y.sons[i])
|
||||
|
||||
template getstr(a: expr): expr =
|
||||
(if a.kind == nkStrLit: a.strVal else: $chr(int(a.intVal)))
|
||||
|
||||
proc pushSafePoint(f: PStackFrame; pc: int) =
|
||||
if f.safePoints.isNil: f.safePoints = @[]
|
||||
f.safePoints.add(pc)
|
||||
|
||||
proc popSafePoint(f: PStackFrame) = discard f.safePoints.pop()
|
||||
|
||||
proc nextSafePoint(f: PStackFrame): int =
|
||||
var f = f
|
||||
while f.safePoints.isNil or f.safePoints.len == 0:
|
||||
f = f.next
|
||||
if f.isNil: return -1
|
||||
result = f.safePoints.pop
|
||||
|
||||
proc cleanUpOnException(c: PCtx; tos: PStackFrame; regs: TNodeSeq): int =
|
||||
let raisedType = c.currentExceptionA.typ.skipTypes(abstractPtrs)
|
||||
while true:
|
||||
var pc2 = tos.nextSafePoint
|
||||
if pc2 == -1: return -1
|
||||
|
||||
var nextExceptOrFinally = -1
|
||||
if c.code[pc2].opcode == opcExcept:
|
||||
nextExceptOrFinally = pc2 + c.code[pc2].regBx - wordExcess
|
||||
inc pc2
|
||||
while c.code[pc2].opcode == opcExcept:
|
||||
let exceptType = c.types[c.code[pc2].regBx-wordExcess].skipTypes(
|
||||
abstractPtrs)
|
||||
if inheritanceDiff(exceptType, raisedType) <= 0:
|
||||
# mark exception as handled but keep it in B for
|
||||
# the getCurrentException() builtin:
|
||||
c.currentExceptionB = c.currentExceptionA
|
||||
c.currentExceptionA = nil
|
||||
# execute the corresponding handler:
|
||||
return pc2
|
||||
inc pc2
|
||||
if nextExceptOrFinally >= 0:
|
||||
pc2 = nextExceptOrFinally
|
||||
if c.code[pc2].opcode == opcFinally:
|
||||
# execute the corresponding handler, but don't quit walking the stack:
|
||||
return pc2
|
||||
|
||||
proc cleanUpOnReturn(c: PCtx; f: PStackFrame): int =
|
||||
if f.safePoints.isNil: return -1
|
||||
for s in f.safePoints:
|
||||
var pc = s
|
||||
while c.code[pc].opcode == opcExcept:
|
||||
pc = pc + c.code[pc].regBx - wordExcess
|
||||
if c.code[pc].opcode == opcFinally:
|
||||
return pc
|
||||
return -1
|
||||
|
||||
proc execute(c: PCtx, start: int) =
|
||||
var pc = start
|
||||
var regs: TNodeSeq # alias to tos.slots for performance
|
||||
var tos: PStackFrame
|
||||
newSeq(regs, c.prc.maxSlots)
|
||||
while true:
|
||||
{.interpreterLoop.}
|
||||
let instr = c.code[pc]
|
||||
let ra = instr.regA
|
||||
echo "PC ", pc, " ", c.code[pc].opcode, " ra ", ra
|
||||
case instr.opcode
|
||||
of opcEof: break
|
||||
of opcRet:
|
||||
# XXX perform any cleanup actions
|
||||
tos = tos.next
|
||||
if tos.isNil: return
|
||||
let retVal = regs[0]
|
||||
move(regs, tos.slots)
|
||||
pc = tos.comesFrom
|
||||
assert c.code[pc].opcode in {opcIndCall, opcIndCallAsgn}
|
||||
if c.code[pc].opcode == opcIndCallAsgn:
|
||||
regs[c.code[pc].regA] = retVal
|
||||
of opcYldYoid: assert false
|
||||
of opcYldVal: assert false
|
||||
of opcAsgnInt:
|
||||
echo ra, " ", instr.regB, " ", regs.len, tos.prc.name.s
|
||||
decodeB(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal
|
||||
of opcAsgnStr:
|
||||
decodeB(nkStrLit)
|
||||
debug regs[rb]
|
||||
echo rb
|
||||
Message(c.debug[pc], warnUser, " here")
|
||||
regs[ra].strVal = regs[rb].strVal
|
||||
of opcAsgnFloat:
|
||||
decodeB(nkFloatLit)
|
||||
regs[ra].floatVal = regs[rb].floatVal
|
||||
of opcAsgnComplex:
|
||||
asgnComplex(regs[ra], regs[instr.regB])
|
||||
of opcAsgnRef:
|
||||
asgnRef(regs[ra], regs[instr.regB])
|
||||
of opcWrGlobalRef:
|
||||
asgnRef(c.globals[instr.regBx-wordExcess-1], regs[ra])
|
||||
of opcWrGlobal:
|
||||
asgnComplex(c.globals.sons[instr.regBx-wordExcess-1], regs[ra])
|
||||
of opcLdArr:
|
||||
# a = b[c]
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
let idx = regs[rc].intVal
|
||||
# XXX what if the array is not 0-based? -> codegen should insert a sub
|
||||
regs[ra] = regs[rb].sons[idx.int]
|
||||
of opcWrArr:
|
||||
# a[b] = c
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
let idx = regs[rb].intVal
|
||||
asgnComplex(regs[ra].sons[idx.int], regs[rc])
|
||||
of opcWrArrRef:
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
let idx = regs[rb].intVal
|
||||
asgnRef(regs[ra].sons[idx.int], regs[rc])
|
||||
of opcLdObj:
|
||||
# a = b.c
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
# XXX this creates a wrong alias
|
||||
asgnComplex(regs[ra], regs[rb].sons[rc])
|
||||
of opcWrObj:
|
||||
# a.b = c
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
asgnComplex(regs[ra].sons[rb], regs[rc])
|
||||
of opcWrObjRef:
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
asgnRef(regs[ra].sons[rb], regs[rc])
|
||||
of opcWrStrIdx:
|
||||
decodeBC(nkStrLit)
|
||||
let idx = regs[rb].intVal.int
|
||||
regs[ra].strVal[idx] = chr(regs[rc].intVal)
|
||||
of opcAddr:
|
||||
decodeB(nkRefTy)
|
||||
if regs[ra].len == 0: regs[ra].add regs[rb]
|
||||
else: regs[ra].sons[0] = regs[rb]
|
||||
of opcDeref:
|
||||
# a = b[]
|
||||
let rb = instr.regB
|
||||
if regs[rb].kind == nkNilLit:
|
||||
stackTrace(c, tos, pc, errNilAccess)
|
||||
assert regs[rb].kind == nkRefTy
|
||||
regs[ra] = regs[rb].sons[0]
|
||||
of opcAddInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal + regs[rc].intVal
|
||||
of opcAddImmInt:
|
||||
decodeBImm(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal + imm
|
||||
of opcSubInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal - regs[rc].intVal
|
||||
of opcSubImmInt:
|
||||
decodeBImm(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal - imm
|
||||
of opcLenSeq:
|
||||
decodeBImm(nkIntLit)
|
||||
assert regs[rb].kind == nkBracket
|
||||
regs[ra].intVal = regs[rb].len - imm
|
||||
of opcLenStr:
|
||||
decodeBImm(nkIntLit)
|
||||
assert regs[rb].kind == nkStrLit
|
||||
regs[ra].intVal = regs[rb].strVal.len - imm
|
||||
of opcIncl:
|
||||
decodeB(nkCurly)
|
||||
if not inSet(regs[ra], regs[rb]): addSon(regs[ra], copyTree(regs[rb]))
|
||||
of opcExcl:
|
||||
decodeB(nkCurly)
|
||||
# XXX arg we need types here :-(
|
||||
var b = newNodeIT(nkCurly, regs[rb].info, regs[rb].typ)
|
||||
addSon(b, regs[rb])
|
||||
var r = diffSets(regs[ra], b)
|
||||
discardSons(regs[ra])
|
||||
for i in countup(0, sonsLen(r) - 1): addSon(regs[ra], r.sons[i])
|
||||
of opcCard:
|
||||
decodeB(nkIntLit)
|
||||
regs[ra].intVal = nimsets.cardSet(regs[rb])
|
||||
of opcMulInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal * regs[rc].intVal
|
||||
of opcDivInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal div regs[rc].intVal
|
||||
of opcModInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal mod regs[rc].intVal
|
||||
of opcAddFloat:
|
||||
decodeBC(nkFloatLit)
|
||||
regs[ra].floatVal = regs[rb].floatVal + regs[rc].floatVal
|
||||
of opcSubFloat:
|
||||
decodeBC(nkFloatLit)
|
||||
regs[ra].floatVal = regs[rb].floatVal - regs[rc].floatVal
|
||||
of opcMulFloat:
|
||||
decodeBC(nkFloatLit)
|
||||
regs[ra].floatVal = regs[rb].floatVal * regs[rc].floatVal
|
||||
of opcDivFloat:
|
||||
decodeBC(nkFloatLit)
|
||||
regs[ra].floatVal = regs[rb].floatVal / regs[rc].floatVal
|
||||
of opcShrInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal shr regs[rc].intVal
|
||||
of opcShlInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal shl regs[rc].intVal
|
||||
of opcBitandInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal and regs[rc].intVal
|
||||
of opcBitorInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal or regs[rc].intVal
|
||||
of opcBitxorInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal xor regs[rc].intVal
|
||||
of opcAddu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal +% regs[rc].intVal
|
||||
of opcSubu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal -% regs[rc].intVal
|
||||
of opcMulu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal *% regs[rc].intVal
|
||||
of opcDivu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal /% regs[rc].intVal
|
||||
of opcModu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = regs[rb].intVal %% regs[rc].intVal
|
||||
of opcEqInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal == regs[rc].intVal)
|
||||
of opcLeInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal <= regs[rc].intVal)
|
||||
of opcLtInt:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal < regs[rc].intVal)
|
||||
of opcEqFloat:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].floatVal == regs[rc].floatVal)
|
||||
of opcLeFloat:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].floatVal <= regs[rc].floatVal)
|
||||
of opcLtFloat:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].floatVal < regs[rc].floatVal)
|
||||
of opcLeu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal <=% regs[rc].intVal)
|
||||
of opcLtu:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal <% regs[rc].intVal)
|
||||
of opcEqRef:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb] == regs[rc])
|
||||
# XXX is this correct? nope ...
|
||||
of opcXor:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = ord(regs[rb].intVal != regs[rc].intVal)
|
||||
of opcNot:
|
||||
decodeB(nkIntLit)
|
||||
assert regs[rb].kind == nkIntLit
|
||||
regs[ra].intVal = 1 - regs[rb].intVal
|
||||
of opcUnaryMinusInt:
|
||||
decodeB(nkIntLit)
|
||||
assert regs[rb].kind == nkIntLit
|
||||
regs[ra].intVal = -regs[rb].intVal
|
||||
of opcUnaryMinusFloat:
|
||||
decodeB(nkFloatLit)
|
||||
assert regs[rb].kind == nkFloatLit
|
||||
regs[ra].floatVal = -regs[rb].floatVal
|
||||
of opcBitnotInt:
|
||||
decodeB(nkIntLit)
|
||||
assert regs[rb].kind == nkIntLit
|
||||
regs[ra].intVal = not regs[rb].intVal
|
||||
of opcEqStr:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(regs[rb].strVal == regs[rc].strVal)
|
||||
of opcLeStr:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(regs[rb].strVal <= regs[rc].strVal)
|
||||
of opcLtStr:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(regs[rb].strVal < regs[rc].strVal)
|
||||
of opcLeSet:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(containsSets(regs[rb], regs[rc]))
|
||||
of opcEqSet:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(equalSets(regs[rb], regs[rc]))
|
||||
of opcLtSet:
|
||||
decodeBC(nkIntLit)
|
||||
let a = regs[rb]
|
||||
let b = regs[rc]
|
||||
regs[ra].intVal = Ord(containsSets(a, b) and not equalSets(a, b))
|
||||
of opcMulSet:
|
||||
decodeBC(nkCurly)
|
||||
move(regs[ra].sons, nimsets.intersectSets(regs[rb], regs[rc]).sons)
|
||||
of opcPlusSet:
|
||||
decodeBC(nkCurly)
|
||||
move(regs[ra].sons, nimsets.unionSets(regs[rb], regs[rc]).sons)
|
||||
of opcMinusSet:
|
||||
decodeBC(nkCurly)
|
||||
move(regs[ra].sons, nimsets.diffSets(regs[rb], regs[rc]).sons)
|
||||
of opcSymDiffSet:
|
||||
decodeBC(nkCurly)
|
||||
move(regs[ra].sons, nimsets.symdiffSets(regs[rb], regs[rc]).sons)
|
||||
of opcConcatStr:
|
||||
decodeBC(nkStrLit)
|
||||
regs[ra].strVal = getstr(regs[rb])
|
||||
for i in rb+1..rb+rc-1:
|
||||
regs[ra].strVal.add getstr(regs[i])
|
||||
of opcEcho:
|
||||
echo regs[ra].strVal
|
||||
of opcContainsSet:
|
||||
decodeBC(nkIntLit)
|
||||
regs[ra].intVal = Ord(inSet(regs[rb], regs[rc]))
|
||||
of opcSubStr:
|
||||
decodeBC(nkStrLit)
|
||||
inc pc
|
||||
assert c.code[pc].opcode == opcSubStr
|
||||
let rd = c.code[pc].regA
|
||||
regs[ra].strVal = substr(regs[rb].strVal, regs[rc].intVal.int,
|
||||
regs[rd].intVal.int)
|
||||
of opcIndCall, opcIndCallAsgn:
|
||||
# dest = call regStart, n; where regStart = fn, arg1, ...
|
||||
let rb = instr.regB
|
||||
let rc = instr.regC
|
||||
let prc = regs[rb].sym
|
||||
let newPc = compile(c, prc)
|
||||
var newFrame = PStackFrame(prc: prc, comesFrom: pc, next: tos)
|
||||
newSeq(newFrame.slots, prc.position)
|
||||
if not isEmptyType(prc.typ.sons[0]):
|
||||
newFrame.slots[0] = getNullValue(prc.typ.sons[0], prc.info)
|
||||
# pass every parameter by var (the language definition allows this):
|
||||
for i in 1 .. rc-1:
|
||||
newFrame.slots[i] = regs[rb+i]
|
||||
# allocate the temporaries:
|
||||
for i in rc .. <prc.position:
|
||||
newFrame.slots[i] = newNode(nkEmpty)
|
||||
tos = newFrame
|
||||
move(regs, newFrame.slots)
|
||||
pc = newPc
|
||||
of opcTJmp:
|
||||
# jump Bx if A != 0
|
||||
let rbx = instr.regBx - wordExcess - 1 # -1 for the following 'inc pc'
|
||||
if regs[ra].intVal != 0:
|
||||
inc pc, rbx
|
||||
of opcFJmp:
|
||||
# jump Bx if A == 0
|
||||
let rbx = instr.regBx - wordExcess - 1 # -1 for the following 'inc pc'
|
||||
if regs[ra].intVal == 0:
|
||||
inc pc, rbx
|
||||
of opcJmp:
|
||||
# jump Bx
|
||||
let rbx = instr.regBx - wordExcess - 1 # -1 for the following 'inc pc'
|
||||
inc pc, rbx
|
||||
of opcBranch:
|
||||
# we know the next instruction is a 'jmp':
|
||||
let branch = c.constants[instr.regBx-wordExcess]
|
||||
var cond = false
|
||||
for j in countup(0, sonsLen(branch) - 2):
|
||||
if overlap(regs[ra], branch.sons[j]):
|
||||
cond = true
|
||||
break
|
||||
assert c.code[pc+1].opcode == opcJmp
|
||||
inc pc
|
||||
# we skip this instruction so that the final 'inc(pc)' skips
|
||||
# the following jump
|
||||
if cond:
|
||||
let instr2 = c.code[pc]
|
||||
let rbx = instr2.regBx - wordExcess - 1 # -1 for the following 'inc pc'
|
||||
inc pc, rbx
|
||||
of opcTry:
|
||||
let rbx = instr.regBx - wordExcess
|
||||
tos.pushSafePoint(pc + rbx)
|
||||
of opcExcept:
|
||||
# just skip it; it's followed by a jump;
|
||||
# we'll execute in the 'raise' handler
|
||||
discard
|
||||
of opcFinally:
|
||||
# just skip it; it's followed by the code we need to execute anyway
|
||||
tos.popSafePoint()
|
||||
of opcFinallyEnd:
|
||||
if c.currentExceptionA != nil:
|
||||
# we are in a cleanup run:
|
||||
pc = cleanupOnException(c, tos, regs)-1
|
||||
if pc < 0:
|
||||
bailOut(c, tos)
|
||||
return
|
||||
of opcRaise:
|
||||
let raised = regs[ra]
|
||||
c.currentExceptionA = raised
|
||||
c.exceptionInstr = pc
|
||||
# -1 because of the following 'inc'
|
||||
pc = cleanupOnException(c, tos, regs) - 1
|
||||
if pc < 0:
|
||||
bailOut(c, tos)
|
||||
return
|
||||
of opcNew:
|
||||
let typ = c.types[instr.regBx - wordExcess]
|
||||
regs[ra] = getNullValue(typ, regs[ra].info)
|
||||
of opcNewSeq:
|
||||
let typ = c.types[instr.regBx - wordExcess]
|
||||
inc pc
|
||||
ensureKind(nkBracket)
|
||||
let instr2 = c.code[pc]
|
||||
let rb = instr2.regA
|
||||
regs[ra].typ = typ
|
||||
newSeq(regs[ra].sons, rb)
|
||||
for i in 0 .. <rb:
|
||||
regs[ra].sons[i] = getNullValue(typ, regs[ra].info)
|
||||
of opcNewStr:
|
||||
decodeB(nkStrLit)
|
||||
regs[ra].strVal = newString(regs[rb].intVal.int)
|
||||
of opcLdImmInt:
|
||||
# dest = immediate value
|
||||
decodeBx(nkIntLit)
|
||||
regs[ra].intVal = rbx
|
||||
of opcLdNull:
|
||||
let typ = c.types[instr.regBx - wordExcess]
|
||||
regs[ra] = getNullValue(typ, c.debug[pc])
|
||||
of opcLdConst:
|
||||
regs[ra] = c.constants.sons[instr.regBx - wordExcess]
|
||||
of opcNBindSym:
|
||||
# trivial implementation:
|
||||
let rb = instr.regB
|
||||
regs[ra] = regs[rb].sons[1]
|
||||
else:
|
||||
InternalError(c.debug[pc], "unknown opcode " & $instr.opcode)
|
||||
inc pc
|
||||
|
||||
proc eval*(c: PCtx, n: PNode): PNode =
|
||||
## eval never returns nil! This simplifies the code a lot and
|
||||
## makes it faster too.
|
||||
let start = genStmt(c, n)
|
||||
# execute new instructions; this redundant opcEof check saves us lots
|
||||
# of allocations in 'execute':
|
||||
if c.code[start].opcode != opcEof:
|
||||
execute(c, start)
|
||||
result = emptyNode
|
||||
|
||||
proc myOpen(module: PSym): PPassContext =
|
||||
#var c = newEvalContext(module, emRepl)
|
||||
#c.features = {allowCast, allowFFI, allowInfiniteLoops}
|
||||
#pushStackFrame(c, newStackFrame())
|
||||
result = newCtx()
|
||||
|
||||
var oldErrorCount: int
|
||||
|
||||
proc myProcess(c: PPassContext, n: PNode): PNode =
|
||||
# don't eval errornous code:
|
||||
if oldErrorCount == msgs.gErrorCounter:
|
||||
result = eval(PCtx(c), n)
|
||||
else:
|
||||
result = n
|
||||
oldErrorCount = msgs.gErrorCounter
|
||||
|
||||
const vmPass* = makePass(myOpen, nil, myProcess, myProcess)
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue