flag tests for opcode 2b - mu - Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society.

diff options

author	Kartik Agaram <vc@akkartik.com>	2019-05-13 10:00:44 -0700
committer	Kartik Agaram <vc@akkartik.com>	2019-05-13 10:00:44 -0700
commit	97ef7c4362b40609ec1c4881d2dedc58a9f12c41 (patch)
tree	f78e6565cc5d3e7c31a627ef8d8e194e8a6f4705 /053new-segment.subx
parent	32a8e12efa6a9f91baaf324d202dfee44726e437 (diff)
download	mu-97ef7c4362b40609ec1c4881d2dedc58a9f12c41.tar.gz

flag tests for opcode 2b

Diffstat (limited to '053new-segment.subx')

0 files changed, 0 insertions, 0 deletions

# # # The Nimrod Compiler # (c) Copyright 2011 Andreas Rumpf # # See the file "copying.txt", included in this # distribution, for details about the copyright. # const RangeExpandLimit = 256 # do not generate ranges # over 'RangeExpandLimit' elements stringCaseThreshold = 8 # above X strings a hash-switch for strings is generated proc genVarTuple(p: BProc, n: PNode) = var tup, field: TLoc if n.kind != nkVarTuple: InternalError(n.info, "genVarTuple") var L = sonsLen(n) genLineDir(p, n) initLocExpr(p, n.sons[L - 1], tup) var t = tup.t for i in countup(0, L - 3): var v = n.sons[i].sym if sfGlobal in v.flags: assignGlobalVar(p, v) genObjectInit(p, cpsInit, v.typ, v.loc, true) else: assignLocalVar(p, v) initVariable(p, v) initLoc(field, locExpr, t.sons[i], tup.s) if t.n == nil: field.r = ropef("$1.Field$2", [rdLoc(tup), toRope(i)]) else: if (t.n.sons[i].kind != nkSym): InternalError(n.info, "genVarTuple") field.r = ropef("$1.$2", [rdLoc(tup), mangleRecFieldName(t.n.sons[i].sym, t)]) putLocIntoDest(p, v.loc, field) proc genSingleVar(p: BProc, a: PNode) = var v = a.sons[0].sym if sfGlobal in v.flags: assignGlobalVar(p, v) genObjectInit(p, cpsInit, v.typ, v.loc, true) else: assignLocalVar(p, v) initVariable(p, v) if a.sons[2].kind != nkEmpty: genLineDir(p, a) expr(p, a.sons[2], v.loc) proc genVarStmt(p: BProc, n: PNode) = for i in countup(0, sonsLen(n) - 1): var a = n.sons[i] if a.kind == nkCommentStmt: continue if a.kind == nkIdentDefs: assert(a.sons[0].kind == nkSym) genSingleVar(p, a) else: genVarTuple(p, a) proc genConstStmt(p: BProc, t: PNode) = for i in countup(0, sonsLen(t) - 1): var it = t.sons[i] if it.kind == nkCommentStmt: continue if it.kind != nkConstDef: InternalError(t.info, "genConstStmt") var c = it.sons[0].sym if sfFakeConst in c.flags: genSingleVar(p, it) elif c.typ.kind in ConstantDataTypes and not (lfNoDecl in c.loc.flags) and c.ast.len != 0: # generate the data: fillLoc(c.loc, locData, c.typ, mangleName(c), OnUnknown) if sfImportc in c.flags: appf(p.module.s[cfsData], "extern NIM_CONST $1 $2;$n", [getTypeDesc(p.module, c.typ), c.loc.r]) else: appf(p.module.s[cfsData], "NIM_CONST $1 $2 = $3;$n", [getTypeDesc(p.module, c.typ), c.loc.r, genConstExpr(p, c.ast)]) proc genIfStmt(p: BProc, n: PNode) = # # if (!expr1) goto L1; # thenPart # goto LEnd # L1: # if (!expr2) goto L2; # thenPart2 # goto LEnd # L2: # elsePart # Lend: # var a: TLoc Lelse: TLabel genLineDir(p, n) var Lend = getLabel(p) for i in countup(0, sonsLen(n) - 1): var it = n.sons[i] case it.kind of nkElifBranch: initLocExpr(p, it.sons[0], a) Lelse = getLabel(p) inc(p.labels) appff(p.s[cpsStmts], "if (!$1) goto $2;$n", "br i1 $1, label %LOC$3, label %$2$n" & "LOC$3: $n", [rdLoc(a), Lelse, toRope(p.labels)]) genStmts(p, it.sons[1]) if sonsLen(n) > 1: appff(p.s[cpsStmts], "goto $1;$n", "br label %$1$n", [Lend]) fixLabel(p, Lelse) of nkElse: genStmts(p, it.sons[0]) else: internalError(n.info, "genIfStmt()") if sonsLen(n) > 1: fixLabel(p, Lend) proc popSafePoints(p: BProc, howMany: int) = var L = p.nestedTryStmts.len # danger of endless recursion! we workaround this here by a temp stack var stack: seq[PNode] newSeq(stack, howMany) for i in countup(1, howMany): stack[i-1] = p.nestedTryStmts[L-i] setLen(p.nestedTryStmts, L-howMany) for tryStmt in items(stack): appcg(p, cpsStmts, "#popSafePoint();$n", []) var finallyStmt = lastSon(tryStmt) if finallyStmt.kind == nkFinally: genStmts(p, finallyStmt.sons[0]) # push old elements again: for i in countdown(howMany-1, 0): p.nestedTryStmts.add(stack[i]) proc genReturnStmt(p: BProc, t: PNode) = p.beforeRetNeeded = true popSafePoints(p, min(1, p.nestedTryStmts.len)) genLineDir(p, t) if (t.sons[0].kind != nkEmpty): genStmts(p, t.sons[0]) appff(p.s[cpsStmts], "goto BeforeRet;$n", "br label %BeforeRet$n", []) proc genWhileStmt(p: BProc, t: PNode) = # we don't generate labels here as for example GCC would produce # significantly worse code var a: TLoc Labl: TLabel length: int inc(p.withinLoop) genLineDir(p, t) assert(sonsLen(t) == 2) inc(p.labels) Labl = con("LA", toRope(p.labels)) length = len(p.blocks) setlen(p.blocks, length + 1) p.blocks[length].id = - p.labels # negative because it isn't used yet p.blocks[length].nestedTryStmts = p.nestedTryStmts.len appf(p.s[cpsStmts], "while (1) {$n") initLocExpr(p, t.sons[0], a) if (t.sons[0].kind != nkIntLit) or (t.sons[0].intVal == 0): p.blocks[length].id = abs(p.blocks[length].id) appf(p.s[cpsStmts], "if (!$1) goto $2;$n", [rdLoc(a), Labl]) genStmts(p, t.sons[1]) if p.blocks[length].id > 0: appf(p.s[cpsStmts], "} $1: ;$n", [Labl]) else: appf(p.s[cpsStmts], "}$n") setlen(p.blocks, len(p.blocks) - 1) dec(p.withinLoop) proc genBlock(p: BProc, t: PNode, d: var TLoc) = inc(p.labels) var idx = len(p.blocks) if t.sons[0].kind != nkEmpty: # named block? assert(t.sons[0].kind == nkSym) var sym = t.sons[0].sym sym.loc.k = locOther sym.loc.a = idx setlen(p.blocks, idx + 1) p.blocks[idx].id = -p.labels # negative because it isn't used yet p.blocks[idx].nestedTryStmts = p.nestedTryStmts.len if t.kind == nkBlockExpr: genStmtListExpr(p, t.sons[1], d) else: genStmts(p, t.sons[1]) if p.blocks[idx].id > 0: appf(p.s[cpsStmts], "LA$1: ;$n", [toRope(p.blocks[idx].id)]) setlen(p.blocks, idx) proc genBreakStmt(p: BProc, t: PNode) = var idx = len(p.blocks) - 1 if t.sons[0].kind != nkEmpty: # named break? assert(t.sons[0].kind == nkSym) var sym = t.sons[0].sym assert(sym.loc.k == locOther) idx = sym.loc.a p.blocks[idx].id = abs(p.blocks[idx].id) # label is used popSafePoints(p, p.nestedTryStmts.len - p.blocks[idx].nestedTryStmts) genLineDir(p, t) appf(p.s[cpsStmts], "goto LA$1;$n", [toRope(p.blocks[idx].id)]) proc getRaiseFrmt(p: BProc): string = #if gCmd == cmdCompileToCpp: # result = "throw #nimException($1, $2);$n" #else: result = "#raiseException((#E_Base*)$1, $2);$n" proc genRaiseStmt(p: BProc, t: PNode) = if t.sons[0].kind != nkEmpty: var a: TLoc InitLocExpr(p, t.sons[0], a) var e = rdLoc(a) var typ = skipTypes(t.sons[0].typ, abstractPtrs) genLineDir(p, t) appcg(p, cpsStmts, getRaiseFrmt(p), [e, makeCString(typ.sym.name.s)]) else: genLineDir(p, t) # reraise the last exception: #if gCmd == cmdCompileToCpp: # appcg(p, cpsStmts, "throw;$n") #else: appcg(p, cpsStmts, "#reraiseException();$n") proc genCaseGenericBranch(p: BProc, b: PNode, e: TLoc, rangeFormat, eqFormat: TFormatStr, labl: TLabel) = var x, y: TLoc var length = sonsLen(b) for i in countup(0, length - 2): if b.sons[i].kind == nkRange: initLocExpr(p, b.sons[i].sons[0], x) initLocExpr(p, b.sons[i].sons[1], y) appcg(p, cpsStmts, rangeFormat, [rdCharLoc(e), rdCharLoc(x), rdCharLoc(y), labl]) else: initLocExpr(p, b.sons[i], x) appcg(p, cpsStmts, eqFormat, [rdCharLoc(e), rdCharLoc(x), labl]) proc genCaseSecondPass(p: BProc, t: PNode, labId, until: int): TLabel = var Lend = getLabel(p) for i in 1..until: appf(p.s[cpsStmts], "LA$1: ;$n", [toRope(labId + i)]) if t.sons[i].kind == nkOfBranch: var length = sonsLen(t.sons[i]) genStmts(p, t.sons[i].sons[length - 1]) appf(p.s[cpsStmts], "goto $1;$n", [Lend]) else: genStmts(p, t.sons[i].sons[0]) result = Lend proc genIfForCaseUntil(p: BProc, t: PNode, rangeFormat, eqFormat: TFormatStr, until: int, a: TLoc): TLabel = # generate a C-if statement for a Nimrod case statement var labId = p.labels for i in 1..until: inc(p.labels) if t.sons[i].kind == nkOfBranch: # else statement genCaseGenericBranch(p, t.sons[i], a, rangeFormat, eqFormat, con("LA", toRope(p.labels))) else: appf(p.s[cpsStmts], "goto LA$1;$n", [toRope(p.labels)]) if until < t.len-1: inc(p.labels) var gotoTarget = p.labels appf(p.s[cpsStmts], "goto LA$1;$n", [toRope(gotoTarget)]) result = genCaseSecondPass(p, t, labId, until) appf(p.s[cpsStmts], "LA$1: ;$n", [toRope(gotoTarget)]) else: result = genCaseSecondPass(p, t, labId, until) proc genCaseGeneric(p: BProc, t: PNode, rangeFormat, eqFormat: TFormatStr) = var a: TLoc initLocExpr(p, t.sons[0], a) var Lend = genIfForCaseUntil(p, t, rangeFormat, eqFormat, sonsLen(t)-1, a) fixLabel(p, Lend) proc genCaseStringBranch(p: BProc, b: PNode, e: TLoc, labl: TLabel, branches: var openArray[PRope]) = var x: TLoc var length = sonsLen(b) for i in countup(0, length - 2): assert(b.sons[i].kind != nkRange) initLocExpr(p, b.sons[i], x) assert(b.sons[i].kind in {nkStrLit..nkTripleStrLit}) var j = int(hashString(b.sons[i].strVal) and high(branches)) appcg(p.module, branches[j], "if (#eqStrings($1, $2)) goto $3;$n", [rdLoc(e), rdLoc(x), labl]) proc genStringCase(p: BProc, t: PNode) = # count how many constant strings there are in the case: var strings = 0 for i in countup(1, sonsLen(t) - 1): if t.sons[i].kind == nkOfBranch: inc(strings, sonsLen(t.sons[i]) - 1) if strings > stringCaseThreshold: var bitMask = math.nextPowerOfTwo(strings) - 1 var branches: seq[PRope] newSeq(branches, bitMask + 1) var a: TLoc initLocExpr(p, t.sons[0], a) # fist pass: gnerate ifs+goto: var labId = p.labels for i in countup(1, sonsLen(t) - 1): inc(p.labels) if t.sons[i].kind == nkOfBranch: genCaseStringBranch(p, t.sons[i], a, con("LA", toRope(p.labels)), branches) else: # else statement: nothing to do yet # but we reserved a label, which we use later appcg(p, cpsStmts, "switch (#hashString($1) & $2) {$n", [rdLoc(a), toRope(bitMask)]) for j in countup(0, high(branches)): if branches[j] != nil: appf(p.s[cpsStmts], "case $1: $n$2break;$n", [intLiteral(j), branches[j]]) appf(p.s[cpsStmts], "}$n") # else statement: if t.sons[sonsLen(t) - 1].kind != nkOfBranch: appf(p.s[cpsStmts], "goto LA$1;$n", [toRope(p.labels)]) # third pass: generate statements var Lend = genCaseSecondPass(p, t, labId, sonsLen(t)-1) fixLabel(p, Lend) else: genCaseGeneric(p, t, "", "if (#eqStrings($1, $2)) goto $3;$n") proc branchHasTooBigRange(b: PNode): bool = for i in countup(0, sonsLen(b)-2): # last son is block if (b.sons[i].Kind == nkRange) and b.sons[i].sons[1].intVal - b.sons[i].sons[0].intVal > RangeExpandLimit: return true proc IfSwitchSplitPoint(p: BProc, n: PNode): int = for i in 1..n.len-1: var branch = n[i] var stmtBlock = lastSon(branch) if stmtBlock.stmtsContainPragma(wLinearScanEnd): result = i elif hasSwitchRange notin CC[ccompiler].props: if branch.kind == nkOfBranch and branchHasTooBigRange(branch): result = i proc genOrdinalCase(p: BProc, n: PNode) = # analyse 'case' statement: var splitPoint = IfSwitchSplitPoint(p, n) # generate if part (might be empty): var a: TLoc initLocExpr(p, n.sons[0], a) var Lend = if splitPoint > 0: genIfForCaseUntil(p, n, rangeFormat = "if ($1 >= $2 && $1 <= $3) goto $4;$n", eqFormat = "if ($1 == $2) goto $3;$n", splitPoint, a) else: nil # generate switch part (might be empty): if splitPoint+1 < n.len: appf(p.s[cpsStmts], "switch ($1) {$n", [rdCharLoc(a)]) var hasDefault = false for i in splitPoint+1 .. < n.len: var branch = n[i] if branch.kind == nkOfBranch: var length = branch.len for j in 0 .. length-2: if branch[j].kind == nkRange: if hasSwitchRange in CC[ccompiler].props: appf(p.s[cpsStmts], "case $1 ... $2:$n", [ genLiteral(p, branch[j][0]), genLiteral(p, branch[j][1])]) else: var v = copyNode(branch[j][0]) while v.intVal <= branch[j][1].intVal: appf(p.s[cpsStmts], "case $1:$n", [genLiteral(p, v)]) Inc(v.intVal) else: appf(p.s[cpsStmts], "case $1:$n", [genLiteral(p, branch[j])]) genStmts(p, branch[length-1]) else: # else part of case statement: appf(p.s[cpsStmts], "default:$n") genStmts(p, branch[0]) hasDefault = true appf(p.s[cpsStmts], "break;$n") if (hasAssume in CC[ccompiler].props) and not hasDefault: appf(p.s[cpsStmts], "default: __assume(0);$n") appf(p.s[cpsStmts], "}$n") if Lend != nil: fixLabel(p, Lend) proc genCaseStmt(p: BProc, t: PNode) = genLineDir(p, t) case skipTypes(t.sons[0].typ, abstractVarRange).kind of tyString: genStringCase(p, t) of tyFloat..tyFloat128: genCaseGeneric(p, t, "if ($1 >= $2 && $1 <= $3) goto $4;$n", "if ($1 == $2) goto $3;$n") else: genOrdinalCase(p, t) proc hasGeneralExceptSection(t: PNode): bool = var length = sonsLen(t) var i = 1 while (i < length) and (t.sons[i].kind == nkExceptBranch): var blen = sonsLen(t.sons[i]) if blen == 1: return true inc(i) result = false proc genTryStmtCpp(p: BProc, t: PNode) = # code to generate: # # bool tmpRethrow = false; # try # { # myDiv(4, 9); # } catch (NimException& tmp) { # tmpRethrow = true; # switch (tmp.exc) # { # case DIVIDE_BY_ZERO: # tmpRethrow = false; # printf("Division by Zero\n"); # break; # default: // used for general except! # generalExceptPart(); # tmpRethrow = false; # } # } # excHandler = excHandler->prev; // we handled the exception # finallyPart(); # if (tmpRethrow) throw; var rethrowFlag: PRope exc: PRope i, length, blen: int genLineDir(p, t) rethrowFlag = nil exc = getTempName() if not hasGeneralExceptSection(t): rethrowFlag = getTempName() appf(p.s[cpsLocals], "volatile NIM_BOOL $1 = NIM_FALSE;$n", [rethrowFlag]) if optStackTrace in p.Options: appcg(p, cpsStmts, "#setFrame((TFrame*)&F);$n") appf(p.s[cpsStmts], "try {$n") add(p.nestedTryStmts, t) genStmts(p, t.sons[0]) length = sonsLen(t) if t.sons[1].kind == nkExceptBranch: appf(p.s[cpsStmts], "} catch (NimException& $1) {$n", [exc]) if rethrowFlag != nil: appf(p.s[cpsStmts], "$1 = NIM_TRUE;$n", [rethrowFlag]) appf(p.s[cpsStmts], "if ($1.sp.exc) {$n", [exc]) i = 1 while (i < length) and (t.sons[i].kind == nkExceptBranch): blen = sonsLen(t.sons[i]) if blen == 1: # general except section: appf(p.s[cpsStmts], "default:$n") genStmts(p, t.sons[i].sons[0]) else: for j in countup(0, blen - 2): assert(t.sons[i].sons[j].kind == nkType) appf(p.s[cpsStmts], "case $1:$n", [toRope(t.sons[i].sons[j].typ.id)]) genStmts(p, t.sons[i].sons[blen - 1]) if rethrowFlag != nil: appf(p.s[cpsStmts], "$1 = NIM_FALSE; ", [rethrowFlag]) appf(p.s[cpsStmts], "break;$n") inc(i) if t.sons[1].kind == nkExceptBranch: appf(p.s[cpsStmts], "}}$n") # end of catch-switch statement appcg(p, cpsStmts, "#popSafePoint();") discard pop(p.nestedTryStmts) if (i < length) and (t.sons[i].kind == nkFinally): genStmts(p, t.sons[i].sons[0]) if rethrowFlag != nil: appf(p.s[cpsStmts], "if ($1) { throw; }$n", [rethrowFlag]) proc genTryStmt(p: BProc, t: PNode) = # code to generate: # # TSafePoint sp; # pushSafePoint(&sp); # sp.status = setjmp(sp.context); # if (sp.status == 0) { # myDiv(4, 9); # popSafePoint(); # } else { # popSafePoint(); # /* except DivisionByZero: */ # if (sp.status == DivisionByZero) { # printf('Division by Zero\n'); # clearException(); # } else { # clearException(); # } # } # /* finally: */ # printf('fin!\n'); # if (exception not cleared) # propagateCurrentException(); genLineDir(p, t) var safePoint = getTempName() discard cgsym(p.module, "E_Base") appcg(p, cpsLocals, "#TSafePoint $1;$n", [safePoint]) appcg(p, cpsStmts, "#pushSafePoint(&$1);$n" & "$1.status = setjmp($1.context);$n", [safePoint]) if optStackTrace in p.Options: appcg(p, cpsStmts, "#setFrame((TFrame*)&F);$n") appf(p.s[cpsStmts], "if ($1.status == 0) {$n", [safePoint]) var length = sonsLen(t) add(p.nestedTryStmts, t) genStmts(p, t.sons[0]) appcg(p, cpsStmts, "#popSafePoint();$n} else {$n#popSafePoint();$n") var i = 1 while (i < length) and (t.sons[i].kind == nkExceptBranch): var blen = sonsLen(t.sons[i]) if blen == 1: # general except section: if i > 1: appf(p.s[cpsStmts], "else {$n") genStmts(p, t.sons[i].sons[0]) appcg(p, cpsStmts, "$1.status = 0;#popCurrentException();$n", [safePoint]) if i > 1: appf(p.s[cpsStmts], "}$n") else: var orExpr: PRope = nil for j in countup(0, blen - 2): assert(t.sons[i].sons[j].kind == nkType) if orExpr != nil: app(orExpr, "||") appcg(p.module, orExpr, "#isObj(#getCurrentException()->Sup.m_type, $1)", [genTypeInfo(p.module, t.sons[i].sons[j].typ)]) if i > 1: app(p.s[cpsStmts], "else ") appf(p.s[cpsStmts], "if ($1) {$n", [orExpr]) genStmts(p, t.sons[i].sons[blen-1]) # code to clear the exception: appcg(p, cpsStmts, "$1.status = 0;#popCurrentException();}$n", [safePoint]) inc(i) appf(p.s[cpsStmts], "}$n") # end of if statement discard pop(p.nestedTryStmts) if i < length and t.sons[i].kind == nkFinally: genStmts(p, t.sons[i].sons[0]) appcg(p, cpsStmts, "if ($1.status != 0) #reraiseException();$n", [safePoint]) proc genAsmOrEmitStmt(p: BProc, t: PNode): PRope = for i in countup(0, sonsLen(t) - 1): case t.sons[i].Kind of nkStrLit..nkTripleStrLit: app(result, t.sons[i].strVal) of nkSym: var sym = t.sons[i].sym if sym.kind in {skProc, skMethod}: var a: TLoc initLocExpr(p, t.sons[i], a) app(result, rdLoc(a)) else: var r = sym.loc.r if r == nil: # if no name has already been given, # it doesn't matter much: r = mangleName(sym) sym.loc.r = r # but be consequent! app(result, r) else: InternalError(t.sons[i].info, "genAsmOrEmitStmt()") proc genAsmStmt(p: BProc, t: PNode) = assert(t.kind == nkAsmStmt) genLineDir(p, t) var s = genAsmOrEmitStmt(p, t) appf(p.s[cpsStmts], CC[ccompiler].asmStmtFrmt, [s]) proc genEmit(p: BProc, t: PNode) = genLineDir(p, t) var s = genAsmOrEmitStmt(p, t.sons[1]) if p.prc == nil: # top level emit pragma? app(p.module.s[cfsProcHeaders], s) else: app(p.s[cpsStmts], s) var breakPointId: int = 0 gBreakpoints: PRope # later the breakpoints are inserted into the main proc proc genBreakPoint(p: BProc, t: PNode) = var name: string if optEndb in p.Options: if t.kind == nkExprColonExpr: assert(t.sons[1].kind in {nkStrLit..nkTripleStrLit}) name = normalize(t.sons[1].strVal) else: inc(breakPointId) name = "bp" & $breakPointId genLineDir(p, t) # BUGFIX appcg(p.module, gBreakpoints, "#dbgRegisterBreakpoint($1, (NCSTRING)$2, (NCSTRING)$3);$n", [ toRope(toLinenumber(t.info)), makeCString(toFilename(t.info)), makeCString(name)]) proc genPragma(p: BProc, n: PNode) = for i in countup(0, sonsLen(n) - 1): var it = n.sons[i] case whichPragma(it) of wEmit: genEmit(p, it) of wBreakpoint: genBreakPoint(p, it) of wDeadCodeElim: if not (optDeadCodeElim in gGlobalOptions): # we need to keep track of ``deadCodeElim`` pragma if (sfDeadCodeElim in p.module.module.flags): addPendingModule(p.module) else: nil proc FieldDiscriminantCheckNeeded(p: BProc, asgn: PNode): bool = if optFieldCheck in p.options: var le = asgn.sons[0] if le.kind == nkCheckedFieldExpr: var field = le.sons[0].sons[1].sym result = sfDiscriminant in field.flags elif le.kind == nkDotExpr: var field = le.sons[1].sym result = sfDiscriminant in field.flags proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType, field: PSym) = var t = skipTypes(objtype, abstractVar) assert t.kind == tyObject discard genTypeInfo(p.module, t) var L = lengthOrd(field.typ) if not ContainsOrIncl(p.module.declaredThings, field.id): appcg(p.module, cfsVars, "extern $1", discriminatorTableDecl(p.module, t, field)) appcg(p, cpsStmts, "#FieldDiscriminantCheck((NI)(NU)($1), (NI)(NU)($2), $3, $4);$n", [rdLoc(a), rdLoc(tmp), discriminatorTableName(p.module, t, field), intLiteral(L+1)]) proc asgnFieldDiscriminant(p: BProc, e: PNode) = var a, tmp: TLoc var dotExpr = e.sons[0] var d: PSym if dotExpr.kind == nkCheckedFieldExpr: dotExpr = dotExpr.sons[0] InitLocExpr(p, e.sons[0], a) getTemp(p, a.t, tmp) expr(p, e.sons[1], tmp) genDiscriminantCheck(p, a, tmp, dotExpr.sons[0].typ, dotExpr.sons[1].sym) genAssignment(p, a, tmp, {}) proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) = genLineDir(p, e) if not FieldDiscriminantCheckNeeded(p, e): var a: TLoc InitLocExpr(p, e.sons[0], a) if fastAsgn: incl(a.flags, lfNoDeepCopy) assert(a.t != nil) expr(p, e.sons[1], a) else: asgnFieldDiscriminant(p, e) proc genStmts(p: BProc, t: PNode) = var a: TLoc prc: PSym case t.kind of nkEmpty: nil of nkStmtList: for i in countup(0, sonsLen(t) - 1): genStmts(p, t.sons[i]) of nkBlockStmt: genBlock(p, t, a) of nkIfStmt: genIfStmt(p, t) of nkWhileStmt: genWhileStmt(p, t) of nkVarSection: genVarStmt(p, t) of nkConstSection: genConstStmt(p, t) of nkForStmt: internalError(t.info, "for statement not eliminated") of nkCaseStmt: genCaseStmt(p, t) of nkReturnStmt: genReturnStmt(p, t) of nkBreakStmt: genBreakStmt(p, t) of nkCall, nkHiddenCallConv, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit: genLineDir(p, t) initLocExpr(p, t, a) of nkAsgn: genAsgn(p, t, fastAsgn=false) of nkFastAsgn: genAsgn(p, t, fastAsgn=true) of nkDiscardStmt: genLineDir(p, t) initLocExpr(p, t.sons[0], a) of nkAsmStmt: genAsmStmt(p, t) of nkTryStmt: #if gCmd == cmdCompileToCpp: genTryStmtCpp(p, t) #else: genTryStmt(p, t) of nkRaiseStmt: genRaiseStmt(p, t) of nkTypeSection: # we have to emit the type information for object types here to support # separate compilation: genTypeSection(p.module, t) of nkCommentStmt, nkNilLit, nkIteratorDef, nkIncludeStmt, nkImportStmt, nkFromStmt, nkTemplateDef, nkMacroDef: nil of nkPragma: genPragma(p, t) of nkProcDef, nkMethodDef, nkConverterDef: if (t.sons[genericParamsPos].kind == nkEmpty): prc = t.sons[namePos].sym if (optDeadCodeElim notin gGlobalOptions and sfDeadCodeElim notin getModule(prc).flags) or ({sfExportc, sfCompilerProc} * prc.flags == {sfExportc}) or (sfExportc in prc.flags and lfExportLib in prc.loc.flags) or (prc.kind == skMethod): # we have not only the header: if t.sons[codePos].kind != nkEmpty or lfDynamicLib in prc.loc.flags: genProc(p.module, prc) else: internalError(t.info, "genStmts(" & $t.kind & ')')


context:
space:
mode: