From 111bd0c7cb4b446c4bfe192b1df82845de17c005 Mon Sep 17 00:00:00 2001 From: dec05eba Date: Mon, 7 Oct 2019 00:51:40 +0200 Subject: Rename ssa to ir --- src/bytecode/bytecode.c | 274 ++++++++++++++++++++++++------------------------ 1 file changed, 137 insertions(+), 137 deletions(-) (limited to 'src/bytecode') diff --git a/src/bytecode/bytecode.c b/src/bytecode/bytecode.c index 98698bc..af9251b 100644 --- a/src/bytecode/bytecode.c +++ b/src/bytecode/bytecode.c @@ -1,7 +1,7 @@ #include "../../include/bytecode/bytecode.h" #include "../../include/std/mem.h" #include "../../include/std/log.h" -#include "../../include/ssa/ssa.h" +#include "../../include/ir/ir.h" #include "../../include/parser.h" #include "../../include/ast.h" #include "../../include/compiler.h" @@ -60,7 +60,7 @@ CHECK_RESULT int buffer_append_header(Buffer *program_data) { return 0; } -static CHECK_RESULT usize ssa_extract_data(u8 *instruction_data, void *result, usize size) { +static CHECK_RESULT usize ir_extract_data(u8 *instruction_data, void *result, usize size) { am_memcpy(result, instruction_data, size); return size; } @@ -80,13 +80,13 @@ static void add_intermediates(BytecodeCompilerContext *self) { |u64 |Value|The type of the value depends on the value of @Type.| */ - Ssa *ssa = self->parser->ssa; + Ir *ir = self->parser->ir; Buffer *instructions = &self->bytecode->data; - SsaNumber *intermediate = buffer_begin(&ssa->intermediates); - SsaNumber *intermediates_end = buffer_end(&ssa->intermediates); + IrNumber *intermediate = buffer_begin(&ir->intermediates); + IrNumber *intermediates_end = buffer_end(&ir->intermediates); int i = 0; - u32 intemediates_size = (sizeof(u8) + sizeof(u64)) * buffer_get_size(&ssa->intermediates, SsaNumber); + u32 intemediates_size = (sizeof(u8) + sizeof(u64)) * buffer_get_size(&ir->intermediates, IrNumber); throw_if_error(buffer_expand(instructions, sizeof(u32) + intemediates_size)); throw_if_error(buffer_append(instructions, &intemediates_size, sizeof(u32))); for(; intermediate != intermediates_end; ++intermediate) { @@ -113,19 +113,19 @@ static void add_strings(BytecodeCompilerContext *self) { |u8* |Data|The data of the string, where the size is defined by @Size. Strings are null-terminated.| */ - Ssa *ssa = self->parser->ssa; + Ir *ir = self->parser->ir; Buffer *instructions = &self->bytecode->data; - BufferView *string = buffer_begin(&ssa->strings); - BufferView *strings_end = buffer_end(&ssa->strings); + BufferView *string = buffer_begin(&ir->strings); + BufferView *strings_end = buffer_end(&ir->strings); u32 strings_size = 0; for(; string != strings_end; ++string) { strings_size += sizeof(u16) + string->size + 1; /* +1 for null-termination of string */ } - string = buffer_begin(&ssa->strings); + string = buffer_begin(&ir->strings); throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + strings_size)); - throw_if_error(buffer_append(instructions, &ssa->string_counter, sizeof(u16))); + throw_if_error(buffer_append(instructions, &ir->string_counter, sizeof(u16))); throw_if_error(buffer_append(instructions, &strings_size, sizeof(u32))); for(; string != strings_end; ++string) { const char null_s = '\0'; @@ -188,16 +188,16 @@ static void add_functions(BytecodeCompilerContext *self) { |u32 |return_types_fixed_size |The size of all non-pointer type return types, in bytes. | */ - Ssa *ssa = self->parser->ssa; + Ir *ir = self->parser->ir; Buffer *instructions = &self->bytecode->data; - SsaFunc *func = buffer_begin(&ssa->funcs); - SsaFunc *func_end = buffer_end(&ssa->funcs); - u32 funcs_size = (u32)ssa->func_counter * sizeof(BytecodeHeaderFunction); + IrFunc *func = buffer_begin(&ir->funcs); + IrFunc *func_end = buffer_end(&ir->funcs); + u32 funcs_size = (u32)ir->func_counter * sizeof(BytecodeHeaderFunction); assert(sizeof(BytecodeHeaderFunction) == 22); self->bytecode->funcs_index = instructions->size; throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + funcs_size)); - throw_if_error(buffer_append(instructions, &ssa->func_counter, sizeof(u16))); + throw_if_error(buffer_append(instructions, &ir->func_counter, sizeof(u16))); throw_if_error(buffer_append(instructions, &funcs_size, sizeof(u32))); for(; func != func_end; ++func) { BytecodeHeaderFunction header_func; @@ -216,7 +216,7 @@ static void add_functions(BytecodeCompilerContext *self) { throw_if_error(buffer_append(instructions, &header_func, sizeof(header_func))); } - assert(sizeof(ssa->func_counter) == sizeof(u16) && "Program decoder needs to be updated since size of func index has changed"); + assert(sizeof(ir->func_counter) == sizeof(u16) && "Program decoder needs to be updated since size of func index has changed"); } static void add_extern_functions(BytecodeCompilerContext *self) { @@ -241,21 +241,21 @@ static void add_extern_functions(BytecodeCompilerContext *self) { |u32 |return_types_fixed_size |The size of all non-pointer type return types, in bytes. | |u8[]|name |The name of the external function, where the size is defined by @name_len. Names are null-terminated.| */ - Ssa *ssa = self->parser->ssa; + Ir *ir = self->parser->ir; Buffer *instructions = &self->bytecode->data; - SsaExternFunc *extern_func = buffer_begin(&ssa->extern_funcs); - SsaExternFunc *extern_func_end = buffer_end(&ssa->extern_funcs); - u32 extern_funcs_size = (u32)ssa->extern_func_counter * sizeof(BytecodeHeaderExternFunction); + IrExternFunc *extern_func = buffer_begin(&ir->extern_funcs); + IrExternFunc *extern_func_end = buffer_end(&ir->extern_funcs); + u32 extern_funcs_size = (u32)ir->extern_func_counter * sizeof(BytecodeHeaderExternFunction); assert(sizeof(BytecodeHeaderExternFunction) == 20); for(; extern_func != extern_func_end; ++extern_func) { extern_funcs_size += extern_func->name.size + 1; /* +1 for null-termination of string */ } - extern_func = buffer_begin(&ssa->extern_funcs); + extern_func = buffer_begin(&ir->extern_funcs); self->bytecode->extern_funcs_index = instructions->size; throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + extern_funcs_size)); - throw_if_error(buffer_append(instructions, &ssa->extern_func_counter, sizeof(u16))); + throw_if_error(buffer_append(instructions, &ir->extern_func_counter, sizeof(u16))); throw_if_error(buffer_append(instructions, &extern_funcs_size, sizeof(u32))); for(; extern_func != extern_func_end; ++extern_func) { const char null_s = '\0'; @@ -288,7 +288,7 @@ static void add_extern_functions(BytecodeCompilerContext *self) { throw_if_error(buffer_append(instructions, &null_s, sizeof(char))); } - assert(sizeof(SsaExternFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of extern func index has changed"); + assert(sizeof(IrExternFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of extern func index has changed"); } static void add_export_functions(BytecodeCompilerContext *self) { @@ -308,19 +308,19 @@ static void add_export_functions(BytecodeCompilerContext *self) { |u8 |name_len |The length of the exported function name, in bytes. Excluding the null-terminate character. | |u8[]|name |The name of the exported function, where the size is defined by @name_len. Names are null-terminated. | */ - Ssa *ssa = self->parser->ssa; + Ir *ir = self->parser->ir; Buffer *instructions = &self->bytecode->data; - SsaExportFunc *export_func = buffer_begin(&ssa->export_funcs); - SsaExportFunc *export_func_end = buffer_end(&ssa->export_funcs); - u32 export_funcs_size = (u32)ssa->export_func_counter * (sizeof(u32) + sizeof(u8) + sizeof(u8)); + IrExportFunc *export_func = buffer_begin(&ir->export_funcs); + IrExportFunc *export_func_end = buffer_end(&ir->export_funcs); + u32 export_funcs_size = (u32)ir->export_func_counter * (sizeof(u32) + sizeof(u8) + sizeof(u8)); for(; export_func != export_func_end; ++export_func) { export_funcs_size += export_func->name.size + 1; /* +1 for null-termination of string */ } - export_func = buffer_begin(&ssa->export_funcs); + export_func = buffer_begin(&ir->export_funcs); throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + export_funcs_size)); - throw_if_error(buffer_append(instructions, &ssa->export_func_counter, sizeof(u16))); + throw_if_error(buffer_append(instructions, &ir->export_func_counter, sizeof(u16))); throw_if_error(buffer_append(instructions, &export_funcs_size, sizeof(u32))); for(; export_func != export_func_end; ++export_func) { const char null_s = '\0'; @@ -333,7 +333,7 @@ static void add_export_functions(BytecodeCompilerContext *self) { throw_if_error(buffer_append(instructions, &null_s, sizeof(char))); } - assert(sizeof(SsaExportFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of export func index has changed"); + assert(sizeof(IrExportFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of export func index has changed"); } static void add_imports(BytecodeCompilerContext *self) { @@ -455,183 +455,183 @@ static void add_instructions(BytecodeCompilerContext *self) { |Instruction[]|Instructions data|The instructions data. Each instructions begins with an opcode, see #Opcode| */ - SsaInsForm1 ssa_ins_form1; - SsaInsForm2 ssa_ins_form2; - SsaInsFuncStart ssa_ins_func_start; - SsaInsFuncCall ssa_ins_func_call; - SsaInsFuncCallExtern ssa_ins_func_call_extern; - SsaInsCallStart ssa_ins_call_start; - SsaInsJumpZero ssa_ins_jump_zero; - SsaInsJump ssa_ins_jump; - - Ssa *ssa = self->parser->ssa; - u8 *instruction = buffer_begin(&ssa->instructions); - u8 *instructions_end = buffer_end(&ssa->instructions); + IrInsForm1 ir_ins_form1; + IrInsForm2 ir_ins_form2; + IrInsFuncStart ir_ins_func_start; + IrInsFuncCall ir_ins_func_call; + IrInsFuncCallExtern ir_ins_func_call_extern; + IrInsCallStart ir_ins_call_start; + IrInsJumpZero ir_ins_jump_zero; + IrInsJump ir_ins_jump; + + Ir *ir = self->parser->ir; + u8 *instruction = buffer_begin(&ir->instructions); + u8 *instructions_end = buffer_end(&ir->instructions); u16 label_counter = 0; u32 num_instructions_index = self->bytecode->data.size; throw_if_error(buffer_append_empty(&self->bytecode->data, sizeof(num_instructions_index))); while(instruction != instructions_end) { - SsaInstruction ins = (SsaInstruction)*instruction++; + IrInstruction ins = (IrInstruction)*instruction++; switch(ins) { - case SSA_ASSIGN_INTER: { - instruction += ssa_extract_data(instruction, &ssa_ins_form1, sizeof(ssa_ins_form1)); - add_ins6(self, AMAL_OP_MOVI, ssa_ins_form1.lhs, ssa_ins_form1.rhs, "movi r%d, i%d"); + case IR_ASSIGN_INTER: { + instruction += ir_extract_data(instruction, &ir_ins_form1, sizeof(ir_ins_form1)); + add_ins6(self, AMAL_OP_MOVI, ir_ins_form1.lhs, ir_ins_form1.rhs, "movi r%d, i%d"); break; } - case SSA_ASSIGN_STRING: { - instruction += ssa_extract_data(instruction, &ssa_ins_form1, sizeof(ssa_ins_form1)); - add_ins6(self, AMAL_OP_MOVD, ssa_ins_form1.lhs, ssa_ins_form1.rhs, "movd r%d, s%d"); + case IR_ASSIGN_STRING: { + instruction += ir_extract_data(instruction, &ir_ins_form1, sizeof(ir_ins_form1)); + add_ins6(self, AMAL_OP_MOVD, ir_ins_form1.lhs, ir_ins_form1.rhs, "movd r%d, s%d"); break; } - case SSA_ASSIGN_REG: { - instruction += ssa_extract_data(instruction, &ssa_ins_form1, sizeof(ssa_ins_form1)); - add_ins3(self, AMAL_OP_MOV, ssa_ins_form1.lhs, ssa_ins_form1.rhs, "mov r%d, r%d"); + case IR_ASSIGN_REG: { + instruction += ir_extract_data(instruction, &ir_ins_form1, sizeof(ir_ins_form1)); + add_ins3(self, AMAL_OP_MOV, ir_ins_form1.lhs, ir_ins_form1.rhs, "mov r%d, r%d"); break; } - case SSA_ADD: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_ADD, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "add r%d, r%d, r%d"); + case IR_ADD: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_ADD, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "add r%d, r%d, r%d"); break; } - case SSA_SUB: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_SUB, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "sub r%d, r%d, r%d"); + case IR_SUB: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_SUB, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "sub r%d, r%d, r%d"); break; } - case SSA_IMUL: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_IMUL, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "imul r%d, r%d, r%d"); + case IR_IMUL: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_IMUL, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "imul r%d, r%d, r%d"); break; } - case SSA_MUL: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_MUL, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "mul r%d, r%d, r%d"); + case IR_MUL: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_MUL, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "mul r%d, r%d, r%d"); break; } - case SSA_IDIV: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_IDIV, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "idiv r%d, r%d, r%d"); + case IR_IDIV: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_IDIV, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "idiv r%d, r%d, r%d"); break; } - case SSA_DIV: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_DIV, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "div r%d, r%d, r%d"); + case IR_DIV: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_DIV, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "div r%d, r%d, r%d"); break; } - case SSA_EQUALS: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_EQ, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "eq r%d, r%d, r%d"); + case IR_EQUALS: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_EQ, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "eq r%d, r%d, r%d"); break; } - case SSA_NOT_EQUAL: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_NEQ, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "neq r%d, r%d, r%d"); + case IR_NOT_EQUAL: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_NEQ, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "neq r%d, r%d, r%d"); break; } - case SSA_AND: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_BIT_AND, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "and r%d, r%d, r%d"); + case IR_AND: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_BIT_AND, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "and r%d, r%d, r%d"); break; } - case SSA_ILT: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_ILT, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "ilt r%d, r%d, r%d"); + case IR_ILT: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_ILT, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "ilt r%d, r%d, r%d"); break; } - case SSA_ILE: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_ILE, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "ile r%d, r%d, r%d"); + case IR_ILE: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_ILE, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "ile r%d, r%d, r%d"); break; } - case SSA_IGT: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_IGT, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "igt r%d, r%d, r%d"); + case IR_IGT: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_IGT, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "igt r%d, r%d, r%d"); break; } - case SSA_IGE: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_IGE, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "ige r%d, r%d, r%d"); + case IR_IGE: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_IGE, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "ige r%d, r%d, r%d"); break; } - case SSA_LT: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_LT, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "lt r%d, r%d, r%d"); + case IR_LT: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_LT, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "lt r%d, r%d, r%d"); break; } - case SSA_LE: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_LE, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "le r%d, r%d, r%d"); + case IR_LE: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_LE, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "le r%d, r%d, r%d"); break; } - case SSA_GT: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_GT, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "gt r%d, r%d, r%d"); + case IR_GT: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_GT, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "gt r%d, r%d, r%d"); break; } - case SSA_GE: { - instruction += ssa_extract_data(instruction, &ssa_ins_form2, sizeof(ssa_ins_form2)); - add_ins5(self, AMAL_OP_GE, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "ge r%d, r%d, r%d"); + case IR_GE: { + instruction += ir_extract_data(instruction, &ir_ins_form2, sizeof(ir_ins_form2)); + add_ins5(self, AMAL_OP_GE, ir_ins_form2.result, ir_ins_form2.lhs, ir_ins_form2.rhs, "ge r%d, r%d, r%d"); break; } - case SSA_FUNC_START: { - instruction += ssa_extract_data(instruction, &ssa_ins_func_start, sizeof(ssa_ins_func_start)); - add_ins6(self, AMAL_OP_FUNC_START, ssa_ins_func_start.flags, ssa_ins_func_start.num_local_vars_regs, "func_start 0x%02x, %u"); + case IR_FUNC_START: { + instruction += ir_extract_data(instruction, &ir_ins_func_start, sizeof(ir_ins_func_start)); + add_ins6(self, AMAL_OP_FUNC_START, ir_ins_func_start.flags, ir_ins_func_start.num_local_vars_regs, "func_start 0x%02x, %u"); label_counter = 0; break; } - case SSA_FUNC_END: { + case IR_FUNC_END: { add_ins1(self, AMAL_OP_FUNC_END, "func_end"); break; } - case SSA_PUSH: { - SsaRegister reg; - am_memcpy(®, instruction, sizeof(SsaRegister)); - instruction += sizeof(SsaRegister); + case IR_PUSH: { + IrRegister reg; + am_memcpy(®, instruction, sizeof(IrRegister)); + instruction += sizeof(IrRegister); add_ins2(self, AMAL_OP_PUSH, reg, "push r%d"); break; } - case SSA_PUSH_RET: { - SsaRegister reg; - am_memcpy(®, instruction, sizeof(SsaRegister)); - instruction += sizeof(SsaRegister); + case IR_PUSH_RET: { + IrRegister reg; + am_memcpy(®, instruction, sizeof(IrRegister)); + instruction += sizeof(IrRegister); add_ins2(self, AMAL_OP_PUSH_RET, reg, "push_ret r%d"); break; } - case SSA_CALL_START: { - instruction += ssa_extract_data(instruction, &ssa_ins_call_start, sizeof(ssa_ins_call_start)); - add_ins2(self, AMAL_OP_CALL_START, ssa_ins_call_start.num_args, "call_start %d"); + case IR_CALL_START: { + instruction += ir_extract_data(instruction, &ir_ins_call_start, sizeof(ir_ins_call_start)); + add_ins2(self, AMAL_OP_CALL_START, ir_ins_call_start.num_args, "call_start %d"); break; } - case SSA_CALL: { - instruction += ssa_extract_data(instruction, &ssa_ins_func_call, sizeof(ssa_ins_func_call)); - add_ins6(self, AMAL_OP_CALL, ssa_ins_func_call.import_index, ssa_ins_func_call.func_decl->ssa_func_index, "call f(%d,%d)"); + case IR_CALL: { + instruction += ir_extract_data(instruction, &ir_ins_func_call, sizeof(ir_ins_func_call)); + add_ins6(self, AMAL_OP_CALL, ir_ins_func_call.import_index, ir_ins_func_call.func_decl->ir_func_index, "call f(%d,%d)"); break; } - case SSA_CALL_EXTERN: { - instruction += ssa_extract_data(instruction, &ssa_ins_func_call_extern, sizeof(ssa_ins_func_call_extern)); - add_ins6(self, AMAL_OP_CALLE, ssa_ins_func_call_extern.import_index, ssa_ins_func_call_extern.func_decl_lhs->extern_index, "calle ef(%d,%d)"); + case IR_CALL_EXTERN: { + instruction += ir_extract_data(instruction, &ir_ins_func_call_extern, sizeof(ir_ins_func_call_extern)); + add_ins6(self, AMAL_OP_CALLE, ir_ins_func_call_extern.import_index, ir_ins_func_call_extern.func_decl_lhs->extern_index, "calle ef(%d,%d)"); break; } - case SSA_JUMP_ZERO: { - instruction += ssa_extract_data(instruction, &ssa_ins_jump_zero, sizeof(ssa_ins_jump_zero)); - add_ins6(self, AMAL_OP_JZ, ssa_ins_jump_zero.condition_reg, ssa_ins_jump_zero.target_label, "jz r%d, l%d"); + case IR_JUMP_ZERO: { + instruction += ir_extract_data(instruction, &ir_ins_jump_zero, sizeof(ir_ins_jump_zero)); + add_ins6(self, AMAL_OP_JZ, ir_ins_jump_zero.condition_reg, ir_ins_jump_zero.target_label, "jz r%d, l%d"); break; } - case SSA_JUMP: { - instruction += ssa_extract_data(instruction, &ssa_ins_jump, sizeof(ssa_ins_jump)); - add_ins4(self, AMAL_OP_JMP, ssa_ins_jump.target_label, "jmp l%d"); + case IR_JUMP: { + instruction += ir_extract_data(instruction, &ir_ins_jump, sizeof(ir_ins_jump)); + add_ins4(self, AMAL_OP_JMP, ir_ins_jump.target_label, "jmp l%d"); break; } - case SSA_RET: { - SsaRegister reg; - am_memcpy(®, instruction, sizeof(SsaRegister)); - instruction += sizeof(SsaRegister); + case IR_RET: { + IrRegister reg; + am_memcpy(®, instruction, sizeof(IrRegister)); + instruction += sizeof(IrRegister); add_ins2(self, AMAL_OP_RET, reg, "ret r%d"); break; } - case SSA_LABEL: { + case IR_LABEL: { add_ins1(self, AMAL_OP_LABEL, NULL); fprintf(stderr, "label l%d\n", label_counter++); break; @@ -652,7 +652,7 @@ static void add_section_magic_number(BytecodeCompilerContext *self) { throw_if_error(buffer_append(&self->bytecode->data, §ion_magic_number, sizeof(section_magic_number))); } -void generate_bytecode_from_ssa(BytecodeCompilerContext *self) { +void generate_bytecode_from_ir(BytecodeCompilerContext *self) { add_section_magic_number(self); add_intermediates(self); -- cgit v1.2.3