init basic
This commit is contained in:
299
ccompiler/middleend/ir.c
Normal file
299
ccompiler/middleend/ir.c
Normal file
@@ -0,0 +1,299 @@
|
||||
#include "ir.h"
|
||||
#include "../frontend/frontend.h"
|
||||
|
||||
typedef struct ASTNode ASTNode;
|
||||
|
||||
// 上下文结构，记录生成过程中的状态
|
||||
typedef struct {
|
||||
ir_func_t* current_func; // 当前处理的函数
|
||||
ir_bblock_t* current_block; // 当前基本块
|
||||
uint32_t vreg_counter; // 虚拟寄存器计数器
|
||||
} IRGenContext;
|
||||
IRGenContext ctx;
|
||||
ir_prog_t prog;
|
||||
ir_type_t type_i32 = {
|
||||
.tag = IR_TYPE_INT32,
|
||||
};
|
||||
static inline void init_ir_node_t(ir_node_t* node) {
|
||||
vector_init(node->used_by);
|
||||
}
|
||||
|
||||
static inline ir_node_t* new_ir_node_t() {
|
||||
ir_node_t* node = xmalloc(sizeof(ir_node_t));
|
||||
init_ir_node_t(node);
|
||||
}
|
||||
|
||||
ir_node_t* emit_instr(ir_bblock_t* block) {
|
||||
if (block == NULL) block = ctx.current_block;
|
||||
ir_node_t *node = new_ir_node_t();
|
||||
vector_push(block->instrs, node);
|
||||
return vector_at(block->instrs, block->instrs.size - 1);
|
||||
}
|
||||
|
||||
void emit_br(ir_node_t cond, const char* true_lable, const char* false_lable) {
|
||||
ir_node_t br = {
|
||||
.tag = IR_NODE_RET,
|
||||
.data = {
|
||||
}
|
||||
};
|
||||
// emit_instr(br, NULL);
|
||||
}
|
||||
|
||||
ir_node_t* gen_ir_expr(ASTNode* node) {
|
||||
switch (node->type) {
|
||||
case NT_TERM_VAL: {
|
||||
ir_node_t* ir = new_ir_node_t();
|
||||
*ir = (ir_node_t) {
|
||||
.tag = IR_NODE_CONST_INT,
|
||||
.data.const_int = {
|
||||
.val = node->syms.tok.constant.i,
|
||||
},
|
||||
};
|
||||
return ir;
|
||||
}
|
||||
case NT_TERM_IDENT: {
|
||||
ir_node_t* decl = node->syms.decl_node->decl_val.data;
|
||||
return decl;
|
||||
}
|
||||
case NT_TERM_CALL: {
|
||||
// TODO
|
||||
ir_node_t* ir = new_ir_node_t();
|
||||
*ir = (ir_node_t) {
|
||||
.tag = IR_NODE_CALL,
|
||||
.data.call = {
|
||||
.callee = NULL,
|
||||
},
|
||||
};
|
||||
vector_init(ir->data.call.args);
|
||||
return ir;
|
||||
}
|
||||
default:
|
||||
goto NEXT;
|
||||
}
|
||||
return NULL;
|
||||
NEXT:
|
||||
ir_node_t* lhs = gen_ir_expr(node->expr.left);
|
||||
ir_node_t* rhs = node->expr.right ? gen_ir_expr(node->expr.right) : NULL;
|
||||
|
||||
if (node->type == NT_COMMA) {
|
||||
return rhs;
|
||||
}
|
||||
|
||||
ir_node_t* instr = emit_instr(NULL);
|
||||
vector_push(lhs->used_by, instr);
|
||||
if (rhs) { vector_push(rhs->used_by, instr); }
|
||||
|
||||
ir_node_t* ret;
|
||||
#define BINOP(operand) do { \
|
||||
*instr = (ir_node_t){ \
|
||||
.tag = IR_NODE_OP, \
|
||||
.data.op = { \
|
||||
.op = operand, \
|
||||
.lhs = lhs, \
|
||||
.rhs = rhs, \
|
||||
}, \
|
||||
}; \
|
||||
ret = instr; \
|
||||
} while (0)
|
||||
|
||||
switch (node->type) {
|
||||
case NT_ADD :// (expr) + (expr)
|
||||
BINOP(IR_OP_ADD);
|
||||
break;
|
||||
case NT_SUB :// (expr) - (expr)
|
||||
BINOP(IR_OP_SUB);
|
||||
break;
|
||||
case NT_MUL :// (expr) * (expr)
|
||||
BINOP(IR_OP_MUL);
|
||||
break;
|
||||
case NT_DIV :// (expr) / (expr)
|
||||
BINOP(IR_OP_DIV);
|
||||
break;
|
||||
case NT_MOD :// (expr) % (expr)
|
||||
BINOP(IR_OP_MOD);
|
||||
break;
|
||||
case NT_AND :// (expr) & (expr)
|
||||
BINOP(IR_OP_AND);
|
||||
break;
|
||||
case NT_OR :// (expr) | (expr)
|
||||
BINOP(IR_OP_OR);
|
||||
break;
|
||||
case NT_XOR :// (expr) ^ (expr)
|
||||
BINOP(IR_OP_XOR);
|
||||
break;
|
||||
case NT_BIT_NOT :// ~ (expr)
|
||||
// TODO
|
||||
// BINOP(IR_OP_NOT);
|
||||
break;
|
||||
case NT_L_SH :// (expr) << (expr)
|
||||
BINOP(IR_OP_SHL);
|
||||
break;
|
||||
case NT_R_SH :// (expr) >> (expr)
|
||||
BINOP(IR_OP_SHR); // Shift right logical.
|
||||
// TODO
|
||||
// BINOP(IR_OP_SAR); // Shift right arithmetic.
|
||||
break;
|
||||
case NT_EQ :// (expr) == (expr)
|
||||
BINOP(IR_OP_EQ);
|
||||
break;
|
||||
case NT_NEQ :// (expr) != (expr)
|
||||
BINOP(IR_OP_NEQ);
|
||||
break;
|
||||
case NT_LE :// (expr) <= (expr)
|
||||
BINOP(IR_OP_LE);
|
||||
break;
|
||||
case NT_GE :// (expr) >= (expr)
|
||||
BINOP(IR_OP_GE);
|
||||
break;
|
||||
case NT_LT :// (expr) < (expr)
|
||||
BINOP(IR_OP_LT);
|
||||
break;
|
||||
case NT_GT :// (expr) > (expr)
|
||||
BINOP(IR_OP_GE);
|
||||
break;
|
||||
case NT_AND_AND :// (expr) && (expr)
|
||||
break;
|
||||
case NT_OR_OR :// (expr) || (expr)
|
||||
break;
|
||||
case NT_NOT :// ! (expr)
|
||||
ir_node_t* zero = xmalloc(sizeof(ir_node_t));
|
||||
*zero = (ir_node_t){
|
||||
.tag = IR_NODE_CONST_INT,
|
||||
.data.const_int = {
|
||||
.val = 0,
|
||||
},
|
||||
};
|
||||
*instr = (ir_node_t){
|
||||
.tag = IR_NODE_OP,
|
||||
.data.op = {
|
||||
.op = IR_OP_EQ,
|
||||
.lhs = zero,
|
||||
.rhs = lhs,
|
||||
},
|
||||
};
|
||||
ret = instr;
|
||||
break;
|
||||
case NT_ASSIGN :// (expr) = (expr)
|
||||
*instr = (ir_node_t){
|
||||
.tag = IR_NODE_STORE,
|
||||
.data.store = {
|
||||
.target = lhs,
|
||||
.value = rhs,
|
||||
},
|
||||
};
|
||||
ret = rhs;
|
||||
break;
|
||||
// case NT_COND : // (expr) ? (expr) : (expr)
|
||||
default:
|
||||
// TODO self error msg
|
||||
error("Unsupported IR generation for AST node type %d", node->type);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void gen_ir_from_ast(struct ASTNode* node) {
|
||||
switch (node->type) {
|
||||
case NT_ROOT: {
|
||||
for (int i = 0; i < node->root.child_size; i ++) {
|
||||
gen_ir_from_ast(node->root.children[i]);
|
||||
}
|
||||
} break;
|
||||
case NT_FUNC: {
|
||||
ir_func_t *func = xmalloc(sizeof(ir_func_t));
|
||||
*func = (ir_func_t) {
|
||||
.name = node->func.name->syms.tok.constant.str,
|
||||
};
|
||||
vector_init(func->bblocks);
|
||||
|
||||
ir_bblock_t *entry = xmalloc(sizeof(ir_bblock_t));
|
||||
*entry = (ir_bblock_t) {
|
||||
.label = "entry",
|
||||
};
|
||||
vector_init(entry->instrs);
|
||||
vector_push(func->bblocks, entry);
|
||||
|
||||
IRGenContext prev_ctx = ctx;
|
||||
ctx = (IRGenContext) {
|
||||
.current_func = func,
|
||||
.current_block = vector_at(func->bblocks, 0),
|
||||
.vreg_counter = 0,
|
||||
};
|
||||
|
||||
gen_ir_from_ast(node->func.body);
|
||||
|
||||
ctx = prev_ctx;
|
||||
vector_push(prog.funcs, func);
|
||||
} break;
|
||||
case NT_STMT_RETURN: {
|
||||
ir_node_t* ret = gen_ir_expr(node->return_stmt.expr_stmt);
|
||||
ir_node_t* ir = emit_instr(NULL);
|
||||
*ir = (ir_node_t) {
|
||||
.tag = IR_NODE_RET,
|
||||
.data = {
|
||||
.ret = {
|
||||
.ret_val = ret,
|
||||
}
|
||||
}
|
||||
};
|
||||
break;
|
||||
}
|
||||
case NT_BLOCK: {
|
||||
for (int i = 0; i < node->block.child_size; i ++) {
|
||||
gen_ir_from_ast(node->block.children[i]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case NT_STMT_IF: {
|
||||
ir_node_t *cond = gen_ir_expr(node->if_stmt.cond);
|
||||
|
||||
// xmalloc();
|
||||
// ir_bblock_t then_block = {
|
||||
// };
|
||||
node->if_stmt.if_stmt;
|
||||
node->if_stmt.else_stmt;
|
||||
break;
|
||||
}
|
||||
case NT_STMT_WHILE: {
|
||||
node->while_stmt.cond;
|
||||
node->while_stmt.body;
|
||||
break;
|
||||
}
|
||||
case NT_STMT_DOWHILE: {
|
||||
node->do_while_stmt.cond;
|
||||
node->do_while_stmt.body;
|
||||
break;
|
||||
}
|
||||
case NT_STMT_FOR: {
|
||||
node->for_stmt.init;
|
||||
node->for_stmt.cond;
|
||||
node->for_stmt.iter;
|
||||
node->for_stmt.body;
|
||||
break;
|
||||
}
|
||||
case NT_DECL_VAR: {
|
||||
ir_node_t* ret_node = emit_instr(NULL);
|
||||
*ret_node = (ir_node_t) {
|
||||
.tag = IR_NODE_ALLOC,
|
||||
.name = node->decl_val.name->syms.tok.constant.str,
|
||||
.type = &type_i32,
|
||||
};
|
||||
node->decl_val.data = ret_node;
|
||||
if (node->decl_val.expr_stmt != NULL) {
|
||||
gen_ir_from_ast(node->decl_val.expr_stmt);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case NT_STMT_EXPR: {
|
||||
gen_ir_expr(node->expr_stmt.expr_stmt);
|
||||
break;
|
||||
}
|
||||
case NT_STMT_EMPTY: {
|
||||
break;
|
||||
}
|
||||
default:
|
||||
// TODO: 错误处理
|
||||
error("unknown node type");
|
||||
break;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user