summary refs log tree commit diff stats
path: root/lib/system/gc.nim
diff options
context:
space:
mode:
Diffstat (limited to 'lib/system/gc.nim')
-rwxr-xr-xlib/system/gc.nim64
1 files changed, 32 insertions, 32 deletions
diff --git a/lib/system/gc.nim b/lib/system/gc.nim
index c7d1ba314..3edde8a86 100755
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -133,30 +133,30 @@ when traceGC:
     of csAllocated:
       if c in states[csAllocated]:
         writeCell("attempt to alloc an already allocated cell", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 1")
       excl(states[csCycFreed], c)
       excl(states[csZctFreed], c)
     of csZctFreed:
       if c in states[csZctFreed]:
         writeCell("attempt to free zct cell twice", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 2")
       if c in states[csCycFreed]:
         writeCell("attempt to free with zct, but already freed with cyc", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 3")
       if c notin states[csAllocated]:
         writeCell("attempt to free not an allocated cell", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 4")
       excl(states[csAllocated], c)
     of csCycFreed:
       if c notin states[csAllocated]:
         writeCell("attempt to free a not allocated cell", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 5")
       if c in states[csCycFreed]:
         writeCell("attempt to free cyc cell twice", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 6")
       if c in states[csZctFreed]:
         writeCell("attempt to free with cyc, but already freed with zct", c)
-        sysAssert(false)
+        sysAssert(false, "traceCell 7")
       excl(states[csAllocated], c)
     incl(states[state], c)
 
@@ -225,7 +225,7 @@ proc decRef(c: PCell) {.inline.} =
   when stressGC:
     if c.refcount <% rcIncrement:
       writeCell("broken cell", c)
-  sysAssert(c.refcount >=% rcIncrement)
+  sysAssert(c.refcount >=% rcIncrement, "decRef")
   #if c.refcount <% rcIncrement: quit("leck mich")
   if --c.refcount:
     rtlAddZCT(c)
@@ -242,7 +242,7 @@ proc nimGCunref(p: pointer) {.compilerProc, inline.} = decRef(usrToCell(p))
 
 proc asgnRef(dest: ppointer, src: pointer) {.compilerProc, inline.} =
   # the code generator calls this proc!
-  sysAssert(not isOnStack(dest))
+  sysAssert(not isOnStack(dest), "asgnRef")
   # BUGFIX: first incRef then decRef!
   if src != nil: incRef(usrToCell(src))
   if dest[] != nil: decRef(usrToCell(dest[]))
@@ -298,7 +298,7 @@ proc forAllSlotsAux(dest: pointer, n: ptr TNimNode, op: TWalkOp) =
   of nkCase:
     var m = selectBranch(dest, n)
     if m != nil: forAllSlotsAux(dest, m, op)
-  of nkNone: sysAssert(false)
+  of nkNone: sysAssert(false, "forAllSlotsAux")
 
 proc forAllChildrenAux(dest: Pointer, mt: PNimType, op: TWalkOp) =
   var d = cast[TAddress](dest)
@@ -315,9 +315,9 @@ proc forAllChildrenAux(dest: Pointer, mt: PNimType, op: TWalkOp) =
     else: nil
 
 proc forAllChildren(cell: PCell, op: TWalkOp) =
-  sysAssert(cell != nil)
-  sysAssert(cell.typ != nil)
-  sysAssert cell.typ.kind in {tyRef, tySequence, tyString}
+  sysAssert(cell != nil, "forAllChildren: 1")
+  sysAssert(cell.typ != nil, "forAllChildren: 2")
+  sysAssert cell.typ.kind in {tyRef, tySequence, tyString}, "forAllChildren: 3"
   case cell.typ.Kind
   of tyRef: # common case
     forAllChildrenAux(cellToUsr(cell), cell.typ.base, op)
@@ -377,11 +377,11 @@ proc addNewObjToZCT(res: PCell, gch: var TGcHeap) {.inline.} =
 proc newObj(typ: PNimType, size: int, gch: var TGcHeap): pointer =
   # generates a new object and sets its reference counter to 0
   acquire(gch)
-  sysAssert(typ.kind in {tyRef, tyString, tySequence})
+  sysAssert(typ.kind in {tyRef, tyString, tySequence}, "newObj: 1")
   collectCT(gch)
   var res = cast[PCell](rawAlloc(gch.region, size + sizeof(TCell)))
   zeroMem(res, size+sizeof(TCell))
-  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0)
+  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
   # now it is buffered in the ZCT
   res.typ = typ
   when debugGC and not hasThreadSupport:
@@ -389,13 +389,13 @@ proc newObj(typ: PNimType, size: int, gch: var TGcHeap): pointer =
       res.filename = framePtr.prev.filename
       res.line = framePtr.prev.line
   res.refcount = rcZct # refcount is zero, but mark it to be in the ZCT  
-  sysAssert(isAllocatedPtr(gch.region, res))
+  sysAssert(isAllocatedPtr(gch.region, res), "newObj: 3")
   # its refcount is zero, so add it to the ZCT:
   addNewObjToZCT(res, gch)
   when logGC: writeCell("new cell", res)
-  gcTrace(res, csAllocated)  
+  gcTrace(res, csAllocated)
   release(gch)
-  result = cellToUsr(res)  
+  result = cellToUsr(res)
 
 proc newObj(typ: PNimType, size: int): pointer {.compilerRtl.} =
   result = newObj(typ, size, gch)
@@ -410,8 +410,8 @@ proc growObj(old: pointer, newsize: int, gch: var TGcHeap): pointer =
   acquire(gch)
   collectCT(gch)
   var ol = usrToCell(old)
-  sysAssert(ol.typ != nil)
-  sysAssert(ol.typ.kind in {tyString, tySequence})
+  sysAssert(ol.typ != nil, "growObj: 1")
+  sysAssert(ol.typ.kind in {tyString, tySequence}, "growObj: 2")
   var res = cast[PCell](rawAlloc(gch.region, newsize + sizeof(TCell)))
   var elemSize = 1
   if ol.typ.kind != tyString: elemSize = ol.typ.base.size
@@ -420,8 +420,8 @@ proc growObj(old: pointer, newsize: int, gch: var TGcHeap): pointer =
   copyMem(res, ol, oldsize + sizeof(TCell))
   zeroMem(cast[pointer](cast[TAddress](res)+% oldsize +% sizeof(TCell)),
           newsize-oldsize)
-  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0)
-  sysAssert(res.refcount shr rcShift <=% 1)
+  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "growObj: 3")
+  sysAssert(res.refcount shr rcShift <=% 1, "growObj: 4")
   #if res.refcount <% rcIncrement:
   #  add(gch.zct, res)
   #else: # XXX: what to do here?
@@ -442,7 +442,7 @@ proc growObj(old: pointer, newsize: int, gch: var TGcHeap): pointer =
   gcTrace(res, csAllocated)
   when reallyDealloc: rawDealloc(gch.region, ol)
   else:
-    sysAssert(ol.typ != nil)
+    sysAssert(ol.typ != nil, "growObj: 5")
     zeroMem(ol, sizeof(TCell))
   release(gch)
   result = cellToUsr(res)
@@ -455,17 +455,17 @@ proc growObj(old: pointer, newsize: int): pointer {.rtl.} =
 proc doOperation(p: pointer, op: TWalkOp) =
   if p == nil: return
   var c: PCell = usrToCell(p)
-  sysAssert(c != nil)
+  sysAssert(c != nil, "doOperation: 1")
   case op # faster than function pointers because of easy prediction
   of waZctDecRef:
-    sysAssert(c.refcount >=% rcIncrement)
+    sysAssert(c.refcount >=% rcIncrement, "doOperation 2")
     c.refcount = c.refcount -% rcIncrement
     when logGC: writeCell("decref (from doOperation)", c)
     if c.refcount <% rcIncrement: addZCT(gch.zct, c)
   of waPush:
     add(gch.tempStack, c)
   of waCycleDecRef:
-    sysAssert(c.refcount >=% rcIncrement)
+    sysAssert(c.refcount >=% rcIncrement, "doOperation 3")
     c.refcount = c.refcount -% rcIncrement
 
 # we now use a much simpler and non-recursive algorithm for cycle removal
@@ -507,7 +507,7 @@ proc collectCycles(gch: var TGcHeap) =
       when logGC: writeCell("cycle collector dealloc cell", c)
       when reallyDealloc: rawDealloc(gch.region, c)
       else:
-        sysAssert(c.typ != nil)
+        sysAssert(c.typ != nil, "collectCycles")
         zeroMem(c, sizeof(TCell))
   Deinit(gch.cycleRoots)
   Init(gch.cycleRoots)
@@ -686,7 +686,7 @@ proc CollectZCT(gch: var TGcHeap) =
   while L[] > 0:
     var c = gch.zct.d[0]
     # remove from ZCT:
-    sysAssert((c.refcount and colorMask) == rcZct)
+    sysAssert((c.refcount and rcZct) == rcZct, "collectZCT")
     c.refcount = c.refcount and not colorMask
     gch.zct.d[0] = gch.zct.d[L[] - 1]
     dec(L[])
@@ -707,19 +707,19 @@ proc CollectZCT(gch: var TGcHeap) =
       forAllChildren(c, waZctDecRef)
       when reallyDealloc: rawDealloc(gch.region, c)
       else:
-        sysAssert(c.typ != nil)
+        sysAssert(c.typ != nil, "collectZCT 2")
         zeroMem(c, sizeof(TCell))
 
 proc unmarkStackAndRegisters(gch: var TGcHeap) = 
   var d = gch.decStack.d
   for i in 0..gch.decStack.len-1:
-    sysAssert isAllocatedPtr(allocator, d[i])
+    sysAssert isAllocatedPtr(gch.region, d[i]), "unmarkStackAndRegisters"
     # decRef(d[i]) inlined: cannot create a cycle and must not acquire lock
     var c = d[i]
     # XXX no need for an atomic dec here:
     if --c.refcount:
       addZCT(gch.zct, c)
-    sysAssert c.typ != nil
+    sysAssert c.typ != nil, "unmarkStackAndRegisters 2"
   gch.decStack.len = 0
 
 proc collectCT(gch: var TGcHeap) =
@@ -727,7 +727,7 @@ proc collectCT(gch: var TGcHeap) =
       getOccupiedMem(gch.region) >= gch.cycleThreshold) or stressGC) and 
       gch.recGcLock == 0:
     gch.stat.maxStackSize = max(gch.stat.maxStackSize, stackSize())
-    sysAssert(gch.decStack.len == 0)
+    sysAssert(gch.decStack.len == 0, "collectCT")
     markStackAndRegisters(gch)
     markThreadStacks(gch)
     gch.stat.maxStackCells = max(gch.stat.maxStackCells, gch.decStack.len)
ass="p"></style> <script type='text/javascript'> <!-- /* function to open any folds containing a jumped-to line before jumping to it */ function JumpToLine() { var lineNum; lineNum = window.location.hash; lineNum = lineNum.substr(1); /* strip off '#' */ if (lineNum.indexOf('L') == -1) { lineNum = 'L'+lineNum; } var lineElem = document.getElementById(lineNum); /* Always jump to new location even if the line was hidden inside a fold, or * we corrected the raw number to a line ID. */ if (lineElem) { lineElem.scrollIntoView(true); } return true; } if ('onhashchange' in window) { window.onhashchange = JumpToLine; } --> </script> </head> <body onload='JumpToLine();'> <a href='https://github.com/akkartik/mu/blob/master/apps/random.subx'>https://github.com/akkartik/mu/blob/master/apps/random.subx</a> <pre id='vimCodeElement'> <span id="L1" class="LineNr"> 1 </span><span class="subxComment"># Repeatedly read 32-bit numbers from /dev/random, print them to stdout.</span> <span id="L2" class="LineNr"> 2 </span><span class="subxComment">#</span> <span id="L3" class="LineNr"> 3 </span><span class="subxComment"># To run:</span> <span id="L4" class="LineNr"> 4 </span><span class="subxComment"># $ ./subx translate init.linux 0*.subx apps/random.subx -o apps/random</span> <span id="L5" class="LineNr"> 5 </span><span class="subxComment"># $ ./subx run apps/random</span> <span id="L6" class="LineNr"> 6 </span> <span id="L7" class="LineNr"> 7 </span>== code 0x09000000 <span id="L8" class="LineNr"> 8 </span><span class="subxComment"># instruction effective address register displacement immediate</span> <span id="L9" class="LineNr"> 9 </span><span class="subxS1Comment"># . op subop mod rm32 base index scale r32</span> <span id="L10" class="LineNr">10 </span><span class="subxS1Comment"># . 1-3 bytes 3 bits 2 bits 3 bits 3 bits 3 bits 2 bits 2 bits 0/1/2/4 bytes 0/1/2/4 bytes</span> <span id="L11" class="LineNr">11 </span> <span id="L12" class="LineNr">12 </span><span class="SpecialChar">Entry</span>: <span id="L13" class="LineNr">13 </span> <span class="subxComment"># stream/esi = syscall(open, &quot;/dev/null&quot;, O_RDONLY, 0) # we can't use 'fd' because it looks like a hex byte</span> <span id="L14" class="LineNr">14 </span> bb/copy-to-ebx <span class="SpecialChar"><a href='random.subx.html#L58'>Filename</a></span>/imm32 <span id="L15" class="LineNr">15 </span> b9/copy-to-ecx 0/imm32/rdonly <span id="L16" class="LineNr">16 </span> ba/copy-to-edx 0x180/imm32/fixed-perms <span id="L17" class="LineNr">17 </span> b8/copy-to-eax 5/imm32/open <span id="L18" class="LineNr">18 </span> cd/syscall 0x80/imm8 <span id="L19" class="LineNr">19 </span> <span class="subxS1Comment"># . stream = eax</span> <span id="L20" class="LineNr">20 </span> 89/copy 3/mod/direct 6/rm32/esi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to esi</span> <span id="L21" class="LineNr">21 </span> <span id="L22" class="LineNr">22 </span><span class="Constant">$loop</span>: <span id="L23" class="LineNr">23 </span> <span id="L24" class="LineNr">24 </span> <span class="subxComment"># syscall(read, Stream, N, 4)</span> <span id="L25" class="LineNr">25 </span> 89/copy 3/mod/direct 3/rm32/ebx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 6/r32/esi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esi to ebx</span> <span id="L26" class="LineNr">26 </span> b9/copy-to-ecx <span class="SpecialChar"><a href='random.subx.html#L56'>N</a></span>/imm32 <span id="L27" class="LineNr">27 </span> ba/copy-to-edx 4/imm32/size <span id="L28" class="LineNr">28 </span> b8/copy-to-eax 3/imm32/read <span id="L29" class="LineNr">29 </span> cd/syscall 0x80/imm8 <span id="L30" class="LineNr">30 </span> <span id="L31" class="LineNr">31 </span> <span class="subxComment"># print-int32-buffered(Stdout, *N)</span> <span id="L32" class="LineNr">32 </span> <span class="subxS2Comment"># . . push args</span> <span id="L33" class="LineNr">33 </span> ff 6/subop/push 0/mod/indirect 5/rm32/.disp32 <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="SpecialChar"><a href='random.subx.html#L56'>N</a></span>/disp32 <span class="subxComment"># push *N</span> <span id="L34" class="LineNr">34 </span> 68/push <span class="SpecialChar"><a href='../064write-byte.subx.html#L10'>Stdout</a></span>/imm32 <span id="L35" class="LineNr">35 </span> <span class="subxS2Comment"># . . call</span> <span id="L36" class="LineNr">36 </span> e8/call <a href='../066print-int.subx.html#L266'>print-int32-buffered</a>/disp32 <span id="L37" class="LineNr">37 </span> <span id="L38" class="LineNr">38 </span> <span class="subxComment"># write-buffered(Stdout, Newline)</span> <span id="L39" class="LineNr">39 </span> <span class="subxS2Comment"># . . push args</span> <span id="L40" class="LineNr">40 </span> 68/push <span class="SpecialChar"><a href='../051test.subx.html#L83'>Newline</a></span>/imm32 <span id="L41" class="LineNr">41 </span> 68/push <span class="SpecialChar"><a href='../064write-byte.subx.html#L10'>Stdout</a></span>/imm32 <span id="L42" class="LineNr">42 </span> <span class="subxS2Comment"># . . call</span> <span id="L43" class="LineNr">43 </span> e8/call <a href='../065write-buffered.subx.html#L8'>write-buffered</a>/disp32 <span id="L44" class="LineNr">44 </span> <span class="subxS2Comment"># . . discard args</span> <span id="L45" class="LineNr">45 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span> <span id="L46" class="LineNr">46 </span> <span id="L47" class="LineNr">47 </span> eb/jump $<span class="Constant">loop</span>/disp8 <span id="L48" class="LineNr">48 </span> <span id="L49" class="LineNr">49 </span> <span class="subxComment"># syscall(exit, 0)</span> <span id="L50" class="LineNr">50 </span> bb/copy-to-ebx 0/imm32 <span id="L51" class="LineNr">51 </span> b8/copy-to-eax 1/imm32/exit <span id="L52" class="LineNr">52 </span> cd/syscall 0x80/imm8 <span id="L53" class="LineNr">53 </span> <span id="L54" class="LineNr">54 </span>== data 0x0a000000 <span id="L55" class="LineNr">55 </span> <span id="L56" class="LineNr">56 </span><span class="SpecialChar">N</span>: <span id="L57" class="LineNr">57 </span> 0/imm32 <span id="L58" class="LineNr">58 </span><span class="SpecialChar">Filename</span>: <span id="L59" class="LineNr">59 </span> 2f 64 65 76 2f 72 61 6e 64 6f 6d 00 <span id="L60" class="LineNr">60 </span><span class="subxComment"># / d e v / r a n d o m null</span> <span id="L61" class="LineNr">61 </span> <span id="L62" class="LineNr">62 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span> </pre> </body> </html> <!-- vim: set foldmethod=manual : -->