summary refs log tree commit diff stats
path: root/compiler/ccgstmts.nim
diff options
context:
space:
mode:
Diffstat (limited to 'compiler/ccgstmts.nim')
-rw-r--r--compiler/ccgstmts.nim1710
1 files changed, 1710 insertions, 0 deletions
diff --git a/compiler/ccgstmts.nim b/compiler/ccgstmts.nim
new file mode 100644
index 000000000..883108f2c
--- /dev/null
+++ b/compiler/ccgstmts.nim
@@ -0,0 +1,1710 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2015 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# included from cgen.nim
+const
+  RangeExpandLimit = 256      # do not generate ranges
+                              # over 'RangeExpandLimit' elements
+  stringCaseThreshold = 8
+    # above X strings a hash-switch for strings is generated
+
+proc registerTraverseProc(p: BProc, v: PSym) =
+  var traverseProc = ""
+  if p.config.selectedGC in {gcMarkAndSweep, gcHooks, gcRefc} and
+      optOwnedRefs notin p.config.globalOptions and
+      containsGarbageCollectedRef(v.loc.t):
+    # we register a specialized marked proc here; this has the advantage
+    # that it works out of the box for thread local storage then :-)
+    traverseProc = genTraverseProcForGlobal(p.module, v, v.info)
+
+  if traverseProc.len != 0 and not p.hcrOn:
+    if sfThread in v.flags:
+      appcg(p.module, p.module.preInitProc.procSec(cpsInit),
+        "$n\t#nimRegisterThreadLocalMarker($1);$n$n", [traverseProc])
+    else:
+      appcg(p.module, p.module.preInitProc.procSec(cpsInit),
+        "$n\t#nimRegisterGlobalMarker($1);$n$n", [traverseProc])
+
+proc isAssignedImmediately(conf: ConfigRef; n: PNode): bool {.inline.} =
+  if n.kind == nkEmpty:
+    result = false
+  elif n.kind in nkCallKinds and n[0] != nil and n[0].typ != nil and n[0].typ.skipTypes(abstractInst).kind == tyProc:
+    if n[0].kind == nkSym and sfConstructor in n[0].sym.flags:
+      result = true
+    elif isInvalidReturnType(conf, n[0].typ, true):
+      # var v = f()
+      # is transformed into: var v;  f(addr v)
+      # where 'f' **does not** initialize the result!
+      result = false
+    else:
+      result = true
+  elif isInvalidReturnType(conf, n.typ, false):
+    result = false
+  else:
+    result = true
+
+proc inExceptBlockLen(p: BProc): int =
+  result = 0
+  for x in p.nestedTryStmts:
+    if x.inExcept: result.inc
+
+proc startBlockInternal(p: BProc): int {.discardable.} =
+  inc(p.labels)
+  result = p.blocks.len
+
+  p.blocks.add initBlock()
+
+  p.blocks[result].id = p.labels
+  p.blocks[result].nestedTryStmts = p.nestedTryStmts.len.int16
+  p.blocks[result].nestedExceptStmts = p.inExceptBlockLen.int16
+
+template startBlock(p: BProc, start: FormatStr = "{$n",
+                args: varargs[Rope]): int =
+  lineCg(p, cpsStmts, start, args)
+  startBlockInternal(p)
+
+proc endBlock(p: BProc)
+
+proc genVarTuple(p: BProc, n: PNode) =
+  if n.kind != nkVarTuple: internalError(p.config, n.info, "genVarTuple")
+
+  # if we have a something that's been captured, use the lowering instead:
+  for i in 0..<n.len-2:
+    if n[i].kind != nkSym:
+      genStmts(p, lowerTupleUnpacking(p.module.g.graph, n, p.module.idgen, p.prc))
+      return
+
+  # check only the first son
+  var forHcr = treatGlobalDifferentlyForHCR(p.module, n[0].sym)
+  let hcrCond = if forHcr: getTempName(p.module) else: ""
+  var hcrGlobals: seq[tuple[loc: TLoc, tp: Rope]] = @[]
+  # determine if the tuple is constructed at top-level scope or inside of a block (if/while/block)
+  let isGlobalInBlock = forHcr and p.blocks.len > 2
+  # do not close and reopen blocks if this is a 'global' but inside of a block (if/while/block)
+  forHcr = forHcr and not isGlobalInBlock
+
+  if forHcr:
+    # check with the boolean if the initializing code for the tuple should be ran
+    lineCg(p, cpsStmts, "if ($1)$n", [hcrCond])
+    startBlock(p)
+
+  genLineDir(p, n)
+  var tup = initLocExpr(p, n[^1])
+  var t = tup.t.skipTypes(abstractInst)
+  for i in 0..<n.len-2:
+    let vn = n[i]
+    let v = vn.sym
+    if sfCompileTime in v.flags: continue
+    if sfGlobal in v.flags:
+      assignGlobalVar(p, vn, "")
+      genObjectInit(p, cpsInit, v.typ, v.loc, constructObj)
+      registerTraverseProc(p, v)
+    else:
+      assignLocalVar(p, vn)
+      initLocalVar(p, v, immediateAsgn=isAssignedImmediately(p.config, n[^1]))
+    var field = initLoc(locExpr, vn, tup.storage)
+    if t.kind == tyTuple:
+      field.snippet = "$1.Field$2" % [rdLoc(tup), rope(i)]
+    else:
+      if t.n[i].kind != nkSym: internalError(p.config, n.info, "genVarTuple")
+      field.snippet = "$1.$2" % [rdLoc(tup), mangleRecFieldName(p.module, t.n[i].sym)]
+    putLocIntoDest(p, v.loc, field)
+    if forHcr or isGlobalInBlock:
+      hcrGlobals.add((loc: v.loc, tp: "NULL"))
+
+  if forHcr:
+    # end the block where the tuple gets initialized
+    endBlock(p)
+  if forHcr or isGlobalInBlock:
+    # insert the registration of the globals for the different parts of the tuple at the
+    # start of the current scope (after they have been iterated) and init a boolean to
+    # check if any of them is newly introduced and the initializing code has to be ran
+    lineCg(p, cpsLocals, "NIM_BOOL $1 = NIM_FALSE;$n", [hcrCond])
+    for curr in hcrGlobals:
+      lineCg(p, cpsLocals, "$1 |= hcrRegisterGlobal($4, \"$2\", sizeof($3), $5, (void**)&$2);$N",
+              [hcrCond, curr.loc.snippet, rdLoc(curr.loc), getModuleDllPath(p.module, n[0].sym), curr.tp])
+
+
+proc loadInto(p: BProc, le, ri: PNode, a: var TLoc) {.inline.} =
+  if ri.kind in nkCallKinds and (ri[0].kind != nkSym or
+                                 ri[0].sym.magic == mNone):
+    genAsgnCall(p, le, ri, a)
+  else:
+    # this is a hacky way to fix #1181 (tmissingderef)::
+    #
+    #  var arr1 = cast[ptr array[4, int8]](addr foo)[]
+    #
+    # However, fixing this properly really requires modelling 'array' as
+    # a 'struct' in C to preserve dereferencing semantics completely. Not
+    # worth the effort until version 1.0 is out.
+    a.flags.incl(lfEnforceDeref)
+    expr(p, ri, a)
+
+proc assignLabel(b: var TBlock; result: var Rope) {.inline.} =
+  b.label = "LA" & b.id.rope
+  result.add b.label
+
+proc blockBody(b: var TBlock; result: var Rope) =
+  result.add b.sections[cpsLocals]
+  if b.frameLen > 0:
+    result.addf("FR_.len+=$1;$n", [b.frameLen.rope])
+  result.add(b.sections[cpsInit])
+  result.add(b.sections[cpsStmts])
+
+proc endBlock(p: BProc, blockEnd: Rope) =
+  let topBlock = p.blocks.len-1
+  # the block is merged into the parent block
+  p.blocks[topBlock].blockBody(p.blocks[topBlock-1].sections[cpsStmts])
+  setLen(p.blocks, topBlock)
+  # this is done after the block is popped so $n is
+  # properly indented when pretty printing is enabled
+  line(p, cpsStmts, blockEnd)
+
+proc endBlock(p: BProc) =
+  let topBlock = p.blocks.len - 1
+  let frameLen = p.blocks[topBlock].frameLen
+  var blockEnd: Rope = ""
+  if frameLen > 0:
+    blockEnd.addf("FR_.len-=$1;$n", [frameLen.rope])
+  if p.blocks[topBlock].label.len != 0:
+    blockEnd.addf("} $1: ;$n", [p.blocks[topBlock].label])
+  else:
+    blockEnd.addf("}$n", [])
+  endBlock(p, blockEnd)
+
+proc genSimpleBlock(p: BProc, stmts: PNode) {.inline.} =
+  startBlock(p)
+  genStmts(p, stmts)
+  endBlock(p)
+
+proc exprBlock(p: BProc, n: PNode, d: var TLoc) =
+  startBlock(p)
+  expr(p, n, d)
+  endBlock(p)
+
+template preserveBreakIdx(body: untyped): untyped =
+  var oldBreakIdx = p.breakIdx
+  body
+  p.breakIdx = oldBreakIdx
+
+proc genState(p: BProc, n: PNode) =
+  internalAssert p.config, n.len == 1
+  let n0 = n[0]
+  if n0.kind == nkIntLit:
+    let idx = n[0].intVal
+    linefmt(p, cpsStmts, "STATE$1: ;$n", [idx])
+  elif n0.kind == nkStrLit:
+    linefmt(p, cpsStmts, "$1: ;$n", [n0.strVal])
+
+proc blockLeaveActions(p: BProc, howManyTrys, howManyExcepts: int) =
+  # Called by return and break stmts.
+  # Deals with issues faced when jumping out of try/except/finally stmts.
+
+  var stack = newSeq[tuple[fin: PNode, inExcept: bool, label: Natural]](0)
+
+  inc p.withinBlockLeaveActions
+  for i in 1..howManyTrys:
+    let tryStmt = p.nestedTryStmts.pop
+    if p.config.exc == excSetjmp:
+      # Pop safe points generated by try
+      if not tryStmt.inExcept:
+        linefmt(p, cpsStmts, "#popSafePoint();$n", [])
+
+    # Pop this try-stmt of the list of nested trys
+    # so we don't infinite recurse on it in the next step.
+    stack.add(tryStmt)
+
+    # Find finally-stmt for this try-stmt
+    # and generate a copy of its sons
+    var finallyStmt = tryStmt.fin
+    if finallyStmt != nil:
+      genStmts(p, finallyStmt[0])
+
+  dec p.withinBlockLeaveActions
+
+  # push old elements again:
+  for i in countdown(howManyTrys-1, 0):
+    p.nestedTryStmts.add(stack[i])
+
+  # Pop exceptions that was handled by the
+  # except-blocks we are in
+  if noSafePoints notin p.flags:
+    for i in countdown(howManyExcepts-1, 0):
+      linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+
+proc genGotoState(p: BProc, n: PNode) =
+  # we resist the temptation to translate it into duff's device as it later
+  # will be translated into computed gotos anyway for GCC at least:
+  # switch (x.state) {
+  #   case 0: goto STATE0;
+  # ...
+  var a: TLoc = initLocExpr(p, n[0])
+  lineF(p, cpsStmts, "switch ($1) {$n", [rdLoc(a)])
+  p.flags.incl beforeRetNeeded
+  lineF(p, cpsStmts, "case -1:$n", [])
+  blockLeaveActions(p,
+    howManyTrys    = p.nestedTryStmts.len,
+    howManyExcepts = p.inExceptBlockLen)
+  lineF(p, cpsStmts, " goto BeforeRet_;$n", [])
+  var statesCounter = lastOrd(p.config, n[0].typ)
+  if n.len >= 2 and n[1].kind == nkIntLit:
+    statesCounter = getInt(n[1])
+  let prefix = if n.len == 3 and n[2].kind == nkStrLit: n[2].strVal.rope
+               else: rope"STATE"
+  for i in 0i64..toInt64(statesCounter):
+    lineF(p, cpsStmts, "case $2: goto $1$2;$n", [prefix, rope(i)])
+  lineF(p, cpsStmts, "}$n", [])
+
+proc genBreakState(p: BProc, n: PNode, d: var TLoc) =
+  var a: TLoc
+  d = initLoc(locExpr, n, OnUnknown)
+
+  if n[0].kind == nkClosure:
+    a = initLocExpr(p, n[0][1])
+    d.snippet = "(((NI*) $1)[1] < 0)" % [rdLoc(a)]
+  else:
+    a = initLocExpr(p, n[0])
+    # the environment is guaranteed to contain the 'state' field at offset 1:
+    d.snippet = "((((NI*) $1.ClE_0)[1]) < 0)" % [rdLoc(a)]
+
+proc genGotoVar(p: BProc; value: PNode) =
+  if value.kind notin {nkCharLit..nkUInt64Lit}:
+    localError(p.config, value.info, "'goto' target must be a literal value")
+  else:
+    lineF(p, cpsStmts, "goto NIMSTATE_$#;$n", [value.intVal.rope])
+
+proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Rope)
+
+proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Rope) =
+  if lfDynamicLib in v.loc.flags or sfThread in v.flags or p.hcrOn:
+    discard "nothing to do"
+  elif sfGlobal in v.flags and value != nil and isDeepConstExpr(value, p.module.compileToCpp) and
+      p.withinLoop == 0 and not containsGarbageCollectedRef(v.typ):
+    #echo "New code produced for ", v.name.s, " ", p.config $ value.info
+    genBracedInit(p, value, isConst = false, v.typ, result)
+
+proc genCppParamsForCtor(p: BProc; call: PNode; didGenTemp: var bool): string =
+  result = ""
+  var argsCounter = 0
+  let typ = skipTypes(call[0].typ, abstractInst)
+  assert(typ.kind == tyProc)
+  for i in 1..<call.len:
+    #if it's a type we can just generate here another initializer as we are in an initializer context
+    if call[i].kind == nkCall and call[i][0].kind == nkSym and call[i][0].sym.kind == skType:
+      if argsCounter > 0: result.add ","
+      result.add genCppInitializer(p.module, p, call[i][0].sym.typ, didGenTemp)
+    else:
+      #We need to test for temp in globals, see: #23657
+      let param =
+        if typ[i].kind in {tyVar} and call[i].kind == nkHiddenAddr:
+          call[i][0]
+        else:
+          call[i]
+      if param.kind != nkBracketExpr or param.typ.kind in
+        {tyRef, tyPtr, tyUncheckedArray, tyArray, tyOpenArray,
+          tyVarargs, tySequence, tyString, tyCstring, tyTuple}:
+        let tempLoc = initLocExprSingleUse(p, param)
+        didGenTemp = didGenTemp or tempLoc.k == locTemp
+      genOtherArg(p, call, i, typ, result, argsCounter)
+
+proc genCppVarForCtor(p: BProc; call: PNode; decl: var Rope, didGenTemp: var bool) =
+  let params = genCppParamsForCtor(p, call, didGenTemp)
+  if params.len == 0:
+    decl = runtimeFormat("$#;\n", [decl])
+  else:
+    decl = runtimeFormat("$#($#);\n", [decl, params])
+
+proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
+  if sfGoto in v.flags:
+    # translate 'var state {.goto.} = X' into 'goto LX':
+    genGotoVar(p, value)
+    return
+  let imm = isAssignedImmediately(p.config, value)
+  let isCppCtorCall = p.module.compileToCpp and imm and
+    value.kind in nkCallKinds and value[0].kind == nkSym and
+    v.typ.kind != tyPtr and sfConstructor in value[0].sym.flags
+  var targetProc = p
+  var valueAsRope = ""
+  potentialValueInit(p, v, value, valueAsRope)
+  if sfGlobal in v.flags:
+    if v.flags * {sfImportc, sfExportc} == {sfImportc} and
+        value.kind == nkEmpty and
+        v.loc.flags * {lfHeader, lfNoDecl} != {}:
+      return
+    if sfPure in v.flags:
+      # v.owner.kind != skModule:
+      targetProc = p.module.preInitProc
+    if isCppCtorCall and not containsHiddenPointer(v.typ):
+      var didGenTemp = false
+      callGlobalVarCppCtor(targetProc, v, vn, value, didGenTemp)
+      if didGenTemp:
+        message(p.config, vn.info, warnGlobalVarConstructorTemporary, vn.sym.name.s)
+        #We fail to call the constructor in the global scope so we do the call inside the main proc
+        assignGlobalVar(targetProc, vn, valueAsRope)
+        var loc = initLocExprSingleUse(targetProc, value)
+        genAssignment(targetProc, v.loc, loc, {})
+    else:
+      assignGlobalVar(targetProc, vn, valueAsRope)
+
+    # XXX: be careful here.
+    # Global variables should not be zeromem-ed within loops
+    # (see bug #20).
+    # That's why we are doing the construction inside the preInitProc.
+    # genObjectInit relies on the C runtime's guarantees that
+    # global variables will be initialized to zero.
+    if valueAsRope.len == 0:
+      var loc = v.loc
+      # When the native TLS is unavailable, a global thread-local variable needs
+      # one more layer of indirection in order to access the TLS block.
+      # Only do this for complex types that may need a call to `objectInit`
+      if sfThread in v.flags and emulatedThreadVars(p.config) and
+        isComplexValueType(v.typ):
+        loc = initLocExprSingleUse(p.module.preInitProc, vn)
+      genObjectInit(p.module.preInitProc, cpsInit, v.typ, loc, constructObj)
+    # Alternative construction using default constructor (which may zeromem):
+    # if sfImportc notin v.flags: constructLoc(p.module.preInitProc, v.loc)
+    if sfExportc in v.flags and p.module.g.generatedHeader != nil:
+      genVarPrototype(p.module.g.generatedHeader, vn)
+    registerTraverseProc(p, v)
+  else:
+    if imm and p.module.compileToCpp and p.splitDecls == 0 and
+        not containsHiddenPointer(v.typ) and
+        nimErrorFlagAccessed notin p.flags:
+      # C++ really doesn't like things like 'Foo f; f = x' as that invokes a
+      # parameterless constructor followed by an assignment operator. So we
+      # generate better code here: 'Foo f = x;'
+      genLineDir(p, vn)
+      var decl = localVarDecl(p, vn)
+      var tmp: TLoc
+      if isCppCtorCall:
+        var didGenTemp = false
+        genCppVarForCtor(p, value, decl, didGenTemp)
+        line(p, cpsStmts, decl)
+      else:
+        tmp = initLocExprSingleUse(p, value)
+        if value.kind == nkEmpty:
+          lineF(p, cpsStmts, "$#;\n", [decl])
+        else:
+          lineF(p, cpsStmts, "$# = $#;\n", [decl, tmp.rdLoc])
+      return
+    assignLocalVar(p, vn)
+    initLocalVar(p, v, imm)
+
+  let traverseProc = "NULL"
+  # If the var is in a block (control flow like if/while or a block) in global scope just
+  # register the so called "global" so it can be used later on. There is no need to close
+  # and reopen of if (nim_hcr_do_init_) blocks because we are in one already anyway.
+  var forHcr = treatGlobalDifferentlyForHCR(p.module, v)
+  if forHcr and targetProc.blocks.len > 3 and v.owner.kind == skModule:
+    # put it in the locals section - mainly because of loops which
+    # use the var in a call to resetLoc() in the statements section
+    lineCg(targetProc, cpsLocals, "hcrRegisterGlobal($3, \"$1\", sizeof($2), $4, (void**)&$1);$n",
+           [v.loc.snippet, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
+    # nothing special left to do later on - let's avoid closing and reopening blocks
+    forHcr = false
+
+  # we close and reopen the global if (nim_hcr_do_init_) blocks in the main Init function
+  # for the module so we can have globals and top-level code be interleaved and still
+  # be able to re-run it but without the top level code - just the init of globals
+  if forHcr:
+    lineCg(targetProc, cpsStmts, "if (hcrRegisterGlobal($3, \"$1\", sizeof($2), $4, (void**)&$1))$N",
+           [v.loc.snippet, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
+    startBlock(targetProc)
+  if value.kind != nkEmpty and valueAsRope.len == 0:
+    genLineDir(targetProc, vn)
+    if not isCppCtorCall:
+      loadInto(targetProc, vn, value, v.loc)
+  if forHcr:
+    endBlock(targetProc)
+
+proc genSingleVar(p: BProc, a: PNode) =
+  let v = a[0].sym
+  if sfCompileTime in v.flags:
+    # fix issue #12640
+    # {.global, compileTime.} pragma in proc
+    if sfGlobal in v.flags and p.prc != nil and p.prc.kind == skProc:
+      discard
+    else:
+      return
+  genSingleVar(p, v, a[0], a[2])
+
+proc genClosureVar(p: BProc, a: PNode) =
+  var immediateAsgn = a[2].kind != nkEmpty
+  var v: TLoc = initLocExpr(p, a[0])
+  genLineDir(p, a)
+  if immediateAsgn:
+    loadInto(p, a[0], a[2], v)
+  elif sfNoInit notin a[0][1].sym.flags:
+    constructLoc(p, v)
+
+proc genVarStmt(p: BProc, n: PNode) =
+  for it in n.sons:
+    if it.kind == nkCommentStmt: continue
+    if it.kind == nkIdentDefs:
+      # can be a lifted var nowadays ...
+      if it[0].kind == nkSym:
+        genSingleVar(p, it)
+      else:
+        genClosureVar(p, it)
+    else:
+      genVarTuple(p, it)
+
+proc genIf(p: BProc, n: PNode, d: var TLoc) =
+  #
+  #  { if (!expr1) goto L1;
+  #   thenPart }
+  #  goto LEnd
+  #  L1:
+  #  { if (!expr2) goto L2;
+  #   thenPart2 }
+  #  goto LEnd
+  #  L2:
+  #  { elsePart }
+  #  Lend:
+  var
+    a: TLoc
+    lelse: TLabel
+  if not isEmptyType(n.typ) and d.k == locNone:
+    d = getTemp(p, n.typ)
+  genLineDir(p, n)
+  let lend = getLabel(p)
+  for it in n.sons:
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(n.typ): d.k = locNone
+    if it.len == 2:
+      startBlock(p)
+      a = initLocExprSingleUse(p, it[0])
+      lelse = getLabel(p)
+      inc(p.labels)
+      lineF(p, cpsStmts, "if (!$1) goto $2;$n",
+            [rdLoc(a), lelse])
+      if p.module.compileToCpp:
+        # avoid "jump to label crosses initialization" error:
+        p.s(cpsStmts).add "{"
+        expr(p, it[1], d)
+        p.s(cpsStmts).add "}"
+      else:
+        expr(p, it[1], d)
+      endBlock(p)
+      if n.len > 1:
+        lineF(p, cpsStmts, "goto $1;$n", [lend])
+      fixLabel(p, lelse)
+    elif it.len == 1:
+      startBlock(p)
+      expr(p, it[0], d)
+      endBlock(p)
+    else: internalError(p.config, n.info, "genIf()")
+  if n.len > 1: fixLabel(p, lend)
+
+proc genReturnStmt(p: BProc, t: PNode) =
+  if nfPreventCg in t.flags: return
+  p.flags.incl beforeRetNeeded
+  genLineDir(p, t)
+  if (t[0].kind != nkEmpty): genStmts(p, t[0])
+  blockLeaveActions(p,
+    howManyTrys    = p.nestedTryStmts.len,
+    howManyExcepts = p.inExceptBlockLen)
+  if (p.finallySafePoints.len > 0) and noSafePoints notin p.flags:
+    # If we're in a finally block, and we came here by exception
+    # consume it before we return.
+    var safePoint = p.finallySafePoints[^1]
+    linefmt(p, cpsStmts, "if ($1.status != 0) #popCurrentException();$n", [safePoint])
+  lineF(p, cpsStmts, "goto BeforeRet_;$n", [])
+
+proc genGotoForCase(p: BProc; caseStmt: PNode) =
+  for i in 1..<caseStmt.len:
+    startBlock(p)
+    let it = caseStmt[i]
+    for j in 0..<it.len-1:
+      if it[j].kind == nkRange:
+        localError(p.config, it.info, "range notation not available for computed goto")
+        return
+      let val = getOrdValue(it[j])
+      lineF(p, cpsStmts, "NIMSTATE_$#:$n", [val.rope])
+    genStmts(p, it.lastSon)
+    endBlock(p)
+
+
+iterator fieldValuePairs(n: PNode): tuple[memberSym, valueSym: PNode] =
+  assert(n.kind in {nkLetSection, nkVarSection})
+  for identDefs in n:
+    if identDefs.kind == nkIdentDefs:
+      let valueSym = identDefs[^1]
+      for i in 0..<identDefs.len-2:
+        let memberSym = identDefs[i]
+        yield((memberSym: memberSym, valueSym: valueSym))
+
+proc genComputedGoto(p: BProc; n: PNode) =
+  # first pass: Generate array of computed labels:
+
+  # flatten the loop body because otherwise let and var sections
+  # wrapped inside stmt lists by inject destructors won't be recognised
+  let n = n.flattenStmts()
+  var casePos = -1
+  var arraySize: int = 0
+  for i in 0..<n.len:
+    let it = n[i]
+    if it.kind == nkCaseStmt:
+      if lastSon(it).kind != nkOfBranch:
+        localError(p.config, it.info,
+            "case statement must be exhaustive for computed goto"); return
+      casePos = i
+      if enumHasHoles(it[0].typ):
+        localError(p.config, it.info,
+            "case statement cannot work on enums with holes for computed goto"); return
+      let aSize = lengthOrd(p.config, it[0].typ)
+      if aSize > 10_000:
+        localError(p.config, it.info,
+            "case statement has too many cases for computed goto"); return
+      arraySize = toInt(aSize)
+      if firstOrd(p.config, it[0].typ) != 0:
+        localError(p.config, it.info,
+            "case statement has to start at 0 for computed goto"); return
+  if casePos < 0:
+    localError(p.config, n.info, "no case statement found for computed goto"); return
+  var id = p.labels+1
+  inc p.labels, arraySize+1
+  let tmp = "TMP$1_" % [id.rope]
+  var gotoArray = "static void* $#[$#] = {" % [tmp, arraySize.rope]
+  for i in 1..arraySize-1:
+    gotoArray.addf("&&TMP$#_, ", [rope(id+i)])
+  gotoArray.addf("&&TMP$#_};$n", [rope(id+arraySize)])
+  line(p, cpsLocals, gotoArray)
+
+  for j in 0..<casePos:
+    genStmts(p, n[j])
+
+  let caseStmt = n[casePos]
+  var a: TLoc = initLocExpr(p, caseStmt[0])
+  # first goto:
+  lineF(p, cpsStmts, "goto *$#[$#];$n", [tmp, a.rdLoc])
+
+  for i in 1..<caseStmt.len:
+    startBlock(p)
+    let it = caseStmt[i]
+    for j in 0..<it.len-1:
+      if it[j].kind == nkRange:
+        localError(p.config, it.info, "range notation not available for computed goto")
+        return
+
+      let val = getOrdValue(it[j])
+      var lit = newRopeAppender()
+      intLiteral(toInt64(val)+id+1, lit)
+      lineF(p, cpsStmts, "TMP$#_:$n", [lit])
+
+    genStmts(p, it.lastSon)
+
+    for j in casePos+1..<n.len:
+      genStmts(p, n[j])
+
+    for j in 0..<casePos:
+      # prevent new local declarations
+      # compile declarations as assignments
+      let it = n[j]
+      if it.kind in {nkLetSection, nkVarSection}:
+        let asgn = copyNode(it)
+        asgn.transitionSonsKind(nkAsgn)
+        asgn.sons.setLen 2
+        for sym, value in it.fieldValuePairs:
+          if value.kind != nkEmpty:
+            asgn[0] = sym
+            asgn[1] = value
+            genStmts(p, asgn)
+      else:
+        genStmts(p, it)
+
+    var a: TLoc = initLocExpr(p, caseStmt[0])
+    lineF(p, cpsStmts, "goto *$#[$#];$n", [tmp, a.rdLoc])
+    endBlock(p)
+
+  for j in casePos+1..<n.len:
+    genStmts(p, n[j])
+
+
+proc genWhileStmt(p: BProc, t: PNode) =
+  # we don't generate labels here as for example GCC would produce
+  # significantly worse code
+  var
+    a: TLoc
+  assert(t.len == 2)
+  inc(p.withinLoop)
+  genLineDir(p, t)
+
+  preserveBreakIdx:
+    var loopBody = t[1]
+    if loopBody.stmtsContainPragma(wComputedGoto) and
+       hasComputedGoto in CC[p.config.cCompiler].props:
+         # for closure support weird loop bodies are generated:
+      if loopBody.len == 2 and loopBody[0].kind == nkEmpty:
+        loopBody = loopBody[1]
+      genComputedGoto(p, loopBody)
+    else:
+      p.breakIdx = startBlock(p, "while (1) {$n")
+      p.blocks[p.breakIdx].isLoop = true
+      a = initLocExpr(p, t[0])
+      if (t[0].kind != nkIntLit) or (t[0].intVal == 0):
+        lineF(p, cpsStmts, "if (!$1) goto ", [rdLoc(a)])
+        assignLabel(p.blocks[p.breakIdx], p.s(cpsStmts))
+        appcg(p, cpsStmts, ";$n", [])
+      genStmts(p, loopBody)
+
+      if optProfiler in p.options:
+        # invoke at loop body exit:
+        linefmt(p, cpsStmts, "#nimProfile();$n", [])
+      endBlock(p)
+
+  dec(p.withinLoop)
+
+proc genBlock(p: BProc, n: PNode, d: var TLoc) =
+  if not isEmptyType(n.typ):
+    # bug #4505: allocate the temp in the outer scope
+    # so that it can escape the generated {}:
+    if d.k == locNone:
+      d = getTemp(p, n.typ)
+    d.flags.incl(lfEnforceDeref)
+  preserveBreakIdx:
+    p.breakIdx = startBlock(p)
+    if n[0].kind != nkEmpty:
+      # named block?
+      assert(n[0].kind == nkSym)
+      var sym = n[0].sym
+      sym.loc.k = locOther
+      sym.position = p.breakIdx+1
+    expr(p, n[1], d)
+    endBlock(p)
+
+proc genParForStmt(p: BProc, t: PNode) =
+  assert(t.len == 3)
+  inc(p.withinLoop)
+  genLineDir(p, t)
+
+  preserveBreakIdx:
+    let forLoopVar = t[0].sym
+    assignLocalVar(p, t[0])
+    #initLoc(forLoopVar.loc, locLocalVar, forLoopVar.typ, onStack)
+    #discard mangleName(forLoopVar)
+    let call = t[1]
+    assert(call.len == 4 or call.len == 5)
+    var rangeA = initLocExpr(p, call[1])
+    var rangeB = initLocExpr(p, call[2])
+
+    # $n at the beginning because of #9710
+    if call.len == 4: # procName(a, b, annotation)
+      if call[0].sym.name.s == "||":  # `||`(a, b, annotation)
+        lineF(p, cpsStmts, "$n#pragma omp $4$n" &
+                            "for ($1 = $2; $1 <= $3; ++$1)",
+                            [forLoopVar.loc.rdLoc,
+                            rangeA.rdLoc, rangeB.rdLoc,
+                            call[3].getStr.rope])
+      else:
+        lineF(p, cpsStmts, "$n#pragma $4$n" &
+                    "for ($1 = $2; $1 <= $3; ++$1)",
+                    [forLoopVar.loc.rdLoc,
+                    rangeA.rdLoc, rangeB.rdLoc,
+                    call[3].getStr.rope])
+    else: # `||`(a, b, step, annotation)
+      var step: TLoc = initLocExpr(p, call[3])
+      lineF(p, cpsStmts, "$n#pragma omp $5$n" &
+                    "for ($1 = $2; $1 <= $3; $1 += $4)",
+                    [forLoopVar.loc.rdLoc,
+                    rangeA.rdLoc, rangeB.rdLoc, step.rdLoc,
+                    call[4].getStr.rope])
+
+    p.breakIdx = startBlock(p)
+    p.blocks[p.breakIdx].isLoop = true
+    genStmts(p, t[2])
+    endBlock(p)
+
+  dec(p.withinLoop)
+
+proc genBreakStmt(p: BProc, t: PNode) =
+  var idx = p.breakIdx
+  if t[0].kind != nkEmpty:
+    # named break?
+    assert(t[0].kind == nkSym)
+    var sym = t[0].sym
+    doAssert(sym.loc.k == locOther)
+    idx = sym.position-1
+  else:
+    # an unnamed 'break' can only break a loop after 'transf' pass:
+    while idx >= 0 and not p.blocks[idx].isLoop: dec idx
+    if idx < 0 or not p.blocks[idx].isLoop:
+      internalError(p.config, t.info, "no loop to break")
+  p.blocks[idx].label = "LA" & p.blocks[idx].id.rope
+  blockLeaveActions(p,
+    p.nestedTryStmts.len - p.blocks[idx].nestedTryStmts,
+    p.inExceptBlockLen - p.blocks[idx].nestedExceptStmts)
+  genLineDir(p, t)
+  lineF(p, cpsStmts, "goto $1;$n", [p.blocks[idx].label])
+
+proc raiseExit(p: BProc) =
+  assert p.config.exc == excGoto
+  if nimErrorFlagDisabled notin p.flags:
+    p.flags.incl nimErrorFlagAccessed
+    if p.nestedTryStmts.len == 0:
+      p.flags.incl beforeRetNeeded
+      # easy case, simply goto 'ret':
+      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;$n", [])
+    else:
+      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) goto LA$1_;$n",
+        [p.nestedTryStmts[^1].label])
+
+proc raiseExitCleanup(p: BProc, destroy: string) =
+  assert p.config.exc == excGoto
+  if nimErrorFlagDisabled notin p.flags:
+    p.flags.incl nimErrorFlagAccessed
+    if p.nestedTryStmts.len == 0:
+      p.flags.incl beforeRetNeeded
+      # easy case, simply goto 'ret':
+      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) {$1; goto BeforeRet_;}$n", [destroy])
+    else:
+      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) {$2; goto LA$1_;}$n",
+        [p.nestedTryStmts[^1].label, destroy])
+
+proc finallyActions(p: BProc) =
+  if p.config.exc != excGoto and p.nestedTryStmts.len > 0 and p.nestedTryStmts[^1].inExcept:
+    # if the current try stmt have a finally block,
+    # we must execute it before reraising
+    let finallyBlock = p.nestedTryStmts[^1].fin
+    if finallyBlock != nil:
+      genSimpleBlock(p, finallyBlock[0])
+
+proc raiseInstr(p: BProc; result: var Rope) =
+  if p.config.exc == excGoto:
+    let L = p.nestedTryStmts.len
+    if L == 0:
+      p.flags.incl beforeRetNeeded
+      # easy case, simply goto 'ret':
+      result.add ropecg(p.module, "goto BeforeRet_;$n", [])
+    else:
+      # raise inside an 'except' must go to the finally block,
+      # raise outside an 'except' block must go to the 'except' list.
+      result.add ropecg(p.module, "goto LA$1_;$n",
+        [p.nestedTryStmts[L-1].label])
+      # + ord(p.nestedTryStmts[L-1].inExcept)])
+
+proc genRaiseStmt(p: BProc, t: PNode) =
+  if t[0].kind != nkEmpty:
+    var a: TLoc = initLocExprSingleUse(p, t[0])
+    finallyActions(p)
+    var e = rdLoc(a)
+    discard getTypeDesc(p.module, t[0].typ)
+    var typ = skipTypes(t[0].typ, abstractPtrs)
+    case p.config.exc
+    of excCpp:
+      blockLeaveActions(p, howManyTrys = 0, howManyExcepts = p.inExceptBlockLen)
+    of excGoto:
+      blockLeaveActions(p, howManyTrys = 0,
+        howManyExcepts = (if p.nestedTryStmts.len > 0 and p.nestedTryStmts[^1].inExcept: 1 else: 0))
+    else:
+      discard
+    genLineDir(p, t)
+    if isImportedException(typ, p.config):
+      lineF(p, cpsStmts, "throw $1;$n", [e])
+    else:
+      lineCg(p, cpsStmts, "#raiseExceptionEx((#Exception*)$1, $2, $3, $4, $5);$n",
+          [e, makeCString(typ.sym.name.s),
+          makeCString(if p.prc != nil: p.prc.name.s else: p.module.module.name.s),
+          quotedFilename(p.config, t.info), toLinenumber(t.info)])
+      if optOwnedRefs in p.config.globalOptions:
+        lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [e])
+  else:
+    finallyActions(p)
+    genLineDir(p, t)
+    linefmt(p, cpsStmts, "#reraiseException();$n", [])
+  raiseInstr(p, p.s(cpsStmts))
+
+template genCaseGenericBranch(p: BProc, b: PNode, e: TLoc,
+                          rangeFormat, eqFormat: FormatStr, labl: TLabel) =
+  var x, y: TLoc
+  for i in 0..<b.len - 1:
+    if b[i].kind == nkRange:
+      x = initLocExpr(p, b[i][0])
+      y = initLocExpr(p, b[i][1])
+      lineCg(p, cpsStmts, rangeFormat,
+           [rdCharLoc(e), rdCharLoc(x), rdCharLoc(y), labl])
+    else:
+      x = initLocExpr(p, b[i])
+      lineCg(p, cpsStmts, eqFormat, [rdCharLoc(e), rdCharLoc(x), labl])
+
+proc genCaseSecondPass(p: BProc, t: PNode, d: var TLoc,
+                       labId, until: int): TLabel =
+  var lend = getLabel(p)
+  for i in 1..until:
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+    lineF(p, cpsStmts, "LA$1_: ;$n", [rope(labId + i)])
+    if t[i].kind == nkOfBranch:
+      exprBlock(p, t[i][^1], d)
+      lineF(p, cpsStmts, "goto $1;$n", [lend])
+    else:
+      exprBlock(p, t[i][0], d)
+  result = lend
+
+template genIfForCaseUntil(p: BProc, t: PNode, d: var TLoc,
+                       rangeFormat, eqFormat: FormatStr,
+                       until: int, a: TLoc): TLabel =
+  # generate a C-if statement for a Nim case statement
+  var res: TLabel
+  var labId = p.labels
+  for i in 1..until:
+    inc(p.labels)
+    if t[i].kind == nkOfBranch: # else statement
+      genCaseGenericBranch(p, t[i], a, rangeFormat, eqFormat,
+                           "LA" & rope(p.labels) & "_")
+    else:
+      lineF(p, cpsStmts, "goto LA$1_;$n", [rope(p.labels)])
+  if until < t.len-1:
+    inc(p.labels)
+    var gotoTarget = p.labels
+    lineF(p, cpsStmts, "goto LA$1_;$n", [rope(gotoTarget)])
+    res = genCaseSecondPass(p, t, d, labId, until)
+    lineF(p, cpsStmts, "LA$1_: ;$n", [rope(gotoTarget)])
+  else:
+    res = genCaseSecondPass(p, t, d, labId, until)
+  res
+
+template genCaseGeneric(p: BProc, t: PNode, d: var TLoc,
+                    rangeFormat, eqFormat: FormatStr) =
+  var a: TLoc = initLocExpr(p, t[0])
+  var lend = genIfForCaseUntil(p, t, d, rangeFormat, eqFormat, t.len-1, a)
+  fixLabel(p, lend)
+
+proc genCaseStringBranch(p: BProc, b: PNode, e: TLoc, labl: TLabel,
+                         stringKind: TTypeKind,
+                         branches: var openArray[Rope]) =
+  var x: TLoc
+  for i in 0..<b.len - 1:
+    assert(b[i].kind != nkRange)
+    x = initLocExpr(p, b[i])
+    var j: int = 0
+    case b[i].kind
+    of nkStrLit..nkTripleStrLit:
+      j = int(hashString(p.config, b[i].strVal) and high(branches))
+    of nkNilLit: j = 0
+    else:
+      assert false, "invalid string case branch node kind"
+    if stringKind == tyCstring:
+      appcg(p.module, branches[j], "if (#eqCstrings($1, $2)) goto $3;$n",
+         [rdLoc(e), rdLoc(x), labl])
+    else:
+      appcg(p.module, branches[j], "if (#eqStrings($1, $2)) goto $3;$n",
+         [rdLoc(e), rdLoc(x), labl])
+
+proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
+  # count how many constant strings there are in the case:
+  var strings = 0
+  for i in 1..<t.len:
+    if t[i].kind == nkOfBranch: inc(strings, t[i].len - 1)
+  if strings > stringCaseThreshold:
+    var bitMask = math.nextPowerOfTwo(strings) - 1
+    var branches: seq[Rope]
+    newSeq(branches, bitMask + 1)
+    var a: TLoc = initLocExpr(p, t[0]) # first pass: generate ifs+goto:
+    var labId = p.labels
+    for i in 1..<t.len:
+      inc(p.labels)
+      if t[i].kind == nkOfBranch:
+        genCaseStringBranch(p, t[i], a, "LA" & rope(p.labels) & "_",
+                            stringKind, branches)
+      else:
+        # else statement: nothing to do yet
+        # but we reserved a label, which we use later
+        discard
+    if stringKind == tyCstring:
+      linefmt(p, cpsStmts, "switch (#hashCstring($1) & $2) {$n",
+              [rdLoc(a), bitMask])
+    else:
+      linefmt(p, cpsStmts, "switch (#hashString($1) & $2) {$n",
+              [rdLoc(a), bitMask])
+    for j in 0..high(branches):
+      if branches[j] != "":
+        var lit = newRopeAppender()
+        intLiteral(j, lit)
+        lineF(p, cpsStmts, "case $1: $n$2break;$n",
+             [lit, branches[j]])
+    lineF(p, cpsStmts, "}$n", []) # else statement:
+    if t[^1].kind != nkOfBranch:
+      lineF(p, cpsStmts, "goto LA$1_;$n", [rope(p.labels)])
+    # third pass: generate statements
+    var lend = genCaseSecondPass(p, t, d, labId, t.len-1)
+    fixLabel(p, lend)
+  else:
+    if stringKind == tyCstring:
+      genCaseGeneric(p, t, d, "", "if (#eqCstrings($1, $2)) goto $3;$n")
+    else:
+      genCaseGeneric(p, t, d, "", "if (#eqStrings($1, $2)) goto $3;$n")
+
+proc branchHasTooBigRange(b: PNode): bool =
+  result = false
+  for it in b:
+    # last son is block
+    if (it.kind == nkRange) and
+        it[1].intVal - it[0].intVal > RangeExpandLimit:
+      return true
+
+proc ifSwitchSplitPoint(p: BProc, n: PNode): int =
+  result = 0
+  for i in 1..<n.len:
+    var branch = n[i]
+    var stmtBlock = lastSon(branch)
+    if stmtBlock.stmtsContainPragma(wLinearScanEnd):
+      result = i
+    elif hasSwitchRange notin CC[p.config.cCompiler].props:
+      if branch.kind == nkOfBranch and branchHasTooBigRange(branch):
+        result = i
+
+proc genCaseRange(p: BProc, branch: PNode) =
+  for j in 0..<branch.len-1:
+    if branch[j].kind == nkRange:
+      if hasSwitchRange in CC[p.config.cCompiler].props:
+        var litA = newRopeAppender()
+        var litB = newRopeAppender()
+        genLiteral(p, branch[j][0], litA)
+        genLiteral(p, branch[j][1], litB)
+        lineF(p, cpsStmts, "case $1 ... $2:$n", [litA, litB])
+      else:
+        var v = copyNode(branch[j][0])
+        while v.intVal <= branch[j][1].intVal:
+          var litA = newRopeAppender()
+          genLiteral(p, v, litA)
+          lineF(p, cpsStmts, "case $1:$n", [litA])
+          inc(v.intVal)
+    else:
+      var litA = newRopeAppender()
+      genLiteral(p, branch[j], litA)
+      lineF(p, cpsStmts, "case $1:$n", [litA])
+
+proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
+  # analyse 'case' statement:
+  var splitPoint = ifSwitchSplitPoint(p, n)
+
+  # generate if part (might be empty):
+  var a: TLoc = initLocExpr(p, n[0])
+  var lend = if splitPoint > 0: genIfForCaseUntil(p, n, d,
+                    rangeFormat = "if ($1 >= $2 && $1 <= $3) goto $4;$n",
+                    eqFormat = "if ($1 == $2) goto $3;$n",
+                    splitPoint, a) else: ""
+
+  # generate switch part (might be empty):
+  if splitPoint+1 < n.len:
+    lineF(p, cpsStmts, "switch ($1) {$n", [rdCharLoc(a)])
+    var hasDefault = false
+    for i in splitPoint+1..<n.len:
+      # bug #4230: avoid false sharing between branches:
+      if d.k == locTemp and isEmptyType(n.typ): d.k = locNone
+      var branch = n[i]
+      if branch.kind == nkOfBranch:
+        genCaseRange(p, branch)
+      else:
+        # else part of case statement:
+        lineF(p, cpsStmts, "default:$n", [])
+        hasDefault = true
+      exprBlock(p, branch.lastSon, d)
+      lineF(p, cpsStmts, "break;$n", [])
+    if not hasDefault:
+      if hasBuiltinUnreachable in CC[p.config.cCompiler].props:
+        lineF(p, cpsStmts, "default: __builtin_unreachable();$n", [])
+      elif hasAssume in CC[p.config.cCompiler].props:
+        lineF(p, cpsStmts, "default: __assume(0);$n", [])
+    lineF(p, cpsStmts, "}$n", [])
+  if lend != "": fixLabel(p, lend)
+
+proc genCase(p: BProc, t: PNode, d: var TLoc) =
+  genLineDir(p, t)
+  if not isEmptyType(t.typ) and d.k == locNone:
+    d = getTemp(p, t.typ)
+  case skipTypes(t[0].typ, abstractVarRange).kind
+  of tyString:
+    genStringCase(p, t, tyString, d)
+  of tyCstring:
+    genStringCase(p, t, tyCstring, d)
+  of tyFloat..tyFloat128:
+    genCaseGeneric(p, t, d, "if ($1 >= $2 && $1 <= $3) goto $4;$n",
+                            "if ($1 == $2) goto $3;$n")
+  else:
+    if t[0].kind == nkSym and sfGoto in t[0].sym.flags:
+      genGotoForCase(p, t)
+    else:
+      genOrdinalCase(p, t, d)
+
+proc genRestoreFrameAfterException(p: BProc) =
+  if optStackTrace in p.module.config.options:
+    if hasCurFramePointer notin p.flags:
+      p.flags.incl hasCurFramePointer
+      p.procSec(cpsLocals).add(ropecg(p.module, "\tTFrame* _nimCurFrame;$n", []))
+      p.procSec(cpsInit).add(ropecg(p.module, "\t_nimCurFrame = #getFrame();$n", []))
+    linefmt(p, cpsStmts, "#setFrame(_nimCurFrame);$n", [])
+
+proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
+  #[ code to generate:
+
+    std::exception_ptr error;
+    try {
+      body;
+    } catch (Exception e) {
+      error = std::current_exception();
+      if (ofExpr(e, TypeHere)) {
+
+        error = nullptr; // handled
+      } else if (...) {
+
+      } else {
+        throw;
+      }
+    } catch(...) {
+      // C++ exception occured, not under Nim's control.
+    }
+    {
+      /* finally: */
+      printf('fin!\n');
+      if (error) std::rethrow_exception(error); // re-raise the exception
+    }
+  ]#
+  p.module.includeHeader("<exception>")
+
+  if not isEmptyType(t.typ) and d.k == locNone:
+    d = getTemp(p, t.typ)
+  genLineDir(p, t)
+
+  inc(p.labels, 2)
+  let etmp = p.labels
+  #init on locals, fixes #23306
+  lineCg(p, cpsLocals, "std::exception_ptr T$1_;$n", [etmp])
+
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  p.nestedTryStmts.add((fin, false, 0.Natural))
+
+  if t.kind == nkHiddenTryStmt:
+    lineCg(p, cpsStmts, "try {$n", [])
+    expr(p, t[0], d)
+    lineCg(p, cpsStmts, "}$n", [])
+  else:
+    startBlock(p, "try {$n")
+    expr(p, t[0], d)
+    endBlock(p)
+
+  # First pass: handle Nim based exceptions:
+  lineCg(p, cpsStmts, "catch (#Exception* T$1_) {$n", [etmp+1])
+  genRestoreFrameAfterException(p)
+  # an unhandled exception happened!
+  lineCg(p, cpsStmts, "T$1_ = std::current_exception();$n", [etmp])
+  p.nestedTryStmts[^1].inExcept = true
+  var hasImportedCppExceptions = false
+  var i = 1
+  var hasIf = false
+  var hasElse = false
+  while (i < t.len) and (t[i].kind == nkExceptBranch):
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+    if t[i].len == 1:
+      hasImportedCppExceptions = true
+      # general except section:
+      hasElse = true
+      if hasIf: lineF(p, cpsStmts, "else ", [])
+      startBlock(p)
+      # we handled the error:
+      expr(p, t[i][0], d)
+      linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+      endBlock(p)
+    else:
+      var orExpr = newRopeAppender()
+      var exvar = PNode(nil)
+      for j in 0..<t[i].len - 1:
+        var typeNode = t[i][j]
+        if t[i][j].isInfixAs():
+          typeNode = t[i][j][1]
+          exvar = t[i][j][2] # ex1 in `except ExceptType as ex1:`
+        assert(typeNode.kind == nkType)
+        if isImportedException(typeNode.typ, p.config):
+          hasImportedCppExceptions = true
+        else:
+          if orExpr.len != 0: orExpr.add("||")
+          let memberName = if p.module.compileToCpp: "m_type" else: "Sup.m_type"
+          if optTinyRtti in p.config.globalOptions:
+            let checkFor = $getObjDepth(typeNode.typ)
+            appcg(p.module, orExpr, "#isObjDisplayCheck(#nimBorrowCurrentException()->$1, $2, $3)", [memberName, checkFor, $genDisplayElem(MD5Digest(hashType(typeNode.typ, p.config)))])
+          else:
+            let checkFor = genTypeInfoV1(p.module, typeNode.typ, typeNode.info)
+            appcg(p.module, orExpr, "#isObj(#nimBorrowCurrentException()->$1, $2)", [memberName, checkFor])
+
+      if orExpr.len != 0:
+        if hasIf:
+          startBlock(p, "else if ($1) {$n", [orExpr])
+        else:
+          startBlock(p, "if ($1) {$n", [orExpr])
+          hasIf = true
+        if exvar != nil:
+          fillLocalName(p, exvar.sym)
+          fillLoc(exvar.sym.loc, locTemp, exvar, OnStack)
+          linefmt(p, cpsStmts, "$1 $2 = T$3_;$n", [getTypeDesc(p.module, exvar.sym.typ),
+            rdLoc(exvar.sym.loc), rope(etmp+1)])
+        # we handled the error:
+        linefmt(p, cpsStmts, "T$1_ = nullptr;$n", [etmp])
+        expr(p, t[i][^1], d)
+        linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+        endBlock(p)
+    inc(i)
+  if hasIf and not hasElse:
+    linefmt(p, cpsStmts, "else throw;$n", [etmp])
+  linefmt(p, cpsStmts, "}$n", [])
+
+  # Second pass: handle C++ based exceptions:
+  template genExceptBranchBody(body: PNode) {.dirty.} =
+    genRestoreFrameAfterException(p)
+    #linefmt(p, cpsStmts, "T$1_ = std::current_exception();$n", [etmp])
+    expr(p, body, d)
+
+  var catchAllPresent = false
+  incl p.flags, noSafePoints # mark as not needing 'popCurrentException'
+  if hasImportedCppExceptions:
+    for i in 1..<t.len:
+      if t[i].kind != nkExceptBranch: break
+
+      # bug #4230: avoid false sharing between branches:
+      if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+
+      if t[i].len == 1:
+        # general except section:
+        startBlock(p, "catch (...) {$n", [])
+        genExceptBranchBody(t[i][0])
+        endBlock(p)
+        catchAllPresent = true
+      else:
+        for j in 0..<t[i].len-1:
+          var typeNode = t[i][j]
+          if t[i][j].isInfixAs():
+            typeNode = t[i][j][1]
+            if isImportedException(typeNode.typ, p.config):
+              let exvar = t[i][j][2] # ex1 in `except ExceptType as ex1:`
+              fillLocalName(p, exvar.sym)
+              fillLoc(exvar.sym.loc, locTemp, exvar, OnStack)
+              startBlock(p, "catch ($1& $2) {$n", getTypeDesc(p.module, typeNode.typ), rdLoc(exvar.sym.loc))
+              genExceptBranchBody(t[i][^1])  # exception handler body will duplicated for every type
+              endBlock(p)
+          elif isImportedException(typeNode.typ, p.config):
+            startBlock(p, "catch ($1&) {$n", getTypeDesc(p.module, t[i][j].typ))
+            genExceptBranchBody(t[i][^1])  # exception handler body will duplicated for every type
+            endBlock(p)
+
+  excl p.flags, noSafePoints
+  discard pop(p.nestedTryStmts)
+  # general finally block:
+  if t.len > 0 and t[^1].kind == nkFinally:
+    if not catchAllPresent:
+      startBlock(p, "catch (...) {$n", [])
+      genRestoreFrameAfterException(p)
+      linefmt(p, cpsStmts, "T$1_ = std::current_exception();$n", [etmp])
+      endBlock(p)
+
+    startBlock(p)
+    genStmts(p, t[^1][0])
+    linefmt(p, cpsStmts, "if (T$1_) std::rethrow_exception(T$1_);$n", [etmp])
+    endBlock(p)
+
+proc genTryCppOld(p: BProc, t: PNode, d: var TLoc) =
+  # There are two versions we generate, depending on whether we
+  # catch C++ exceptions, imported via .importcpp or not. The
+  # code can be easier if there are no imported C++ exceptions
+  # to deal with.
+
+  # code to generate:
+  #
+  #   try
+  #   {
+  #      myDiv(4, 9);
+  #   } catch (NimExceptionType1&) {
+  #      body
+  #   } catch (NimExceptionType2&) {
+  #      finallyPart()
+  #      raise;
+  #   }
+  #   catch(...) {
+  #     general_handler_body
+  #   }
+  #   finallyPart();
+
+  template genExceptBranchBody(body: PNode) {.dirty.} =
+    genRestoreFrameAfterException(p)
+    expr(p, body, d)
+
+  if not isEmptyType(t.typ) and d.k == locNone:
+    d = getTemp(p, t.typ)
+  genLineDir(p, t)
+  cgsym(p.module, "popCurrentExceptionEx")
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  p.nestedTryStmts.add((fin, false, 0.Natural))
+  startBlock(p, "try {$n")
+  expr(p, t[0], d)
+  endBlock(p)
+
+  var catchAllPresent = false
+
+  p.nestedTryStmts[^1].inExcept = true
+  for i in 1..<t.len:
+    if t[i].kind != nkExceptBranch: break
+
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+
+    if t[i].len == 1:
+      # general except section:
+      catchAllPresent = true
+      startBlock(p, "catch (...) {$n")
+      genExceptBranchBody(t[i][0])
+      endBlock(p)
+    else:
+      for j in 0..<t[i].len-1:
+        if t[i][j].isInfixAs():
+          let exvar = t[i][j][2] # ex1 in `except ExceptType as ex1:`
+          fillLocalName(p, exvar.sym)
+          fillLoc(exvar.sym.loc, locTemp, exvar, OnUnknown)
+          startBlock(p, "catch ($1& $2) {$n", getTypeDesc(p.module, t[i][j][1].typ), rdLoc(exvar.sym.loc))
+        else:
+          startBlock(p, "catch ($1&) {$n", getTypeDesc(p.module, t[i][j].typ))
+        genExceptBranchBody(t[i][^1])  # exception handler body will duplicated for every type
+        endBlock(p)
+
+  discard pop(p.nestedTryStmts)
+
+  if t[^1].kind == nkFinally:
+    # c++ does not have finally, therefore code needs to be generated twice
+    if not catchAllPresent:
+      # finally requires catch all presence
+      startBlock(p, "catch (...) {$n")
+      genStmts(p, t[^1][0])
+      line(p, cpsStmts, "throw;\n")
+      endBlock(p)
+
+    genSimpleBlock(p, t[^1][0])
+
+proc bodyCanRaise(p: BProc; n: PNode): bool =
+  case n.kind
+  of nkCallKinds:
+    result = canRaiseDisp(p, n[0])
+    if not result:
+      # also check the arguments:
+      for i in 1 ..< n.len:
+        if bodyCanRaise(p, n[i]): return true
+  of nkRaiseStmt:
+    result = true
+  of nkTypeSection, nkProcDef, nkConverterDef, nkMethodDef, nkIteratorDef,
+      nkMacroDef, nkTemplateDef, nkLambda, nkDo, nkFuncDef:
+    result = false
+  else:
+    for i in 0 ..< safeLen(n):
+      if bodyCanRaise(p, n[i]): return true
+    result = false
+
+proc genTryGoto(p: BProc; t: PNode; d: var TLoc) =
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  inc p.labels
+  let lab = p.labels
+  let hasExcept = t[1].kind == nkExceptBranch
+  if hasExcept: inc p.withinTryWithExcept
+  p.nestedTryStmts.add((fin, false, Natural lab))
+
+  p.flags.incl nimErrorFlagAccessed
+
+  if not isEmptyType(t.typ) and d.k == locNone:
+    d = getTemp(p, t.typ)
+
+  expr(p, t[0], d)
+
+  if 1 < t.len and t[1].kind == nkExceptBranch:
+    startBlock(p, "if (NIM_UNLIKELY(*nimErr_)) {$n")
+  else:
+    startBlock(p)
+  linefmt(p, cpsStmts, "LA$1_:;$n", [lab])
+
+  p.nestedTryStmts[^1].inExcept = true
+  var i = 1
+  while (i < t.len) and (t[i].kind == nkExceptBranch):
+
+    inc p.labels
+    let nextExcept = p.labels
+    p.nestedTryStmts[^1].label = nextExcept
+
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+    if t[i].len == 1:
+      # general except section:
+      if i > 1: lineF(p, cpsStmts, "else", [])
+      startBlock(p)
+      # we handled the exception, remember this:
+      linefmt(p, cpsStmts, "*nimErr_ = NIM_FALSE;$n", [])
+      expr(p, t[i][0], d)
+    else:
+      var orExpr = newRopeAppender()
+      for j in 0..<t[i].len - 1:
+        assert(t[i][j].kind == nkType)
+        if orExpr.len != 0: orExpr.add("||")
+        let memberName = if p.module.compileToCpp: "m_type" else: "Sup.m_type"
+        if optTinyRtti in p.config.globalOptions:
+          let checkFor = $getObjDepth(t[i][j].typ)
+          appcg(p.module, orExpr, "#isObjDisplayCheck(#nimBorrowCurrentException()->$1, $2, $3)",
+            [memberName, checkFor, $genDisplayElem(MD5Digest(hashType(t[i][j].typ, p.config)))])
+        else:
+          let checkFor = genTypeInfoV1(p.module, t[i][j].typ, t[i][j].info)
+          appcg(p.module, orExpr, "#isObj(#nimBorrowCurrentException()->$1, $2)", [memberName, checkFor])
+
+      if i > 1: line(p, cpsStmts, "else ")
+      startBlock(p, "if ($1) {$n", [orExpr])
+      # we handled the exception, remember this:
+      linefmt(p, cpsStmts, "*nimErr_ = NIM_FALSE;$n", [])
+      expr(p, t[i][^1], d)
+
+    linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+    linefmt(p, cpsStmts, "LA$1_:;$n", [nextExcept])
+    endBlock(p)
+
+    inc(i)
+  discard pop(p.nestedTryStmts)
+  endBlock(p)
+
+  if i < t.len and t[i].kind == nkFinally:
+    startBlock(p)
+    if not bodyCanRaise(p, t[i][0]):
+      # this is an important optimization; most destroy blocks are detected not to raise an
+      # exception and so we help the C optimizer by not mutating nimErr_ pointlessly:
+      genStmts(p, t[i][0])
+    else:
+      # pretend we did handle the error for the safe execution of the 'finally' section:
+      p.procSec(cpsLocals).add(ropecg(p.module, "NIM_BOOL oldNimErrFin$1_;$n", [lab]))
+      linefmt(p, cpsStmts, "oldNimErrFin$1_ = *nimErr_; *nimErr_ = NIM_FALSE;$n", [lab])
+      genStmts(p, t[i][0])
+      # this is correct for all these cases:
+      # 1. finally is run during ordinary control flow
+      # 2. finally is run after 'except' block handling: these however set the
+      #    error back to nil.
+      # 3. finally is run for exception handling code without any 'except'
+      #    handler present or only handlers that did not match.
+      linefmt(p, cpsStmts, "*nimErr_ = oldNimErrFin$1_;$n", [lab])
+    endBlock(p)
+  raiseExit(p)
+  if hasExcept: inc p.withinTryWithExcept
+
+proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
+  # code to generate:
+  #
+  # XXX: There should be a standard dispatch algorithm
+  # that's used both here and with multi-methods
+  #
+  #  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();
+  #
+  if not isEmptyType(t.typ) and d.k == locNone:
+    d = getTemp(p, t.typ)
+  let quirkyExceptions = p.config.exc == excQuirky or
+      (t.kind == nkHiddenTryStmt and sfSystemModule in p.module.module.flags)
+  if not quirkyExceptions:
+    p.module.includeHeader("<setjmp.h>")
+  else:
+    p.flags.incl noSafePoints
+  genLineDir(p, t)
+  cgsym(p.module, "Exception")
+  var safePoint: Rope = ""
+  if not quirkyExceptions:
+    safePoint = getTempName(p.module)
+    linefmt(p, cpsLocals, "#TSafePoint $1;$n", [safePoint])
+    linefmt(p, cpsStmts, "#pushSafePoint(&$1);$n", [safePoint])
+    if isDefined(p.config, "nimStdSetjmp"):
+      linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
+    elif isDefined(p.config, "nimSigSetjmp"):
+      linefmt(p, cpsStmts, "$1.status = sigsetjmp($1.context, 0);$n", [safePoint])
+    elif isDefined(p.config, "nimBuiltinSetjmp"):
+      linefmt(p, cpsStmts, "$1.status = __builtin_setjmp($1.context);$n", [safePoint])
+    elif isDefined(p.config, "nimRawSetjmp"):
+      if isDefined(p.config, "mswindows"):
+        if isDefined(p.config, "vcc") or isDefined(p.config, "clangcl"):
+          # For the vcc compiler, use `setjmp()` with one argument.
+          # See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/setjmp?view=msvc-170
+          linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
+        else:
+          # The Windows `_setjmp()` takes two arguments, with the second being an
+          # undocumented buffer used by the SEH mechanism for stack unwinding.
+          # Mingw-w64 has been trying to get it right for years, but it's still
+          # prone to stack corruption during unwinding, so we disable that by setting
+          # it to NULL.
+          # More details: https://github.com/status-im/nimbus-eth2/issues/3121
+          linefmt(p, cpsStmts, "$1.status = _setjmp($1.context, 0);$n", [safePoint])
+      else:
+        linefmt(p, cpsStmts, "$1.status = _setjmp($1.context);$n", [safePoint])
+    else:
+      linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
+    lineCg(p, cpsStmts, "if ($1.status == 0) {$n", [safePoint])
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  p.nestedTryStmts.add((fin, quirkyExceptions, 0.Natural))
+  expr(p, t[0], d)
+  if not quirkyExceptions:
+    linefmt(p, cpsStmts, "#popSafePoint();$n", [])
+    lineCg(p, cpsStmts, "}$n", [])
+    startBlock(p, "else {$n")
+    linefmt(p, cpsStmts, "#popSafePoint();$n", [])
+    genRestoreFrameAfterException(p)
+  elif 1 < t.len and t[1].kind == nkExceptBranch:
+    startBlock(p, "if (#nimBorrowCurrentException()) {$n")
+  else:
+    startBlock(p)
+  p.nestedTryStmts[^1].inExcept = true
+  var i = 1
+  while (i < t.len) and (t[i].kind == nkExceptBranch):
+    # bug #4230: avoid false sharing between branches:
+    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
+    if t[i].len == 1:
+      # general except section:
+      if i > 1: lineF(p, cpsStmts, "else", [])
+      startBlock(p)
+      if not quirkyExceptions:
+        linefmt(p, cpsStmts, "$1.status = 0;$n", [safePoint])
+      expr(p, t[i][0], d)
+      linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+      endBlock(p)
+    else:
+      var orExpr = newRopeAppender()
+      for j in 0..<t[i].len - 1:
+        assert(t[i][j].kind == nkType)
+        if orExpr.len != 0: orExpr.add("||")
+        let memberName = if p.module.compileToCpp: "m_type" else: "Sup.m_type"
+        if optTinyRtti in p.config.globalOptions:
+          let checkFor = $getObjDepth(t[i][j].typ)
+          appcg(p.module, orExpr, "#isObjDisplayCheck(#nimBorrowCurrentException()->$1, $2, $3)",
+              [memberName, checkFor, $genDisplayElem(MD5Digest(hashType(t[i][j].typ, p.config)))])
+        else:
+          let checkFor = genTypeInfoV1(p.module, t[i][j].typ, t[i][j].info)
+          appcg(p.module, orExpr, "#isObj(#nimBorrowCurrentException()->$1, $2)", [memberName, checkFor])
+
+      if i > 1: line(p, cpsStmts, "else ")
+      startBlock(p, "if ($1) {$n", [orExpr])
+      if not quirkyExceptions:
+        linefmt(p, cpsStmts, "$1.status = 0;$n", [safePoint])
+      expr(p, t[i][^1], d)
+      linefmt(p, cpsStmts, "#popCurrentException();$n", [])
+      endBlock(p)
+    inc(i)
+  discard pop(p.nestedTryStmts)
+  endBlock(p) # end of else block
+  if i < t.len and t[i].kind == nkFinally:
+    p.finallySafePoints.add(safePoint)
+    startBlock(p)
+    genStmts(p, t[i][0])
+    # pretend we handled the exception in a 'finally' so that we don't
+    # re-raise the unhandled one but instead keep the old one (it was
+    # not popped either):
+    if not quirkyExceptions and getCompilerProc(p.module.g.graph, "nimLeaveFinally") != nil:
+      linefmt(p, cpsStmts, "if ($1.status != 0) #nimLeaveFinally();$n", [safePoint])
+    endBlock(p)
+    discard pop(p.finallySafePoints)
+  if not quirkyExceptions:
+    linefmt(p, cpsStmts, "if ($1.status != 0) #reraiseException();$n", [safePoint])
+
+proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false; result: var Rope) =
+  var res = ""
+  let offset =
+    if isAsmStmt: 1 # first son is pragmas
+    else: 0
+
+  for i in offset..<t.len:
+    let it = t[i]
+    case it.kind
+    of nkStrLit..nkTripleStrLit:
+      res.add(it.strVal)
+    of nkSym:
+      var sym = it.sym
+      if sym.kind in {skProc, skFunc, skIterator, skMethod}:
+        var a: TLoc = initLocExpr(p, it)
+        res.add($rdLoc(a))
+      elif sym.kind == skType:
+        res.add($getTypeDesc(p.module, sym.typ))
+      else:
+        discard getTypeDesc(p.module, skipTypes(sym.typ, abstractPtrs))
+        fillBackendName(p.module, sym)
+        res.add($sym.loc.snippet)
+    of nkTypeOfExpr:
+      res.add($getTypeDesc(p.module, it.typ))
+    else:
+      discard getTypeDesc(p.module, skipTypes(it.typ, abstractPtrs))
+      var a: TLoc = initLocExpr(p, it)
+      res.add($a.rdLoc)
+
+  if isAsmStmt and hasGnuAsm in CC[p.config.cCompiler].props:
+    for x in splitLines(res):
+      var j = 0
+      while j < x.len and x[j] in {' ', '\t'}: inc(j)
+      if j < x.len:
+        if x[j] in {'"', ':'}:
+          # don't modify the line if already in quotes or
+          # some clobber register list:
+          result.add(x); result.add("\L")
+        else:
+          # ignore empty lines
+          result.add("\"")
+          result.add(x.replace("\"", "\\\""))
+          result.add("\\n\"\n")
+  else:
+    res.add("\L")
+    result.add res.rope
+
+proc genAsmStmt(p: BProc, t: PNode) =
+  assert(t.kind == nkAsmStmt)
+  genLineDir(p, t)
+  var s = newRopeAppender()
+
+  var asmSyntax = ""
+  if (let p = t[0]; p.kind == nkPragma):
+    for i in p:
+      if whichPragma(i) == wAsmSyntax:
+        asmSyntax = i[1].strVal
+
+  if asmSyntax != "" and
+     not (
+      asmSyntax == "gcc" and hasGnuAsm in CC[p.config.cCompiler].props or
+      asmSyntax == "vcc" and hasGnuAsm notin CC[p.config.cCompiler].props):
+    localError(
+      p.config, t.info,
+      "Your compiler does not support the specified inline assembler")
+
+  genAsmOrEmitStmt(p, t, isAsmStmt=true, s)
+  # see bug #2362, "top level asm statements" seem to be a mis-feature
+  # but even if we don't do this, the example in #2362 cannot possibly
+  # work:
+  if p.prc == nil:
+    # top level asm statement?
+    p.module.s[cfsProcHeaders].add runtimeFormat(CC[p.config.cCompiler].asmStmtFrmt, [s])
+  else:
+    addIndent p, p.s(cpsStmts)
+    p.s(cpsStmts).add runtimeFormat(CC[p.config.cCompiler].asmStmtFrmt, [s])
+
+proc determineSection(n: PNode): TCFileSection =
+  result = cfsProcHeaders
+  if n.len >= 1 and n[0].kind in {nkStrLit..nkTripleStrLit}:
+    let sec = n[0].strVal
+    if sec.startsWith("/*TYPESECTION*/"): result = cfsForwardTypes # TODO WORKAROUND
+    elif sec.startsWith("/*VARSECTION*/"): result = cfsVars
+    elif sec.startsWith("/*INCLUDESECTION*/"): result = cfsHeaders
+
+proc genEmit(p: BProc, t: PNode) =
+  var s = newRopeAppender()
+  genAsmOrEmitStmt(p, t[1], false, s)
+  if p.prc == nil:
+    # top level emit pragma?
+    let section = determineSection(t[1])
+    genCLineDir(p.module.s[section], t.info, p.config)
+    p.module.s[section].add(s)
+  else:
+    genLineDir(p, t)
+    line(p, cpsStmts, s)
+
+proc genPragma(p: BProc, n: PNode) =
+  for i in 0..<n.len:
+    let it = n[i]
+    case whichPragma(it)
+    of wEmit: genEmit(p, it)
+    of wPush:
+      processPushBackendOption(p.config, p.optionsStack, p.options, n, i+1)
+    of wPop:
+      processPopBackendOption(p.config, p.optionsStack, p.options)
+    else: discard
+
+
+proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType,
+                          field: PSym) =
+  var t = skipTypes(objtype, abstractVar)
+  assert t.kind == tyObject
+  discard genTypeInfoV1(p.module, t, a.lode.info)
+  if not containsOrIncl(p.module.declaredThings, field.id):
+    appcg(p.module, cfsVars, "extern $1",
+          [discriminatorTableDecl(p.module, t, field)])
+  var lit = newRopeAppender()
+  intLiteral(toInt64(lengthOrd(p.config, field.typ))+1, lit)
+  lineCg(p, cpsStmts,
+        "#FieldDiscriminantCheck((NI)(NU)($1), (NI)(NU)($2), $3, $4);$n",
+        [rdLoc(a), rdLoc(tmp), discriminatorTableName(p.module, t, field),
+         lit])
+  if p.config.exc == excGoto:
+    raiseExit(p)
+
+when false:
+  proc genCaseObjDiscMapping(p: BProc, e: PNode, t: PType, field: PSym; d: var TLoc) =
+    const ObjDiscMappingProcSlot = -5
+    var theProc: PSym = nil
+    for idx, p in items(t.methods):
+      if idx == ObjDiscMappingProcSlot:
+        theProc = p
+        break
+    if theProc == nil:
+      theProc = genCaseObjDiscMapping(t, field, e.info, p.module.g.graph, p.module.idgen)
+      t.methods.add((ObjDiscMappingProcSlot, theProc))
+    var call = newNodeIT(nkCall, e.info, getSysType(p.module.g.graph, e.info, tyUInt8))
+    call.add newSymNode(theProc)
+    call.add e
+    expr(p, call, d)
+
+proc asgnFieldDiscriminant(p: BProc, e: PNode) =
+  var dotExpr = e[0]
+  if dotExpr.kind == nkCheckedFieldExpr: dotExpr = dotExpr[0]
+  var a = initLocExpr(p, e[0])
+  var tmp: TLoc = getTemp(p, a.t)
+  expr(p, e[1], tmp)
+  if p.inUncheckedAssignSection == 0:
+    let field = dotExpr[1].sym
+    genDiscriminantCheck(p, a, tmp, dotExpr[0].typ, field)
+    message(p.config, e.info, warnCaseTransition)
+  genAssignment(p, a, tmp, {})
+
+proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) =
+  if e[0].kind == nkSym and sfGoto in e[0].sym.flags:
+    genLineDir(p, e)
+    genGotoVar(p, e[1])
+  elif optFieldCheck in p.options and isDiscriminantField(e[0]):
+    genLineDir(p, e)
+    asgnFieldDiscriminant(p, e)
+  else:
+    let le = e[0]
+    let ri = e[1]
+    var a: TLoc = initLoc(locNone, le, OnUnknown)
+    discard getTypeDesc(p.module, le.typ.skipTypes(skipPtrs), dkVar)
+    a.flags.incl(lfEnforceDeref)
+    a.flags.incl(lfPrepareForMutation)
+    genLineDir(p, le) # it can be a nkBracketExpr, which may raise
+    expr(p, le, a)
+    a.flags.excl(lfPrepareForMutation)
+    if fastAsgn: incl(a.flags, lfNoDeepCopy)
+    assert(a.t != nil)
+    genLineDir(p, ri)
+    loadInto(p, le, ri, a)
+
+proc genStmts(p: BProc, t: PNode) =
+  var a: TLoc = default(TLoc)
+
+  let isPush = p.config.hasHint(hintExtendedContext)
+  if isPush: pushInfoContext(p.config, t.info)
+  expr(p, t, a)
+  if isPush: popInfoContext(p.config)
+  internalAssert p.config, a.k in {locNone, locTemp, locLocalVar, locExpr}