diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b57308f..1f65445 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -160,7 +160,7 @@ jobs:
       - name: Check `nph` formatting
         uses: arnetheduck/nph-action@v1
         with:
-          version: 0.6.2
+          version: 0.7.0
           options: "llvm nlvm"
           fail: true
           suggest: true
diff --git a/Nim b/Nim
index dfc3cf8..66fb00f 160000
--- a/Nim
+++ b/Nim
@@ -1 +1 @@
-Subproject commit dfc3cf8c767f73f63d5a73816c3cd8c5416ceaa5
+Subproject commit 66fb00f658ed741e0a29050b70715c71bcb8133f
diff --git a/nlvm-lib/nlvm_system.nim b/nlvm-lib/nlvm_system.nim
index 7c6cc85..04da715 100644
--- a/nlvm-lib/nlvm_system.nim
+++ b/nlvm-lib/nlvm_system.nim
@@ -341,6 +341,9 @@ proc nlvmRaise(e: ref Exception) {.compilerproc, noreturn.} =
   c_abort()
 
 proc nlvmReraise() {.compilerproc, noreturn.} =
+  if not ehGlobals.closureException.isNil:
+    nlvmRaise(ehGlobals.closureException)
+
   let unwindException = ehGlobals.caughtExceptions
   if unwindException.isNil():
     nlvmRaise((ref ReraiseDefect)(msg: "no exception to reraise"))
@@ -369,10 +372,12 @@ proc nlvmReraise() {.compilerproc, noreturn.} =
   c_abort()
 
 proc nlvmSetClosureException(e: ref Exception) {.compilerproc.} =
+  dprintf "set clo: %p\n", addr e[]
   ehGlobals.closureException = e
 
 proc nlvmGetCurrentException(): ref Exception {.compilerproc.} =
   if not ehGlobals.closureException.isNil:
+    dprintf("closure: %p\n", addr ehGlobals.closureException[])
     ehGlobals.closureException
   else:
     let unwindException = ehGlobals.caughtExceptions
@@ -386,6 +391,13 @@ proc nlvmGetCurrentExceptionMsg(): string {.compilerproc.} =
   let e = nlvmGetCurrentException()
   if e != nil: e.msg else: ""
 
+proc nlvmPushCurrentException(e: sink(ref Exception)) {.compilerRtl, inl.} =
+  e.up = nlvmGetCurrentException()
+  nlvmSetClosureException(e)
+
+proc nlvmPopCurrentException() {.compilerRtl, inl.} =
+  nlvmSetClosureException(nlvmGetCurrentException().up)
+
 proc nlvmBeginCatch(unwindArg: pointer) {.compilerproc.} =
   dprintf("begin catch %p\n", unwindArg)
   ehGlobals.closureException = nil # Just in case, see workaround notes
@@ -397,9 +409,9 @@ proc nlvmBeginCatch(unwindArg: pointer) {.compilerproc.} =
     dprintf("begin native %d\n", exceptionHeader.handlerCount)
     exceptionHeader.handlerCount =
       if exceptionHeader.handlerCount < 0:
-        -exceptionHeader.handlerCount + 1
+        -exceptionHeader.handlerCount +% 1
       else:
-        exceptionHeader.handlerCount + 1
+        exceptionHeader.handlerCount +% 1
 
     if ehGlobals.caughtExceptions != unwindException:
       exceptionHeader.nextException = ehGlobals.caughtExceptions
@@ -426,13 +438,13 @@ proc nlvmEndCatch() {.compilerproc.} =
     dprintf("end native %d\n", exceptionHeader.handlerCount)
     if exceptionHeader.handlerCount < 0:
       # Rethrowing
-      exceptionHeader.handlerCount += 1
+      exceptionHeader.handlerCount = exceptionHeader.handlerCount +% 1
       if exceptionHeader.handlerCount == 0:
         ehGlobals.caughtExceptions = exceptionHeader.nextException
     else:
       # TODO When passing exceptions between threads is supported, this needs
       #      to be atomic..
-      exceptionHeader.handlerCount -= 1
+      exceptionHeader.handlerCount = exceptionHeader.handlerCount -% 1
       if exceptionHeader.handlerCount == 0:
         ehGlobals.caughtExceptions = exceptionHeader.nextException
 
diff --git a/nlvm/llgen.nim b/nlvm/llgen.nim
index c703609..5b1b007 100644
--- a/nlvm/llgen.nim
+++ b/nlvm/llgen.nim
@@ -1702,7 +1702,9 @@ proc debugTupleType(g: LLGen, typ: PType): llvm.MetadataRef =
   g.dstructs[sig] = result
 
   var members = newSeq[MetadataRef]()
-  for _, field in typ.ikids:
+  for field in typ.kids:
+    if isEmptyType(field):
+      continue
     let
       mline =
         if field.sym != nil:
@@ -2412,8 +2414,10 @@ proc llTupleType(g: LLGen, typ: PType, deep: bool): llvm.TypeRef =
   g.types[sig] = result
 
   var elements = newSeq[TypeRef]()
-  for _, t in typ.ikids:
-    elements.add(g.llType(t))
+  for tf in typ.kids:
+    if isEmptyType(tf):
+      continue
+    elements.add(g.llType(tf))
 
   p("llTupleType " & $name & " " & $elements, typ, g.depth)
 
@@ -2603,9 +2607,11 @@ proc genMarker(g: LLGen, typ: PType, v, op: llvm.ValueRef) =
     if typ.n != nil and tfUnion notin typ.flags:
       g.genMarkerFields(mapper, typ.n, ty, v, op)
   of tyTuple:
-    for i in 0 ..< typ.len:
+    for i, tf in typ.ikids:
+      if isEmptyType(tf):
+        continue
       let gep = g.b.buildStructGEP2(ty, v, cuint i, g.nn("mk.tuple.field" & $i, v))
-      g.genMarker(typ[i], gep, op)
+      g.genMarker(tf, gep, op)
   of tyRef, tySequence:
     let vl = g.b.buildLoad2(ty, v)
     discard g.callCompilerProc("nimGCVisit", [vl, op])
@@ -2793,7 +2799,10 @@ proc genGcRegistrar(g: LLGen, sym: PSym, v: llvm.ValueRef) =
   g.withFunc(g.registrar):
     g.debugUpdateLoc(sym)
     g.withBlock(g.section(g.f, secBody)):
-      discard g.callCompilerProc("nimRegisterGlobalMarker", [prc])
+      if sfThread in sym.flags:
+        discard g.callCompilerProc("nimRegisterThreadLocalMarker", [prc])
+      else:
+        discard g.callCompilerProc("nimRegisterGlobalMarker", [prc])
 
 proc genTypeInfoInit(
     g: LLGen,
@@ -2840,11 +2849,10 @@ proc genTypeInfoInit(
 
   let flagsVar = g.constInt8(flags)
 
-  var values =
-    @[
-      sizeVar, alignVar, kindVar, flagsVar, baseVar, nodeVar, finalizerVar, markerVar,
-      deepcopyVar,
-    ]
+  var values = @[
+    sizeVar, alignVar, kindVar, flagsVar, baseVar, nodeVar, finalizerVar, markerVar,
+    deepcopyVar,
+  ]
 
   if isDefined(g.config, "nimSeqsV2"):
     values.add(
@@ -3041,6 +3049,9 @@ proc genTupleNodeInfoInit(g: LLGen, t: PType): llvm.ValueRef =
   let prefix = ".nodeinfo." & g.llName(t, sig) & "."
 
   for i, tf in t.ikids:
+    if isEmptyType(tf):
+      continue
+
     let
       name = prefix & $i
       field = g.m.addPrivateConstant(tnn, name)
@@ -3180,19 +3191,18 @@ proc genTypeInfoV1(
     if typeInfoV2 != nil:
       let init = getInitializer(ti)
       if init.getAggregateElement(8).isNull() == llvm.True:
-        var values =
-          @[
-            init.getAggregateElement(0),
-            init.getAggregateElement(1),
-            init.getAggregateElement(2),
-            init.getAggregateElement(3),
-            init.getAggregateElement(4),
-            init.getAggregateElement(5),
-            init.getAggregateElement(6),
-            init.getAggregateElement(7),
-            init.getAggregateElement(8),
-            typeInfoV2,
-          ]
+        var values = @[
+          init.getAggregateElement(0),
+          init.getAggregateElement(1),
+          init.getAggregateElement(2),
+          init.getAggregateElement(3),
+          init.getAggregateElement(4),
+          init.getAggregateElement(5),
+          init.getAggregateElement(6),
+          init.getAggregateElement(7),
+          init.getAggregateElement(8),
+          typeInfoV2,
+        ]
 
         if isDefined(g.config, "nimTypeNames"):
           values.add init.getAggregateElement(10)
@@ -3726,16 +3736,15 @@ proc callCompilerProc(
     f = g.genFunctionWithBody(sym).v
     fty = f.globalGetValueType()
 
-  if noInvoke:
-    let ret = g.b.buildCall2(
-      fty,
-      f,
-      args,
-      if fty.getReturnType().getTypeKind() == llvm.VoidTypeKind:
-        ""
-      else:
-        g.nn("call.cp." & name),
-    )
+  if noInvoke or g.f.nestedTryStmts.len == 0:
+    let
+      name =
+        if fty.getReturnType().getTypeKind() == llvm.VoidTypeKind:
+          cstring("")
+        else:
+          name
+
+      ret = g.b.buildCall2(fty, f, args, name)
     if noReturn:
       discard g.b.buildUnreachable()
       g.b.positionBuilderAtEnd(g.getDeadBlock())
@@ -3855,7 +3864,7 @@ proc callRaise(
   discard g.b.buildCondBr(cond, raised, cont)
 
   g.b.positionBuilderAtEnd(raised)
-  discard g.callCompilerProc(raiser, args)
+  discard g.callCompilerProc(raiser, args, noReturn = true)
   discard g.b.buildUnreachable()
   g.b.positionBuilderAtEnd(cont)
 
@@ -3980,10 +3989,16 @@ proc callIsObj(g: LLGen, v: llvm.ValueRef, typ: PType): llvm.ValueRef =
         llvm.False,
       )
 
-    g.callCompilerProc("isObjDisplayCheck", [mtype, cmpTo, elem])
+    g.callCompilerProc("isObjDisplayCheck", [mtype, cmpTo, elem], noInvoke = true)
   else:
     let cmpTo = g.genTypeInfoV1(typ)
-    g.callCompilerProc("isObj", [mtype, cmpTo])
+    g.callCompilerProc("isObj", [mtype, cmpTo], noInvoke = true)
+
+proc callAsgnRef(g: LLGen, dest, src: llvm.ValueRef) =
+  discard g.callCompilerProc("asgnRef", [dest, src], noInvoke = true)
+
+proc callUnsureAsgnRef(g: LLGen, dest, src: llvm.ValueRef) =
+  discard g.callCompilerProc("unsureAsgnRef", [dest, src], noInvoke = true)
 
 # These are taken from cgen and take care of some of the fallout from the
 # beautiful copy-on-write string literal pessimisation :/
@@ -4100,10 +4115,10 @@ proc genObjectInit(g: LLGen, typ: PType, v: llvm.ValueRef, setType: bool) =
 
       discard g.b.buildStore(pname, tgt)
   of tyTuple:
-    for i in 0 ..< xtyp.len:
-      if analyseObjectWithTypeField(xtyp[i]) != frNone:
+    for i, tf in xtyp.ikids:
+      if analyseObjectWithTypeField(tf) != frNone:
         let gep = g.b.buildStructGEP2(ty, v, cuint i, g.nn("oi.field" & $i, v))
-        g.genObjectInit(xtyp[i], gep)
+        g.genObjectInit(tf, gep)
   else:
     discard
 
@@ -4384,9 +4399,11 @@ proc genReset(g: LLGen, typ: PType, v: LLValue) =
 
       g.genResetFields(mapper, typ.n, ty, v)
     of tyTuple:
-      for i in 0 ..< typ.len:
+      for i, tf in typ.ikids:
+        if isEmptyType(tf):
+          continue
         let gep = g.b.buildStructGEP2(ty, v, cuint i, g.nn("reset.field" & $i, v))
-        g.callReset(typ[i], gep)
+        g.callReset(tf, gep)
     of tyString, tyRef, tySequence:
       g.genRefAssign(v, constNull(ty))
     of tyProc:
@@ -4592,11 +4609,13 @@ proc genAssign(g: LLGen, typ: PType, dest, src, shallow: llvm.ValueRef) =
 
       g.genAssignFields(mapper, typ.n, ty, dest, src, shallow)
     of tyTuple:
-      for i in 0 ..< typ.len:
+      for i, tf in typ.ikids:
+        if isEmptyType(tf):
+          continue
         let
           gepd = g.b.buildStructGEP2(ty, dest, cuint i, g.nn("asgn.field" & $i, dest))
           geps = g.b.buildStructGEP2(ty, src, cuint i, g.nn("asgn.field" & $i, src))
-        g.callAssign(typ[i], gepd, geps, shallow)
+        g.callAssign(tf, gepd, geps, shallow)
     of tyString:
       let srcl = g.b.buildLoad2(ty, src)
 
@@ -4624,10 +4643,10 @@ proc genAssign(g: LLGen, typ: PType, dest, src, shallow: llvm.ValueRef) =
         let phi = g.b.buildPHI(v.typeOfX(), g.nn("nilcheck.phi", v))
         phi.addIncoming([srcl, v], [pre, lcopy])
 
-        discard g.callCompilerProc("unsureAsgnRef", [dest, phi])
+        g.callUnsureAsgnRef(dest, phi)
     of tyRef:
       let srcl = g.b.buildLoad2(g.ptrTy, src)
-      discard g.callCompilerProc("unsureAsgnRef", [dest, srcl])
+      g.callUnsureAsgnRef(dest, srcl)
     of tySequence:
       let
         srcl = g.b.buildLoad2(g.ptrTy, src)
@@ -4673,7 +4692,7 @@ proc genAssign(g: LLGen, typ: PType, dest, src, shallow: llvm.ValueRef) =
       g.b.positionBuilderAtEnd(lasgn)
       let phi = g.b.buildPhi(g.ptrTy, g.nn("asgn.phi", srcl))
       phi.addIncoming([srcl, srcphi], [pre, postasgn])
-      discard g.callCompilerProc("unsureAsgnRef", [dest, phi])
+      g.callUnsureAsgnRef(dest, phi)
     of tyProc:
       if typ.callConv == ccClosure:
         block:
@@ -4688,7 +4707,7 @@ proc genAssign(g: LLGen, typ: PType, dest, src, shallow: llvm.ValueRef) =
             srce = g.buildClosureEnvGEP(src)
             srcl = g.b.buildLoad2(g.ptrTy, srce)
             destp = g.buildClosureEnvGEP(dest)
-          discard g.callCompilerProc("unsureAsgnRef", [destp, srcl])
+          g.callUnsureAsgnRef(destp, srcl)
       else:
         let srcl = g.b.buildLoad2(g.ptrTy, src)
         discard g.b.buildStore(srcl, dest)
@@ -4758,7 +4777,7 @@ proc callAssign(
     g.callMemcpy(dest, src, size)
   elif typ.kind == tyRef:
     let srcl = g.b.buildLoad2(g.ptrTy, src)
-    discard g.callCompilerProc("unsureAsgnRef", [dest, srcl])
+    g.callUnsureAsgnRef(dest, srcl)
   else:
     let
       f = g.genAssignFunc(typ)
@@ -5281,6 +5300,17 @@ proc genFakeCall(g: LLGen, n: PNode, o: var LLValue, load: bool): bool =
       )
       return true
 
+    if s.name.s == "pushCurrentException":
+      let tmp = g.genNode(n[1], true)
+      discard g.callCompilerProc("nlvmPushCurrentException", [tmp.v], noInvoke = true)
+
+      return true
+
+    if s.name.s == "popCurrentException":
+      discard g.callCompilerProc("nlvmPopCurrentException", [], noInvoke = true)
+
+      return true
+
     if s.name.s == "getCurrentExceptionMsg":
       let ax = g.callCompilerProc("nlvmGetCurrentExceptionMsg", [], noInvoke = true)
       o = LLValue(
@@ -5294,7 +5324,7 @@ proc genFakeCall(g: LLGen, n: PNode, o: var LLValue, load: bool): bool =
       )
       return true
 
-    if s.name.s in ["closureIterSetupExc", "setCurrentException"]:
+    if s.name.s in ["closureIterSetExc", "setCurrentException"]:
       let p0 = g.genNode(n[1], true).v
       discard g.callCompilerProc("nlvmSetClosureException", [p0], noInvoke = true)
       return true
@@ -5386,11 +5416,9 @@ proc genFakeCall(g: LLGen, n: PNode, o: var LLValue, load: bool): bool =
       o = LLValue(v: g.b.buildAtomicRMW(AtomicRMWBinOpXchg, p0, p1, ord, llvm.False))
 
       return true
-    elif s.name.s in
-        [
-          "atomic_compare_exchange_strong_explicit",
-          "atomic_compare_exchange_weak_explicit",
-        ]:
+    elif s.name.s in [
+      "atomic_compare_exchange_strong_explicit", "atomic_compare_exchange_weak_explicit"
+    ]:
       let
         p0 = g.genNode(n[1], true).v
         p1 = g.genNode(n[2], true).v
@@ -5855,9 +5883,9 @@ proc genRefAssign(g: LLGen, dest: LLValue, src: llvm.ValueRef) =
       not usesWriteBarrier(g.config):
     discard g.b.buildStore(src, dest.v)
   elif dest.storage == OnHeap:
-    discard g.callCompilerProc("asgnRef", [dest.v, src])
+    g.callAsgnRef(dest.v, src)
   else:
-    discard g.callCompilerProc("unsureAsgnRef", [dest.v, src])
+    g.callUnsureAsgnRef(dest.v, src)
 
 proc callGenericAssign(
     g: LLGen, dest, src: LLValue, typ: PType, flags: TAssignmentFlags
@@ -5918,10 +5946,10 @@ proc genAssignment(g: LLGen, dest, src: LLValue, typ: PType, flags: TAssignmentF
         let srcc = g.callCompilerProc("copyStringRC1", [src.v])
         discard g.b.buildStore(srcc, dest.v)
         g.withNotNil(destl):
-          discard g.callCompilerProc("nimGCunrefNoCycle", [destl])
+          discard g.callCompilerProc("nimGCunrefNoCycle", [destl], noInvoke = true)
       else:
         let srcc = g.callCompilerProc("copyString", [src.v])
-        discard g.callCompilerProc("unsureAsgnRef", [dest.v, srcc])
+        g.callUnsureAsgnRef(dest.v, srcc)
   of tyProc:
     if typ.containsGarbageCollectedRef():
       # TODO this is a hack to work around "automatic" conversion between
@@ -6691,16 +6719,16 @@ proc rawGenNew(g: LLGen, dest: LLValue, sizeExpr: llvm.ValueRef, typ: PType) =
       let destl = g.buildLoadValue(g.llType(refType), dest)
       g.withNotNil(destl.v):
         if g.graph.canFormAcycle(typ):
-          discard g.callCompilerProc("nimGCunrefRC1", [destl.v])
+          discard g.callCompilerProc("nimGCunrefRC1", [destl.v], noInvoke = true)
         else:
-          discard g.callCompilerProc("nimGCunrefNoCycle", [destl.v])
+          discard g.callCompilerProc("nimGCunrefNoCycle", [destl.v], noInvoke = true)
         discard g.b.buildStore(constNull(g.llType(refType)), dest.v)
 
       if g.config.selectedGC == gcGo:
         # newObjRC1() would clash with unsureAsgnRef() - which is used by gcGo to
         # implement the write barrier
         let src = g.callCompilerProc("newObj", [ti, sizeExpr])
-        discard g.callCompilerProc("unsureAsgnRef", [dest.v, src])
+        g.callUnsureAsgnRef(dest.v, src)
       else:
         # use newObjRC1 as an optimization
         let src = g.callCompilerProc("newObjRC1", [ti, sizeExpr])
@@ -6765,16 +6793,16 @@ proc genNewSeqAux(g: LLGen, dest: LLValue, destTyp: PType, len: llvm.ValueRef) =
     let destl = g.buildLoadValue(g.llType(destTyp), dest)
     g.withNotNil(destl.v):
       if g.graph.canFormAcycle(destTyp):
-        discard g.callCompilerProc("nimGCunrefRC1", [destl.v])
+        discard g.callCompilerProc("nimGCunrefRC1", [destl.v], noInvoke = true)
       else:
-        discard g.callCompilerProc("nimGCunrefNoCycle", [destl.v])
+        discard g.callCompilerProc("nimGCunrefNoCycle", [destl.v], noInvoke = true)
       discard g.b.buildStore(constNull(g.llType(destTyp)), dest.v)
 
     if not len.isZero():
       if g.config.selectedGC == gcGo:
         # we need the write barrier
         let src = g.callCompilerProc("newSeq", args)
-        discard g.callCompilerProc("unsureAsgnRef", [dest.v, src])
+        g.callUnsureAsgnRef(dest.v, src)
       else:
         let src = g.callCompilerProc("newSeqRC1", args)
         discard g.b.buildStore(src, dest.v)
@@ -10497,7 +10525,7 @@ proc writeOutput(g: LLGen, project: string) =
 
   let outFile = g.config.getOutFile(g.config.outFile, ext)
 
-  g.runOptimizers()
+  #g.runOptimizers()
 
   var err: cstring
   if optCompileOnly in g.config.globalOptions:
@@ -10573,6 +10601,31 @@ proc runModule(g: LLGen, m: llvm.ModuleRef, fcns: openArray[string]) =
       g.config.internalError($err.getErrorMessage)
     cast[proc() {.cdecl.}](main)()
 
+proc handleProcGlobals(g: LLGen, m: LLModule) =
+  if g.graph.procGlobals.len == 0:
+    return
+
+  # Order is important here: when called recursively below, those inits must
+  # happen before the inits that caused the recursive call!
+  let pre = g.f.sections[secPreinit]
+  g.f.sections[secPreinit] = appendBasicBlockInContext(g.lc, g.f.f, g.nn($secPreinit))
+
+  if g.f.sections[secLastPreinit] == nil:
+    g.f.sections[secLastPreinit] = g.f.sections[secPreinit]
+
+  g.withBlock(g.f.sections[secPreinit]):
+    var procGlobals: seq[PNode] = move g.graph.procGlobals
+
+    for i in 0 ..< procGlobals.len:
+      var transformedN = procGlobals[i]
+      if sfInjectDestructors in m.sym.flags:
+        transformedN = injectDestructorCalls(g.graph, g.idgen, m.sym, transformedN)
+      g.genNode(transformedN)
+
+      handleProcGlobals(g, m)
+    if pre != nil:
+      discard g.b.buildBr(pre)
+
 proc myProcess(b: PPassContext, n: PNode): PNode =
   let
     m = LLModule(b)
@@ -10587,15 +10640,19 @@ proc myProcess(b: PPassContext, n: PNode): PNode =
     transformedN = injectDestructorCalls(g.graph, g.idgen, m.sym, transformedN)
 
   g.withModule(m):
-    g.withFunc(g.getInitFunc()):
+    let initFunc = g.getInitFunc()
+    g.withFunc(initFunc):
       # Process the code with any top-level stuff going to the init func
       g.b.positionBuilderAtEnd(g.section(g.f, secLastBody))
       g.debugUpdateLoc(n)
 
       g.f.options = g.config.options
       g.genNode(transformedN)
+
       g.f.sections[secLastBody] = g.b.getInsertBlock()
 
+      g.handleProcGlobals(m)
+
   if g.interactive() and g.init.sections[secBody].getFirstInstruction() != nil and
       m.sym.name.s == "stdin":
     # When we've reached the stdin module, it means we're processing the
diff --git a/nlvm/llplatform.nim b/nlvm/llplatform.nim
index c3ec5a5..e7af1fd 100644
--- a/nlvm/llplatform.nim
+++ b/nlvm/llplatform.nim
@@ -27,6 +27,7 @@ proc toLLVMArch*(cpu: TSystemCPU): string =
   of cpuPowerpc64el: "powerpc64le"
   of cpuSparc: "sparc"
   of cpuSparc64: "sparc64"
+  of cpuS390x: "s390x"
   of cpuAVR: "avr"
   of cpuIa64: "ia64"
   of cpuM68k: "m68k"
@@ -171,6 +172,8 @@ proc parseTarget*(target: string): tuple[cpu: TSystemCPU, os: TSystemOS] =
     cpu = cpuSparc64
   of "sparc":
     cpu = cpuSparc
+  of "s390x", "systemz":
+    cpu = cpuS390x
   of "ia64", "itanium":
     cpu = cpuIa64
   of "avr":
diff --git a/nlvm/nlvm.nim b/nlvm/nlvm.nim
index 0385dbf..f2bdc85 100644
--- a/nlvm/nlvm.nim
+++ b/nlvm/nlvm.nim
@@ -20,8 +20,7 @@ const
   NlvmHash = gorge("git rev-parse HEAD").strip
   NimHash = gorge("git -C ../Nim rev-parse HEAD").strip
 
-  HelpHeader =
-    """nlvm compiler for Nim, version $1 [$2: $3]
+  HelpHeader = """nlvm compiler for Nim, version $1 [$2: $3]
 
 Copyright (c) 2015-2026 Jacek Sieka
 Nim compiler (c) 2009-2026 Andreas Rumpf
diff --git a/skipped-tests.txt b/skipped-tests.txt
index 45f7094..183c870 100644
--- a/skipped-tests.txt
+++ b/skipped-tests.txt
@@ -1,3 +1,7 @@
+lib/nimrtl.nim c  -d:nimDebugDlOpen -d:release --mm:refc --outdir:tests/dll
+lib/nimrtl.nim c  -d:nimDebugDlOpen -d:release --outdir:tests/dll
+lib/nimrtl.nim c  -d:nimDebugDlOpen --mm:refc --outdir:tests/dll
+lib/nimrtl.nim c  -d:nimDebugDlOpen --outdir:tests/dll
 tests/align/talign.nim c
 tests/arc/t16458.nim c --gc:orc --d:useNimRtl
 tests/arc/t18977.nim c --mm:arc
@@ -95,13 +99,11 @@ tests/dll/visibility.nim c  -d:nimDebugDlOpen --threads:off
 tests/effects/tdiagnostic_messages.nim c
 tests/errmsgs/t14444.nim c --hints:off
 tests/errmsgs/t23536.nim c --stackTrace:on --excessiveStackTrace:off
+tests/errmsgs/t24974.nim c
 tests/errmsgs/tcall_with_default_arg.nim c
 tests/errmsgs/tproper_stacktrace2.nim c --stackTrace:on
 tests/errmsgs/tproper_stacktrace3.nim c --stackTrace:on
 tests/errmsgs/tproper_stacktrace.nim c --stackTrace:on --hint:all:off --warnings:off
-tests/errmsgs/trecursiveproctype2.nim c
-tests/errmsgs/trecursiveproctype3.nim c
-tests/errmsgs/trecursiveproctype4.nim c
 tests/exception/t13115.nim c
 tests/exception/t18620.nim c --gc:arc
 tests/exception/t18620.nim c --gc:refc
@@ -124,6 +126,8 @@ tests/int/tints.nim js --backend:js --jsbigint64:off -d:nimStringHash2
 tests/int/tints.nim js --backend:js --jsbigint64:on
 tests/iter/tnestedclosures.nim c
 tests/iter/tshallowcopy_closures.nim c --mm:refc
+tests/iter/tyieldintry.nim c
+tests/iter/tyieldintry.nim c --experimental:strictdefs
 tests/lent/tbasic_lent_check.nim c
 tests/let/timportc.nim c
 tests/macros/tmemit.nim c
@@ -212,6 +216,7 @@ tests/testament/tshould_not_work.nim c
 tests/threads/tonthreadcreation.nim c  --threads:on -d:release --mm:orc --deepcopy:on
 tests/threads/tonthreadcreation.nim c  --threads:on --mm:orc --deepcopy:on
 tests/threads/tonthreadcreation.nim c  --threads:on --tlsEmulation:on --mm:orc --deepcopy:on
+tests/tools/tctags2.nim c
 tests/tools/tctags.nim c
 tests/tools/tnimgrep.nim c
 tests/views/tsplit_into_seq.nim c