kdx/IronGOLEM
1
0
Fork 0
forked from starnakin/IronGOLEM
Code Pull Requests Activity

rename LOCATION to GALLOC

Browse Source
This commit is contained in:
starnakin 2023-07-26 19:35:27 +02:00
parent f05f3945fe
commit 21c78421a4
4 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
src/galloc.🗿
View File

@ -1,8 +1,8 @@
define HEAP_SIZE = 0x4000;
global heap[HEAP_SIZE] = 0;
define PADDING_SIZE = 4;
define HEADER_SIZE = 5;
define GALLOC_PADDING_SIZE = 4;
define GALLOC_HEADER_SIZE = 5;
🗿HEADER REPRESENTATION
🗿+-------------+--------+--------+-------------------------------+---------------------------+---------+---------+---------+
@ -26,26 +26,26 @@ define HEADER_SIZE = 5;
🗿 Is used to check invalid write
🗿 If a case doesn't equal to 0 it is an invalid write
enum LOCATION_INITIALISED, LOCATION_USED, LOCATION_SIZE, LOCATION_PREV, LOCATION_NEXT;
define LOCATION_DATA = HEADER_SIZE + PADDING_SIZE;
enum GALLOC_INITIALISED, GALLOC_USED, GALLOC_SIZE, GALLOC_PREV, GALLOC_NEXT;
define GALLOC_DATA = GALLOC_HEADER_SIZE + GALLOC_PADDING_SIZE;
galloc_setup_header(ptr, used, size, next_block, prev_block)
{
local i;
[ptr + LOCATION_INITIALISED] = 1;
[ptr + LOCATION_USED] = used;
[ptr + LOCATION_SIZE] = size;
[ptr + LOCATION_PREV] = prev_block;
[ptr + LOCATION_NEXT] = next_block;
[ptr + GALLOC_INITIALISED] = 1;
[ptr + GALLOC_USED] = used;
[ptr + GALLOC_SIZE] = size;
[ptr + GALLOC_PREV] = prev_block;
[ptr + GALLOC_NEXT] = next_block;
i = HEADER_SIZE;
i = GALLOC_HEADER_SIZE;
loop
{
if (i == HEADER_SIZE + PADDING_SIZE)
if (i == GALLOC_HEADER_SIZE + GALLOC_PADDING_SIZE)
break;
[ptr + i] = 0; 🗿 INITIALISE TOP PADDING
[ptr + i + PADDING_SIZE + size] = 0; 🗿 INITIALISE BOT PADDING
[ptr + i + GALLOC_HEADER_SIZE] = 0; 🗿 INITIALISE TOP PADDING
[ptr + i + GALLOC_PADDING_SIZE + size] = 0; 🗿 INITIALISE BOT PADDING
i++;
}
}
@ -57,10 +57,10 @@ galloc_find_next_space(size)
current = heap;
loop
{
if ([current + LOCATION_USED] == 0
& [current + LOCATION_SIZE] >= size)
if ([current + GALLOC_USED] == 0
& [current + GALLOC_SIZE] >= size)
return (current);
current = [current + LOCATION_NEXT];
current = [current + GALLOC_NEXT];
if (current == 0)
return (0);
}
@ -87,18 +87,18 @@ galloc_split_block(ptr, size)
local prev;
local old_size;
old_size = [ptr + LOCATION_SIZE];
if (size + HEADER_SIZE + PADDING_SIZE * 2 > old_size) 🗿 if the block is to small to be split
old_size = [ptr + GALLOC_SIZE];
if (size + GALLOC_HEADER_SIZE + GALLOC_PADDING_SIZE * 2 > old_size) 🗿 if the block is to small to be split
{
[ptr + LOCATION_USED] = 1;
[ptr + GALLOC_USED] = 1;
return (ptr);
}
old_next = [ptr + LOCATION_NEXT];
next = ptr + size + HEADER_SIZE + PADDING_SIZE * 2;
prev = [ptr + LOCATION_PREV];
old_next = [ptr + GALLOC_NEXT];
next = ptr + size + GALLOC_HEADER_SIZE + GALLOC_PADDING_SIZE * 2;
prev = [ptr + GALLOC_PREV];
🗿 galloc_setup_header(ptr, used, size, next_block, prev_block);
galloc_setup_header(ptr, 1, size, ptr + HEADER_SIZE + PADDING_SIZE * 2 + size, prev);
galloc_setup_header(next, 0, old_size - size - HEADER_SIZE - PADDING_SIZE * 2, old_next, ptr);
galloc_setup_header(ptr, 1, size, ptr + GALLOC_HEADER_SIZE + GALLOC_PADDING_SIZE * 2 + size, prev);
galloc_setup_header(next, 0, old_size - size - GALLOC_HEADER_SIZE - GALLOC_PADDING_SIZE * 2, old_next, ptr);
return (0);
}
@ -107,17 +107,17 @@ galloc(size)
local ptr;
if ([heap] == 0) 🗿 if the heap is not initialised
galloc_setup_header(heap, 0, HEAP_SIZE - HEADER_SIZE - PADDING_SIZE * 2, 0, 0); 🗿 initialised all the heap
galloc_setup_header(heap, 0, HEAP_SIZE - GALLOC_HEADER_SIZE - GALLOC_PADDING_SIZE * 2, 0, 0); 🗿 initialised all the heap
ptr = galloc_find_next_space(size);
if (ptr == 0)
return (0);
if ([ptr + LOCATION_SIZE] == size)
if ([ptr + GALLOC_SIZE] == size)
{
[ptr + LOCATION_USED] = 1;
return (ptr + LOCATION_DATA);
[ptr + GALLOC_USED] = 1;
return (ptr + GALLOC_DATA);
}
galloc_split_block(ptr, size);
return (ptr + LOCATION_DATA);
return (ptr + GALLOC_DATA);
}
galloc_merge_blocks(first_block, last_block)
@ -126,10 +126,10 @@ galloc_merge_blocks(first_block, last_block)
if (last_block == first_block)
{
galloc_setup_header(first_block, 0, [first_block + LOCATION_SIZE], [first_block + LOCATION_NEXT], [first_block + LOCATION_PREV]);
galloc_setup_header(first_block, 0, [first_block + GALLOC_SIZE], [first_block + GALLOC_NEXT], [first_block + GALLOC_PREV]);
}
size = last_block - first_block + [last_block + LOCATION_SIZE];
galloc_setup_header(first_block, 0, size, [last_block + LOCATION_NEXT], [first_block + LOCATION_PREV]);
size = last_block - first_block + [last_block + GALLOC_SIZE];
galloc_setup_header(first_block, 0, size, [last_block + GALLOC_NEXT], [first_block + GALLOC_PREV]);
}
free(ptr)
@ -145,14 +145,14 @@ free(ptr)
putstr("Error: free: invalid ptr\n");
return;
}
block = ptr - LOCATION_DATA;
prev_block = [block + LOCATION_PREV];
if (prev_block == 0 | [prev_block + LOCATION_USED])
block = ptr - GALLOC_DATA;
prev_block = [block + GALLOC_PREV];
if (prev_block == 0 | [prev_block + GALLOC_USED])
first_block = block;
else
first_block = prev_block;
next_block = [block + LOCATION_NEXT];
if (next_block == 0 | [next_block + LOCATION_USED])
next_block = [block + GALLOC_NEXT];
if (next_block == 0 | [next_block + GALLOC_USED])
last_block = block;
else
last_block = next_block;
@ -161,5 +161,5 @@ free(ptr)
leaks()
{
return ([heap + LOCATION_NEXT] != 0);
return ([heap + GALLOC_NEXT] != 0);
}

4
src/realloc.🗿
View File

@ -12,11 +12,11 @@ realloc(ptr, new_size)
}
if (ptr == NULL)
return new_space;
block_ptr = ptr - LOCATION_DATA;
block_ptr = ptr - GALLOC_DATA;
i = 0;
loop
{
if (i == new_size | i == [block_ptr + LOCATION_SIZE])
if (i == new_size | i == [block_ptr + GALLOC_SIZE])
break;
[new_space + i] = [ptr + i];
i++;

4
tests/galloc.🗿
View File

@ -7,11 +7,11 @@ main()
name = "galloc";
ptr1 = galloc(1);
test_num(ptr1, heap + LOCATION_DATA, "");
test_num(ptr1, heap + GALLOC_DATA, "");
free(ptr1);
ptr1 = galloc(1);
test_num(ptr1, heap + LOCATION_DATA, "alloc after free");
test_num(ptr1, heap + GALLOC_DATA, "alloc after free");
free(ptr1);
ptr2 = galloc(0x9000);

2
tests/realloc.🗿
View File

@ -12,7 +12,7 @@ main()
test_num(leaks(), 0, "standart: leaks");
ptr2 = realloc(NULL, 6);
test_num(heap + LOCATION_DATA, ptr2, "NULL: value");
test_num(heap + GALLOC_DATA, ptr2, "NULL: value");
free(ptr2);
test_num(leaks(), 0, "NULL: leaks");