vishapoberon/compiler
1
0
Fork 0
mirror of https://github.com/vishapoberon/compiler.git synced 2026-04-06 06:22:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Completely update addresing vars in heap from LONGINT to SYSTEM.UINTPTR.

Browse source
This commit is contained in:
David Brown 2016-09-03 18:55:55 +01:00
parent db18774de1
commit 4ec2e61ed0
6 changed files with 380 additions and 379 deletions
Download patch file Download diff file Expand all files Collapse all files

128
bootstrap/unix-44/Heap.c
View file

@ -51,15 +51,15 @@ typedef
Heap_ModuleName name; Heap_ModuleName name;
int32 refcnt; int32 refcnt;
Heap_Cmd cmds; Heap_Cmd cmds;
int32 types; uintptr types;
Heap_EnumProc enumPtrs; Heap_EnumProc enumPtrs;
int32 reserved1, reserved2; int32 reserved1, reserved2;
} Heap_ModuleDesc; } Heap_ModuleDesc;
export SYSTEM_PTR Heap_modules; export SYSTEM_PTR Heap_modules;
static int32 Heap_freeList[10]; static uintptr Heap_freeList[10];
static int32 Heap_bigBlocks; static uintptr Heap_bigBlocks;
export uintptr Heap_allocated; export uintptr Heap_allocated;
static BOOLEAN Heap_firstTry; static BOOLEAN Heap_firstTry;
static uintptr Heap_heap, Heap_heapend; static uintptr Heap_heap, Heap_heapend;
@ -75,18 +75,18 @@ export LONGINT *Heap_FinDesc__typ;
export LONGINT *Heap__1__typ; export LONGINT *Heap__1__typ;
static void Heap_CheckFin (void); static void Heap_CheckFin (void);
static void Heap_ExtendHeap (int32 blksz); static void Heap_ExtendHeap (uintptr blksz);
export void Heap_FINALL (void); export void Heap_FINALL (void);
static void Heap_Finalize (void); static void Heap_Finalize (void);
export void Heap_GC (BOOLEAN markStack); export void Heap_GC (BOOLEAN markStack);
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len); static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len);
export void Heap_INCREF (Heap_Module m); export void Heap_INCREF (Heap_Module m);
export void Heap_InitHeap (void); export void Heap_InitHeap (void);
export void Heap_Lock (void); export void Heap_Lock (void);
static void Heap_Mark (int32 q); static void Heap_Mark (uintptr q);
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len);
static void Heap_MarkP (SYSTEM_PTR p); static void Heap_MarkP (SYSTEM_PTR p);
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len);
export SYSTEM_PTR Heap_NEWBLK (uintptr size); export SYSTEM_PTR Heap_NEWBLK (uintptr size);
export SYSTEM_PTR Heap_NEWREC (uintptr tag); export SYSTEM_PTR Heap_NEWREC (uintptr tag);
static uintptr Heap_NewChunk (uintptr blksz); static uintptr Heap_NewChunk (uintptr blksz);
@ -95,11 +95,11 @@ export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
export void Heap_REGTYP (Heap_Module m, uintptr typ); export void Heap_REGTYP (Heap_Module m, uintptr typ);
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize); export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
static void Heap_Scan (void); static void Heap_Scan (void);
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len); static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len);
export void Heap_Unlock (void); export void Heap_Unlock (void);
extern void *Heap__init(); extern void *Heap__init();
extern LONGINT Platform_MainStackFrame; extern uintptr Platform_MainStackFrame;
extern uintptr Platform_OSAllocate(uintptr size); extern uintptr Platform_OSAllocate(uintptr size);
#define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer))) #define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer)))
#define Heap_HeapModuleInit() Heap__init() #define Heap_HeapModuleInit() Heap__init()
@ -156,7 +156,7 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
void Heap_REGTYP (Heap_Module m, uintptr typ) void Heap_REGTYP (Heap_Module m, uintptr typ)
{ {
__PUT(typ, m->types, int32); __PUT(typ, m->types, uintptr);
m->types = typ; m->types = typ;
} }
@ -174,8 +174,8 @@ static uintptr Heap_NewChunk (uintptr blksz)
__PUT(chnk + 4, chnk + (12 + blksz), uintptr); __PUT(chnk + 4, chnk + (12 + blksz), uintptr);
__PUT(chnk + 12, chnk + 16, uintptr); __PUT(chnk + 12, chnk + 16, uintptr);
__PUT(chnk + 16, blksz, uintptr); __PUT(chnk + 16, blksz, uintptr);
__PUT(chnk + 20, -4, int32); __PUT(chnk + 20, -4, uintptr);
__PUT(chnk + 24, Heap_bigBlocks, int32); __PUT(chnk + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = chnk + 12; Heap_bigBlocks = chnk + 12;
Heap_heapsize += blksz; Heap_heapsize += blksz;
} }
@ -183,9 +183,9 @@ static uintptr Heap_NewChunk (uintptr blksz)
return _o_result; return _o_result;
} }
static void Heap_ExtendHeap (int32 blksz) static void Heap_ExtendHeap (uintptr blksz)
{ {
int32 size, chnk, j, next; uintptr size, chnk, j, next;
if (blksz > 160000) { if (blksz > 160000) {
size = blksz; size = blksz;
} else { } else {
@ -203,8 +203,8 @@ static void Heap_ExtendHeap (int32 blksz)
j = next; j = next;
next = Heap_FetchAddress(j); next = Heap_FetchAddress(j);
} }
__PUT(chnk, next, int32); __PUT(chnk, next, uintptr);
__PUT(j, chnk, int32); __PUT(j, chnk, uintptr);
} }
if (next == 0) { if (next == 0) {
Heap_heapend = Heap_FetchAddress(chnk + 4); Heap_heapend = Heap_FetchAddress(chnk + 4);
@ -236,10 +236,10 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = __ASHL(di, 4); restsize = __ASHL(di, 4);
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
adr += restsize; adr += restsize;
} }
@ -280,8 +280,8 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = t - blksz; restsize = t - blksz;
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
if (restsize > 144) { if (restsize > 144) {
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
} else { } else {
@ -294,7 +294,7 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
if (restsize > 0) { if (restsize > 0) {
di = __ASHR(restsize, 4); di = __ASHR(restsize, 4);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
} }
} }
@ -303,16 +303,16 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
i = adr + 16; i = adr + 16;
end = adr + blksz; end = adr + blksz;
while (i < end) { while (i < end) {
__PUT(i, 0, int32); __PUT(i, 0, uintptr);
__PUT(i + 4, 0, int32); __PUT(i + 4, 0, uintptr);
__PUT(i + 8, 0, int32); __PUT(i + 8, 0, uintptr);
__PUT(i + 12, 0, int32); __PUT(i + 12, 0, uintptr);
i += 16; i += 16;
} }
__PUT(adr + 12, 0, int32); __PUT(adr + 12, 0, uintptr);
__PUT(adr, tag, uintptr); __PUT(adr, tag, uintptr);
__PUT(adr + 4, 0, int32); __PUT(adr + 4, 0, uintptr);
__PUT(adr + 8, 0, int32); __PUT(adr + 8, 0, uintptr);
Heap_allocated += blksz; Heap_allocated += blksz;
Heap_Unlock(); Heap_Unlock();
_o_result = (SYSTEM_PTR)(uintptr)(adr + 4); _o_result = (SYSTEM_PTR)(uintptr)(adr + 4);
@ -327,29 +327,29 @@ SYSTEM_PTR Heap_NEWBLK (uintptr size)
Heap_Lock(); Heap_Lock();
blksz = __ASHL(__ASHR(size + 31, 4), 4); blksz = __ASHL(__ASHR(size + 31, 4), 4);
new = Heap_NEWREC((uintptr)&blksz); new = Heap_NEWREC((uintptr)&blksz);
tag = (((int32)(uintptr)new) + blksz) - 12; tag = ((uintptr)(uintptr)new + blksz) - 12;
__PUT(tag - 4, 0, int32); __PUT(tag - 4, 0, uintptr);
__PUT(tag, blksz, uintptr); __PUT(tag, blksz, uintptr);
__PUT(tag + 4, -4, int32); __PUT(tag + 4, -4, uintptr);
__PUT((int32)(uintptr)new - 4, tag, uintptr); __PUT((uintptr)(uintptr)new - 4, tag, uintptr);
Heap_Unlock(); Heap_Unlock();
_o_result = new; _o_result = new;
return _o_result; return _o_result;
} }
static void Heap_Mark (int32 q) static void Heap_Mark (uintptr q)
{ {
int32 p, tag, fld, n, offset, tagbits; uintptr p, tag, offset, fld, n, tagbits;
if (q != 0) { if (q != 0) {
tagbits = Heap_FetchAddress(q - 4); tagbits = Heap_FetchAddress(q - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(q - 4, tagbits + 1, int32); __PUT(q - 4, tagbits + 1, uintptr);
p = 0; p = 0;
tag = tagbits + 4; tag = tagbits + 4;
for (;;) { for (;;) {
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
if (offset < 0) { if (__BIT((uintptr)&offset, 31)) {
__PUT(q - 4, (tag + offset) + 1, int32); __PUT(q - 4, (tag + offset) + 1, uintptr);
if (p == 0) { if (p == 0) {
break; break;
} }
@ -357,7 +357,7 @@ static void Heap_Mark (int32 q)
q = p; q = p;
tag = Heap_FetchAddress(q - 4); tag = Heap_FetchAddress(q - 4);
tag -= 1; tag -= 1;
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
fld = q + offset; fld = q + offset;
p = Heap_FetchAddress(fld); p = Heap_FetchAddress(fld);
__PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR);
@ -367,8 +367,8 @@ static void Heap_Mark (int32 q)
if (n != 0) { if (n != 0) {
tagbits = Heap_FetchAddress(n - 4); tagbits = Heap_FetchAddress(n - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(n - 4, tagbits + 1, int32); __PUT(n - 4, tagbits + 1, uintptr);
__PUT(q - 4, tag + 1, int32); __PUT(q - 4, tag + 1, uintptr);
__PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR);
p = q; p = q;
q = n; q = n;
@ -384,7 +384,7 @@ static void Heap_Mark (int32 q)
static void Heap_MarkP (SYSTEM_PTR p) static void Heap_MarkP (SYSTEM_PTR p)
{ {
Heap_Mark((int32)(uintptr)p); Heap_Mark((uintptr)(uintptr)p);
} }
static void Heap_Scan (void) static void Heap_Scan (void)
@ -409,14 +409,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -435,14 +435,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -450,9 +450,9 @@ static void Heap_Scan (void)
} }
} }
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len) static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len)
{ {
int32 i, j, x; uintptr i, j, x;
j = l; j = l;
x = a[j]; x = a[j];
for (;;) { for (;;) {
@ -469,9 +469,9 @@ static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len)
a[i] = x; a[i] = x;
} }
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len) static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len)
{ {
int32 l, r, x; uintptr l, r, x;
l = __ASHR(n, 1); l = __ASHR(n, 1);
r = n - 1; r = n - 1;
while (l > 0) { while (l > 0) {
@ -487,9 +487,9 @@ static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len)
} }
} }
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
int32 chnk, adr, tag, next, lim, lim1, i, ptr, size; uintptr chnk, adr, tag, next, lim, lim1, i, ptr, size;
chnk = Heap_heap; chnk = Heap_heap;
i = 0; i = 0;
lim = cand[n - 1]; lim = cand[n - 1];
@ -527,7 +527,7 @@ static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len)
static void Heap_CheckFin (void) static void Heap_CheckFin (void)
{ {
Heap_FinNode n; Heap_FinNode n;
int32 tag; uintptr tag;
n = Heap_fin; n = Heap_fin;
while (n != NIL) { while (n != NIL) {
tag = Heap_FetchAddress(n->obj - 4); tag = Heap_FetchAddress(n->obj - 4);
@ -576,10 +576,10 @@ void Heap_FINALL (void)
} }
} }
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
SYSTEM_PTR frame; SYSTEM_PTR frame;
int32 inc, nofcand, sp, p, stack0; uintptr inc, nofcand, sp, p, stack0;
struct Heap__1 align; struct Heap__1 align;
if (n > 0) { if (n > 0) {
Heap_MarkStack(n - 1, cand, cand__len); Heap_MarkStack(n - 1, cand, cand__len);
@ -596,7 +596,7 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
inc = -inc; inc = -inc;
} }
while (sp != stack0) { while (sp != stack0) {
__GET(sp, p, int32); __GET(sp, p, uintptr);
if ((p > Heap_heap && p < Heap_heapend)) { if ((p > Heap_heap && p < Heap_heapend)) {
if (nofcand == cand__len) { if (nofcand == cand__len) {
Heap_HeapSort(nofcand, (void*)cand, cand__len); Heap_HeapSort(nofcand, (void*)cand, cand__len);
@ -618,8 +618,8 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
void Heap_GC (BOOLEAN markStack) void Heap_GC (BOOLEAN markStack)
{ {
Heap_Module m; Heap_Module m;
int32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23; uintptr i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
int32 cand[10000]; uintptr cand[10000];
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) { if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
Heap_Lock(); Heap_Lock();
m = (Heap_Module)(uintptr)Heap_modules; m = (Heap_Module)(uintptr)Heap_modules;
@ -699,7 +699,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
{ {
Heap_FinNode f; Heap_FinNode f;
__NEW(f, Heap_FinDesc); __NEW(f, Heap_FinDesc);
f->obj = (int32)(uintptr)obj; f->obj = (uintptr)(uintptr)obj;
f->finalize = finalize; f->finalize = finalize;
f->marked = 1; f->marked = 1;
f->next = Heap_fin; f->next = Heap_fin;
@ -710,7 +710,7 @@ void Heap_InitHeap (void)
{ {
Heap_heap = Heap_NewChunk(128000); Heap_heap = Heap_NewChunk(128000);
Heap_heapend = Heap_FetchAddress(Heap_heap + 4); Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
__PUT(Heap_heap, 0, int32); __PUT(Heap_heap, 0, uintptr);
Heap_allocated = 0; Heap_allocated = 0;
Heap_firstTry = 1; Heap_firstTry = 1;
Heap_freeList[9] = 1; Heap_freeList[9] = 1;

128
bootstrap/unix-48/Heap.c
View file

@ -51,15 +51,15 @@ typedef
Heap_ModuleName name; Heap_ModuleName name;
int32 refcnt; int32 refcnt;
Heap_Cmd cmds; Heap_Cmd cmds;
int32 types; uintptr types;
Heap_EnumProc enumPtrs; Heap_EnumProc enumPtrs;
int32 reserved1, reserved2; int32 reserved1, reserved2;
} Heap_ModuleDesc; } Heap_ModuleDesc;
export SYSTEM_PTR Heap_modules; export SYSTEM_PTR Heap_modules;
static int32 Heap_freeList[10]; static uintptr Heap_freeList[10];
static int32 Heap_bigBlocks; static uintptr Heap_bigBlocks;
export uintptr Heap_allocated; export uintptr Heap_allocated;
static BOOLEAN Heap_firstTry; static BOOLEAN Heap_firstTry;
static uintptr Heap_heap, Heap_heapend; static uintptr Heap_heap, Heap_heapend;
@ -75,18 +75,18 @@ export LONGINT *Heap_FinDesc__typ;
export LONGINT *Heap__1__typ; export LONGINT *Heap__1__typ;
static void Heap_CheckFin (void); static void Heap_CheckFin (void);
static void Heap_ExtendHeap (int32 blksz); static void Heap_ExtendHeap (uintptr blksz);
export void Heap_FINALL (void); export void Heap_FINALL (void);
static void Heap_Finalize (void); static void Heap_Finalize (void);
export void Heap_GC (BOOLEAN markStack); export void Heap_GC (BOOLEAN markStack);
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len); static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len);
export void Heap_INCREF (Heap_Module m); export void Heap_INCREF (Heap_Module m);
export void Heap_InitHeap (void); export void Heap_InitHeap (void);
export void Heap_Lock (void); export void Heap_Lock (void);
static void Heap_Mark (int32 q); static void Heap_Mark (uintptr q);
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len);
static void Heap_MarkP (SYSTEM_PTR p); static void Heap_MarkP (SYSTEM_PTR p);
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len);
export SYSTEM_PTR Heap_NEWBLK (uintptr size); export SYSTEM_PTR Heap_NEWBLK (uintptr size);
export SYSTEM_PTR Heap_NEWREC (uintptr tag); export SYSTEM_PTR Heap_NEWREC (uintptr tag);
static uintptr Heap_NewChunk (uintptr blksz); static uintptr Heap_NewChunk (uintptr blksz);
@ -95,11 +95,11 @@ export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
export void Heap_REGTYP (Heap_Module m, uintptr typ); export void Heap_REGTYP (Heap_Module m, uintptr typ);
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize); export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
static void Heap_Scan (void); static void Heap_Scan (void);
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len); static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len);
export void Heap_Unlock (void); export void Heap_Unlock (void);
extern void *Heap__init(); extern void *Heap__init();
extern LONGINT Platform_MainStackFrame; extern uintptr Platform_MainStackFrame;
extern uintptr Platform_OSAllocate(uintptr size); extern uintptr Platform_OSAllocate(uintptr size);
#define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer))) #define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer)))
#define Heap_HeapModuleInit() Heap__init() #define Heap_HeapModuleInit() Heap__init()
@ -156,7 +156,7 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
void Heap_REGTYP (Heap_Module m, uintptr typ) void Heap_REGTYP (Heap_Module m, uintptr typ)
{ {
__PUT(typ, m->types, int32); __PUT(typ, m->types, uintptr);
m->types = typ; m->types = typ;
} }
@ -174,8 +174,8 @@ static uintptr Heap_NewChunk (uintptr blksz)
__PUT(chnk + 4, chnk + (12 + blksz), uintptr); __PUT(chnk + 4, chnk + (12 + blksz), uintptr);
__PUT(chnk + 12, chnk + 16, uintptr); __PUT(chnk + 12, chnk + 16, uintptr);
__PUT(chnk + 16, blksz, uintptr); __PUT(chnk + 16, blksz, uintptr);
__PUT(chnk + 20, -4, int32); __PUT(chnk + 20, -4, uintptr);
__PUT(chnk + 24, Heap_bigBlocks, int32); __PUT(chnk + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = chnk + 12; Heap_bigBlocks = chnk + 12;
Heap_heapsize += blksz; Heap_heapsize += blksz;
} }
@ -183,9 +183,9 @@ static uintptr Heap_NewChunk (uintptr blksz)
return _o_result; return _o_result;
} }
static void Heap_ExtendHeap (int32 blksz) static void Heap_ExtendHeap (uintptr blksz)
{ {
int32 size, chnk, j, next; uintptr size, chnk, j, next;
if (blksz > 160000) { if (blksz > 160000) {
size = blksz; size = blksz;
} else { } else {
@ -203,8 +203,8 @@ static void Heap_ExtendHeap (int32 blksz)
j = next; j = next;
next = Heap_FetchAddress(j); next = Heap_FetchAddress(j);
} }
__PUT(chnk, next, int32); __PUT(chnk, next, uintptr);
__PUT(j, chnk, int32); __PUT(j, chnk, uintptr);
} }
if (next == 0) { if (next == 0) {
Heap_heapend = Heap_FetchAddress(chnk + 4); Heap_heapend = Heap_FetchAddress(chnk + 4);
@ -236,10 +236,10 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = __ASHL(di, 4); restsize = __ASHL(di, 4);
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
adr += restsize; adr += restsize;
} }
@ -280,8 +280,8 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = t - blksz; restsize = t - blksz;
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
if (restsize > 144) { if (restsize > 144) {
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
} else { } else {
@ -294,7 +294,7 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
if (restsize > 0) { if (restsize > 0) {
di = __ASHR(restsize, 4); di = __ASHR(restsize, 4);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
} }
} }
@ -303,16 +303,16 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
i = adr + 16; i = adr + 16;
end = adr + blksz; end = adr + blksz;
while (i < end) { while (i < end) {
__PUT(i, 0, int32); __PUT(i, 0, uintptr);
__PUT(i + 4, 0, int32); __PUT(i + 4, 0, uintptr);
__PUT(i + 8, 0, int32); __PUT(i + 8, 0, uintptr);
__PUT(i + 12, 0, int32); __PUT(i + 12, 0, uintptr);
i += 16; i += 16;
} }
__PUT(adr + 12, 0, int32); __PUT(adr + 12, 0, uintptr);
__PUT(adr, tag, uintptr); __PUT(adr, tag, uintptr);
__PUT(adr + 4, 0, int32); __PUT(adr + 4, 0, uintptr);
__PUT(adr + 8, 0, int32); __PUT(adr + 8, 0, uintptr);
Heap_allocated += blksz; Heap_allocated += blksz;
Heap_Unlock(); Heap_Unlock();
_o_result = (SYSTEM_PTR)(uintptr)(adr + 4); _o_result = (SYSTEM_PTR)(uintptr)(adr + 4);
@ -327,29 +327,29 @@ SYSTEM_PTR Heap_NEWBLK (uintptr size)
Heap_Lock(); Heap_Lock();
blksz = __ASHL(__ASHR(size + 31, 4), 4); blksz = __ASHL(__ASHR(size + 31, 4), 4);
new = Heap_NEWREC((uintptr)&blksz); new = Heap_NEWREC((uintptr)&blksz);
tag = (((int32)(uintptr)new) + blksz) - 12; tag = ((uintptr)(uintptr)new + blksz) - 12;
__PUT(tag - 4, 0, int32); __PUT(tag - 4, 0, uintptr);
__PUT(tag, blksz, uintptr); __PUT(tag, blksz, uintptr);
__PUT(tag + 4, -4, int32); __PUT(tag + 4, -4, uintptr);
__PUT((int32)(uintptr)new - 4, tag, uintptr); __PUT((uintptr)(uintptr)new - 4, tag, uintptr);
Heap_Unlock(); Heap_Unlock();
_o_result = new; _o_result = new;
return _o_result; return _o_result;
} }
static void Heap_Mark (int32 q) static void Heap_Mark (uintptr q)
{ {
int32 p, tag, fld, n, offset, tagbits; uintptr p, tag, offset, fld, n, tagbits;
if (q != 0) { if (q != 0) {
tagbits = Heap_FetchAddress(q - 4); tagbits = Heap_FetchAddress(q - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(q - 4, tagbits + 1, int32); __PUT(q - 4, tagbits + 1, uintptr);
p = 0; p = 0;
tag = tagbits + 4; tag = tagbits + 4;
for (;;) { for (;;) {
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
if (offset < 0) { if (__BIT((uintptr)&offset, 31)) {
__PUT(q - 4, (tag + offset) + 1, int32); __PUT(q - 4, (tag + offset) + 1, uintptr);
if (p == 0) { if (p == 0) {
break; break;
} }
@ -357,7 +357,7 @@ static void Heap_Mark (int32 q)
q = p; q = p;
tag = Heap_FetchAddress(q - 4); tag = Heap_FetchAddress(q - 4);
tag -= 1; tag -= 1;
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
fld = q + offset; fld = q + offset;
p = Heap_FetchAddress(fld); p = Heap_FetchAddress(fld);
__PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR);
@ -367,8 +367,8 @@ static void Heap_Mark (int32 q)
if (n != 0) { if (n != 0) {
tagbits = Heap_FetchAddress(n - 4); tagbits = Heap_FetchAddress(n - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(n - 4, tagbits + 1, int32); __PUT(n - 4, tagbits + 1, uintptr);
__PUT(q - 4, tag + 1, int32); __PUT(q - 4, tag + 1, uintptr);
__PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR);
p = q; p = q;
q = n; q = n;
@ -384,7 +384,7 @@ static void Heap_Mark (int32 q)
static void Heap_MarkP (SYSTEM_PTR p) static void Heap_MarkP (SYSTEM_PTR p)
{ {
Heap_Mark((int32)(uintptr)p); Heap_Mark((uintptr)(uintptr)p);
} }
static void Heap_Scan (void) static void Heap_Scan (void)
@ -409,14 +409,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -435,14 +435,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -450,9 +450,9 @@ static void Heap_Scan (void)
} }
} }
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len) static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len)
{ {
int32 i, j, x; uintptr i, j, x;
j = l; j = l;
x = a[j]; x = a[j];
for (;;) { for (;;) {
@ -469,9 +469,9 @@ static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len)
a[i] = x; a[i] = x;
} }
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len) static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len)
{ {
int32 l, r, x; uintptr l, r, x;
l = __ASHR(n, 1); l = __ASHR(n, 1);
r = n - 1; r = n - 1;
while (l > 0) { while (l > 0) {
@ -487,9 +487,9 @@ static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len)
} }
} }
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
int32 chnk, adr, tag, next, lim, lim1, i, ptr, size; uintptr chnk, adr, tag, next, lim, lim1, i, ptr, size;
chnk = Heap_heap; chnk = Heap_heap;
i = 0; i = 0;
lim = cand[n - 1]; lim = cand[n - 1];
@ -527,7 +527,7 @@ static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len)
static void Heap_CheckFin (void) static void Heap_CheckFin (void)
{ {
Heap_FinNode n; Heap_FinNode n;
int32 tag; uintptr tag;
n = Heap_fin; n = Heap_fin;
while (n != NIL) { while (n != NIL) {
tag = Heap_FetchAddress(n->obj - 4); tag = Heap_FetchAddress(n->obj - 4);
@ -576,10 +576,10 @@ void Heap_FINALL (void)
} }
} }
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
SYSTEM_PTR frame; SYSTEM_PTR frame;
int32 inc, nofcand, sp, p, stack0; uintptr inc, nofcand, sp, p, stack0;
struct Heap__1 align; struct Heap__1 align;
if (n > 0) { if (n > 0) {
Heap_MarkStack(n - 1, cand, cand__len); Heap_MarkStack(n - 1, cand, cand__len);
@ -596,7 +596,7 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
inc = -inc; inc = -inc;
} }
while (sp != stack0) { while (sp != stack0) {
__GET(sp, p, int32); __GET(sp, p, uintptr);
if ((p > Heap_heap && p < Heap_heapend)) { if ((p > Heap_heap && p < Heap_heapend)) {
if (nofcand == cand__len) { if (nofcand == cand__len) {
Heap_HeapSort(nofcand, (void*)cand, cand__len); Heap_HeapSort(nofcand, (void*)cand, cand__len);
@ -618,8 +618,8 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
void Heap_GC (BOOLEAN markStack) void Heap_GC (BOOLEAN markStack)
{ {
Heap_Module m; Heap_Module m;
int32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23; uintptr i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
int32 cand[10000]; uintptr cand[10000];
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) { if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
Heap_Lock(); Heap_Lock();
m = (Heap_Module)(uintptr)Heap_modules; m = (Heap_Module)(uintptr)Heap_modules;
@ -699,7 +699,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
{ {
Heap_FinNode f; Heap_FinNode f;
__NEW(f, Heap_FinDesc); __NEW(f, Heap_FinDesc);
f->obj = (int32)(uintptr)obj; f->obj = (uintptr)(uintptr)obj;
f->finalize = finalize; f->finalize = finalize;
f->marked = 1; f->marked = 1;
f->next = Heap_fin; f->next = Heap_fin;
@ -710,7 +710,7 @@ void Heap_InitHeap (void)
{ {
Heap_heap = Heap_NewChunk(128000); Heap_heap = Heap_NewChunk(128000);
Heap_heapend = Heap_FetchAddress(Heap_heap + 4); Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
__PUT(Heap_heap, 0, int32); __PUT(Heap_heap, 0, uintptr);
Heap_allocated = 0; Heap_allocated = 0;
Heap_firstTry = 1; Heap_firstTry = 1;
Heap_freeList[9] = 1; Heap_freeList[9] = 1;

128
bootstrap/unix-88/Heap.c
View file

@ -52,15 +52,15 @@ typedef
Heap_ModuleName name; Heap_ModuleName name;
int64 refcnt; int64 refcnt;
Heap_Cmd cmds; Heap_Cmd cmds;
int64 types; uintptr types;
Heap_EnumProc enumPtrs; Heap_EnumProc enumPtrs;
int64 reserved1, reserved2; int64 reserved1, reserved2;
} Heap_ModuleDesc; } Heap_ModuleDesc;
export SYSTEM_PTR Heap_modules; export SYSTEM_PTR Heap_modules;
static int64 Heap_freeList[10]; static uintptr Heap_freeList[10];
static int64 Heap_bigBlocks; static uintptr Heap_bigBlocks;
export uintptr Heap_allocated; export uintptr Heap_allocated;
static BOOLEAN Heap_firstTry; static BOOLEAN Heap_firstTry;
static uintptr Heap_heap, Heap_heapend; static uintptr Heap_heap, Heap_heapend;
@ -76,18 +76,18 @@ export LONGINT *Heap_FinDesc__typ;
export LONGINT *Heap__1__typ; export LONGINT *Heap__1__typ;
static void Heap_CheckFin (void); static void Heap_CheckFin (void);
static void Heap_ExtendHeap (int64 blksz); static void Heap_ExtendHeap (uintptr blksz);
export void Heap_FINALL (void); export void Heap_FINALL (void);
static void Heap_Finalize (void); static void Heap_Finalize (void);
export void Heap_GC (BOOLEAN markStack); export void Heap_GC (BOOLEAN markStack);
static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len); static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len);
export void Heap_INCREF (Heap_Module m); export void Heap_INCREF (Heap_Module m);
export void Heap_InitHeap (void); export void Heap_InitHeap (void);
export void Heap_Lock (void); export void Heap_Lock (void);
static void Heap_Mark (int64 q); static void Heap_Mark (uintptr q);
static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len); static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len);
static void Heap_MarkP (SYSTEM_PTR p); static void Heap_MarkP (SYSTEM_PTR p);
static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len); static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len);
export SYSTEM_PTR Heap_NEWBLK (uintptr size); export SYSTEM_PTR Heap_NEWBLK (uintptr size);
export SYSTEM_PTR Heap_NEWREC (uintptr tag); export SYSTEM_PTR Heap_NEWREC (uintptr tag);
static uintptr Heap_NewChunk (uintptr blksz); static uintptr Heap_NewChunk (uintptr blksz);
@ -96,11 +96,11 @@ export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
export void Heap_REGTYP (Heap_Module m, uintptr typ); export void Heap_REGTYP (Heap_Module m, uintptr typ);
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize); export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
static void Heap_Scan (void); static void Heap_Scan (void);
static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len); static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len);
export void Heap_Unlock (void); export void Heap_Unlock (void);
extern void *Heap__init(); extern void *Heap__init();
extern LONGINT Platform_MainStackFrame; extern uintptr Platform_MainStackFrame;
extern uintptr Platform_OSAllocate(uintptr size); extern uintptr Platform_OSAllocate(uintptr size);
#define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer))) #define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer)))
#define Heap_HeapModuleInit() Heap__init() #define Heap_HeapModuleInit() Heap__init()
@ -157,7 +157,7 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
void Heap_REGTYP (Heap_Module m, uintptr typ) void Heap_REGTYP (Heap_Module m, uintptr typ)
{ {
__PUT(typ, m->types, int64); __PUT(typ, m->types, uintptr);
m->types = typ; m->types = typ;
} }
@ -175,8 +175,8 @@ static uintptr Heap_NewChunk (uintptr blksz)
__PUT(chnk + 8, chnk + (24 + blksz), uintptr); __PUT(chnk + 8, chnk + (24 + blksz), uintptr);
__PUT(chnk + 24, chnk + 32, uintptr); __PUT(chnk + 24, chnk + 32, uintptr);
__PUT(chnk + 32, blksz, uintptr); __PUT(chnk + 32, blksz, uintptr);
__PUT(chnk + 40, -8, int64); __PUT(chnk + 40, -8, uintptr);
__PUT(chnk + 48, Heap_bigBlocks, int64); __PUT(chnk + 48, Heap_bigBlocks, uintptr);
Heap_bigBlocks = chnk + 24; Heap_bigBlocks = chnk + 24;
Heap_heapsize += blksz; Heap_heapsize += blksz;
} }
@ -184,9 +184,9 @@ static uintptr Heap_NewChunk (uintptr blksz)
return _o_result; return _o_result;
} }
static void Heap_ExtendHeap (int64 blksz) static void Heap_ExtendHeap (uintptr blksz)
{ {
int64 size, chnk, j, next; uintptr size, chnk, j, next;
if (blksz > 320000) { if (blksz > 320000) {
size = blksz; size = blksz;
} else { } else {
@ -204,8 +204,8 @@ static void Heap_ExtendHeap (int64 blksz)
j = next; j = next;
next = Heap_FetchAddress(j); next = Heap_FetchAddress(j);
} }
__PUT(chnk, next, int64); __PUT(chnk, next, uintptr);
__PUT(j, chnk, int64); __PUT(j, chnk, uintptr);
} }
if (next == 0) { if (next == 0) {
Heap_heapend = Heap_FetchAddress(chnk + 8); Heap_heapend = Heap_FetchAddress(chnk + 8);
@ -237,10 +237,10 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = __ASHL(di, 5); restsize = __ASHL(di, 5);
end = adr + restsize; end = adr + restsize;
__PUT(end + 8, blksz, uintptr); __PUT(end + 8, blksz, uintptr);
__PUT(end + 16, -8, int64); __PUT(end + 16, -8, uintptr);
__PUT(end, end + 8, int64); __PUT(end, end + 8, uintptr);
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
__PUT(adr + 24, Heap_freeList[di], int64); __PUT(adr + 24, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
adr += restsize; adr += restsize;
} }
@ -281,8 +281,8 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = t - blksz; restsize = t - blksz;
end = adr + restsize; end = adr + restsize;
__PUT(end + 8, blksz, uintptr); __PUT(end + 8, blksz, uintptr);
__PUT(end + 16, -8, int64); __PUT(end + 16, -8, uintptr);
__PUT(end, end + 8, int64); __PUT(end, end + 8, uintptr);
if (restsize > 288) { if (restsize > 288) {
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
} else { } else {
@ -295,7 +295,7 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
if (restsize > 0) { if (restsize > 0) {
di = __ASHR(restsize, 5); di = __ASHR(restsize, 5);
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
__PUT(adr + 24, Heap_freeList[di], int64); __PUT(adr + 24, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
} }
} }
@ -304,16 +304,16 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
i = adr + 32; i = adr + 32;
end = adr + blksz; end = adr + blksz;
while (i < end) { while (i < end) {
__PUT(i, 0, int64); __PUT(i, 0, uintptr);
__PUT(i + 8, 0, int64); __PUT(i + 8, 0, uintptr);
__PUT(i + 16, 0, int64); __PUT(i + 16, 0, uintptr);
__PUT(i + 24, 0, int64); __PUT(i + 24, 0, uintptr);
i += 32; i += 32;
} }
__PUT(adr + 24, 0, int64); __PUT(adr + 24, 0, uintptr);
__PUT(adr, tag, uintptr); __PUT(adr, tag, uintptr);
__PUT(adr + 8, 0, int64); __PUT(adr + 8, 0, uintptr);
__PUT(adr + 16, 0, int64); __PUT(adr + 16, 0, uintptr);
Heap_allocated += blksz; Heap_allocated += blksz;
Heap_Unlock(); Heap_Unlock();
_o_result = (SYSTEM_PTR)(uintptr)(adr + 8); _o_result = (SYSTEM_PTR)(uintptr)(adr + 8);
@ -328,29 +328,29 @@ SYSTEM_PTR Heap_NEWBLK (uintptr size)
Heap_Lock(); Heap_Lock();
blksz = __ASHL(__ASHR(size + 63, 5), 5); blksz = __ASHL(__ASHR(size + 63, 5), 5);
new = Heap_NEWREC((uintptr)&blksz); new = Heap_NEWREC((uintptr)&blksz);
tag = (((int64)(uintptr)new) + blksz) - 24; tag = ((uintptr)(uintptr)new + blksz) - 24;
__PUT(tag - 8, 0, int64); __PUT(tag - 8, 0, uintptr);
__PUT(tag, blksz, uintptr); __PUT(tag, blksz, uintptr);
__PUT(tag + 8, -8, int64); __PUT(tag + 8, -8, uintptr);
__PUT((int64)(uintptr)new - 8, tag, uintptr); __PUT((uintptr)(uintptr)new - 8, tag, uintptr);
Heap_Unlock(); Heap_Unlock();
_o_result = new; _o_result = new;
return _o_result; return _o_result;
} }
static void Heap_Mark (int64 q) static void Heap_Mark (uintptr q)
{ {
int64 p, tag, fld, n, offset, tagbits; uintptr p, tag, offset, fld, n, tagbits;
if (q != 0) { if (q != 0) {
tagbits = Heap_FetchAddress(q - 8); tagbits = Heap_FetchAddress(q - 8);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(q - 8, tagbits + 1, int64); __PUT(q - 8, tagbits + 1, uintptr);
p = 0; p = 0;
tag = tagbits + 8; tag = tagbits + 8;
for (;;) { for (;;) {
__GET(tag, offset, int64); __GET(tag, offset, uintptr);
if (offset < 0) { if (__BIT((uintptr)&offset, 63)) {
__PUT(q - 8, (tag + offset) + 1, int64); __PUT(q - 8, (tag + offset) + 1, uintptr);
if (p == 0) { if (p == 0) {
break; break;
} }
@ -358,7 +358,7 @@ static void Heap_Mark (int64 q)
q = p; q = p;
tag = Heap_FetchAddress(q - 8); tag = Heap_FetchAddress(q - 8);
tag -= 1; tag -= 1;
__GET(tag, offset, int64); __GET(tag, offset, uintptr);
fld = q + offset; fld = q + offset;
p = Heap_FetchAddress(fld); p = Heap_FetchAddress(fld);
__PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR);
@ -368,8 +368,8 @@ static void Heap_Mark (int64 q)
if (n != 0) { if (n != 0) {
tagbits = Heap_FetchAddress(n - 8); tagbits = Heap_FetchAddress(n - 8);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(n - 8, tagbits + 1, int64); __PUT(n - 8, tagbits + 1, uintptr);
__PUT(q - 8, tag + 1, int64); __PUT(q - 8, tag + 1, uintptr);
__PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR);
p = q; p = q;
q = n; q = n;
@ -385,7 +385,7 @@ static void Heap_Mark (int64 q)
static void Heap_MarkP (SYSTEM_PTR p) static void Heap_MarkP (SYSTEM_PTR p)
{ {
Heap_Mark((int64)(uintptr)p); Heap_Mark((uintptr)(uintptr)p);
} }
static void Heap_Scan (void) static void Heap_Scan (void)
@ -410,14 +410,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 8, uintptr); __PUT(start, start + 8, uintptr);
__PUT(start + 8, freesize, uintptr); __PUT(start + 8, freesize, uintptr);
__PUT(start + 16, -8, int64); __PUT(start + 16, -8, uintptr);
i = __ASHR(freesize, 5); i = __ASHR(freesize, 5);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 24, Heap_freeList[i], int64); __PUT(start + 24, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 24, Heap_bigBlocks, int64); __PUT(start + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -436,14 +436,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 8, uintptr); __PUT(start, start + 8, uintptr);
__PUT(start + 8, freesize, uintptr); __PUT(start + 8, freesize, uintptr);
__PUT(start + 16, -8, int64); __PUT(start + 16, -8, uintptr);
i = __ASHR(freesize, 5); i = __ASHR(freesize, 5);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 24, Heap_freeList[i], int64); __PUT(start + 24, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 24, Heap_bigBlocks, int64); __PUT(start + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -451,9 +451,9 @@ static void Heap_Scan (void)
} }
} }
static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len) static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len)
{ {
int64 i, j, x; uintptr i, j, x;
j = l; j = l;
x = a[j]; x = a[j];
for (;;) { for (;;) {
@ -470,9 +470,9 @@ static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len)
a[i] = x; a[i] = x;
} }
static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len) static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len)
{ {
int64 l, r, x; uintptr l, r, x;
l = __ASHR(n, 1); l = __ASHR(n, 1);
r = n - 1; r = n - 1;
while (l > 0) { while (l > 0) {
@ -488,9 +488,9 @@ static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len)
} }
} }
static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len) static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
int64 chnk, adr, tag, next, lim, lim1, i, ptr, size; uintptr chnk, adr, tag, next, lim, lim1, i, ptr, size;
chnk = Heap_heap; chnk = Heap_heap;
i = 0; i = 0;
lim = cand[n - 1]; lim = cand[n - 1];
@ -528,7 +528,7 @@ static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len)
static void Heap_CheckFin (void) static void Heap_CheckFin (void)
{ {
Heap_FinNode n; Heap_FinNode n;
int64 tag; uintptr tag;
n = Heap_fin; n = Heap_fin;
while (n != NIL) { while (n != NIL) {
tag = Heap_FetchAddress(n->obj - 8); tag = Heap_FetchAddress(n->obj - 8);
@ -577,10 +577,10 @@ void Heap_FINALL (void)
} }
} }
static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len) static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
SYSTEM_PTR frame; SYSTEM_PTR frame;
int64 inc, nofcand, sp, p, stack0; uintptr inc, nofcand, sp, p, stack0;
struct Heap__1 align; struct Heap__1 align;
if (n > 0) { if (n > 0) {
Heap_MarkStack(n - 1, cand, cand__len); Heap_MarkStack(n - 1, cand, cand__len);
@ -597,7 +597,7 @@ static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len)
inc = -inc; inc = -inc;
} }
while (sp != stack0) { while (sp != stack0) {
__GET(sp, p, int64); __GET(sp, p, uintptr);
if ((p > Heap_heap && p < Heap_heapend)) { if ((p > Heap_heap && p < Heap_heapend)) {
if (nofcand == cand__len) { if (nofcand == cand__len) {
Heap_HeapSort(nofcand, (void*)cand, cand__len); Heap_HeapSort(nofcand, (void*)cand, cand__len);
@ -619,8 +619,8 @@ static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len)
void Heap_GC (BOOLEAN markStack) void Heap_GC (BOOLEAN markStack)
{ {
Heap_Module m; Heap_Module m;
int64 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23; uintptr i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
int64 cand[10000]; uintptr cand[10000];
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) { if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
Heap_Lock(); Heap_Lock();
m = (Heap_Module)(uintptr)Heap_modules; m = (Heap_Module)(uintptr)Heap_modules;
@ -700,7 +700,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
{ {
Heap_FinNode f; Heap_FinNode f;
__NEW(f, Heap_FinDesc); __NEW(f, Heap_FinDesc);
f->obj = (int64)(uintptr)obj; f->obj = (uintptr)(uintptr)obj;
f->finalize = finalize; f->finalize = finalize;
f->marked = 1; f->marked = 1;
f->next = Heap_fin; f->next = Heap_fin;
@ -711,7 +711,7 @@ void Heap_InitHeap (void)
{ {
Heap_heap = Heap_NewChunk(256000); Heap_heap = Heap_NewChunk(256000);
Heap_heapend = Heap_FetchAddress(Heap_heap + 8); Heap_heapend = Heap_FetchAddress(Heap_heap + 8);
__PUT(Heap_heap, 0, int64); __PUT(Heap_heap, 0, uintptr);
Heap_allocated = 0; Heap_allocated = 0;
Heap_firstTry = 1; Heap_firstTry = 1;
Heap_freeList[9] = 1; Heap_freeList[9] = 1;

128
bootstrap/windows-48/Heap.c
View file

@ -51,15 +51,15 @@ typedef
Heap_ModuleName name; Heap_ModuleName name;
int32 refcnt; int32 refcnt;
Heap_Cmd cmds; Heap_Cmd cmds;
int32 types; uintptr types;
Heap_EnumProc enumPtrs; Heap_EnumProc enumPtrs;
int32 reserved1, reserved2; int32 reserved1, reserved2;
} Heap_ModuleDesc; } Heap_ModuleDesc;
export SYSTEM_PTR Heap_modules; export SYSTEM_PTR Heap_modules;
static int32 Heap_freeList[10]; static uintptr Heap_freeList[10];
static int32 Heap_bigBlocks; static uintptr Heap_bigBlocks;
export uintptr Heap_allocated; export uintptr Heap_allocated;
static BOOLEAN Heap_firstTry; static BOOLEAN Heap_firstTry;
static uintptr Heap_heap, Heap_heapend; static uintptr Heap_heap, Heap_heapend;
@ -75,18 +75,18 @@ export LONGINT *Heap_FinDesc__typ;
export LONGINT *Heap__1__typ; export LONGINT *Heap__1__typ;
static void Heap_CheckFin (void); static void Heap_CheckFin (void);
static void Heap_ExtendHeap (int32 blksz); static void Heap_ExtendHeap (uintptr blksz);
export void Heap_FINALL (void); export void Heap_FINALL (void);
static void Heap_Finalize (void); static void Heap_Finalize (void);
export void Heap_GC (BOOLEAN markStack); export void Heap_GC (BOOLEAN markStack);
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len); static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len);
export void Heap_INCREF (Heap_Module m); export void Heap_INCREF (Heap_Module m);
export void Heap_InitHeap (void); export void Heap_InitHeap (void);
export void Heap_Lock (void); export void Heap_Lock (void);
static void Heap_Mark (int32 q); static void Heap_Mark (uintptr q);
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len);
static void Heap_MarkP (SYSTEM_PTR p); static void Heap_MarkP (SYSTEM_PTR p);
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len); static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len);
export SYSTEM_PTR Heap_NEWBLK (uintptr size); export SYSTEM_PTR Heap_NEWBLK (uintptr size);
export SYSTEM_PTR Heap_NEWREC (uintptr tag); export SYSTEM_PTR Heap_NEWREC (uintptr tag);
static uintptr Heap_NewChunk (uintptr blksz); static uintptr Heap_NewChunk (uintptr blksz);
@ -95,11 +95,11 @@ export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
export void Heap_REGTYP (Heap_Module m, uintptr typ); export void Heap_REGTYP (Heap_Module m, uintptr typ);
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize); export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
static void Heap_Scan (void); static void Heap_Scan (void);
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len); static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len);
export void Heap_Unlock (void); export void Heap_Unlock (void);
extern void *Heap__init(); extern void *Heap__init();
extern LONGINT Platform_MainStackFrame; extern uintptr Platform_MainStackFrame;
extern uintptr Platform_OSAllocate(uintptr size); extern uintptr Platform_OSAllocate(uintptr size);
#define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer))) #define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer)))
#define Heap_HeapModuleInit() Heap__init() #define Heap_HeapModuleInit() Heap__init()
@ -156,7 +156,7 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
void Heap_REGTYP (Heap_Module m, uintptr typ) void Heap_REGTYP (Heap_Module m, uintptr typ)
{ {
__PUT(typ, m->types, int32); __PUT(typ, m->types, uintptr);
m->types = typ; m->types = typ;
} }
@ -174,8 +174,8 @@ static uintptr Heap_NewChunk (uintptr blksz)
__PUT(chnk + 4, chnk + (12 + blksz), uintptr); __PUT(chnk + 4, chnk + (12 + blksz), uintptr);
__PUT(chnk + 12, chnk + 16, uintptr); __PUT(chnk + 12, chnk + 16, uintptr);
__PUT(chnk + 16, blksz, uintptr); __PUT(chnk + 16, blksz, uintptr);
__PUT(chnk + 20, -4, int32); __PUT(chnk + 20, -4, uintptr);
__PUT(chnk + 24, Heap_bigBlocks, int32); __PUT(chnk + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = chnk + 12; Heap_bigBlocks = chnk + 12;
Heap_heapsize += blksz; Heap_heapsize += blksz;
} }
@ -183,9 +183,9 @@ static uintptr Heap_NewChunk (uintptr blksz)
return _o_result; return _o_result;
} }
static void Heap_ExtendHeap (int32 blksz) static void Heap_ExtendHeap (uintptr blksz)
{ {
int32 size, chnk, j, next; uintptr size, chnk, j, next;
if (blksz > 160000) { if (blksz > 160000) {
size = blksz; size = blksz;
} else { } else {
@ -203,8 +203,8 @@ static void Heap_ExtendHeap (int32 blksz)
j = next; j = next;
next = Heap_FetchAddress(j); next = Heap_FetchAddress(j);
} }
__PUT(chnk, next, int32); __PUT(chnk, next, uintptr);
__PUT(j, chnk, int32); __PUT(j, chnk, uintptr);
} }
if (next == 0) { if (next == 0) {
Heap_heapend = Heap_FetchAddress(chnk + 4); Heap_heapend = Heap_FetchAddress(chnk + 4);
@ -236,10 +236,10 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = __ASHL(di, 4); restsize = __ASHL(di, 4);
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
adr += restsize; adr += restsize;
} }
@ -280,8 +280,8 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = t - blksz; restsize = t - blksz;
end = adr + restsize; end = adr + restsize;
__PUT(end + 4, blksz, uintptr); __PUT(end + 4, blksz, uintptr);
__PUT(end + 8, -4, int32); __PUT(end + 8, -4, uintptr);
__PUT(end, end + 4, int32); __PUT(end, end + 4, uintptr);
if (restsize > 144) { if (restsize > 144) {
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
} else { } else {
@ -294,7 +294,7 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
if (restsize > 0) { if (restsize > 0) {
di = __ASHR(restsize, 4); di = __ASHR(restsize, 4);
__PUT(adr + 4, restsize, uintptr); __PUT(adr + 4, restsize, uintptr);
__PUT(adr + 12, Heap_freeList[di], int32); __PUT(adr + 12, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
} }
} }
@ -303,16 +303,16 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
i = adr + 16; i = adr + 16;
end = adr + blksz; end = adr + blksz;
while (i < end) { while (i < end) {
__PUT(i, 0, int32); __PUT(i, 0, uintptr);
__PUT(i + 4, 0, int32); __PUT(i + 4, 0, uintptr);
__PUT(i + 8, 0, int32); __PUT(i + 8, 0, uintptr);
__PUT(i + 12, 0, int32); __PUT(i + 12, 0, uintptr);
i += 16; i += 16;
} }
__PUT(adr + 12, 0, int32); __PUT(adr + 12, 0, uintptr);
__PUT(adr, tag, uintptr); __PUT(adr, tag, uintptr);
__PUT(adr + 4, 0, int32); __PUT(adr + 4, 0, uintptr);
__PUT(adr + 8, 0, int32); __PUT(adr + 8, 0, uintptr);
Heap_allocated += blksz; Heap_allocated += blksz;
Heap_Unlock(); Heap_Unlock();
_o_result = (SYSTEM_PTR)(uintptr)(adr + 4); _o_result = (SYSTEM_PTR)(uintptr)(adr + 4);
@ -327,29 +327,29 @@ SYSTEM_PTR Heap_NEWBLK (uintptr size)
Heap_Lock(); Heap_Lock();
blksz = __ASHL(__ASHR(size + 31, 4), 4); blksz = __ASHL(__ASHR(size + 31, 4), 4);
new = Heap_NEWREC((uintptr)&blksz); new = Heap_NEWREC((uintptr)&blksz);
tag = (((int32)(uintptr)new) + blksz) - 12; tag = ((uintptr)(uintptr)new + blksz) - 12;
__PUT(tag - 4, 0, int32); __PUT(tag - 4, 0, uintptr);
__PUT(tag, blksz, uintptr); __PUT(tag, blksz, uintptr);
__PUT(tag + 4, -4, int32); __PUT(tag + 4, -4, uintptr);
__PUT((int32)(uintptr)new - 4, tag, uintptr); __PUT((uintptr)(uintptr)new - 4, tag, uintptr);
Heap_Unlock(); Heap_Unlock();
_o_result = new; _o_result = new;
return _o_result; return _o_result;
} }
static void Heap_Mark (int32 q) static void Heap_Mark (uintptr q)
{ {
int32 p, tag, fld, n, offset, tagbits; uintptr p, tag, offset, fld, n, tagbits;
if (q != 0) { if (q != 0) {
tagbits = Heap_FetchAddress(q - 4); tagbits = Heap_FetchAddress(q - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(q - 4, tagbits + 1, int32); __PUT(q - 4, tagbits + 1, uintptr);
p = 0; p = 0;
tag = tagbits + 4; tag = tagbits + 4;
for (;;) { for (;;) {
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
if (offset < 0) { if (__BIT((uintptr)&offset, 31)) {
__PUT(q - 4, (tag + offset) + 1, int32); __PUT(q - 4, (tag + offset) + 1, uintptr);
if (p == 0) { if (p == 0) {
break; break;
} }
@ -357,7 +357,7 @@ static void Heap_Mark (int32 q)
q = p; q = p;
tag = Heap_FetchAddress(q - 4); tag = Heap_FetchAddress(q - 4);
tag -= 1; tag -= 1;
__GET(tag, offset, int32); __GET(tag, offset, uintptr);
fld = q + offset; fld = q + offset;
p = Heap_FetchAddress(fld); p = Heap_FetchAddress(fld);
__PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR);
@ -367,8 +367,8 @@ static void Heap_Mark (int32 q)
if (n != 0) { if (n != 0) {
tagbits = Heap_FetchAddress(n - 4); tagbits = Heap_FetchAddress(n - 4);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(n - 4, tagbits + 1, int32); __PUT(n - 4, tagbits + 1, uintptr);
__PUT(q - 4, tag + 1, int32); __PUT(q - 4, tag + 1, uintptr);
__PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR);
p = q; p = q;
q = n; q = n;
@ -384,7 +384,7 @@ static void Heap_Mark (int32 q)
static void Heap_MarkP (SYSTEM_PTR p) static void Heap_MarkP (SYSTEM_PTR p)
{ {
Heap_Mark((int32)(uintptr)p); Heap_Mark((uintptr)(uintptr)p);
} }
static void Heap_Scan (void) static void Heap_Scan (void)
@ -409,14 +409,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -435,14 +435,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 4, uintptr); __PUT(start, start + 4, uintptr);
__PUT(start + 4, freesize, uintptr); __PUT(start + 4, freesize, uintptr);
__PUT(start + 8, -4, int32); __PUT(start + 8, -4, uintptr);
i = __ASHR(freesize, 4); i = __ASHR(freesize, 4);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 12, Heap_freeList[i], int32); __PUT(start + 12, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 12, Heap_bigBlocks, int32); __PUT(start + 12, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -450,9 +450,9 @@ static void Heap_Scan (void)
} }
} }
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len) static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len)
{ {
int32 i, j, x; uintptr i, j, x;
j = l; j = l;
x = a[j]; x = a[j];
for (;;) { for (;;) {
@ -469,9 +469,9 @@ static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len)
a[i] = x; a[i] = x;
} }
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len) static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len)
{ {
int32 l, r, x; uintptr l, r, x;
l = __ASHR(n, 1); l = __ASHR(n, 1);
r = n - 1; r = n - 1;
while (l > 0) { while (l > 0) {
@ -487,9 +487,9 @@ static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len)
} }
} }
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
int32 chnk, adr, tag, next, lim, lim1, i, ptr, size; uintptr chnk, adr, tag, next, lim, lim1, i, ptr, size;
chnk = Heap_heap; chnk = Heap_heap;
i = 0; i = 0;
lim = cand[n - 1]; lim = cand[n - 1];
@ -527,7 +527,7 @@ static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len)
static void Heap_CheckFin (void) static void Heap_CheckFin (void)
{ {
Heap_FinNode n; Heap_FinNode n;
int32 tag; uintptr tag;
n = Heap_fin; n = Heap_fin;
while (n != NIL) { while (n != NIL) {
tag = Heap_FetchAddress(n->obj - 4); tag = Heap_FetchAddress(n->obj - 4);
@ -576,10 +576,10 @@ void Heap_FINALL (void)
} }
} }
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len) static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
SYSTEM_PTR frame; SYSTEM_PTR frame;
int32 inc, nofcand, sp, p, stack0; uintptr inc, nofcand, sp, p, stack0;
struct Heap__1 align; struct Heap__1 align;
if (n > 0) { if (n > 0) {
Heap_MarkStack(n - 1, cand, cand__len); Heap_MarkStack(n - 1, cand, cand__len);
@ -596,7 +596,7 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
inc = -inc; inc = -inc;
} }
while (sp != stack0) { while (sp != stack0) {
__GET(sp, p, int32); __GET(sp, p, uintptr);
if ((p > Heap_heap && p < Heap_heapend)) { if ((p > Heap_heap && p < Heap_heapend)) {
if (nofcand == cand__len) { if (nofcand == cand__len) {
Heap_HeapSort(nofcand, (void*)cand, cand__len); Heap_HeapSort(nofcand, (void*)cand, cand__len);
@ -618,8 +618,8 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
void Heap_GC (BOOLEAN markStack) void Heap_GC (BOOLEAN markStack)
{ {
Heap_Module m; Heap_Module m;
int32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23; uintptr i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
int32 cand[10000]; uintptr cand[10000];
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) { if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
Heap_Lock(); Heap_Lock();
m = (Heap_Module)(uintptr)Heap_modules; m = (Heap_Module)(uintptr)Heap_modules;
@ -699,7 +699,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
{ {
Heap_FinNode f; Heap_FinNode f;
__NEW(f, Heap_FinDesc); __NEW(f, Heap_FinDesc);
f->obj = (int32)(uintptr)obj; f->obj = (uintptr)(uintptr)obj;
f->finalize = finalize; f->finalize = finalize;
f->marked = 1; f->marked = 1;
f->next = Heap_fin; f->next = Heap_fin;
@ -710,7 +710,7 @@ void Heap_InitHeap (void)
{ {
Heap_heap = Heap_NewChunk(128000); Heap_heap = Heap_NewChunk(128000);
Heap_heapend = Heap_FetchAddress(Heap_heap + 4); Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
__PUT(Heap_heap, 0, int32); __PUT(Heap_heap, 0, uintptr);
Heap_allocated = 0; Heap_allocated = 0;
Heap_firstTry = 1; Heap_firstTry = 1;
Heap_freeList[9] = 1; Heap_freeList[9] = 1;

128
bootstrap/windows-88/Heap.c
View file

@ -52,15 +52,15 @@ typedef
Heap_ModuleName name; Heap_ModuleName name;
int64 refcnt; int64 refcnt;
Heap_Cmd cmds; Heap_Cmd cmds;
int64 types; uintptr types;
Heap_EnumProc enumPtrs; Heap_EnumProc enumPtrs;
int64 reserved1, reserved2; int64 reserved1, reserved2;
} Heap_ModuleDesc; } Heap_ModuleDesc;
export SYSTEM_PTR Heap_modules; export SYSTEM_PTR Heap_modules;
static int64 Heap_freeList[10]; static uintptr Heap_freeList[10];
static int64 Heap_bigBlocks; static uintptr Heap_bigBlocks;
export uintptr Heap_allocated; export uintptr Heap_allocated;
static BOOLEAN Heap_firstTry; static BOOLEAN Heap_firstTry;
static uintptr Heap_heap, Heap_heapend; static uintptr Heap_heap, Heap_heapend;
@ -76,18 +76,18 @@ export LONGINT *Heap_FinDesc__typ;
export LONGINT *Heap__1__typ; export LONGINT *Heap__1__typ;
static void Heap_CheckFin (void); static void Heap_CheckFin (void);
static void Heap_ExtendHeap (int64 blksz); static void Heap_ExtendHeap (uintptr blksz);
export void Heap_FINALL (void); export void Heap_FINALL (void);
static void Heap_Finalize (void); static void Heap_Finalize (void);
export void Heap_GC (BOOLEAN markStack); export void Heap_GC (BOOLEAN markStack);
static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len); static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len);
export void Heap_INCREF (Heap_Module m); export void Heap_INCREF (Heap_Module m);
export void Heap_InitHeap (void); export void Heap_InitHeap (void);
export void Heap_Lock (void); export void Heap_Lock (void);
static void Heap_Mark (int64 q); static void Heap_Mark (uintptr q);
static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len); static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len);
static void Heap_MarkP (SYSTEM_PTR p); static void Heap_MarkP (SYSTEM_PTR p);
static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len); static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len);
export SYSTEM_PTR Heap_NEWBLK (uintptr size); export SYSTEM_PTR Heap_NEWBLK (uintptr size);
export SYSTEM_PTR Heap_NEWREC (uintptr tag); export SYSTEM_PTR Heap_NEWREC (uintptr tag);
static uintptr Heap_NewChunk (uintptr blksz); static uintptr Heap_NewChunk (uintptr blksz);
@ -96,11 +96,11 @@ export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
export void Heap_REGTYP (Heap_Module m, uintptr typ); export void Heap_REGTYP (Heap_Module m, uintptr typ);
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize); export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
static void Heap_Scan (void); static void Heap_Scan (void);
static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len); static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len);
export void Heap_Unlock (void); export void Heap_Unlock (void);
extern void *Heap__init(); extern void *Heap__init();
extern LONGINT Platform_MainStackFrame; extern uintptr Platform_MainStackFrame;
extern uintptr Platform_OSAllocate(uintptr size); extern uintptr Platform_OSAllocate(uintptr size);
#define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer))) #define Heap_FetchAddress(pointer) (uintptr)(*((void**)((uintptr)pointer)))
#define Heap_HeapModuleInit() Heap__init() #define Heap_HeapModuleInit() Heap__init()
@ -157,7 +157,7 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
void Heap_REGTYP (Heap_Module m, uintptr typ) void Heap_REGTYP (Heap_Module m, uintptr typ)
{ {
__PUT(typ, m->types, int64); __PUT(typ, m->types, uintptr);
m->types = typ; m->types = typ;
} }
@ -175,8 +175,8 @@ static uintptr Heap_NewChunk (uintptr blksz)
__PUT(chnk + 8, chnk + (24 + blksz), uintptr); __PUT(chnk + 8, chnk + (24 + blksz), uintptr);
__PUT(chnk + 24, chnk + 32, uintptr); __PUT(chnk + 24, chnk + 32, uintptr);
__PUT(chnk + 32, blksz, uintptr); __PUT(chnk + 32, blksz, uintptr);
__PUT(chnk + 40, -8, int64); __PUT(chnk + 40, -8, uintptr);
__PUT(chnk + 48, Heap_bigBlocks, int64); __PUT(chnk + 48, Heap_bigBlocks, uintptr);
Heap_bigBlocks = chnk + 24; Heap_bigBlocks = chnk + 24;
Heap_heapsize += blksz; Heap_heapsize += blksz;
} }
@ -184,9 +184,9 @@ static uintptr Heap_NewChunk (uintptr blksz)
return _o_result; return _o_result;
} }
static void Heap_ExtendHeap (int64 blksz) static void Heap_ExtendHeap (uintptr blksz)
{ {
int64 size, chnk, j, next; uintptr size, chnk, j, next;
if (blksz > 320000) { if (blksz > 320000) {
size = blksz; size = blksz;
} else { } else {
@ -204,8 +204,8 @@ static void Heap_ExtendHeap (int64 blksz)
j = next; j = next;
next = Heap_FetchAddress(j); next = Heap_FetchAddress(j);
} }
__PUT(chnk, next, int64); __PUT(chnk, next, uintptr);
__PUT(j, chnk, int64); __PUT(j, chnk, uintptr);
} }
if (next == 0) { if (next == 0) {
Heap_heapend = Heap_FetchAddress(chnk + 8); Heap_heapend = Heap_FetchAddress(chnk + 8);
@ -237,10 +237,10 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = __ASHL(di, 5); restsize = __ASHL(di, 5);
end = adr + restsize; end = adr + restsize;
__PUT(end + 8, blksz, uintptr); __PUT(end + 8, blksz, uintptr);
__PUT(end + 16, -8, int64); __PUT(end + 16, -8, uintptr);
__PUT(end, end + 8, int64); __PUT(end, end + 8, uintptr);
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
__PUT(adr + 24, Heap_freeList[di], int64); __PUT(adr + 24, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
adr += restsize; adr += restsize;
} }
@ -281,8 +281,8 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
restsize = t - blksz; restsize = t - blksz;
end = adr + restsize; end = adr + restsize;
__PUT(end + 8, blksz, uintptr); __PUT(end + 8, blksz, uintptr);
__PUT(end + 16, -8, int64); __PUT(end + 16, -8, uintptr);
__PUT(end, end + 8, int64); __PUT(end, end + 8, uintptr);
if (restsize > 288) { if (restsize > 288) {
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
} else { } else {
@ -295,7 +295,7 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
if (restsize > 0) { if (restsize > 0) {
di = __ASHR(restsize, 5); di = __ASHR(restsize, 5);
__PUT(adr + 8, restsize, uintptr); __PUT(adr + 8, restsize, uintptr);
__PUT(adr + 24, Heap_freeList[di], int64); __PUT(adr + 24, Heap_freeList[di], uintptr);
Heap_freeList[di] = adr; Heap_freeList[di] = adr;
} }
} }
@ -304,16 +304,16 @@ SYSTEM_PTR Heap_NEWREC (uintptr tag)
i = adr + 32; i = adr + 32;
end = adr + blksz; end = adr + blksz;
while (i < end) { while (i < end) {
__PUT(i, 0, int64); __PUT(i, 0, uintptr);
__PUT(i + 8, 0, int64); __PUT(i + 8, 0, uintptr);
__PUT(i + 16, 0, int64); __PUT(i + 16, 0, uintptr);
__PUT(i + 24, 0, int64); __PUT(i + 24, 0, uintptr);
i += 32; i += 32;
} }
__PUT(adr + 24, 0, int64); __PUT(adr + 24, 0, uintptr);
__PUT(adr, tag, uintptr); __PUT(adr, tag, uintptr);
__PUT(adr + 8, 0, int64); __PUT(adr + 8, 0, uintptr);
__PUT(adr + 16, 0, int64); __PUT(adr + 16, 0, uintptr);
Heap_allocated += blksz; Heap_allocated += blksz;
Heap_Unlock(); Heap_Unlock();
_o_result = (SYSTEM_PTR)(uintptr)(adr + 8); _o_result = (SYSTEM_PTR)(uintptr)(adr + 8);
@ -328,29 +328,29 @@ SYSTEM_PTR Heap_NEWBLK (uintptr size)
Heap_Lock(); Heap_Lock();
blksz = __ASHL(__ASHR(size + 63, 5), 5); blksz = __ASHL(__ASHR(size + 63, 5), 5);
new = Heap_NEWREC((uintptr)&blksz); new = Heap_NEWREC((uintptr)&blksz);
tag = (((int64)(uintptr)new) + blksz) - 24; tag = ((uintptr)(uintptr)new + blksz) - 24;
__PUT(tag - 8, 0, int64); __PUT(tag - 8, 0, uintptr);
__PUT(tag, blksz, uintptr); __PUT(tag, blksz, uintptr);
__PUT(tag + 8, -8, int64); __PUT(tag + 8, -8, uintptr);
__PUT((int64)(uintptr)new - 8, tag, uintptr); __PUT((uintptr)(uintptr)new - 8, tag, uintptr);
Heap_Unlock(); Heap_Unlock();
_o_result = new; _o_result = new;
return _o_result; return _o_result;
} }
static void Heap_Mark (int64 q) static void Heap_Mark (uintptr q)
{ {
int64 p, tag, fld, n, offset, tagbits; uintptr p, tag, offset, fld, n, tagbits;
if (q != 0) { if (q != 0) {
tagbits = Heap_FetchAddress(q - 8); tagbits = Heap_FetchAddress(q - 8);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(q - 8, tagbits + 1, int64); __PUT(q - 8, tagbits + 1, uintptr);
p = 0; p = 0;
tag = tagbits + 8; tag = tagbits + 8;
for (;;) { for (;;) {
__GET(tag, offset, int64); __GET(tag, offset, uintptr);
if (offset < 0) { if (__BIT((uintptr)&offset, 63)) {
__PUT(q - 8, (tag + offset) + 1, int64); __PUT(q - 8, (tag + offset) + 1, uintptr);
if (p == 0) { if (p == 0) {
break; break;
} }
@ -358,7 +358,7 @@ static void Heap_Mark (int64 q)
q = p; q = p;
tag = Heap_FetchAddress(q - 8); tag = Heap_FetchAddress(q - 8);
tag -= 1; tag -= 1;
__GET(tag, offset, int64); __GET(tag, offset, uintptr);
fld = q + offset; fld = q + offset;
p = Heap_FetchAddress(fld); p = Heap_FetchAddress(fld);
__PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)n, SYSTEM_PTR);
@ -368,8 +368,8 @@ static void Heap_Mark (int64 q)
if (n != 0) { if (n != 0) {
tagbits = Heap_FetchAddress(n - 8); tagbits = Heap_FetchAddress(n - 8);
if (!__ODD(tagbits)) { if (!__ODD(tagbits)) {
__PUT(n - 8, tagbits + 1, int64); __PUT(n - 8, tagbits + 1, uintptr);
__PUT(q - 8, tag + 1, int64); __PUT(q - 8, tag + 1, uintptr);
__PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR); __PUT(fld, (SYSTEM_PTR)(uintptr)p, SYSTEM_PTR);
p = q; p = q;
q = n; q = n;
@ -385,7 +385,7 @@ static void Heap_Mark (int64 q)
static void Heap_MarkP (SYSTEM_PTR p) static void Heap_MarkP (SYSTEM_PTR p)
{ {
Heap_Mark((int64)(uintptr)p); Heap_Mark((uintptr)(uintptr)p);
} }
static void Heap_Scan (void) static void Heap_Scan (void)
@ -410,14 +410,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 8, uintptr); __PUT(start, start + 8, uintptr);
__PUT(start + 8, freesize, uintptr); __PUT(start + 8, freesize, uintptr);
__PUT(start + 16, -8, int64); __PUT(start + 16, -8, uintptr);
i = __ASHR(freesize, 5); i = __ASHR(freesize, 5);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 24, Heap_freeList[i], int64); __PUT(start + 24, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 24, Heap_bigBlocks, int64); __PUT(start + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -436,14 +436,14 @@ static void Heap_Scan (void)
start = adr - freesize; start = adr - freesize;
__PUT(start, start + 8, uintptr); __PUT(start, start + 8, uintptr);
__PUT(start + 8, freesize, uintptr); __PUT(start + 8, freesize, uintptr);
__PUT(start + 16, -8, int64); __PUT(start + 16, -8, uintptr);
i = __ASHR(freesize, 5); i = __ASHR(freesize, 5);
freesize = 0; freesize = 0;
if (i < 9) { if (i < 9) {
__PUT(start + 24, Heap_freeList[i], int64); __PUT(start + 24, Heap_freeList[i], uintptr);
Heap_freeList[i] = start; Heap_freeList[i] = start;
} else { } else {
__PUT(start + 24, Heap_bigBlocks, int64); __PUT(start + 24, Heap_bigBlocks, uintptr);
Heap_bigBlocks = start; Heap_bigBlocks = start;
} }
} }
@ -451,9 +451,9 @@ static void Heap_Scan (void)
} }
} }
static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len) static void Heap_Sift (uintptr l, uintptr r, uintptr *a, LONGINT a__len)
{ {
int64 i, j, x; uintptr i, j, x;
j = l; j = l;
x = a[j]; x = a[j];
for (;;) { for (;;) {
@ -470,9 +470,9 @@ static void Heap_Sift (int64 l, int64 r, int64 *a, LONGINT a__len)
a[i] = x; a[i] = x;
} }
static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len) static void Heap_HeapSort (uintptr n, uintptr *a, LONGINT a__len)
{ {
int64 l, r, x; uintptr l, r, x;
l = __ASHR(n, 1); l = __ASHR(n, 1);
r = n - 1; r = n - 1;
while (l > 0) { while (l > 0) {
@ -488,9 +488,9 @@ static void Heap_HeapSort (int64 n, int64 *a, LONGINT a__len)
} }
} }
static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len) static void Heap_MarkCandidates (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
int64 chnk, adr, tag, next, lim, lim1, i, ptr, size; uintptr chnk, adr, tag, next, lim, lim1, i, ptr, size;
chnk = Heap_heap; chnk = Heap_heap;
i = 0; i = 0;
lim = cand[n - 1]; lim = cand[n - 1];
@ -528,7 +528,7 @@ static void Heap_MarkCandidates (int64 n, int64 *cand, LONGINT cand__len)
static void Heap_CheckFin (void) static void Heap_CheckFin (void)
{ {
Heap_FinNode n; Heap_FinNode n;
int64 tag; uintptr tag;
n = Heap_fin; n = Heap_fin;
while (n != NIL) { while (n != NIL) {
tag = Heap_FetchAddress(n->obj - 8); tag = Heap_FetchAddress(n->obj - 8);
@ -577,10 +577,10 @@ void Heap_FINALL (void)
} }
} }
static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len) static void Heap_MarkStack (uintptr n, uintptr *cand, LONGINT cand__len)
{ {
SYSTEM_PTR frame; SYSTEM_PTR frame;
int64 inc, nofcand, sp, p, stack0; uintptr inc, nofcand, sp, p, stack0;
struct Heap__1 align; struct Heap__1 align;
if (n > 0) { if (n > 0) {
Heap_MarkStack(n - 1, cand, cand__len); Heap_MarkStack(n - 1, cand, cand__len);
@ -597,7 +597,7 @@ static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len)
inc = -inc; inc = -inc;
} }
while (sp != stack0) { while (sp != stack0) {
__GET(sp, p, int64); __GET(sp, p, uintptr);
if ((p > Heap_heap && p < Heap_heapend)) { if ((p > Heap_heap && p < Heap_heapend)) {
if (nofcand == cand__len) { if (nofcand == cand__len) {
Heap_HeapSort(nofcand, (void*)cand, cand__len); Heap_HeapSort(nofcand, (void*)cand, cand__len);
@ -619,8 +619,8 @@ static void Heap_MarkStack (int64 n, int64 *cand, LONGINT cand__len)
void Heap_GC (BOOLEAN markStack) void Heap_GC (BOOLEAN markStack)
{ {
Heap_Module m; Heap_Module m;
int64 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23; uintptr i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
int64 cand[10000]; uintptr cand[10000];
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) { if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
Heap_Lock(); Heap_Lock();
m = (Heap_Module)(uintptr)Heap_modules; m = (Heap_Module)(uintptr)Heap_modules;
@ -700,7 +700,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
{ {
Heap_FinNode f; Heap_FinNode f;
__NEW(f, Heap_FinDesc); __NEW(f, Heap_FinDesc);
f->obj = (int64)(uintptr)obj; f->obj = (uintptr)(uintptr)obj;
f->finalize = finalize; f->finalize = finalize;
f->marked = 1; f->marked = 1;
f->next = Heap_fin; f->next = Heap_fin;
@ -711,7 +711,7 @@ void Heap_InitHeap (void)
{ {
Heap_heap = Heap_NewChunk(256000); Heap_heap = Heap_NewChunk(256000);
Heap_heapend = Heap_FetchAddress(Heap_heap + 8); Heap_heapend = Heap_FetchAddress(Heap_heap + 8);
__PUT(Heap_heap, 0, int64); __PUT(Heap_heap, 0, uintptr);
Heap_allocated = 0; Heap_allocated = 0;
Heap_firstTry = 1; Heap_firstTry = 1;
Heap_freeList[9] = 1; Heap_freeList[9] = 1;

119
src/system/Heap.Mod
View file

@ -6,30 +6,30 @@ MODULE Heap;
CONST CONST
ModNameLen = 20; ModNameLen = 20;
CmdNameLen = 24; CmdNameLen = 24;
SZL = SIZE(LONGINT); SZA = SIZE(SYSTEM.UINTPTR); (* Size of address *)
Unit = 4*SZL; (* smallest possible heap block *) Unit = 4*SZA; (* smallest possible heap block *)
nofLists = 9; (* number of free_lists *) nofLists = 9; (* number of free_lists *)
heapSize0 = 8000*Unit; (* startup heap size *) heapSize0 = 8000*Unit; (* startup heap size *)
(* all blocks look the same: (* all blocks look the same:
free blocks describe themselves: size = Unit free blocks describe themselves: size = Unit
tag = &tag++ tag = &tag++
->block size ->block size
sentinel = -SZL sentinel = -SZA
next next
*) *)
(* heap chunks *) (* heap chunks *)
nextChnkOff = SYSTEM.VAL(SYSTEM.UINTPTR, 0); (* next heap chunk, sorted ascendingly! *) nextChnkOff = SYSTEM.VAL(SYSTEM.UINTPTR, 0); (* next heap chunk, sorted ascendingly! *)
endOff = SYSTEM.VAL(SYSTEM.UINTPTR, SZL); (* end of heap chunk *) endOff = SYSTEM.VAL(SYSTEM.UINTPTR, SZA); (* end of heap chunk *)
blkOff = SYSTEM.VAL(SYSTEM.UINTPTR, 3*SZL); (* first block in a chunk *) blkOff = SYSTEM.VAL(SYSTEM.UINTPTR, 3*SZA); (* first block in a chunk *)
(* heap blocks *) (* heap blocks *)
tagOff = SYSTEM.VAL(SYSTEM.UINTPTR, 0); (* block starts with tag *) tagOff = SYSTEM.VAL(SYSTEM.UINTPTR, 0); (* block starts with tag *)
sizeOff = SYSTEM.VAL(SYSTEM.UINTPTR, SZL); (* block size in free block relative to block start *) sizeOff = SYSTEM.VAL(SYSTEM.UINTPTR, SZA); (* block size in free block relative to block start *)
sntlOff = SYSTEM.VAL(SYSTEM.UINTPTR, 2*SZL); (* pointer offset table sentinel in free block relative to block start *) sntlOff = SYSTEM.VAL(SYSTEM.UINTPTR, 2*SZA); (* pointer offset table sentinel in free block relative to block start *)
nextOff = SYSTEM.VAL(SYSTEM.UINTPTR, 3*SZL); (* next pointer in free block relative to block start *) nextOff = SYSTEM.VAL(SYSTEM.UINTPTR, 3*SZA); (* next pointer in free block relative to block start *)
NoPtrSntl = SYSTEM.VAL(SYSTEM.UINTPTR, -SZL); NoPtrSntl = SYSTEM.VAL(SYSTEM.UINTPTR, -SZA);
AddressZero = SYSTEM.VAL(SYSTEM.UINTPTR, 0); AddressZero = SYSTEM.VAL(SYSTEM.UINTPTR, 0);
TYPE TYPE
@ -46,7 +46,7 @@ MODULE Heap;
name: ModuleName; name: ModuleName;
refcnt: LONGINT; refcnt: LONGINT;
cmds: Cmd; cmds: Cmd;
types: LONGINT; types: SYSTEM.UINTPTR;
enumPtrs: EnumProc; enumPtrs: EnumProc;
reserved1, reserved2: LONGINT reserved1, reserved2: LONGINT
END ; END ;
@ -73,8 +73,8 @@ MODULE Heap;
(* the list of loaded (=initialization started) modules *) (* the list of loaded (=initialization started) modules *)
modules*: SYSTEM.PTR; modules*: SYSTEM.PTR;
freeList: ARRAY nofLists + 1 OF LONGINT; (* dummy, 16, 32, 48, 64, 80, 96, 112, 128, sentinel *) freeList: ARRAY nofLists + 1 OF SYSTEM.UINTPTR; (* dummy, 16, 32, 48, 64, 80, 96, 112, 128, sentinel *)
bigBlocks: LONGINT; bigBlocks: SYSTEM.UINTPTR;
allocated*: SYSTEM.UINTPTR; allocated*: SYSTEM.UINTPTR;
firstTry: BOOLEAN; firstTry: BOOLEAN;
@ -193,8 +193,8 @@ MODULE Heap;
*) *)
PROCEDURE -FetchAddress(pointer: SYSTEM.UINTPTR): SYSTEM.UINTPTR "(uintptr)(*((void**)((uintptr)pointer)))"; PROCEDURE -FetchAddress(pointer: SYSTEM.UINTPTR): SYSTEM.UINTPTR "(uintptr)(*((void**)((uintptr)pointer)))";
PROCEDURE ExtendHeap(blksz: LONGINT); PROCEDURE ExtendHeap(blksz: SYSTEM.UINTPTR);
VAR size, chnk, j, next: LONGINT; VAR size, chnk, j, next: SYSTEM.UINTPTR;
BEGIN BEGIN
IF blksz > 10000*Unit THEN size := blksz IF blksz > 10000*Unit THEN size := blksz
ELSE size := 10000*Unit (* additional heuristics *) ELSE size := 10000*Unit (* additional heuristics *)
@ -293,13 +293,13 @@ MODULE Heap;
END ; END ;
INC(adr, restsize) INC(adr, restsize)
END ; END ;
i := adr + 4*SZL; end := adr + blksz; i := adr + 4*SZA; end := adr + blksz;
WHILE i < end DO (*deliberately unrolled*) WHILE i < end DO (*deliberately unrolled*)
SYSTEM.PUT(i, AddressZero); SYSTEM.PUT(i, AddressZero);
SYSTEM.PUT(i + SZL, AddressZero); SYSTEM.PUT(i + SZA, AddressZero);
SYSTEM.PUT(i + 2*SZL, AddressZero); SYSTEM.PUT(i + 2*SZA, AddressZero);
SYSTEM.PUT(i + 3*SZL, AddressZero); SYSTEM.PUT(i + 3*SZA, AddressZero);
INC(i, 4*SZL) INC(i, 4*SZA)
END ; END ;
SYSTEM.PUT(adr + nextOff, AddressZero); SYSTEM.PUT(adr + nextOff, AddressZero);
SYSTEM.PUT(adr, tag); SYSTEM.PUT(adr, tag);
@ -307,57 +307,58 @@ MODULE Heap;
SYSTEM.PUT(adr + sntlOff, AddressZero); SYSTEM.PUT(adr + sntlOff, AddressZero);
INC(allocated, blksz); INC(allocated, blksz);
Unlock(); Unlock();
RETURN SYSTEM.VAL(SYSTEM.PTR, adr + SZL) RETURN SYSTEM.VAL(SYSTEM.PTR, adr + SZA)
END NEWREC; END NEWREC;
PROCEDURE NEWBLK*(size: SYSTEM.UINTPTR): SYSTEM.PTR; PROCEDURE NEWBLK*(size: SYSTEM.UINTPTR): SYSTEM.PTR;
VAR blksz, tag: SYSTEM.UINTPTR; new: SYSTEM.PTR; VAR blksz, tag: SYSTEM.UINTPTR; new: SYSTEM.PTR;
BEGIN BEGIN
Lock(); Lock();
blksz := (size + (4*SZL + Unit - 1)) DIV Unit * Unit; (*size + tag + meta + blksz + sntnl + UnitAlignment*) blksz := (size + (4*SZA + Unit - 1)) DIV Unit * Unit; (*size + tag + meta + blksz + sntnl + UnitAlignment*)
new := NEWREC(SYSTEM.ADR(blksz)); new := NEWREC(SYSTEM.ADR(blksz));
tag := SYSTEM.VAL(LONGINT, new) + blksz - 3*SZL; tag := SYSTEM.VAL(SYSTEM.UINTPTR, new) + blksz - 3*SZA;
SYSTEM.PUT(tag - SZL, AddressZero); (*reserved for meta info*) SYSTEM.PUT(tag - SZA, AddressZero); (*reserved for meta info*)
SYSTEM.PUT(tag, blksz); SYSTEM.PUT(tag, blksz);
SYSTEM.PUT(tag + SZL, NoPtrSntl); SYSTEM.PUT(tag + SZA, NoPtrSntl);
SYSTEM.PUT(SYSTEM.VAL(LONGINT, new) - SZL, tag); SYSTEM.PUT(SYSTEM.VAL(SYSTEM.UINTPTR, new) - SZA, tag);
Unlock(); Unlock();
RETURN new RETURN new
END NEWBLK; END NEWBLK;
PROCEDURE Mark(q: LONGINT); PROCEDURE Mark(q: SYSTEM.UINTPTR);
VAR p, tag, fld, n, offset, tagbits: LONGINT; VAR p, tag, offset, fld, n, tagbits: SYSTEM.UINTPTR;
BEGIN BEGIN
IF q # 0 THEN IF q # 0 THEN
tagbits := FetchAddress(q - SZL); (* Load the tag for the record at q *) tagbits := FetchAddress(q - SZA); (* Load the tag for the record at q *)
IF ~ODD(tagbits) THEN (* If it has not already been marked *) IF ~ODD(tagbits) THEN (* If it has not already been marked *)
SYSTEM.PUT(q - SZL, tagbits + 1); (* Mark it *) SYSTEM.PUT(q - SZA, tagbits + 1); (* Mark it *)
p := 0; p := 0;
tag := tagbits + SZL; (* Tag addresses first offset *) tag := tagbits + SZA; (* Tag addresses first offset *)
LOOP LOOP
SYSTEM.GET(tag, offset); (* Get next ptr field offset *) SYSTEM.GET(tag, offset); (* Get next ptr field offset *)
IF offset < 0 THEN (* If sentinel. (Value is -8*(#fields+1) *) IF SYSTEM.BIT(SYSTEM.ADR(offset), SIZE(SYSTEM.UINTPTR)*8 - 1) THEN
SYSTEM.PUT(q - SZL, tag + offset + 1); (* Rotate base ptr into tag *) (* Sentinel reached: Value is -8*(#fields+1) *)
SYSTEM.PUT(q - SZA, tag + offset + 1); (* Rotate base ptr into tag *)
IF p = 0 THEN EXIT END ; IF p = 0 THEN EXIT END ;
n := q; q := p; n := q; q := p;
tag := FetchAddress(q - SZL); DEC(tag, 1); tag := FetchAddress(q - SZA); DEC(tag, 1);
SYSTEM.GET(tag, offset); fld := q + offset; SYSTEM.GET(tag, offset); fld := q + offset;
p := FetchAddress(fld); SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, n)) p := FetchAddress(fld); SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, n))
ELSE (* offset references a ptr field *) ELSE (* offset references a ptr field *)
fld := q + offset; (* Address the pointer *) fld := q + offset; (* Address the pointer *)
n := FetchAddress(fld); (* Load the pointer *) n := FetchAddress(fld); (* Load the pointer *)
IF n # 0 THEN (* If pointer is not NIL *) IF n # 0 THEN (* If pointer is not NIL *)
tagbits := FetchAddress(n - SZL); (* Consider record pointed to by this field *) tagbits := FetchAddress(n - SZA); (* Consider record pointed to by this field *)
IF ~ODD(tagbits) THEN IF ~ODD(tagbits) THEN
SYSTEM.PUT(n - SZL, tagbits + 1); SYSTEM.PUT(n - SZA, tagbits + 1);
SYSTEM.PUT(q - SZL, tag + 1); SYSTEM.PUT(q - SZA, tag + 1);
SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, p)); SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, p));
p := q; q := n; p := q; q := n;
tag := tagbits tag := tagbits
END END
END END
END ; END ;
INC(tag, SZL) INC(tag, SZA)
END END
END END
END END
@ -365,7 +366,7 @@ MODULE Heap;
PROCEDURE MarkP(p: SYSTEM.PTR); (* for compatibility with EnumPtrs in ANSI mode *) PROCEDURE MarkP(p: SYSTEM.PTR); (* for compatibility with EnumPtrs in ANSI mode *)
BEGIN BEGIN
Mark(SYSTEM.VAL(LONGINT, p)) Mark(SYSTEM.VAL(SYSTEM.UINTPTR, p))
END MarkP; END MarkP;
PROCEDURE Scan; PROCEDURE Scan;
@ -381,7 +382,7 @@ MODULE Heap;
IF ODD(tag) THEN (*marked*) IF ODD(tag) THEN (*marked*)
IF freesize > 0 THEN IF freesize > 0 THEN
start := adr - freesize; start := adr - freesize;
SYSTEM.PUT(start, start+SZL); SYSTEM.PUT(start, start+SZA);
SYSTEM.PUT(start+sizeOff, freesize); SYSTEM.PUT(start+sizeOff, freesize);
SYSTEM.PUT(start+sntlOff, NoPtrSntl); SYSTEM.PUT(start+sntlOff, NoPtrSntl);
i := freesize DIV Unit; freesize := 0; i := freesize DIV Unit; freesize := 0;
@ -402,7 +403,7 @@ MODULE Heap;
END ; END ;
IF freesize > 0 THEN (*collect last block*) IF freesize > 0 THEN (*collect last block*)
start := adr - freesize; start := adr - freesize;
SYSTEM.PUT(start, start+SZL); SYSTEM.PUT(start, start+SZA);
SYSTEM.PUT(start+sizeOff, freesize); SYSTEM.PUT(start+sizeOff, freesize);
SYSTEM.PUT(start+sntlOff, NoPtrSntl); SYSTEM.PUT(start+sntlOff, NoPtrSntl);
i := freesize DIV Unit; freesize := 0; i := freesize DIV Unit; freesize := 0;
@ -414,8 +415,8 @@ MODULE Heap;
END END
END Scan; END Scan;
PROCEDURE Sift (l, r: LONGINT; VAR a: ARRAY OF LONGINT); PROCEDURE Sift (l, r: SYSTEM.UINTPTR; VAR a: ARRAY OF SYSTEM.UINTPTR);
VAR i, j, x: LONGINT; VAR i, j, x: SYSTEM.UINTPTR;
BEGIN j := l; x := a[j]; BEGIN j := l; x := a[j];
LOOP i := j; j := 2*j + 1; LOOP i := j; j := 2*j + 1;
IF (j < r) & (a[j] < a[j+1]) THEN INC(j) END; IF (j < r) & (a[j] < a[j+1]) THEN INC(j) END;
@ -425,15 +426,15 @@ MODULE Heap;
a[i] := x a[i] := x
END Sift; END Sift;
PROCEDURE HeapSort (n: LONGINT; VAR a: ARRAY OF LONGINT); PROCEDURE HeapSort (n: SYSTEM.UINTPTR; VAR a: ARRAY OF SYSTEM.UINTPTR);
VAR l, r, x: LONGINT; VAR l, r, x: SYSTEM.UINTPTR;
BEGIN l := n DIV 2; r := n - 1; BEGIN l := n DIV 2; r := n - 1;
WHILE l > 0 DO DEC(l); Sift(l, r, a) END; WHILE l > 0 DO DEC(l); Sift(l, r, a) END;
WHILE r > 0 DO x := a[0]; a[0] := a[r]; a[r] := x; DEC(r); Sift(l, r, a) END WHILE r > 0 DO x := a[0]; a[0] := a[r]; a[r] := x; DEC(r); Sift(l, r, a) END
END HeapSort; END HeapSort;
PROCEDURE MarkCandidates(n: LONGINT; VAR cand: ARRAY OF LONGINT); PROCEDURE MarkCandidates(n: SYSTEM.UINTPTR; VAR cand: ARRAY OF SYSTEM.UINTPTR);
VAR chnk, adr, tag, next, lim, lim1, i, ptr, size: LONGINT; VAR chnk, adr, tag, next, lim, lim1, i, ptr, size: SYSTEM.UINTPTR;
BEGIN BEGIN
chnk := heap; i := 0; lim := cand[n-1]; chnk := heap; i := 0; lim := cand[n-1];
WHILE (chnk # 0 ) & (chnk < lim) DO WHILE (chnk # 0 ) & (chnk < lim) DO
@ -446,7 +447,7 @@ MODULE Heap;
size := FetchAddress(tag-1); INC(adr, size) size := FetchAddress(tag-1); INC(adr, size)
ELSE ELSE
size := FetchAddress(tag); size := FetchAddress(tag);
ptr := adr + SZL; ptr := adr + SZA;
WHILE cand[i] < ptr DO INC(i) END ; WHILE cand[i] < ptr DO INC(i) END ;
IF i = n THEN RETURN END ; IF i = n THEN RETURN END ;
next := adr + size; next := adr + size;
@ -459,11 +460,11 @@ MODULE Heap;
END MarkCandidates; END MarkCandidates;
PROCEDURE CheckFin; PROCEDURE CheckFin;
VAR n: FinNode; tag: LONGINT; VAR n: FinNode; tag: SYSTEM.UINTPTR;
BEGIN BEGIN
n := fin; n := fin;
WHILE n # NIL DO WHILE n # NIL DO
tag := FetchAddress(n.obj - SZL); tag := FetchAddress(n.obj - SZA);
IF ~ODD(tag) THEN n.marked := FALSE; Mark(n.obj) IF ~ODD(tag) THEN n.marked := FALSE; Mark(n.obj)
ELSE n.marked := TRUE ELSE n.marked := TRUE
END ; END ;
@ -495,14 +496,14 @@ MODULE Heap;
END END
END FINALL; END FINALL;
PROCEDURE -ExternMainStackFrame "extern LONGINT Platform_MainStackFrame;"; PROCEDURE -ExternMainStackFrame "extern uintptr Platform_MainStackFrame;";
PROCEDURE -PlatformMainStackFrame(): LONGINT "Platform_MainStackFrame"; PROCEDURE -PlatformMainStackFrame(): SYSTEM.UINTPTR "Platform_MainStackFrame";
PROCEDURE MarkStack(n: LONGINT; VAR cand: ARRAY OF LONGINT); PROCEDURE MarkStack(n: SYSTEM.UINTPTR; VAR cand: ARRAY OF SYSTEM.UINTPTR);
VAR VAR
frame: SYSTEM.PTR; frame: SYSTEM.PTR;
inc, nofcand: LONGINT; inc, nofcand: SYSTEM.UINTPTR;
sp, p, stack0: LONGINT; sp, p, stack0: SYSTEM.UINTPTR;
align: RECORD ch: CHAR; p: SYSTEM.PTR END ; align: RECORD ch: CHAR; p: SYSTEM.PTR END ;
BEGIN BEGIN
IF n > 0 THEN MarkStack(n-1, cand); (* flush register windows by means of recursive calls *) IF n > 0 THEN MarkStack(n-1, cand); (* flush register windows by means of recursive calls *)
@ -529,8 +530,8 @@ MODULE Heap;
PROCEDURE GC*(markStack: BOOLEAN); PROCEDURE GC*(markStack: BOOLEAN);
VAR VAR
m: Module; m: Module;
i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23: LONGINT; i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23: SYSTEM.UINTPTR;
cand: ARRAY 10000 OF LONGINT; cand: ARRAY 10000 OF SYSTEM.UINTPTR;
BEGIN BEGIN
IF (lockdepth = 0) OR (lockdepth = 1) & ~markStack THEN IF (lockdepth = 0) OR (lockdepth = 1) & ~markStack THEN
Lock(); Lock();
@ -565,7 +566,7 @@ MODULE Heap;
PROCEDURE RegisterFinalizer*(obj: SYSTEM.PTR; finalize: Finalizer); PROCEDURE RegisterFinalizer*(obj: SYSTEM.PTR; finalize: Finalizer);
VAR f: FinNode; VAR f: FinNode;
BEGIN NEW(f); BEGIN NEW(f);
f.obj := SYSTEM.VAL(LONGINT, obj); f.finalize := finalize; f.marked := TRUE; f.obj := SYSTEM.VAL(SYSTEM.UINTPTR, obj); f.finalize := finalize; f.marked := TRUE;
f.next := fin; fin := f; f.next := fin; fin := f;
END RegisterFinalizer; END RegisterFinalizer;