From 8e9d0b5e9a4613e9ef980b5c0fd8e53f2c394195 Mon Sep 17 00:00:00 2001 From: A404M Date: Tue, 8 Oct 2024 19:58:00 +0330 Subject: fixed some bugs in fasm --- project | 29 ++++- src/fasm/lexer/lexer.c | 7 +- src/fasm/linker/linker.c | 2 +- src/fasm/runner/runner.c | 322 ++++++++++++++++++++++++----------------------- src/main.c | 20 ++- src/utils/types.h | 13 ++ 6 files changed, 227 insertions(+), 166 deletions(-) diff --git a/project b/project index 6ceac89..352f57a 100755 --- a/project +++ b/project @@ -10,7 +10,7 @@ function compile(){ fi fi - gcc -Wall -Wextra -std=gnu23 -I./src/ -g \ + gcc -Wall -Wextra -std=gnu23 -I./src/ -O3 \ ./src/main.c \ ./src/compiler/source_code/source_code.c \ ./src/compiler/error_helper/error_helper.c \ @@ -46,6 +46,10 @@ function clean(){ if [ "$(ls ./test/generated_output/)" ]; then rm -r ./test/generated_output/* fi + + if [ "$(ls ./test/fasm/generated_output/)" ]; then + rm -r ./test/fasm/generated_output/* + fi } function test(){ @@ -71,6 +75,29 @@ function test(){ done } +function fasm_test(){ + clean && compile + if [ $? -ne 0 ]; then + echo "compile error" + exit + fi + local RED='\033[0;31m' + local GREEN='\033[0;32m' + local NC='\033[0m' + + for file_path in ./test/fasm/input/*; do + local file_name=$(basename "$file_path") + local start=`date +%s.%N` + local ret=$(eval "./build/$project_name run-fasm $file_path > ./test/fasm/generated_output/$file_name") + local end=`date +%s.%N` + runtime="$(jq -n $end-$start)" + $ret && \ + cmp --silent "./test/fasm/generated_output/$file_name" "./test/fasm/output/$file_name" && \ + printf "${GREEN}PASSED${NC} %.9fs $file_path\n" $runtime || \ + printf "${RED}FAILED${NC} %.9fs $file_path\n" $runtime + done +} + function val_test(){ clean && compile if [ $? -ne 0 ]; then diff --git a/src/fasm/lexer/lexer.c b/src/fasm/lexer/lexer.c index e3e9610..5a9e38e 100644 --- a/src/fasm/lexer/lexer.c +++ b/src/fasm/lexer/lexer.c @@ -316,12 +316,15 @@ FasmLines fasmLexerCode(Code *code, SourceCode *sourceCode) { } else { UNEXPECTED: fasmLinePrint(line); - printError("Unexpected character", sourceCode, iter, iter + 1); + printError("Unexpected character '%c'", sourceCode, iter, iter + 1, + *iter); goto RETURN_ERROR; } break; case FASM_LINE_LOOKING_FOR_INSTRUCTION: - if (fasmLexerIsWord(c)) { + if (fasmLexerIsLineSeparator(c)) { + continue; + } else if (fasmLexerIsWord(c)) { char *begin = iter; char *end = iter = fasmLexerGetNextWord(iter); line.end = end; diff --git a/src/fasm/linker/linker.c b/src/fasm/linker/linker.c index faa3cd8..fe58065 100644 --- a/src/fasm/linker/linker.c +++ b/src/fasm/linker/linker.c @@ -10,7 +10,7 @@ #include void fasmVariablePrint(FasmVariable variable) { - printf(" {name='%.*s',value=0x%ld}\n", (int)(variable.end - variable.begin), + printf(" {name='%.*s',value=0x%lx}\n", (int)(variable.end - variable.begin), variable.begin, variable.value); } diff --git a/src/fasm/runner/runner.c b/src/fasm/runner/runner.c index c01db18..ac7b768 100644 --- a/src/fasm/runner/runner.c +++ b/src/fasm/runner/runner.c @@ -11,8 +11,7 @@ #define PUSHN(bits) \ pushToStack##bits##Bits(&stack, &stack_size, &stack_filled, \ - getNext##bits##Bits(&ip)); \ - ip += bits / 8 + getNext##bits##Bits(&ip)) #define LOADN(bits) \ pushToStack##bits##Bits(&stack, &stack_size, &stack_filled, \ @@ -49,11 +48,11 @@ #define OPERATION(type, bits, op) \ { \ - const type a = \ + const uint##bits##_t a = \ popFromStack##bits##Bits(&stack, &stack_size, &stack_filled); \ - const type b = \ + const uint##bits##_t b = \ popFromStack##bits##Bits(&stack, &stack_size, &stack_filled); \ - const type result = a op b; \ + const type result = *((type *)&a)op * ((type *)&b); \ pushToStack##bits##Bits(&stack, &stack_size, &stack_filled, \ *(uint##bits##_t *)&result); \ } @@ -101,6 +100,9 @@ int fasmRunner(ByteCode bytecode) { size_t data_size = bytecode.data_size; memcpy(data, bytecode.data, data_size); + uint8_t *code = bytecode.code; + /*size_t code_size = bytecode.code_size;*/ + size_t stack_size = 0; size_t stack_filled = 0; uint8_t *stack = a404m_malloc(stack_size); @@ -109,413 +111,413 @@ int fasmRunner(ByteCode bytecode) { size_t functions_index = -1; FasmFunction *functions = a404m_malloc(functions_size * sizeof(*functions)); - uint8_t *ip = bytecode.code; + uint8_t *ip = code; while (true) { const FasmToken instruction = *ip; ++ip; switch (instruction) { case FASM_TOKEN_NOOP: - break; + continue; case FASM_TOKEN_PUSH8: PUSHN(8); - break; + continue; case FASM_TOKEN_PUSH16: PUSHN(16); - break; + continue; case FASM_TOKEN_PUSH32: PUSHN(32); - break; + continue; case FASM_TOKEN_PUSH64: PUSHN(64); - break; + continue; case FASM_TOKEN_LOAD8: LOADN(8); - break; + continue; case FASM_TOKEN_LOAD16: LOADN(16); - break; + continue; case FASM_TOKEN_LOAD32: LOADN(32); - break; + continue; case FASM_TOKEN_LOAD64: LOADN(64); - break; + continue; case FASM_TOKEN_POP8: POPN(8); - break; + continue; case FASM_TOKEN_POP16: POPN(16); - break; + continue; case FASM_TOKEN_POP32: POPN(32); - break; + continue; case FASM_TOKEN_POP64: POPN(64); - break; + continue; case FASM_TOKEN_DUP8: DUPN(8); - break; + continue; case FASM_TOKEN_DUP16: DUPN(16); - break; + continue; case FASM_TOKEN_DUP32: DUPN(32); - break; + continue; case FASM_TOKEN_DUP64: DUPN(64); - break; + continue; case FASM_TOKEN_SWAP8: SWAPN(8); - break; + continue; case FASM_TOKEN_SWAP16: SWAPN(16); - break; + continue; case FASM_TOKEN_SWAP32: SWAPN(32); - break; + continue; case FASM_TOKEN_SWAP64: SWAPN(64); - break; + continue; case FASM_TOKEN_DROP8: DROPN(8); - break; + continue; case FASM_TOKEN_DROP16: DROPN(16); - break; + continue; case FASM_TOKEN_DROP32: DROPN(32); - break; + continue; case FASM_TOKEN_DROP64: DROPN(64); - break; + continue; case FASM_TOKEN_ADD_I8: ADD(uint8_t, 8); - break; + continue; case FASM_TOKEN_ADD_I16: ADD(uint16_t, 16); - break; + continue; case FASM_TOKEN_ADD_I32: ADD(uint32_t, 32); - break; + continue; case FASM_TOKEN_ADD_I64: ADD(uint64_t, 64); - break; + continue; case FASM_TOKEN_ADD_F32: ADD(float, 32); - break; + continue; case FASM_TOKEN_ADD_F64: ADD(double, 64); - break; + continue; case FASM_TOKEN_SUB_I8: SUB(uint8_t, 8); - break; + continue; case FASM_TOKEN_SUB_I16: SUB(uint16_t, 16); - break; + continue; case FASM_TOKEN_SUB_I32: SUB(uint32_t, 32); - break; + continue; case FASM_TOKEN_SUB_I64: SUB(uint64_t, 64); - break; + continue; case FASM_TOKEN_SUB_F32: SUB(float, 32); - break; + continue; case FASM_TOKEN_SUB_F64: SUB(double, 64); - break; + continue; case FASM_TOKEN_NEG_I8: NEG(int8_t, 8); - break; + continue; case FASM_TOKEN_NEG_I16: NEG(int16_t, 16); - break; + continue; case FASM_TOKEN_NEG_I32: NEG(int32_t, 32); - break; + continue; case FASM_TOKEN_NEG_I64: NEG(int64_t, 64); - break; + continue; case FASM_TOKEN_NEG_F32: NEG(float, 32); - break; + continue; case FASM_TOKEN_NEG_F64: NEG(double, 64); - break; + continue; case FASM_TOKEN_MUL_I8: MUL(int8_t, 8); - break; + continue; case FASM_TOKEN_MUL_I16: MUL(int16_t, 16); - break; + continue; case FASM_TOKEN_MUL_I32: MUL(int32_t, 32); - break; + continue; case FASM_TOKEN_MUL_I64: MUL(int64_t, 64); - break; + continue; case FASM_TOKEN_MUL_U8: MUL(uint8_t, 8); - break; + continue; case FASM_TOKEN_MUL_U16: MUL(uint16_t, 16); - break; + continue; case FASM_TOKEN_MUL_U32: MUL(uint32_t, 32); - break; + continue; case FASM_TOKEN_MUL_U64: MUL(uint64_t, 64); - break; + continue; case FASM_TOKEN_MUL_F32: MUL(float, 32); - break; + continue; case FASM_TOKEN_MUL_F64: MUL(double, 64); - break; + continue; case FASM_TOKEN_DIV_I8: DIV(int8_t, 8); - break; + continue; case FASM_TOKEN_DIV_I16: DIV(int16_t, 16); - break; + continue; case FASM_TOKEN_DIV_I32: DIV(int32_t, 32); - break; + continue; case FASM_TOKEN_DIV_I64: DIV(int64_t, 64); - break; + continue; case FASM_TOKEN_DIV_U8: DIV(uint8_t, 8); - break; + continue; case FASM_TOKEN_DIV_U16: DIV(uint16_t, 16); - break; + continue; case FASM_TOKEN_DIV_U32: DIV(uint32_t, 32); - break; + continue; case FASM_TOKEN_DIV_U64: DIV(uint64_t, 64); - break; + continue; case FASM_TOKEN_DIV_F32: DIV(float, 32); - break; + continue; case FASM_TOKEN_DIV_F64: DIV(double, 64); - break; + continue; case FASM_TOKEN_REM_I8: REM(int8_t, 8); - break; + continue; case FASM_TOKEN_REM_I16: REM(int16_t, 16); - break; + continue; case FASM_TOKEN_REM_I32: REM(int32_t, 32); - break; + continue; case FASM_TOKEN_REM_I64: REM(int64_t, 64); - break; + continue; case FASM_TOKEN_REM_U8: REM(uint8_t, 8); - break; + continue; case FASM_TOKEN_REM_U16: REM(uint16_t, 16); - break; + continue; case FASM_TOKEN_REM_U32: REM(uint32_t, 32); - break; + continue; case FASM_TOKEN_REM_U64: REM(uint64_t, 64); - break; + continue; case FASM_TOKEN_CAST_I8_I64: CAST(int8_t, 8, int64_t, 64); - break; + continue; case FASM_TOKEN_CAST_I16_I64: CAST(int16_t, 16, int64_t, 64); - break; + continue; case FASM_TOKEN_CAST_I32_I64: CAST(int32_t, 32, int64_t, 64); - break; + continue; case FASM_TOKEN_CAST_I64_I8: CAST(int64_t, 64, int8_t, 8); - break; + continue; case FASM_TOKEN_CAST_I64_I16: CAST(int64_t, 64, int16_t, 16); - break; + continue; case FASM_TOKEN_CAST_I64_I32: CAST(int64_t, 64, int32_t, 32); - break; + continue; case FASM_TOKEN_CAST_F64_I64: CAST(double, 64, int64_t, 64); - break; + continue; case FASM_TOKEN_CAST_I64_F64: CAST(int64_t, 64, double, 64); - break; + continue; case FASM_TOKEN_CAST_U8_U64: CAST(uint8_t, 8, uint64_t, 64); - break; + continue; case FASM_TOKEN_CAST_U16_U64: CAST(uint16_t, 16, uint64_t, 64); - break; + continue; case FASM_TOKEN_CAST_U32_U64: CAST(uint32_t, 32, uint64_t, 64); - break; + continue; case FASM_TOKEN_CAST_U64_U8: CAST(uint64_t, 64, uint8_t, 8); - break; + continue; case FASM_TOKEN_CAST_U64_U16: CAST(uint64_t, 64, uint16_t, 16); - break; + continue; case FASM_TOKEN_CAST_U64_U32: CAST(uint64_t, 64, uint32_t, 32); - break; + continue; case FASM_TOKEN_CAST_F64_U64: CAST(double, 64, uint64_t, 64); - break; + continue; case FASM_TOKEN_CAST_U64_F64: CAST(uint64_t, 64, double, 64); - break; + continue; case FASM_TOKEN_CAST_F32_F64: CAST(float, 32, double, 64); - break; + continue; case FASM_TOKEN_CAST_F64_F32: CAST(double, 64, float, 32); - break; + continue; case FASM_TOKEN_JUMP: ip = (uint8_t *)popFromStack64Bits(&stack, &stack_size, &stack_filled); - break; + continue; case FASM_TOKEN_JZ_I8: COND_JUMP(int8_t, 8, ==); - break; + continue; case FASM_TOKEN_JNZ_I8: COND_JUMP(int8_t, 8, !=); - break; + continue; case FASM_TOKEN_JN_I8: COND_JUMP(int8_t, 8, <); - break; + continue; case FASM_TOKEN_JNN_I8: COND_JUMP(int8_t, 8, >=); - break; + continue; case FASM_TOKEN_JP_I8: COND_JUMP(int8_t, 8, >); - break; + continue; case FASM_TOKEN_JNP_I8: COND_JUMP(int8_t, 8, <=); - break; + continue; case FASM_TOKEN_JZ_I16: COND_JUMP(int16_t, 16, ==); - break; + continue; case FASM_TOKEN_JNZ_I16: COND_JUMP(int16_t, 16, !=); - break; + continue; case FASM_TOKEN_JN_I16: COND_JUMP(int16_t, 16, <); - break; + continue; case FASM_TOKEN_JNN_I16: COND_JUMP(int16_t, 16, >=); - break; + continue; case FASM_TOKEN_JP_I16: COND_JUMP(int16_t, 16, >); - break; + continue; case FASM_TOKEN_JNP_I16: COND_JUMP(int16_t, 16, <=); - break; + continue; case FASM_TOKEN_JZ_I32: COND_JUMP(int32_t, 32, ==); - break; + continue; case FASM_TOKEN_JNZ_I32: COND_JUMP(int32_t, 32, !=); - break; + continue; case FASM_TOKEN_JN_I32: COND_JUMP(int32_t, 32, <); - break; + continue; case FASM_TOKEN_JNN_I32: COND_JUMP(int32_t, 32, >=); - break; + continue; case FASM_TOKEN_JP_I32: COND_JUMP(int32_t, 32, >); - break; + continue; case FASM_TOKEN_JNP_I32: COND_JUMP(int32_t, 32, <=); - break; + continue; case FASM_TOKEN_JZ_I64: COND_JUMP(int64_t, 64, ==); - break; + continue; case FASM_TOKEN_JNZ_I64: COND_JUMP(int64_t, 64, !=); - break; + continue; case FASM_TOKEN_JN_I64: COND_JUMP(int64_t, 64, <); - break; + continue; case FASM_TOKEN_JNN_I64: COND_JUMP(int64_t, 64, >=); - break; + continue; case FASM_TOKEN_JP_I64: COND_JUMP(int64_t, 64, >); - break; + continue; case FASM_TOKEN_JNP_I64: COND_JUMP(int64_t, 64, <=); - break; + continue; case FASM_TOKEN_JZ_F32: COND_JUMP(float, 32, ==); - break; + continue; case FASM_TOKEN_JNZ_F32: COND_JUMP(float, 32, !=); - break; + continue; case FASM_TOKEN_JN_F32: COND_JUMP(float, 32, <); - break; + continue; case FASM_TOKEN_JNN_F32: COND_JUMP(float, 32, >=); - break; + continue; case FASM_TOKEN_JP_F32: COND_JUMP(float, 32, >); - break; + continue; case FASM_TOKEN_JNP_F32: COND_JUMP(float, 32, <=); - break; + continue; case FASM_TOKEN_JZ_F64: COND_JUMP(double, 64, ==); - break; + continue; case FASM_TOKEN_JNZ_F64: COND_JUMP(double, 64, !=); - break; + continue; case FASM_TOKEN_JN_F64: COND_JUMP(double, 64, <); - break; + continue; case FASM_TOKEN_JNN_F64: COND_JUMP(double, 64, >=); - break; + continue; case FASM_TOKEN_JP_F64: COND_JUMP(double, 64, >); - break; + continue; case FASM_TOKEN_JNP_F64: COND_JUMP(double, 64, <=); - break; + continue; case FASM_TOKEN_ALLOC_HEAP: pushToStack64Bits(&stack, &stack_size, &stack_filled, (uint64_t)a404m_malloc(popFromStack64Bits( &stack, &stack_size, &stack_filled))); - break; + continue; case FASM_TOKEN_ALLOC_STACK: functions[functions_index].stack_size = popFromStack64Bits(&stack, &stack_size, &stack_filled); functions[functions_index].stack = a404m_malloc(functions[functions_index].stack_size); - break; + continue; case FASM_TOKEN_FREE_HEAP: free((void *)popFromStack64Bits(&stack, &stack_size, &stack_filled)); - break; + continue; case FASM_TOKEN_GET_STACK_ADDRESS: pushToStack64Bits(&stack, &stack_size, &stack_filled, (uint64_t)functions[functions_index].stack); - break; + continue; case FASM_TOKEN_GET_GLOBAL_ADDRESS: pushToStack64Bits(&stack, &stack_size, &stack_filled, (uint64_t)data); - break; + continue; case FASM_TOKEN_CALL: { uint8_t *const newIp = - (uint8_t *)popFromStack64Bits(&stack, &stack_size, &stack_filled); + code + popFromStack64Bits(&stack, &stack_size, &stack_filled); ++functions_index; if (functions_index == functions_size) { functions_size += functions_size / 2 + 1; @@ -529,7 +531,8 @@ int fasmRunner(ByteCode bytecode) { }; functions[functions_index] = function; ip = newIp; - } break; + } + continue; case FASM_TOKEN_RET: { FasmFunction function = functions[functions_index]; free(function.stack); @@ -540,10 +543,12 @@ int fasmRunner(ByteCode bytecode) { functions = a404m_realloc(functions, functions_size * sizeof(*functions)); } - } break; + } + continue; case FASM_TOKEN_SYSCALL: { - switch ((FasmSyscall)popFromStack8Bits(&stack, &stack_size, - &stack_filled)) { + FasmSyscall syscallId = + popFromStack8Bits(&stack, &stack_size, &stack_filled); + switch (syscallId) { case FASM_SYSCALL_READ: { uint32_t fd = popFromStack32Bits(&stack, &stack_size, &stack_filled); @@ -552,7 +557,8 @@ int fasmRunner(ByteCode bytecode) { uint64_t count = popFromStack64Bits(&stack, &stack_size, &stack_filled); syscall(SYS_read, fd, buf, count); - } break; + } + continue; case FASM_SYSCALL_WRITE: { uint32_t fd = popFromStack32Bits(&stack, &stack_size, &stack_filled); @@ -561,7 +567,8 @@ int fasmRunner(ByteCode bytecode) { uint64_t count = popFromStack64Bits(&stack, &stack_size, &stack_filled); syscall(SYS_write, fd, buf, count); - } break; + } + continue; case FASM_SYSCALL_OPEN: { int8_t *filename = (int8_t *)popFromStack64Bits(&stack, &stack_size, &stack_filled); @@ -570,14 +577,16 @@ int fasmRunner(ByteCode bytecode) { uint32_t mode = popFromStack32Bits(&stack, &stack_size, &stack_filled); syscall(SYS_open, filename, flags, mode); - } break; + } + continue; case FASM_SYSCALL_CLOSE: { uint32_t fd = popFromStack32Bits(&stack, &stack_size, &stack_filled); syscall(SYS_close, fd); - } break; + } + continue; case FASM_SYSCALL_EXIT: - for (size_t i = functions_index; i != (size_t)-1; ++i) { + for (size_t i = functions_index; i != (size_t)-1; --i) { free(functions[i].stack); } const uint32_t status = @@ -587,24 +596,25 @@ int fasmRunner(ByteCode bytecode) { free(data); return status; } - } break; + fprintf(stderr, "Bad system call %d", syscallId); + exit(1); + } case FASM_TOKEN_DEFINE_BYTE: case FASM_TOKEN_DEFINE_WORD: case FASM_TOKEN_DEFINE_DWORD: case FASM_TOKEN_DEFINE_QWORD: case FASM_TOKEN_NONE: - default: - fprintf(stderr, "Bad fasm instruction %d", instruction); - exit(1); } + fprintf(stderr, "Bad fasm instruction %d", instruction); + exit(1); } } -#define getNextNBits(bits) \ - uint##bits##_t getNext##bits##Bits(uint8_t **pos) { \ - uint##bits##_t *p = *((uint##bits##_t **)pos); \ - pos += sizeof(*p); \ - return *p; \ +#define getNextNBits(bits) \ + uint##bits##_t getNext##bits##Bits(uint8_t **pos) { \ + uint##bits##_t value = *((uint##bits##_t *)(*pos)); \ + *pos += sizeof(value); \ + return value; \ } getNextNBits(8); diff --git a/src/main.c b/src/main.c index 8f9b095..fec258d 100644 --- a/src/main.c +++ b/src/main.c @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -56,17 +57,17 @@ int compileFasm(const char *const filePath) { } pushToSourceCode(&sourceCode, code); - printf("----lexing:\n"); + // printf("----lexing:\n"); FasmLines *lines; if ((lines = fasmLexer(&sourceCode)) == NULL) { goto RETURN_ERROR; } - for (size_t i = 0; i < sourceCode.size; ++i) { - fasmLinesPrint(lines[i]); - } + // for (size_t i = 0; i < sourceCode.size; ++i) { + // fasmLinesPrint(lines[i]); + // } - printf("----linking:\n"); + // printf("----linking:\n"); FasmLinkedLines linkedLines = fasmLinker(lines, &sourceCode); @@ -74,10 +75,17 @@ int compileFasm(const char *const filePath) { goto RETURN_LINKED_ERROR; } - fasmLinkedLinesPrint(linkedLines); + // fasmLinkedLinesPrint(linkedLines); + + // printf("----bytecode:\n"); ByteCode bytecode = fasmCodeGenerator(&linkedLines); + // for (size_t i = 0; i < bytecode.code_size; ++i) { + // printf("0x%.2x ", bytecode.code[i]); + //} + // printf("\n"); + deleteByteCodeInners(bytecode); fasmLinkedLinesDeleteInner(linkedLines); diff --git a/src/utils/types.h b/src/utils/types.h index b75d64d..4994014 100644 --- a/src/utils/types.h +++ b/src/utils/types.h @@ -14,4 +14,17 @@ typedef struct SizedString { size_t size; } SizedString; +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +typedef int8_t i8; +typedef int16_t i16; +typedef int32_t i32; +typedef int64_t i64; + +typedef float f32; +typedef double f64; + #define ERROR_SIZE INT64_MAX -- cgit v1.2.3