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

4
tests/galloc.🗿
View File

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

2
tests/realloc.🗿
View File

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