backend

Unnamed repository; edit this file 'description' to name the repository.
git clone https://git.deepztream.com/backend
Log | Files | Refs | Submodules

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 };