ir_backend.c (8420B)
1 Temp_allocator temp_allocator = {0}; 2 3 const char * 4 ir_arg_to_cstr(Ir_arg arg) 5 { 6 int len; 7 char *str; 8 if (arg.kind == ARG_INT_LITERAL) { 9 len = snprintf(NULL, 0, "%li", arg.i64) + 1; 10 str = ta_alloc(&temp_allocator, len); 11 snprintf(str, len, "%li", arg.i64); 12 } else if (arg.kind == ARG_TEMP_STORAGE) { 13 len = snprintf(NULL, 0, "%%%li", arg.temp_id) + 1; 14 str = ta_alloc(&temp_allocator, len); 15 snprintf(str, len, "%%%li", arg.temp_id); 16 } else if (arg.kind == ARG_ADDRESS) { 17 len = snprintf(NULL, 0, "0x%p", arg.addr) + 1; 18 str = ta_alloc(&temp_allocator, len); 19 snprintf(str, len, "0x%p", arg.addr); 20 } else if (arg.kind == ARG_CSTRING_LITERAL) { 21 str = ta_alloc(&temp_allocator, arg.sv.count + 3); 22 memcpy(str + 1, arg.sv.items, arg.sv.count); 23 str[0] = '"'; 24 str[arg.sv.count + 1] = '"'; 25 str[arg.sv.count + 2] = '\0'; 26 } else if (arg.kind == ARG_STATIC_VARIABLE) { 27 str = ta_alloc(&temp_allocator, arg.name.count + 2); 28 memcpy(str + 1, arg.name.items, arg.name.count); 29 str[0] = '?'; 30 str[arg.sv.count + 1] = '\0'; 31 } else { 32 fprintf(stderr, "Invalid arg %i\n", arg.kind); 33 abort(); 34 } 35 return str; 36 } 37 38 const char * 39 ir_binop_to_cstr(enum Ir_binop binop) 40 { 41 const char *str; 42 switch (binop) { 43 case OP_ADD: str = "+"; break; 44 case OP_SUB: str = "-"; break; 45 case OP_MUL: str = "*"; break; 46 case OP_DIV: str = "/"; break; 47 case OP_LT: str = "<"; break; 48 case OP_GT: str = ">"; break; 49 case OP_EQ: str = "=="; break; 50 case OP_LEQ: str = "<="; break; 51 case OP_GEQ: str = "=>"; break; 52 default: assert(0 && "Unknown binop"); 53 } 54 return str; 55 } 56 57 const char * 58 ir_type_to_cstr(Ir_type type) 59 { 60 const char *str; 61 switch (type) { 62 case TYPE_VOID: str = "void"; break; 63 case TYPE_I8: str = "i8"; break; 64 case TYPE_I16: str = "i16"; break; 65 case TYPE_I32: str = "i32"; break; 66 case TYPE_I64: str = "i64"; break; 67 case TYPE_PTR: str = "ptr"; break; 68 case TYPE_F32: str = "f32"; break; 69 case TYPE_F64: str = "f64"; break; 70 case TYPE_UNKNOWN: str = "??"; break; 71 default: assert(0 && "Unknown type"); 72 } 73 return str; 74 } 75 76 bool 77 ir_compile_block(Ir_block block, Sb *sb) 78 { 79 size_t i, j; 80 Ir ir; 81 Temp_allocator saved_allocator; 82 const char *str; 83 for (i = 0; i < block.count; i++) { 84 saved_allocator = temp_allocator; 85 ir = block.items[i]; 86 assert(ir.result.kind == ARG_TEMP_STORAGE || ir.result.kind == ARG_NONE); 87 sb_append_cstr(sb, " "); 88 switch (ir.kind) { 89 case IR_LOAD: 90 assert(ir.result.kind != ARG_NONE); 91 assert(ir.result.type != TYPE_VOID); 92 sb_printf(sb, " %s =%s load %s %s", ir_arg_to_cstr(ir.result), ir_type_to_cstr(ir.result.type), ir_type_to_cstr(ir.load.type), ir_arg_to_cstr(ir.load.loc)); 93 break; 94 case IR_STORE: 95 assert(ir.result.kind == ARG_NONE); 96 assert(ir.store.data.type != TYPE_VOID); 97 sb_printf(sb, " store(%s, %s %s)", ir_arg_to_cstr(ir.store.loc), ir_type_to_cstr(ir.store.data.type), ir_arg_to_cstr(ir.store.data)); 98 break; 99 case IR_ASSIGN: 100 assert(ir.result.kind != ARG_NONE); 101 assert(ir.result.type != TYPE_VOID); 102 str = ir_arg_to_cstr(ir.result); 103 sb_printf(sb, " %s", str); 104 str = ir_type_to_cstr(ir.result.type); 105 sb_printf(sb, " =%s", str); 106 str = ir_arg_to_cstr(ir.assign); 107 sb_printf(sb, " %s", str); 108 break; 109 case IR_BINOP: 110 assert(ir.result.kind != ARG_NONE); 111 assert(ir.result.type != TYPE_VOID); 112 sb_printf(sb, " %s = %s %s %s", ir_arg_to_cstr(ir.result), ir_arg_to_cstr(ir.binop.left), ir_binop_to_cstr(ir.binop.op), ir_arg_to_cstr(ir.binop.right)); 113 break; 114 case IR_CALL: 115 assert(ir.result.kind != ARG_NONE); 116 if (ir.call.indirect.kind != ARG_NONE) { 117 sb_printf(sb, " %s = call %s (", ir_arg_to_cstr(ir.result), ir_arg_to_cstr(ir.call.indirect)); 118 } else { 119 sb_printf(sb, " %s = call $%.*s (", ir_arg_to_cstr(ir.result), ir.call.name.count, ir.call.name.data); 120 } 121 for (j = 0; j < ir.call.args.count; j++) { 122 if (j) { 123 sb_append_cstr(sb, ", "); 124 } 125 sb_append_cstr(sb, ir_arg_to_cstr(ir.call.args.items[j])); 126 } 127 sb_append_char(sb, ')'); 128 break; 129 case IR_SYSCALL: 130 assert(ir.result.kind != ARG_NONE); 131 sb_printf(sb, " %s = syscall %s (", ir_arg_to_cstr(ir.result), ir_arg_to_cstr(ir.syscall.syscall)); 132 for (j = 0; j < ir.syscall.args.count; j++) { 133 if (j) { 134 sb_append_cstr(sb, ", "); 135 } 136 sb_append_cstr(sb, ir_arg_to_cstr(ir.syscall.args.items[j])); 137 } 138 sb_append_char(sb, ')'); 139 break; 140 case IR_RETURN: 141 assert(ir.result.kind == ARG_NONE); 142 sb_printf(sb, " return %s", ir_arg_to_cstr(ir.ret)); 143 break; 144 /* case IR_LABEL: */ 145 /* assert(ir.result.kind == ARG_NONE); */ 146 /* sb_printf(sb, "#%li:", ir.label_id); */ 147 /* break; */ 148 case IR_JUMP: 149 assert(ir.result.kind == ARG_NONE); 150 if (ir.jump.label.resolved) { 151 sb_printf(sb, " jump #%li", ir.jump.label.id); 152 } else { 153 sb_printf(sb, " jump #%.*s", (int) ir.jump.label.sv.count, ir.jump.label.sv.items); 154 } 155 break; 156 case IR_BRANCH: 157 assert(ir.result.kind == ARG_NONE); 158 if (ir.branch.true_label.resolved && ir.branch.false_label.resolved) { 159 sb_printf(sb, " branch %s #%li #%li", ir_arg_to_cstr(ir.branch.cond), ir.branch.true_label.id, ir.branch.false_label.id); 160 } else if (!ir.branch.true_label.resolved && !ir.branch.false_label.resolved) { 161 sb_printf(sb, " branch %s #%.*s #%.*s", ir_arg_to_cstr(ir.branch.cond), (int) ir.branch.true_label.sv.count, ir.branch.true_label.sv.items, (int) ir.branch.false_label.sv.count, ir.branch.false_label.sv.items); 162 } else { 163 unreachable("out-of-sync labels"); 164 } 165 break; 166 case IR_PHI: 167 assert(ir.result.kind == ARG_TEMP_STORAGE); 168 sb_printf(sb, " phi %s [", ir_arg_to_cstr(ir.result)); 169 for (j = 0; j < ir.phi_list.count; j++) { 170 if (j) { 171 da_append(sb, ' '); 172 } 173 if (ir.phi_list.items[j].label.resolved) { 174 sb_printf(sb, "(#%li %%%li)", ir.phi_list.items[j].label.id, ir.phi_list.items[j].temp_id); 175 } else { 176 sb_printf(sb, "(#%.*s %%%li)", (int) ir.phi_list.items[j].label.sv.count, ir.phi_list.items[j].label.sv.items, ir.phi_list.items[j].temp_id); 177 } 178 } 179 sb_printf(sb, "]"); 180 break; 181 default: 182 fprintf(stderr, "Error: Unknown IR %lu\n", i); 183 temp_allocator = saved_allocator; 184 return false; 185 } 186 sb_append_char(sb, '\n'); 187 temp_allocator = saved_allocator; 188 } 189 return true; 190 } 191 192 bool 193 ir_dump_extern(Ir_extern ext, Sb *sb) 194 { 195 sb_printf(sb, "extern $%.*s\n", (int) ext.symbol.count, ext.symbol.data); 196 return true; 197 } 198 199 bool 200 ir_dump(Ir_program prog, Sb *sb) 201 { 202 size_t i, j; 203 Ir_function function; 204 Temp_allocator saved_allocator; 205 for (i = 0; i < prog.externs.count; i++) { 206 if (!ir_dump_extern(prog.externs.items[i], sb)) { 207 return false; 208 } 209 } 210 if (i) { 211 sb_append_char(sb, '\n'); 212 } 213 for (i = 0; i < prog.functions.count; i++) { 214 saved_allocator = temp_allocator; 215 if (i) { 216 sb_append_char(sb, '\n'); 217 } 218 function = prog.functions.items[i]; 219 sb_printf(sb, "$%.*s(", function.name.count, function.name.data); 220 for (j = 0; j < function.argument_types.count; j++) { 221 if (j) { 222 sb_append_cstr(sb, ", "); 223 } 224 sb_append_cstr(sb, ir_type_to_cstr(function.argument_types.items[j])); 225 } 226 sb_printf(sb, ") -> %s {\n", ir_type_to_cstr(function.return_type)); 227 for (j = 0; j < function.body.count; j++) { 228 if (function.resolved_labels) { 229 sb_printf(sb, "#%lu:\n", j); 230 } else { 231 sb_printf(sb, "#%.*s:\n", (int) function.labels.items[j].count, function.labels.items[j].data); 232 } 233 if (!ir_compile_block(function.body.items[j], sb)) { 234 temp_allocator = saved_allocator; 235 return false; 236 } 237 } 238 sb_append_cstr(sb, "}\n"); 239 temp_allocator = saved_allocator; 240 } 241 return true; 242 } 243 244 Backend ir_backend = { 245 "IR Dump", 246 ir_dump, 247 };