Merge branch 'devel' into sig-handler

Author: arnetheduck

compiler/ast.nim

@@ -819,6 +819,7 @@ type
                                 # nodes are compared by structure!
     counter*: int
     data*: TNodePairSeq
+    ignoreTypes*: bool
 
   TObjectSeq* = seq[RootRef]
   TObjectSet* = object
@@ -1641,8 +1642,8 @@ proc initObjectSet*(): TObjectSet =
   result = TObjectSet(counter: 0)
   newSeq(result.data, StartSize)
 
-proc initNodeTable*(): TNodeTable =
-  result = TNodeTable(counter: 0)
+proc initNodeTable*(ignoreTypes=false): TNodeTable =
+  result = TNodeTable(counter: 0, ignoreTypes: ignoreTypes)
   newSeq(result.data, StartSize)
 
 proc skipTypes*(t: PType, kinds: TTypeKinds; maxIters: int): PType =

compiler/ccgexprs.nim

@@ -981,7 +981,11 @@ proc genAddr(p: BProc, e: PNode, d: var TLoc) =
     var a: TLoc = initLocExpr(p, e[0])
     if e[0].kind in {nkHiddenStdConv, nkHiddenSubConv, nkConv} and not ignoreConv(e[0]):
       # addr (conv x) introduces a temp because `conv x` is not a rvalue
-      putIntoDest(p, d, e, addrLoc(p.config, expressionsNeedsTmp(p, a)), a.storage)
+      # transform addr ( conv ( x ) ) -> conv ( addr ( x ) )
+      var exprLoc: TLoc = initLocExpr(p, e[0][1])
+      var tmp = getTemp(p, e.typ, needsInit=false)
+      putIntoDest(p, tmp, e, cCast(getTypeDesc(p.module, e.typ), addrLoc(p.config, exprLoc)))
+      putIntoDest(p, d, e, rdLoc(tmp))
     else:
       putIntoDest(p, d, e, addrLoc(p.config, a), a.storage)
 

compiler/transf.nim

@@ -259,7 +259,8 @@ proc transformBlock(c: PTransf, n: PNode): PNode =
   var labl: PSym
   if c.inlining > 0:
     labl = newLabel(c, n[0])
-    c.transCon.mapping[n[0].sym.itemId] = newSymNode(labl)
+    if n[0].kind != nkEmpty:
+      c.transCon.mapping[n[0].sym.itemId] = newSymNode(labl)
   else:
     labl =
       if n[0].kind != nkEmpty:

compiler/treetab.nim

@@ -42,32 +42,37 @@ proc hashTree*(n: PNode): Hash =
   #echo "hashTree ", result
   #echo n
 
-proc treesEquivalent(a, b: PNode): bool =
+proc treesEquivalent(a, b: PNode; ignoreTypes: bool): bool =
   if a == b:
     result = true
   elif (a != nil) and (b != nil) and (a.kind == b.kind):
     case a.kind
-    of nkEmpty, nkNilLit, nkType: result = true
+    of nkEmpty: result = true
     of nkSym: result = a.sym.id == b.sym.id
     of nkIdent: result = a.ident.id == b.ident.id
     of nkCharLit..nkUInt64Lit: result = a.intVal == b.intVal
-    of nkFloatLit..nkFloat64Lit: result = a.floatVal == b.floatVal
+    of nkFloatLit..nkFloat64Lit:
+      result = cast[uint64](a.floatVal) == cast[uint64](b.floatVal)
+      #result = a.floatVal == b.floatVal
     of nkStrLit..nkTripleStrLit: result = a.strVal == b.strVal
+    of nkType, nkNilLit:
+      result = a.typ == b.typ
     else:
       if a.len == b.len:
         for i in 0..<a.len:
-          if not treesEquivalent(a[i], b[i]): return
+          if not treesEquivalent(a[i], b[i], ignoreTypes): return
         result = true
       else:
         result = false
-    if result: result = sameTypeOrNil(a.typ, b.typ)
+    if result and not ignoreTypes:
+      result = sameTypeOrNil(a.typ, b.typ)
   else:
     result = false
 
 proc nodeTableRawGet(t: TNodeTable, k: Hash, key: PNode): int =
   var h: Hash = k and high(t.data)
   while t.data[h].key != nil:
-    if (t.data[h].h == k) and treesEquivalent(t.data[h].key, key):
+    if (t.data[h].h == k) and treesEquivalent(t.data[h].key, key, t.ignoreTypes):
       return h
     h = nextTry(h, high(t.data))
   result = -1

compiler/vmdef.nim

@@ -249,6 +249,7 @@ type
                             # to not slow down interpretation
     globals*: PNode         #
     constants*: PNode       # constant data
+    contstantTab*: TNodeTable
     types*: seq[PType]      # some instructions reference types (e.g. 'except')
     currentExceptionA*, currentExceptionB*: PNode
     exceptionInstr*: int # index of instruction that raised the exception
@@ -298,7 +299,8 @@ proc newCtx*(module: PSym; cache: IdentCache; g: ModuleGraph; idgen: IdGenerator
     prc: PProc(blocks: @[]), module: module, loopIterations: g.config.maxLoopIterationsVM,
     callDepth: g.config.maxCallDepthVM,
     comesFromHeuristic: unknownLineInfo, callbacks: @[], callbackIndex: initTable[string, int](), errorFlag: "",
-    cache: cache, config: g.config, graph: g, idgen: idgen)
+    cache: cache, config: g.config, graph: g, idgen: idgen,
+    contstantTab: initNodeTable(true))
 
 proc refresh*(c: PCtx, module: PSym; idgen: IdGenerator) =
   c.module = module

compiler/vmgen.nim

@@ -33,7 +33,8 @@ when defined(nimPreviewSlimSystem):
 
 import
   ast, types, msgs, renderer, vmdef, trees,
-  magicsys, options, lowerings, lineinfos, transf, astmsgs
+  magicsys, options, lowerings, lineinfos, transf, astmsgs,
+  treetab
 
 from modulegraphs import getBody
 
@@ -478,10 +479,16 @@ proc sameConstant*(a, b: PNode): bool =
         result = true
 
 proc genLiteral(c: PCtx; n: PNode): int =
-  # types do not matter here:
-  for i in 0..<c.constants.len:
-    if sameConstant(c.constants[i], n): return i
-  result = rawGenLiteral(c, n)
+  result = nodeTableTestOrSet(c.contstantTab, n, c.constants.len)
+  if result == c.constants.len:
+    let lit = rawGenLiteral(c, n)
+    assert lit == result
+
+  when false:
+    # types do not matter here:
+    for i in 0..<c.constants.len:
+      if sameConstant(c.constants[i], n): return i
+    result = rawGenLiteral(c, n)
 
 proc unused(c: PCtx; n: PNode; x: TDest) {.inline.} =
   if x >= 0:
@@ -1182,8 +1189,10 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {}, m: TMag
   of mEqF64: genBinaryABC(c, n, dest, opcEqFloat)
   of mLeF64: genBinaryABC(c, n, dest, opcLeFloat)
   of mLtF64: genBinaryABC(c, n, dest, opcLtFloat)
-  of mLePtr, mLeU: genBinaryABC(c, n, dest, opcLeu)
-  of mLtPtr, mLtU: genBinaryABC(c, n, dest, opcLtu)
+  of mLeU: genBinaryABC(c, n, dest, opcLeu)
+  of mLtU: genBinaryABC(c, n, dest, opcLtu)
+  of mLePtr, mLtPtr:
+    globalError(c.config, n.info, "pointer comparisons are not available at compile-time")
   of mEqProc, mEqRef:
     genBinaryABC(c, n, dest, opcEqRef)
   of mXor: genBinaryABC(c, n, dest, opcXor)
@@ -1547,8 +1556,7 @@ template cannotEval(c: PCtx; n: PNode) =
   if c.config.cmd == cmdCheck and c.config.m.errorOutputs != {}:
     # nim check command with no error outputs doesn't need to cascade here,
     # includes `tryConstExpr` case which should not continue generating code
-    localError(c.config, n.info, "cannot evaluate at compile time: " & 
-    n.renderTree)
+    localError(c.config, n.info, "cannot evaluate at compile time: " & n.renderTree)
     c.cannotEval = true
     return
   globalError(c.config, n.info, "cannot evaluate at compile time: " &
@@ -1886,7 +1894,7 @@ proc genCheckedObjAccess(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
   c.freeTemp(objR)
 
 proc genArrAccess(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
-  if n[0].typ == nil: 
+  if n[0].typ == nil:
     globalError(c.config, n.info, "cannot access array with nil type")
     return
 

lib/pure/strutils.nim

@@ -74,6 +74,7 @@ import std/parseutils
 from std/math import pow, floor, log10
 from std/algorithm import fill, reverse
 import std/enumutils
+from std/bitops import fastLog2
 
 from std/unicode import toLower, toUpper
 export toLower, toUpper
@@ -2639,37 +2640,35 @@ func formatSize*(bytes: int64,
   ## * `strformat module<strformat.html>`_ for string interpolation and formatting
   runnableExamples:
     doAssert formatSize((1'i64 shl 31) + (300'i64 shl 20)) == "2.293GiB"
-    doAssert formatSize((2.234*1024*1024).int) == "2.234MiB"
+    doAssert formatSize((2.234*1024*1024).int) == "2.233MiB"
     doAssert formatSize(4096, includeSpace = true) == "4 KiB"
     doAssert formatSize(4096, prefix = bpColloquial, includeSpace = true) == "4 kB"
     doAssert formatSize(4096) == "4KiB"
-    doAssert formatSize(5_378_934, prefix = bpColloquial, decimalSep = ',') == "5,13MB"
+    doAssert formatSize(5_378_934, prefix = bpColloquial, decimalSep = ',') == "5,129MB"
 
-  const iecPrefixes = ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"]
-  const collPrefixes = ["", "k", "M", "G", "T", "P", "E", "Z", "Y"]
-  var
-    xb: int64 = bytes
-    fbytes: float
-    lastXb: int64 = bytes
-    matchedIndex = 0
-    prefixes: array[9, string]
+  # It doesn't needs Zi and larger units until we use int72 or larger ints.
+  const iecPrefixes = ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei"]
+  const collPrefixes = ["", "k", "M", "G", "T", "P", "E"]
+
+  let lg2 = if bytes == 0:
+      0
+    else:
+      when hasWorkingInt64:
+        fastLog2(bytes)
+      else:
+        fastLog2(int32 bytes)
+  let matchedIndex = lg2 div 10
+  # Lower bits that are smaller than 0.001 when `bytes` is converted to a real number and added prefix, are discard.
+  # Then it is converted to float with round down.
+  let discardBits = (lg2 div 10 - 1) * 10
+
+  var prefixes: array[7, string]
   if prefix == bpColloquial:
     prefixes = collPrefixes
   else:
     prefixes = iecPrefixes
 
-  # Iterate through prefixes seeing if value will be greater than
-  # 0 in each case
-  for index in 1..<prefixes.len:
-    lastXb = xb
-    xb = bytes div (1'i64 shl (index*10))
-    matchedIndex = index
-    if xb == 0:
-      xb = lastXb
-      matchedIndex = index - 1
-      break
-  # xb has the integer number for the latest value; index should be correct
-  fbytes = bytes.float / (1'i64 shl (matchedIndex*10)).float
+  let fbytes = if lg2 < 10: bytes.float elif lg2 < 20: bytes.float / 1024.0 else: (bytes shr discardBits).float / 1024.0
   result = formatFloat(fbytes, format = ffDecimal, precision = 3,
       decimalSep = decimalSep)
   result.trimZeros(decimalSep)

tests/ccgbugs/taddrconvs.nim

@@ -25,3 +25,23 @@ block:
     var m = uint64(12)
     foo(culonglong(m))
   main()
+
+block: # bug #25109
+  type T = culonglong
+  proc r(c: var T) = c = 1
+  proc h(a: var culonglong) = r(T(a))
+  var a: culonglong
+  h(a)
+  doAssert a == 1
+
+block: # bug #25111
+  type T = culonglong
+  proc r(c: var T) = c = 1
+
+  proc foo =
+    var a: uint64
+    r(T(a))
+    doAssert a == 1
+
+  foo()
+

tests/iter/titer_issues.nim

@@ -412,3 +412,15 @@ block: # bug #24033
     collections.add (id, str, $num)
 
   doAssert collections[1] == (1, "foo", "3.14")
+
+
+block: # bug #25121
+  iterator k(): int =
+    when nimvm:
+      yield 0
+    else:
+      yield 0
+
+  for _ in k():
+    (proc() = (; let _ = block: 0))()
+

tests/stdlib/tstrutils.nim

@@ -789,12 +789,71 @@ bar
   block: # formatSize
     disableVm:
       when hasWorkingInt64:
+        doAssert formatSize(1024'i64 * 1024 * 1024 * 2 - 1) == "1.999GiB"
+        doAssert formatSize(1024'i64 * 1024 * 1024 * 2) == "2GiB"
         doAssert formatSize((1'i64 shl 31) + (300'i64 shl 20)) == "2.293GiB" # <=== bug #8231
-      doAssert formatSize((2.234*1024*1024).int) == "2.234MiB"
+        doAssert formatSize(int64.high) == "7.999EiB"
+        doAssert formatSize(int64.high div 2 + 1) == "4EiB"
+        doAssert formatSize(int64.high div 2) == "3.999EiB"
+        doAssert formatSize(int64.high div 4 + 1) == "2EiB"
+        doAssert formatSize(int64.high div 4) == "1.999EiB"
+        doAssert formatSize(int64.high div 8 + 1) == "1EiB"
+        doAssert formatSize(int64.high div 8) == "1023.999PiB"
+        doAssert formatSize(int64.high div 16 + 1) == "512PiB"
+        doAssert formatSize(int64.high div 16) == "511.999PiB"
+      doAssert formatSize(0) == "0B"
+      doAssert formatSize(0, includeSpace = true) == "0 B"
+      doAssert formatSize(1) == "1B"
+      doAssert formatSize(2) == "2B"
+      doAssert formatSize(1022) == "1022B"
+      doAssert formatSize(1023) == "1023B"
+      doAssert formatSize(1024) == "1KiB"
+      doAssert formatSize(1025) == "1.001KiB"
+      doAssert formatSize(1026) == "1.002KiB"
+      doAssert formatSize(1024 * 2 - 2) == "1.998KiB"
+      doAssert formatSize(1024 * 2 - 1) == "1.999KiB"
+      doAssert formatSize(1024 * 2) == "2KiB"
+      doAssert formatSize(1024 * 2 + 1) == "2.001KiB"
+      doAssert formatSize(1024 * 2 + 2) == "2.002KiB"
+      doAssert formatSize(4096 - 1) == "3.999KiB"
       doAssert formatSize(4096) == "4KiB"
+      doAssert formatSize(4096 + 1) == "4.001KiB"
+      doAssert formatSize(1024 * 512 - 1) == "511.999KiB"
+      doAssert formatSize(1024 * 512) == "512KiB"
+      doAssert formatSize(1024 * 512 + 1) == "512.001KiB"
+      doAssert formatSize(1024 * 1024 - 2) == "1023.998KiB"
+      doAssert formatSize(1024 * 1024 - 1) == "1023.999KiB"
+      doAssert formatSize(1024 * 1024) == "1MiB"
+      doAssert formatSize(1024 * 1024 + 1) == "1MiB"
+      doAssert formatSize(1024 * 1024 + 1023) == "1MiB"
+      doAssert formatSize(1024 * 1024 + 1024) == "1.001MiB"
+      doAssert formatSize(1024 * 1024 + 1024 * 2) == "1.002MiB"
+      doAssert formatSize(1024 * 1024 * 2 - 1) == "1.999MiB"
+      doAssert formatSize(1024 * 1024 * 2) == "2MiB"
+      doAssert formatSize(1024 * 1024 * 2 + 1) == "2MiB"
+      doAssert formatSize(1024 * 1024 * 2 + 1024) == "2.001MiB"
+      doAssert formatSize(1024 * 1024 * 2 + 1024 * 2) == "2.002MiB"
+      doAssert formatSize(1024 * 1024 * 4 - 1) == "3.999MiB"
+      doAssert formatSize(1024 * 1024 * 4) == "4MiB"
+      doAssert formatSize(1024 * (1024 * 4 + 1)) == "4.001MiB"
+      doAssert formatSize(1024 * 1024 * 512 - 1025) == "511.998MiB"
+      doAssert formatSize(1024 * 1024 * 512 - 1) == "511.999MiB"
+      doAssert formatSize(1024 * 1024 * 512) == "512MiB"
+      doAssert formatSize(1024 * 1024 * 512 + 1) == "512MiB"
+      doAssert formatSize(1024 * 1024 * 512 + 1024) == "512.001MiB"
+      doAssert formatSize(1024 * 1024 * 512 + 1024 * 2) == "512.002MiB"
+      doAssert formatSize(1024 * 1024 * 1024 - 1) == "1023.999MiB"
+      doAssert formatSize(1024 * 1024 * 1024) == "1GiB"
+      doAssert formatSize(1024 * 1024 * 1024 + 1) == "1GiB"
+      doAssert formatSize(1024 * 1024 * 1025) == "1.001GiB"
+      doAssert formatSize(1024 * 1024 * 1026) == "1.002GiB"
+      # != 2.234MiB as (2.234 * 1024 * 1024).int.float / (1024 * 1024) = 2.23399...
+      # and formatSize round down the value
+      doAssert formatSize((2.234*1024*1024).int) == "2.233MiB"
       doAssert formatSize(4096, prefix = bpColloquial, includeSpace = true) == "4 kB"
       doAssert formatSize(4096, includeSpace = true) == "4 KiB"
-      doAssert formatSize(5_378_934, prefix = bpColloquial, decimalSep = ',') == "5,13MB"
+      # (5378934).float / (1024 * 1024) = 5.12975...
+      doAssert formatSize(5_378_934, prefix = bpColloquial, decimalSep = ',') == "5,129MB"
 
   block: # formatEng
     disableVm: