kit

opt_util.c (7405B)

---

 #include <string.h>
 
 #include "opt/opt_internal.h"
 
 int opt_val_in_inst_defs(const Inst* in, Val v) {
   if (!in || v == VAL_NONE) return 0;
   if (in->def == v) return 1;
   for (u32 i = 0; i < in->ndefs; ++i)
     if (in->defs[i] == v) return 1;
   return 0;
 }
 
 int opt_indirect_index_type_valid(Func* f, KitCgTypeId type) {
   u64 size;
   if (!f || !f->c || type == KIT_CG_TYPE_NONE ||
       !cg_type_is_int(f->c, type) ||
       opt_value_reg_class(f->c, type) != RC_INT)
     return 0;
   size = cg_type_size(f->c, type);
   return size != 0u && size <= f->c->target.ptr_size;
 }
 
 int opt_inst_operand_is_def(const Inst* in, u32 i) {
   if (!in || i >= in->nopnds) return 0;
   switch ((IROp)in->op) {
     case IR_LOAD_IMM:
     case IR_LOAD_CONST:
     case IR_TLS_ADDR_OF:
     case IR_LOAD_LABEL_ADDR:
     case IR_COPY:
     case IR_CONVERT:
     case IR_UNOP:
     case IR_VA_ARG:
     case IR_LOAD:
     case IR_ADDR_OF:
     case IR_BITFIELD_LOAD:
     case IR_ATOMIC_LOAD:
     case IR_BINOP:
     case IR_CMP:
     case IR_ALLOCA:
     case IR_ATOMIC_RMW:
       return i == 0u;
     case IR_ATOMIC_CAS:
       return i == 0u || i == 1u;
     default:
       return 0;
   }
 }
 
 static KitCgTypeId indirect_frame_type(Func* f, FrameSlot slot,
                                        KitCgTypeId fallback) {
   if (f && slot != FRAME_SLOT_NONE && slot <= f->nframe_slots) {
     KitCgTypeId type = f->frame_slots[slot - 1u].type;
     if (type) return type;
   }
   return fallback;
 }
 
 static void indirect_part_operand(Func* f, const Operand* owner, u32 value,
                                   u8 kind, KitCgTypeId component_type,
                                   Operand* out) {
   *out = *owner;
   out->cls = RC_INT;
   out->flags |= OPT_OPERAND_WALK_INDIRECT_PART;
   if (component_type) out->type = component_type;
   switch ((OptIndirectLocKind)kind) {
     case OPT_INDIRECT_REG:
       out->kind = OPK_REG;
       out->v.reg = (Reg)value;
       if (!component_type && (PReg)value < opt_reg_count(f) &&
           opt_reg_type(f, (PReg)value))
         out->type = opt_reg_type(f, (PReg)value);
       return;
     case OPT_INDIRECT_FRAME:
       out->kind = OPK_STACK;
       out->v.frame_slot = (FrameSlot)value;
       if (!component_type)
         out->type = indirect_frame_type(f, (FrameSlot)value, owner->type);
       return;
     case OPT_INDIRECT_FRAME_ADDR:
       out->kind = OPK_FRAME_ADDR;
       out->v.frame_slot = (FrameSlot)value;
       return;
   }
 }
 
 static void indirect_part_commit(Func* f, Inst* in, Operand* owner,
                                  Operand* part, u32* value, u8* kind,
                                  KitCgTypeId* component_type) {
   if (component_type) *component_type = part->type;
   switch ((OptOperandKind)part->kind) {
     case OPK_REG:
       *value = part->v.reg;
       *kind = OPT_INDIRECT_REG;
       return;
     case OPK_STACK:
       *value = part->v.frame_slot;
       *kind = OPT_INDIRECT_FRAME;
       return;
     case OPK_FRAME_ADDR:
       *value = part->v.frame_slot;
       *kind = OPT_INDIRECT_FRAME_ADDR;
       return;
     default:
       compiler_panic(f->c, in ? in->loc : (SrcLoc){0, 0, 0},
                      "opt operand walk: invalid indirect location kind %u",
                      (unsigned)part->kind);
   }
   (void)owner;
 }
 
 void opt_walk_operand(Func* f, Inst* in, Operand* op, int is_def,
                       OptOperandWalkFn fn, void* ctx) {
   if (!op || !fn) return;
   if (op->kind != OPK_INDIRECT) {
     fn(f, in, op, is_def, ctx);
   } else if (op->kind == OPK_INDIRECT) {
     Operand base;
     /* Expose the complete address owner as well as its scalar components.
      * Location-aware consumers (notably MIR verification) need to validate
      * the tuple; register-rewrite callbacks simply ignore non-register kinds. */
     fn(f, in, op, 0, ctx);
     indirect_part_operand(f, op, op->v.ind.base, op->v.ind.base_kind,
                           op->v.ind.base_type, &base);
     fn(f, in, &base, 0, ctx);
     indirect_part_commit(f, in, op, &base, &op->v.ind.base,
                          &op->v.ind.base_kind, &op->v.ind.base_type);
     if (op->v.ind.index_kind != OPT_INDIRECT_REG ||
         op->v.ind.index != (Reg)REG_NONE) {
       Operand idx;
       indirect_part_operand(f, op, op->v.ind.index, op->v.ind.index_kind,
                             op->v.ind.index_type, &idx);
       fn(f, in, &idx, 0, ctx);
       indirect_part_commit(f, in, op, &idx, &op->v.ind.index,
                            &op->v.ind.index_kind, &op->v.ind.index_type);
     }
   }
 }
 
 void opt_walk_abivalue(Func* f, Inst* in, CGABIValue* v, int storage_def,
                        OptOperandWalkFn fn, void* ctx) {
   if (!v) return;
   opt_walk_operand(f, in, &v->storage, storage_def, fn, ctx);
   for (u32 i = 0; i < v->nparts; ++i)
     opt_walk_operand(f, in, (Operand*)&v->parts[i].op, storage_def, fn, ctx);
 }
 
 void opt_walk_inst_operands(Func* f, Inst* in, OptOperandWalkFn fn, void* ctx) {
   if (!in || !fn) return;
   for (u32 i = 0; i < in->nopnds; ++i) {
     int is_def = opt_inst_operand_is_def(in, i);
     if (!is_def) opt_walk_operand(f, in, &in->opnds[i], 0, fn, ctx);
   }
   for (u32 i = 0; i < in->nopnds; ++i) {
     int is_def = opt_inst_operand_is_def(in, i);
     if (is_def) opt_walk_operand(f, in, &in->opnds[i], 1, fn, ctx);
   }
 
   switch ((IROp)in->op) {
     case IR_PARAM_DECL: {
       Operand def;
       if (in->def == VAL_NONE) break;
       memset(&def, 0, sizeof def);
       def.kind = OPK_REG;
       def.cls = (f->preg_info && in->def < opt_reg_count(f))
                     ? f->preg_info[in->def].cls
                     : 0;
       def.type = in->type;
       def.v.reg = (Reg)in->def;
       opt_walk_operand(f, in, &def, 1, fn, ctx);
       break;
     }
     case IR_CALL: {
       IRCallAux* aux = (IRCallAux*)in->extra.aux;
       if (!aux) break;
       if (aux->use_plan_replay) {
         opt_walk_operand(f, in, &aux->plan.callee, 0, fn, ctx);
         for (u32 i = 0; i < aux->plan.nargs; ++i)
           opt_walk_operand(f, in, &aux->plan.args[i].src, 0, fn, ctx);
         for (u32 i = 0; i < aux->plan.nrets; ++i)
           opt_walk_operand(f, in, &aux->plan.rets[i].dst, 1, fn, ctx);
       } else {
         opt_walk_operand(f, in, &aux->desc.callee, 0, fn, ctx);
         for (u32 i = 0; i < aux->desc.nargs; ++i)
           opt_walk_abivalue(f, in, (CGABIValue*)&aux->desc.args[i], 0, fn, ctx);
         opt_walk_abivalue(f, in, &aux->desc.ret, 1, fn, ctx);
       }
       break;
     }
     case IR_RET: {
       IRRetAux* aux = (IRRetAux*)in->extra.aux;
       if (aux && aux->present) opt_walk_abivalue(f, in, &aux->val, 0, fn, ctx);
       break;
     }
     case IR_SCOPE_BEGIN:
       break;
     case IR_ASM_BLOCK: {
       IRAsmAux* aux = (IRAsmAux*)in->extra.aux;
       if (!aux) break;
       for (u32 i = 0; i < aux->nin; ++i)
         opt_walk_operand(f, in, &aux->in_ops[i], 0, fn, ctx);
       for (u32 i = 0; i < aux->nout; ++i)
         opt_walk_operand(f, in, &aux->out_ops[i], 1, fn, ctx);
       break;
     }
     case IR_INTRINSIC: {
       IRIntrinAux* aux = (IRIntrinAux*)in->extra.aux;
       if (!aux) break;
       for (u32 i = 0; i < aux->narg; ++i)
         opt_walk_operand(f, in, &aux->args[i], 0, fn, ctx);
       for (u32 i = 0; i < aux->ndst; ++i)
         opt_walk_operand(f, in, &aux->dsts[i], 1, fn, ctx);
       break;
     }
     default:
       break;
   }
 }
 
 int opt_mem_observable(const MemAccess* m) {
   return (m->flags & (MF_VOLATILE | MF_ATOMIC)) != 0;
 }