jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix #12122 (#21096)

Browse source
This commit is contained in:
Bung 2022-12-16 15:01:15 +08:00 • committed by GitHub
commit a9bd78d579
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 140 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

70
lib/system/alloc.nim
View file

@ -290,7 +290,7 @@ proc llAlloc(a: var MemRegion, size: int): pointer =
a.llmem.size = PageSize - sizeof(LLChunk)
a.llmem.acc = sizeof(LLChunk)
a.llmem.next = old
result = cast[pointer](cast[ByteAddress](a.llmem) + a.llmem.acc)
result = cast[pointer](cast[int](a.llmem) + a.llmem.acc)
dec(a.llmem.size, size)
inc(a.llmem.acc, size)
zeroMem(result, size)
@ -422,7 +422,7 @@ iterator allObjects(m: var MemRegion): pointer {.inline.} =
var c = cast[PSmallChunk](c)
let size = c.size
var a = cast[ByteAddress](addr(c.data))
var a = cast[int](addr(c.data))
let limit = a + c.acc
while a <% limit:
yield cast[pointer](a)
@ -441,13 +441,13 @@ when not defined(gcDestructors):
# ------------- chunk management ----------------------------------------------
proc pageIndex(c: PChunk): int {.inline.} =
result = cast[ByteAddress](c) shr PageShift
result = cast[int](c) shr PageShift
proc pageIndex(p: pointer): int {.inline.} =
result = cast[ByteAddress](p) shr PageShift
result = cast[int](p) shr PageShift
proc pageAddr(p: pointer): PChunk {.inline.} =
result = cast[PChunk](cast[ByteAddress](p) and not PageMask)
result = cast[PChunk](cast[int](p) and not PageMask)
#sysAssert(Contains(allocator.chunkStarts, pageIndex(result)))
when false:
@ -495,13 +495,13 @@ proc requestOsChunks(a: var MemRegion, size: int): PBigChunk =
when defined(memtracker):
trackLocation(addr result.size, sizeof(int))
sysAssert((cast[ByteAddress](result) and PageMask) == 0, "requestOsChunks 1")
sysAssert((cast[int](result) and PageMask) == 0, "requestOsChunks 1")
#zeroMem(result, size)
result.next = nil
result.prev = nil
result.size = size
# update next.prevSize:
var nxt = cast[ByteAddress](result) +% size
var nxt = cast[int](result) +% size
sysAssert((nxt and PageMask) == 0, "requestOsChunks 2")
var next = cast[PChunk](nxt)
if pageIndex(next) in a.chunkStarts:
@ -509,7 +509,7 @@ proc requestOsChunks(a: var MemRegion, size: int): PBigChunk =
next.prevSize = size or (next.prevSize and 1)
# set result.prevSize:
var lastSize = if a.lastSize != 0: a.lastSize else: PageSize
var prv = cast[ByteAddress](result) -% lastSize
var prv = cast[int](result) -% lastSize
sysAssert((nxt and PageMask) == 0, "requestOsChunks 3")
var prev = cast[PChunk](prv)
if pageIndex(prev) in a.chunkStarts and prev.size == lastSize:
@ -555,13 +555,13 @@ proc listRemove[T](head: var T, c: T) {.inline.} =
proc updatePrevSize(a: var MemRegion, c: PBigChunk,
prevSize: int) {.inline.} =
var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "updatePrevSize")
var ri = cast[PChunk](cast[int](c) +% c.size)
sysAssert((cast[int](ri) and PageMask) == 0, "updatePrevSize")
if isAccessible(a, ri):
ri.prevSize = prevSize or (ri.prevSize and 1)
proc splitChunk2(a: var MemRegion, c: PBigChunk, size: int): PBigChunk =
result = cast[PBigChunk](cast[ByteAddress](c) +% size)
result = cast[PBigChunk](cast[int](c) +% size)
result.size = c.size - size
track("result.size", addr result.size, sizeof(int))
when not defined(nimOptimizedSplitChunk):
@ -590,8 +590,8 @@ proc freeBigChunk(a: var MemRegion, c: PBigChunk) =
when coalescLeft:
let prevSize = c.prevSize
if prevSize != 0:
var le = cast[PChunk](cast[ByteAddress](c) -% prevSize)
sysAssert((cast[ByteAddress](le) and PageMask) == 0, "freeBigChunk 4")
var le = cast[PChunk](cast[int](c) -% prevSize)
sysAssert((cast[int](le) and PageMask) == 0, "freeBigChunk 4")
if isAccessible(a, le) and chunkUnused(le):
sysAssert(not isSmallChunk(le), "freeBigChunk 5")
if not isSmallChunk(le) and le.size < MaxBigChunkSize:
@ -607,8 +607,8 @@ proc freeBigChunk(a: var MemRegion, c: PBigChunk) =
addChunkToMatrix(a, c)
c = rest
when coalescRight:
var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "freeBigChunk 2")
var ri = cast[PChunk](cast[int](c) +% c.size)
sysAssert((cast[int](ri) and PageMask) == 0, "freeBigChunk 2")
if isAccessible(a, ri) and chunkUnused(ri):
sysAssert(not isSmallChunk(ri), "freeBigChunk 3")
if not isSmallChunk(ri) and c.size < MaxBigChunkSize:
@ -669,7 +669,7 @@ proc getHugeChunk(a: var MemRegion; size: int): PBigChunk =
incCurrMem(a, size)
# XXX add this to the heap links. But also remove it from it later.
when false: a.addHeapLink(result, size)
sysAssert((cast[ByteAddress](result) and PageMask) == 0, "getHugeChunk")
sysAssert((cast[int](result) and PageMask) == 0, "getHugeChunk")
result.next = nil
result.prev = nil
result.size = size
@ -838,7 +838,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
c.prev = nil
listAdd(a.freeSmallChunks[s], c)
result = addr(c.data)
sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 4")
sysAssert((cast[int](result) and (MemAlign-1)) == 0, "rawAlloc 4")
else:
sysAssert(allocInv(a), "rawAlloc: begin c != nil")
sysAssert c.next != c, "rawAlloc 5"
@ -856,7 +856,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
if c.freeList == nil:
sysAssert(c.acc + smallChunkOverhead() + size <= SmallChunkSize,
"rawAlloc 7")
result = cast[pointer](cast[ByteAddress](addr(c.data)) +% c.acc)
result = cast[pointer](cast[int](addr(c.data)) +% c.acc)
inc(c.acc, size)
else:
result = c.freeList
@ -864,14 +864,14 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
sysAssert(c.freeList.zeroField == 0, "rawAlloc 8")
c.freeList = c.freeList.next
dec(c.free, size)
sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 9")
sysAssert((cast[int](result) and (MemAlign-1)) == 0, "rawAlloc 9")
sysAssert(allocInv(a), "rawAlloc: end c != nil")
sysAssert(allocInv(a), "rawAlloc: before c.free < size")
if c.free < size:
sysAssert(allocInv(a), "rawAlloc: before listRemove test")
listRemove(a.freeSmallChunks[s], c)
sysAssert(allocInv(a), "rawAlloc: end listRemove test")
sysAssert(((cast[ByteAddress](result) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[int](result) and PageMask) - smallChunkOverhead()) %%
size == 0, "rawAlloc 21")
sysAssert(allocInv(a), "rawAlloc: end small size")
inc a.occ, size
@ -893,11 +893,11 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
sysAssert c.prev == nil, "rawAlloc 10"
sysAssert c.next == nil, "rawAlloc 11"
result = addr(c.data)
sysAssert((cast[ByteAddress](c) and (MemAlign-1)) == 0, "rawAlloc 13")
sysAssert((cast[ByteAddress](c) and PageMask) == 0, "rawAlloc: Not aligned on a page boundary")
sysAssert((cast[int](c) and (MemAlign-1)) == 0, "rawAlloc 13")
sysAssert((cast[int](c) and PageMask) == 0, "rawAlloc: Not aligned on a page boundary")
when not defined(gcDestructors):
if a.root == nil: a.root = getBottom(a)
add(a, a.root, cast[ByteAddress](result), cast[ByteAddress](result)+%size)
add(a, a.root, cast[int](result), cast[int](result)+%size)
inc a.occ, c.size
trackSize(c.size)
sysAssert(isAccessible(a, result), "rawAlloc 14")
@ -927,10 +927,10 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
dec a.occ, s
untrackSize(s)
sysAssert a.occ >= 0, "rawDealloc: negative occupied memory (case A)"
sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[int](p) and PageMask) - smallChunkOverhead()) %%
s == 0, "rawDealloc 3")
when not defined(gcDestructors):
#echo("setting to nil: ", $cast[ByteAddress](addr(f.zeroField)))
#echo("setting to nil: ", $cast[int](addr(f.zeroField)))
sysAssert(f.zeroField != 0, "rawDealloc 1")
f.zeroField = 0
f.next = c.freeList
@ -953,7 +953,7 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
else:
when defined(gcDestructors):
addToSharedFreeList(c, f)
sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[int](p) and PageMask) - smallChunkOverhead()) %%
s == 0, "rawDealloc 2")
else:
# set to 0xff to check for usage after free bugs:
@ -975,7 +975,7 @@ when not defined(gcDestructors):
if not chunkUnused(c):
if isSmallChunk(c):
var c = cast[PSmallChunk](c)
var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
var offset = (cast[int](p) and (PageSize-1)) -%
smallChunkOverhead()
result = (c.acc >% offset) and (offset %% c.size == 0) and
(cast[ptr FreeCell](p).zeroField >% 1)
@ -993,12 +993,12 @@ when not defined(gcDestructors):
if not chunkUnused(c):
if isSmallChunk(c):
var c = cast[PSmallChunk](c)
var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
var offset = (cast[int](p) and (PageSize-1)) -%
smallChunkOverhead()
if c.acc >% offset:
sysAssert(cast[ByteAddress](addr(c.data)) +% offset ==
cast[ByteAddress](p), "offset is not what you think it is")
var d = cast[ptr FreeCell](cast[ByteAddress](addr(c.data)) +%
sysAssert(cast[int](addr(c.data)) +% offset ==
cast[int](p), "offset is not what you think it is")
var d = cast[ptr FreeCell](cast[int](addr(c.data)) +%
offset -% (offset %% c.size))
if d.zeroField >% 1:
result = d
@ -1025,7 +1025,7 @@ when not defined(gcDestructors):
proc ptrSize(p: pointer): int =
when not defined(gcDestructors):
var x = cast[pointer](cast[ByteAddress](p) -% sizeof(FreeCell))
var x = cast[pointer](cast[int](p) -% sizeof(FreeCell))
var c = pageAddr(p)
sysAssert(not chunkUnused(c), "ptrSize")
result = c.size -% sizeof(FreeCell)
@ -1043,7 +1043,7 @@ proc alloc(allocator: var MemRegion, size: Natural): pointer {.gcsafe.} =
result = rawAlloc(allocator, size+sizeof(FreeCell))
cast[ptr FreeCell](result).zeroField = 1 # mark it as used
sysAssert(not isAllocatedPtr(allocator, result), "alloc")
result = cast[pointer](cast[ByteAddress](result) +% sizeof(FreeCell))
result = cast[pointer](cast[int](result) +% sizeof(FreeCell))
track("alloc", result, size)
else:
result = rawAlloc(allocator, size)
@ -1055,7 +1055,7 @@ proc alloc0(allocator: var MemRegion, size: Natural): pointer =
proc dealloc(allocator: var MemRegion, p: pointer) =
when not defined(gcDestructors):
sysAssert(p != nil, "dealloc: p is nil")
var x = cast[pointer](cast[ByteAddress](p) -% sizeof(FreeCell))
var x = cast[pointer](cast[int](p) -% sizeof(FreeCell))
sysAssert(x != nil, "dealloc: x is nil")
sysAssert(isAccessible(allocator, x), "is not accessible")
sysAssert(cast[ptr FreeCell](x).zeroField == 1, "dealloc: object header corrupted")
@ -1116,7 +1116,7 @@ template instantiateForRegion(allocator: untyped) {.dirty.} =
result = interiorAllocatedPtr(allocator, p)
proc isAllocatedPtr*(p: pointer): bool =
let p = cast[pointer](cast[ByteAddress](p)-%ByteAddress(sizeof(Cell)))
let p = cast[pointer](cast[int](p)-%ByteAddress(sizeof(Cell)))
result = isAllocatedPtr(allocator, p)
proc deallocOsPages = deallocOsPages(allocator)