ok

Author: yglukhov

compiler/closureiters.nim

@@ -153,6 +153,7 @@ type
     body: PNode
     excLandingState: PNode # label of exception landing state (except or finally)
     inlinable: bool
+    deletable: bool
 
   Ctx = object
     g: ModuleGraph
@@ -162,6 +163,7 @@ type
     curExcLevelSym: PSym # Current exception
 
     # states: seq[tuple[label: PNode, body: PNode, inlinable: bool]] # The resulting states. Label is int literal.
+    uninlinableStates: seq[PNode] # List of state labels that must not be inlined
     states: seq[State] # The resulting states. Label is int literal.
     finallyPathStack: seq[FinallyTarget] # nkWhileStmt, nkBlock, nkTryStmt
     stateLoopLabel: PSym # Label to break on, when jumping between states.
@@ -254,7 +256,7 @@ proc newCurExcLevelAccess(ctx: var Ctx): PNode =
 proc newStateLabel(ctx: Ctx): PNode =
   ctx.g.newIntLit(TLineInfo(), 0)
 
-proc newState1(ctx: var Ctx, n: PNode, inlinable: bool, label: PNode): PNode =
+proc newState(ctx: var Ctx, n: PNode, inlinable: bool, label: PNode): PNode =
   # Creates a new state, adds it to the context
   # Returns label of the newly created state
 
@@ -896,6 +898,8 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
   #     :state = :env.finallyPath[curFinallyLevel_const]
 
   let nextState = ctx.newFinallyPathAccess(ctx.curFinallyLevel, info)
+  let exitFinally = newTree(nkGotoState, nextState)
+
   let cmpStateToZero = newTreeIT(nkCall,
                           info, ctx.g.getSysType(info, tyBool),
                           newSymNode(ctx.g.getSysMagic(info, "==", mEqI), info),
@@ -921,7 +925,6 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
       newTree(nkReturnStmt, retValue)
   retStmt.flags.incl(nfNoRewrite)
 
-  let exitFinally = newTree(nkGotoState, nextState)
 
   let ifBody = newTree(nkIfStmt,
                        newTree(nkElifBranch, excNilCmp, retStmt),
@@ -932,7 +935,8 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
 
   result = newTree(nkIfStmt,
                    newTreeI(nkElifBranch, info, cmpStateToZero, ifBody),
-                   newTreeI(nkElse, info, exitFinally))
+                   # newTreeI(nkElse, info, exitFinally)
+  )
 
 
 proc newJumpAlongFinallyChain(ctx: var Ctx, finallyChain: seq[PNode], info: TLineInfo): PNode =
@@ -975,9 +979,10 @@ proc transformBreakStmt(ctx: var Ctx, n: PNode): PNode =
     elif b.kind == nkFinally:
       finallyChain.add(ctx.finallyPathStack[i].enterLabel)
 
-  assert(finallyChain.len > 0)
-
-  result = ctx.newJumpAlongFinallyChain(finallyChain, n.info)
+  if finallyChain.len > 0:
+    result = ctx.newJumpAlongFinallyChain(finallyChain, n.info)
+  else:
+    result = n
 
 proc transformContinueStmt(ctx: var Ctx, n: PNode): PNode =
   # "Continuing" involves finding the corresponding target state in finallyPathStack,
@@ -1072,17 +1077,18 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
           s.add(n[j])
 
         n.sons.setLen(i + 1)
-        discard ctx.newState1(s, true, label)
+        discard ctx.newState(s, true, label)
         if ctx.transformClosureIteratorBody(s, gotoOut) != s:
           internalError(ctx.g.config, "transformClosureIteratorBody != s")
         break
       else:
         n[i] = ctx.transformBreaksContinuesAndReturns(n[i])
 
   of nkYieldStmt:
-    result = newNodeI(nkStmtList, n.info)
-    result.add(n)
-    result.add(gotoOut)
+    result = addGotoOut(result, gotoOut)
+    # result = newNodeI(nkStmtList, n.info)
+    # result.add(n)
+    # result.add(gotoOut)
 
   of nkElse, nkElseExpr:
     result[0] = addGotoOut(result[0], gotoOut)
@@ -1115,7 +1121,7 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
     # result = newNodeI(nkGotoState, n.info)
 
     let s = newNodeI(nkStmtList, n.info)
-    let enterLabel = ctx.newState1(s, false, nil)
+    let enterLabel = ctx.newState(s, false, nil)
 
     let ifNode = newNodeI(nkIfStmt, n.info)
     let elifBranch = newNodeI(nkElifBranch, n.info)
@@ -1190,7 +1196,7 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
                              elif finallyBody.kind != nkEmpty: finallyLabel
                              else: oldExcLandingState
       # ctx.curExcHandlingState = exceptIdx
-      discard ctx.newState1(tryBody, false, tryLabel)
+      discard ctx.newState(tryBody, false, tryLabel)
       # assert(realTryIdx.intVal == tryIdx)
 
       if finallyBody.kind != nkEmpty:
@@ -1203,7 +1209,7 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
       if exceptBody.kind != nkEmpty:
         ctx.curExcLandingState = if finallyBody.kind != nkEmpty: finallyLabel
                                  else: oldExcLandingState
-        discard ctx.newState1(exceptBody, false, exceptLabel)
+        discard ctx.newState(exceptBody, false, exceptLabel)
         # assert(realExceptIdx.intVal == -exceptIdx)
 
         let normalOut = if finallyBody.kind != nkEmpty: gotoOut else: nil
@@ -1216,8 +1222,9 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
 
       if finallyBody.kind != nkEmpty:
         discard ctx.finallyPathStack.pop()
-        discard ctx.newState1(finallyBody, false, finallyLabel)
-        if ctx.transformClosureIteratorBody(finallyBody, gotoOut) != finallyBody:
+        discard ctx.newState(finallyBody, false, finallyLabel)
+        let finallyExit = newTree(nkGotoState, ctx.newFinallyPathAccess(ctx.curFinallyLevel - 1, finallyBody.info))
+        if ctx.transformClosureIteratorBody(finallyBody, finallyExit) != finallyBody:
           internalError(ctx.g.config, "transformClosureIteratorBody != finallyBody")
         dec ctx.curFinallyLevel
 
@@ -1490,27 +1497,119 @@ proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
   blockStmt.add(blockBody)
   loopBody.add(blockStmt)
 
-proc countStateOccurences(n: PNode, stateOccurences: var openArray[int]) =
+proc countStateOccurences(ctx: var Ctx, n: PNode, stateOccurences: var openArray[int]) =
   ## Find all nkGotoState(stateIdx) nodes that do not follow nkYield.
   ## For every such node increment stateOccurences[stateIdx]
   for i, c in n:
-    if c.kind == nkGotoState and (i == 0 or n[i - 1].kind != nkYieldStmt):
+    if c.kind == nkGotoState and c[0].kind == nkIntLit and (i > 0 and n[i - 1].kind != nkYieldStmt):
       let stateIdx = c[0].intVal
       if stateIdx >= 0:
         inc stateOccurences[stateIdx]
+    elif c.kind == nkIntLit:
+      let idx = c.intVal
+      if idx >= 0 and idx < ctx.states.len and ctx.states[idx].label == c:
+        ctx.states[idx].inlinable = false
     else:
-      countStateOccurences(c, stateOccurences)
+      ctx.countStateOccurences(c, stateOccurences)
+
+proc replaceDeletedStates(ctx: var Ctx, n: PNode): PNode =
+  result = n
+  for i in 0 ..< n.safeLen:
+    let c = n[i]
+    if c.kind == nkIntLit:
+      let idx = c.intVal
+      if idx >= 0 and idx < ctx.states.len and ctx.states[idx].label == c and ctx.states[idx].deletable:
+        let ns = ctx.replaceDeletedStates(ctx.states[idx].body)
+        assert(ns.kind == nkStmtList and ns.len == 1 and ns[0].kind == nkGotoState and ns[0][0].kind == nkIntLit)
+        n[i] = ns[0][0]
+    else:
+      n[i] = ctx.replaceDeletedStates(c)
+
+proc replaceInlinedStates(ctx: var Ctx, n: PNode): PNode =
+  ## Find all nkGotoState(stateIdx) nodes that do not follow nkYield.
+  ## For every such node increment stateOccurences[stateIdx]
+  result = n
+  for i in 0 ..< n.safeLen:
+    let c = n[i]
+    if c.kind == nkGotoState and c[0].kind == nkIntLit and (i > 0 and n[i - 1].kind != nkYieldStmt):
+      let stateIdx = c[0].intVal
+      if stateIdx >= 0:
+        if ctx.states[stateIdx].inlinable:
+          n[i] = ctx.states[stateIdx].body
+    else:
+      n[i] = ctx.replaceInlinedStates(c)
+
 
 proc deleteEmptyStates(ctx: var Ctx) =
+  # 1. Assign temporary indexes to state labels to facilitate
+  # countStateOccurences. Label number will correspond to index in
+  # ctx.states
+
+  # for i in 0 .. ctx.states.high:
+  #   ctx.states[i].label.intVal = i
+
+  # 1. Delete empty states: go through ctx.states,
+  # if a state consists only of gotoState node, delete it from states
+  # and replace its label index to its target state
+
+  # var labelsToReplace = newSeq[(PNode, PNode, bool)]()
+
+  # Collect empty states
+  for i in 0 .. ctx.states.high:
+    let s = ctx.states[i]
+    let body = skipStmtList(s.body)
+    if body.kind == nkGotoState and body[0].kind == nkIntLit and body[0].intVal >= 0:
+      ctx.states[i].deletable = true
+
+  # Delete empty states
+  for i in 0 .. ctx.states.high:
+    ctx.states[i].body = ctx.replaceDeletedStates(ctx.states[i].body)
+
+  # Remove deletable states
+  var i = 0
+  while i < ctx.states.len:
+    if ctx.states[i].deletable:
+      ctx.states.delete(i)
+    else:
+      inc i
+
+  # Reassign state label indexes
+  for i in 0 .. ctx.states.high:
+    ctx.states[i].label.intVal = i
+
+  # 2. Count state occurences
   var stateOccurences = newSeq[int](ctx.states.len)
   for s in ctx.states:
-    countStateOccurences(s.body, stateOccurences)
-  echo "StateOccurences: ", stateOccurences
+    ctx.countStateOccurences(s.body, stateOccurences)
+
   var statesToInline = newSeq[int]()
   for i, o in stateOccurences:
     if o == 1 and ctx.states[i].inlinable:
-      statesToInline.add(i)
-  echo "States to inline: ", statesToInline
+      discard
+    else:
+      ctx.states[i].inlinable = false
+      # statesToInline.add(i)
+
+  # echo "States to optimize:"
+  # for i, s in ctx.states:
+  #   if s.deletable: echo i, ": delete"
+  #   elif s.inlinable: echo i, ": inline"
+
+  # Inline states
+  for i in 0 .. ctx.states.high:
+    ctx.states[i].body = ctx.replaceInlinedStates(ctx.states[i].body)
+
+  # Remove inlined states
+  i = 0
+  while i < ctx.states.len:
+    if ctx.states[i].inlinable:
+      ctx.states.delete(i)
+    else:
+      inc i
+
+  # Reassign state label indexes
+  for i in 0 .. ctx.states.high:
+    ctx.states[i].label.intVal = i
 
 # proc deleteEmptyStates(ctx: var Ctx) =
 #   let goOut = newTree(nkGotoState, ctx.g.newIntLit(TLineInfo(), -1))
@@ -1625,7 +1724,7 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   var n = n.toStmtList
   # echo "transformed into ", n
 
-  discard ctx.newState1(n, false, nil)
+  discard ctx.newState(n, false, nil)
   let gotoOut = newTree(nkGotoState, g.newIntLit(n.info, -1))
 
   var ns = false
@@ -1638,13 +1737,13 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   # Splitting transformation
   discard ctx.transformClosureIteratorBody(n, gotoOut)
 
-  # Optimize empty states away
-  # ctx.deleteEmptyStates()
-
   # Assign state label indexes
   for i in 0 .. ctx.states.high:
     ctx.states[i].label.intVal = i
 
+  # Optimize empty states away
+  ctx.deleteEmptyStates()
+
   let caseDispatcher = newTreeI(nkCaseStmt, n.info,
       ctx.newStateAccess())
 
@@ -1662,11 +1761,11 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   result = liftLocals(ctx, result)
 
   when false:
-    echo "TRANSFORM TO STATES: "
+    echo "TRANSFORM TO STATES:"
     echo renderTree(result)
 
     # echo "exception table:"
     # for i, s in ctx.states:
     #   echo i, " -> ", s.excLandingState
 
-    echo "ENV: ", renderTree(getEnvParam(fn).typ.elementType.n)
+    # echo "ENV: ", renderTree(getEnvParam(fn).typ.elementType.n)

lib/system/embedded.nim

@@ -50,9 +50,6 @@ proc writeStackTrace() = discard
 proc unsetControlCHook() = discard
 proc setControlCHook(hook: proc () {.noconv.}) = discard
 
-proc closureIterSetupExc(e: ref Exception) {.compilerproc, inline.} =
-  sysFatal(ReraiseDefect, "exception handling is not available")
-
 when gotoBasedExceptions:
   var nimInErrorMode {.threadvar.}: bool
 

lib/system/excpt.nim

@@ -461,11 +461,9 @@ proc raiseExceptionAux(e: sink(ref Exception)) {.nodestroy.} =
   if globalRaiseHook != nil:
     if not globalRaiseHook(e): return
   when defined(cpp) and not defined(noCppExceptions) and not gotoBasedExceptions:
-    if e == currException:
-      {.emit: "throw;".}
-    else:
+    if e != currException:
       pushCurrentException(e)
-      {.emit: "throw `e`;".}
+    {.emit: "throw `e`;".}
   elif quirkyExceptions or gotoBasedExceptions:
     pushCurrentException(e)
     when gotoBasedExceptions:

lib/system/jssys.nim

@@ -72,8 +72,10 @@ proc getCurrentExceptionMsg*(): string =
 proc setCurrentException*(exc: ref Exception) =
   lastJSError = cast[PJSError](exc)
 
-proc closureIterSetupExc(e: ref Exception) {.compilerproc, inline.} =
-  ## Used to set up exception handling for closure iterators
+proc pushCurrentException(e: sink(ref Exception)) {.compilerRtl, inline.} =
+  ## Used to set up exception handling for closure iterators.
+
+  # XXX Shouldn't there be execption stack like in excpt.nim?
   setCurrentException(e)
 
 proc auxWriteStackTrace(f: PCallFrame): string =