kit

ir_print.c (10643B)

---

 #include "core/slice.h"
 #include "core/strbuf.h"
 #include "opt/opt.h"
 
 static void dump_write(Writer* w, const char* s) {
   kit_writer_write(w, s, slice_from_cstr(s).len);
 }
 
 static void dump_sb(Writer* w, const StrBuf* sb) {
   kit_writer_write(w, strbuf_cstr(sb), strbuf_len(sb));
 }
 
 /* Append a signed value with an explicit leading sign, matching printf's
  * "%+lld"/"%+d" formatting (forced '+' on non-negative values). */
 static void strbuf_put_i64_plus(StrBuf* sb, i64 v) {
   if (v < 0) {
     strbuf_putc(sb, '-');
     strbuf_put_u64(sb, (u64)(-(v + 1)) + 1u);
   } else {
     strbuf_putc(sb, '+');
     strbuf_put_u64(sb, (u64)v);
   }
 }
 
 static const char* op_name(IROp op) {
   switch (op) {
     case IR_NOP:
       return "nop";
     case IR_CONST_I:
       return "const_i";
     case IR_CONST_BYTES:
       return "const_bytes";
     case IR_PARAM_DECL:
       return "param_decl";
     case IR_LOAD_IMM:
       return "load_imm";
     case IR_LOAD_CONST:
       return "load_const";
     case IR_COPY:
       return "copy";
     case IR_LOAD:
       return "load";
     case IR_STORE:
       return "store";
     case IR_ADDR_OF:
       return "addr_of";
     case IR_TLS_ADDR_OF:
       return "tls_addr_of";
     case IR_AGG_COPY:
       return "agg_copy";
     case IR_AGG_SET:
       return "agg_set";
     case IR_BITFIELD_LOAD:
       return "bitfield_load";
     case IR_BITFIELD_STORE:
       return "bitfield_store";
     case IR_BINOP:
       return "binop";
     case IR_UNOP:
       return "unop";
     case IR_CMP:
       return "cmp";
     case IR_CONVERT:
       return "convert";
     case IR_CALL:
       return "call";
     case IR_PHI:
       return "phi";
     case IR_BR:
       return "br";
     case IR_CONDBR:
       return "condbr";
     case IR_CMP_BRANCH:
       return "cmp_branch";
     case IR_SWITCH:
       return "switch";
     case IR_INDIRECT_BRANCH:
       return "indirect_branch";
     case IR_LOAD_LABEL_ADDR:
       return "load_label_addr";
     case IR_LOCAL_STATIC_DATA_BEGIN:
       return "local_static_data_begin";
     case IR_LOCAL_STATIC_DATA_WRITE:
       return "local_static_data_write";
     case IR_LOCAL_STATIC_DATA_LABEL_ADDR:
       return "local_static_data_label_addr";
     case IR_LOCAL_STATIC_DATA_END:
       return "local_static_data_end";
     case IR_RET:
       return "ret";
     case IR_UNREACHABLE:
       return "unreachable";
     case IR_SCOPE_BEGIN:
       return "scope_begin";
     case IR_SCOPE_END:
       return "scope_end";
     case IR_BREAK_TO:
       return "break_to";
     case IR_CONTINUE_TO:
       return "continue_to";
     case IR_ALLOCA:
       return "alloca";
     case IR_VA_START:
       return "va_start";
     case IR_VA_ARG:
       return "va_arg";
     case IR_VA_END:
       return "va_end";
     case IR_VA_COPY:
       return "va_copy";
     case IR_ATOMIC_LOAD:
       return "atomic_load";
     case IR_ATOMIC_STORE:
       return "atomic_store";
     case IR_ATOMIC_RMW:
       return "atomic_rmw";
     case IR_ATOMIC_CAS:
       return "atomic_cas";
     case IR_FENCE:
       return "fence";
     case IR_ASM_BLOCK:
       return "asm_block";
     case IR_INTRINSIC:
       return "intrinsic";
     default:
       return "unknown";
   }
 }
 
 static const char* alias_name(u8 kind) {
   switch ((AliasKind)kind) {
     case ALIAS_UNKNOWN:
       return "unknown";
     case ALIAS_LOCAL:
       return "local";
     case ALIAS_GLOBAL:
       return "global";
     case ALIAS_PARAM:
       return "param";
     case ALIAS_HEAP:
       return "heap";
     case ALIAS_STRING:
       return "string";
     default:
       return "alias?";
   }
 }
 
 static void dump_alias(Writer* w, const AliasRoot* a) {
   char buf[64];
   StrBuf sb;
   dump_write(w, alias_name(a->kind));
   strbuf_init(&sb, buf, sizeof buf);
   switch ((AliasKind)a->kind) {
     case ALIAS_LOCAL:
       strbuf_putc(&sb, '#');
       strbuf_put_i64(&sb, (i64)(int)a->v.local_id);
       dump_sb(w, &sb);
       break;
     case ALIAS_GLOBAL:
       strbuf_putc(&sb, '#');
       strbuf_put_u64(&sb, (u64)(unsigned)a->v.global);
       dump_sb(w, &sb);
       break;
     case ALIAS_PARAM:
       strbuf_putc(&sb, '#');
       strbuf_put_u64(&sb, (u64)(unsigned)a->v.param_idx);
       dump_sb(w, &sb);
       break;
     case ALIAS_STRING:
       strbuf_putc(&sb, '#');
       strbuf_put_u64(&sb, (u64)(unsigned)a->v.string_id);
       dump_sb(w, &sb);
       break;
     default:
       break;
   }
 }
 
 static void dump_operand(Writer* w, const Operand* op) {
   char buf[96];
   StrBuf sb;
   if (!op) {
     dump_write(w, "-");
     return;
   }
   strbuf_init(&sb, buf, sizeof buf);
   switch ((OptOperandKind)op->kind) {
     case OPK_IMM:
       strbuf_puts(&sb, "imm:");
       strbuf_put_i64(&sb, (i64)op->v.imm);
       dump_sb(w, &sb);
       break;
     case OPK_REG:
       strbuf_putc(&sb, 'v');
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.reg);
       dump_sb(w, &sb);
       break;
     case OPK_LOCAL:
       strbuf_puts(&sb, "local#");
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.frame_slot);
       dump_sb(w, &sb);
       break;
     case OPK_STACK:
       strbuf_puts(&sb, "stack#");
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.frame_slot);
       dump_sb(w, &sb);
       break;
     case OPK_FRAME_ADDR:
       strbuf_puts(&sb, "&frame#");
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.frame_slot);
       dump_sb(w, &sb);
       break;
     case OPK_GLOBAL:
       strbuf_puts(&sb, "global#");
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.global.sym);
       strbuf_put_i64_plus(&sb, (i64)op->v.global.addend);
       dump_sb(w, &sb);
       break;
     case OPK_INDIRECT:
       strbuf_putc(&sb, '[');
       if (op->v.ind.base_kind == OPT_INDIRECT_FRAME)
         strbuf_puts(&sb, "frame-value#");
       else if (op->v.ind.base_kind == OPT_INDIRECT_FRAME_ADDR)
         strbuf_puts(&sb, "frame#");
       else
         strbuf_putc(&sb, 'v');
       strbuf_put_u64(&sb, (u64)(unsigned)op->v.ind.base);
       if (op->v.ind.index_kind != OPT_INDIRECT_REG ||
           op->v.ind.index != (Reg)REG_NONE) {
         strbuf_puts(&sb, "+");
         if (op->v.ind.index_kind == OPT_INDIRECT_FRAME)
           strbuf_puts(&sb, "frame-value#");
         else if (op->v.ind.index_kind == OPT_INDIRECT_FRAME_ADDR)
           strbuf_puts(&sb, "frame#");
         else
           strbuf_putc(&sb, 'v');
         strbuf_put_u64(&sb, (u64)(unsigned)op->v.ind.index);
         if (op->v.ind.log2_scale) {
           strbuf_puts(&sb, "<<");
           strbuf_put_u64(&sb, op->v.ind.log2_scale);
         }
       }
       strbuf_put_i64_plus(&sb, (i64)(int)op->v.ind.ofs);
       strbuf_putc(&sb, ']');
       dump_sb(w, &sb);
       break;
     default:
       dump_write(w, "op?");
       break;
   }
 }
 
 static void dump_operands(Writer* w, const Inst* in) {
   dump_write(w, " opnds=[");
   for (u32 i = 0; i < in->nopnds; ++i) {
     if (i) dump_write(w, ",");
     dump_operand(w, &in->opnds[i]);
   }
   dump_write(w, "]");
 }
 
 static void dump_mem(Writer* w, const MemAccess* m) {
   char buf[128];
   StrBuf sb;
   strbuf_init(&sb, buf, sizeof buf);
   strbuf_puts(&sb, " mem=size");
   strbuf_put_u64(&sb, (u64)(unsigned)m->size);
   strbuf_puts(&sb, " align");
   strbuf_put_u64(&sb, (u64)(unsigned)m->align);
   strbuf_puts(&sb, " flags=");
   strbuf_put_hex_u64(&sb, (u64)(unsigned)m->flags);
   strbuf_puts(&sb, " alias=");
   dump_sb(w, &sb);
   dump_alias(w, &m->alias);
 }
 
 static void dump_phi(Writer* w, const Inst* in) {
   char buf[96];
   StrBuf sb;
   IRPhiAux* aux = (IRPhiAux*)in->extra.aux;
   strbuf_init(&sb, buf, sizeof buf);
   strbuf_puts(&sb, " slot=");
   strbuf_put_u64(&sb, aux ? (u64)(unsigned)aux->slot_id : 0u);
   strbuf_puts(&sb, " preds=[");
   dump_sb(w, &sb);
   if (aux) {
     for (u32 p = 0; p < aux->npreds; ++p) {
       strbuf_reset(&sb);
       if (p) strbuf_putc(&sb, ',');
       strbuf_putc(&sb, 'b');
       strbuf_put_u64(&sb, (u64)(unsigned)aux->pred_blocks[p]);
       strbuf_puts(&sb, ":v");
       strbuf_put_u64(&sb, (u64)(unsigned)aux->pred_vals[p]);
       dump_sb(w, &sb);
     }
   }
   dump_write(w, "]");
 }
 
 static void dump_ret(Writer* w, const Inst* in) {
   IRRetAux* aux = (IRRetAux*)in->extra.aux;
   if (!aux || !aux->present) {
     dump_write(w, " ret=void");
     return;
   }
   dump_write(w, " ret=");
   dump_operand(w, &aux->val.storage);
 }
 
 void opt_ir_dump(Func* f, Writer* w) {
   if (!f || !w) return;
   char buf[160];
   StrBuf sb;
   strbuf_init(&sb, buf, sizeof buf);
   strbuf_puts(&sb, "ir blocks=");
   strbuf_put_u64(&sb, (u64)(unsigned)f->nblocks);
   strbuf_puts(&sb, " vals=");
   strbuf_put_u64(&sb, (u64)(unsigned)f->nvals);
   strbuf_putc(&sb, '\n');
   dump_sb(w, &sb);
   for (u32 b = 0; b < f->nblocks; ++b) {
     Block* bl = &f->blocks[b];
     strbuf_reset(&sb);
     strbuf_puts(&sb, "block ");
     strbuf_put_u64(&sb, (u64)(unsigned)b);
     strbuf_puts(&sb, " preds=[");
     dump_sb(w, &sb);
     for (u32 p = 0; p < bl->npreds; ++p) {
       strbuf_reset(&sb);
       if (p) strbuf_putc(&sb, ',');
       strbuf_putc(&sb, 'b');
       strbuf_put_u64(&sb, (u64)(unsigned)bl->preds[p]);
       dump_sb(w, &sb);
     }
     dump_write(w, "] succs=[");
     for (u32 s = 0; s < bl->nsucc; ++s) {
       strbuf_reset(&sb);
       if (s) strbuf_putc(&sb, ',');
       strbuf_putc(&sb, 'b');
       strbuf_put_u64(&sb, (u64)(unsigned)bl->succ[s]);
       dump_sb(w, &sb);
     }
     strbuf_reset(&sb);
     strbuf_puts(&sb, "] insts=");
     strbuf_put_u64(&sb, (u64)(unsigned)bl->ninsts);
     strbuf_putc(&sb, '\n');
     dump_sb(w, &sb);
 
     for (u32 i = 0; i < bl->ninsts; ++i) {
       Inst* in = &bl->insts[i];
       strbuf_reset(&sb);
       strbuf_puts(&sb, "  ");
       strbuf_put_u64(&sb, (u64)(unsigned)i);
       strbuf_putc(&sb, ' ');
       strbuf_puts(&sb, op_name((IROp)in->op));
       dump_sb(w, &sb);
       if (in->def != VAL_NONE) {
         strbuf_reset(&sb);
         strbuf_puts(&sb, " def=v");
         strbuf_put_u64(&sb, (u64)(unsigned)in->def);
         dump_sb(w, &sb);
       }
       if (in->ndefs) {
         dump_write(w, " defs=[");
         for (u32 d = 0; d < in->ndefs; ++d) {
           strbuf_reset(&sb);
           if (d) strbuf_putc(&sb, ',');
           strbuf_putc(&sb, 'v');
           strbuf_put_u64(&sb, (u64)(unsigned)in->defs[d]);
           dump_sb(w, &sb);
         }
         dump_write(w, "]");
       }
       if (in->nopnds) dump_operands(w, in);
       if ((IROp)in->op == IR_LOAD || (IROp)in->op == IR_STORE)
         dump_mem(w, &in->extra.mem);
       if ((IROp)in->op == IR_LOAD_IMM || (IROp)in->op == IR_CONST_I) {
         strbuf_reset(&sb);
         strbuf_puts(&sb, " imm=");
         strbuf_put_i64(&sb, (i64)in->extra.imm);
         dump_sb(w, &sb);
       }
       if ((IROp)in->op == IR_PHI) dump_phi(w, in);
       if ((IROp)in->op == IR_RET) dump_ret(w, in);
       dump_write(w, "\n");
     }
   }
 }