diff --git a/src/data/registers.c b/src/data/registers.c new file mode 100644 index 0000000..075c1ed --- /dev/null +++ b/src/data/registers.c @@ -0,0 +1,92 @@ +#include "registers.h" + +register_data_t *const registers[] = { + // Instruction pointer + &(register_data_t){"rip", REG_RIP, OPERAND_SIZE_64}, + &(register_data_t){"eip", REG_RIP, OPERAND_SIZE_32}, + &(register_data_t){"ip", REG_RIP, OPERAND_SIZE_16}, + + // 64-bit general purpose registers + &(register_data_t){"rax", REG_A, OPERAND_SIZE_64}, + &(register_data_t){"rcx", REG_C, OPERAND_SIZE_64}, + &(register_data_t){"rdx", REG_D, OPERAND_SIZE_64}, + &(register_data_t){"rbx", REG_B, OPERAND_SIZE_64}, + &(register_data_t){"rsp", REG_SP, OPERAND_SIZE_64}, + &(register_data_t){"rbp", REG_BP, OPERAND_SIZE_64}, + &(register_data_t){"rsi", REG_SI, OPERAND_SIZE_64}, + &(register_data_t){"rdi", REG_DI, OPERAND_SIZE_64}, + &(register_data_t){"r8", REG_8, OPERAND_SIZE_64}, + &(register_data_t){"r9", REG_9, OPERAND_SIZE_64}, + &(register_data_t){"r10", REG_10, OPERAND_SIZE_64}, + &(register_data_t){"r11", REG_11, OPERAND_SIZE_64}, + &(register_data_t){"r12", REG_12, OPERAND_SIZE_64}, + &(register_data_t){"r13", REG_13, OPERAND_SIZE_64}, + &(register_data_t){"r14", REG_14, OPERAND_SIZE_64}, + &(register_data_t){"r15", REG_15, OPERAND_SIZE_64}, + + // 32-bit general purpose registers + &(register_data_t){"eax", REG_A, OPERAND_SIZE_32}, + &(register_data_t){"ecx", REG_C, OPERAND_SIZE_32}, + &(register_data_t){"edx", REG_D, OPERAND_SIZE_32}, + &(register_data_t){"ebx", REG_B, OPERAND_SIZE_32}, + &(register_data_t){"esp", REG_SP, OPERAND_SIZE_32}, + &(register_data_t){"ebp", REG_BP, OPERAND_SIZE_32}, + &(register_data_t){"esi", REG_SI, OPERAND_SIZE_32}, + &(register_data_t){"edi", REG_DI, OPERAND_SIZE_32}, + &(register_data_t){"r8d", REG_8, OPERAND_SIZE_32}, + &(register_data_t){"r9d", REG_9, OPERAND_SIZE_32}, + &(register_data_t){"r10d", REG_10, OPERAND_SIZE_32}, + &(register_data_t){"r11d", REG_11, OPERAND_SIZE_32}, + &(register_data_t){"r12d", REG_12, OPERAND_SIZE_32}, + &(register_data_t){"r13d", REG_13, OPERAND_SIZE_32}, + &(register_data_t){"r14d", REG_14, OPERAND_SIZE_32}, + &(register_data_t){"r15d", REG_15, OPERAND_SIZE_32}, + + // 16-bit general purpose registers + &(register_data_t){"ax", REG_A, OPERAND_SIZE_16}, + &(register_data_t){"cx", REG_C, OPERAND_SIZE_16}, + &(register_data_t){"dx", REG_D, OPERAND_SIZE_16}, + &(register_data_t){"bx", REG_B, OPERAND_SIZE_16}, + &(register_data_t){"sp", REG_SP, OPERAND_SIZE_16}, + &(register_data_t){"bp", REG_BP, OPERAND_SIZE_16}, + &(register_data_t){"si", REG_SI, OPERAND_SIZE_16}, + &(register_data_t){"di", REG_DI, OPERAND_SIZE_16}, + &(register_data_t){"r8w", REG_8, OPERAND_SIZE_16}, + &(register_data_t){"r9w", REG_9, OPERAND_SIZE_16}, + &(register_data_t){"r10w", REG_10, OPERAND_SIZE_16}, + &(register_data_t){"r11w", REG_11, OPERAND_SIZE_16}, + &(register_data_t){"r12w", REG_12, OPERAND_SIZE_16}, + &(register_data_t){"r13w", REG_13, OPERAND_SIZE_16}, + &(register_data_t){"r14w", REG_14, OPERAND_SIZE_16}, + &(register_data_t){"r15w", REG_15, OPERAND_SIZE_16}, + + // 8-bit general purpose registers (low byte) + &(register_data_t){"al", REG_A, OPERAND_SIZE_8 }, + &(register_data_t){"cl", REG_C, OPERAND_SIZE_8 }, + &(register_data_t){"dl", REG_D, OPERAND_SIZE_8 }, + &(register_data_t){"bl", REG_B, OPERAND_SIZE_8 }, + &(register_data_t){"spl", REG_SP, OPERAND_SIZE_8 }, + &(register_data_t){"bpl", REG_BP, OPERAND_SIZE_8 }, + &(register_data_t){"sil", REG_SI, OPERAND_SIZE_8 }, + &(register_data_t){"dil", REG_DI, OPERAND_SIZE_8 }, + &(register_data_t){"r8b", REG_8, OPERAND_SIZE_8 }, + &(register_data_t){"r9b", REG_9, OPERAND_SIZE_8 }, + &(register_data_t){"r10b", REG_10, OPERAND_SIZE_8 }, + &(register_data_t){"r11b", REG_11, OPERAND_SIZE_8 }, + &(register_data_t){"r12b", REG_12, OPERAND_SIZE_8 }, + &(register_data_t){"r13b", REG_13, OPERAND_SIZE_8 }, + &(register_data_t){"r14b", REG_14, OPERAND_SIZE_8 }, + &(register_data_t){"r15b", REG_15, OPERAND_SIZE_8 }, + + // x87 floating point registers + &(register_data_t){"st0", REG_ST0, OPERAND_SIZE_80}, + &(register_data_t){"st1", REG_ST1, OPERAND_SIZE_80}, + &(register_data_t){"st2", REG_ST2, OPERAND_SIZE_80}, + &(register_data_t){"st3", REG_ST3, OPERAND_SIZE_80}, + &(register_data_t){"st4", REG_ST4, OPERAND_SIZE_80}, + &(register_data_t){"st5", REG_ST5, OPERAND_SIZE_80}, + &(register_data_t){"st6", REG_ST6, OPERAND_SIZE_80}, + &(register_data_t){"st7", REG_ST7, OPERAND_SIZE_80}, + + nullptr, +}; diff --git a/src/data/registers.h b/src/data/registers.h new file mode 100644 index 0000000..29bb90f --- /dev/null +++ b/src/data/registers.h @@ -0,0 +1,82 @@ +#ifndef INCLUDE_DATA_REGISTERS_H_ +#define INCLUDE_DATA_REGISTERS_H_ + +typedef enum operand_size { + OPERAND_SIZE_INVALID = 0, + + OPERAND_SIZE_8 = 1 << 0, + OPERAND_SIZE_16 = 1 << 1, + OPERAND_SIZE_32 = 1 << 2, + OPERAND_SIZE_64 = 1 << 3, + + OPERAND_SIZE_80 = 1 << 4, + OPERAND_SIZE_128 = 1 << 5, + OPERAND_SIZE_256 = 1 << 6, + OPERAND_SIZE_512 = 1 << 7, +} operand_size_t; + +static inline operand_size_t bits_to_operand_size(int bits) { + switch (bits) { + case 8: + return OPERAND_SIZE_8; + case 16: + return OPERAND_SIZE_16; + case 32: + return OPERAND_SIZE_32; + case 64: + return OPERAND_SIZE_64; + case 80: + return OPERAND_SIZE_80; + case 128: + return OPERAND_SIZE_128; + case 256: + return OPERAND_SIZE_256; + case 512: + return OPERAND_SIZE_512; + default: + return OPERAND_SIZE_INVALID; + } +} + +typedef enum register_id { + // Special registers + REG_RIP = -1, + + // General purpose registers + REG_A = 0x0000, + REG_C, + REG_D, + REG_B, + REG_SP, + REG_BP, + REG_SI, + REG_DI, + + REG_8, + REG_9, + REG_10, + REG_11, + REG_12, + REG_13, + REG_14, + REG_15, + + REG_ST0 = 0x1000, + REG_ST1, + REG_ST2, + REG_ST3, + REG_ST4, + REG_ST5, + REG_ST6, + REG_ST7, +} register_id_t; + +typedef struct register_data { + const char *name; + register_id_t id; + operand_size_t size; +} register_data_t; + +extern register_data_t *const registers[]; + +#endif // INCLUDE_DATA_REGISTERS_H_ diff --git a/src/parser/primitives.c b/src/parser/primitives.c index a8acf56..166c89a 100644 --- a/src/parser/primitives.c +++ b/src/parser/primitives.c @@ -1,5 +1,6 @@ #include "primitives.h" #include "../ast.h" +#include "../data/registers.h" #include parse_result_t parse_identifier(tokenlist_entry_t *current) { @@ -71,23 +72,9 @@ parse_result_t parse_label_reference(tokenlist_entry_t *current) { nullptr); } -const char *registers[] = { - // 64-bit registers - "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10", - "r11", "r12", "r13", "r14", "r15", - // 32-bit registers - "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "r8d", "r9d", - "r10d", "r11d", "r12d", "r13d", "r14d", "r15d", - // 16-bit registers - "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", "r8w", "r9w", "r10w", - "r11w", "r12w", "r13w", "r14w", "r15w", - // 8-bit low registers - "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", "r8b", "r9b", "r10b", - "r11b", "r12b", "r13b", "r14b", "r15b", nullptr}; - bool is_register_token(lexer_token_t *token) { for (size_t i = 0; registers[i] != nullptr; ++i) - if (strcmp(token->value, registers[i]) == 0) + if (strcmp(token->value, registers[i]->name) == 0) return true; return false; }