kit

reg_effects.c (7636B)

---

 #include <string.h>
 
 #include "opt/opt_internal.h"
 
 #if defined(__GNUC__) || defined(__clang__)
 #define EFFECT_ALWAYS_INLINE static inline __attribute__((always_inline))
 #else
 #define EFFECT_ALWAYS_INLINE static inline
 #endif
 
 static void effect_add(OptHardRegSet* set, u8 cls, Reg reg) {
   if (!set || cls >= OPT_REG_CLASSES || reg >= OPT_MAX_HARD_REGS) return;
   set->cls[cls] |= 1u << reg;
 }
 
 static void effect_add_use(OptRegEffectMasks* effects,
                            u8 (*use_count)[OPT_MAX_HARD_REGS], u8 cls,
                            Reg reg) {
   if (!effects || cls >= OPT_REG_CLASSES || reg >= OPT_MAX_HARD_REGS) return;
   effect_add(&effects->uses, cls, reg);
   if (use_count && use_count[cls][reg] < 2u)
     ++use_count[cls][reg];
 }
 
 EFFECT_ALWAYS_INLINE void effect_use_operand(
     OptRegEffectMasks* effects, u8 (*use_count)[OPT_MAX_HARD_REGS],
     const Operand* op) {
   if (!effects || !op) return;
   if (op->kind == OPK_REG) {
     effect_add_use(effects, use_count, op->cls, op->v.reg);
   } else if (op->kind == OPK_INDIRECT) {
     if (op->v.ind.base_kind == OPT_INDIRECT_REG)
       effect_add_use(effects, use_count, RC_INT, op->v.ind.base);
     if (op->v.ind.index_kind == OPT_INDIRECT_REG &&
         op->v.ind.index != (Reg)REG_NONE)
       effect_add_use(effects, use_count, RC_INT, op->v.ind.index);
   }
 }
 
 static void effect_def_operand(OptRegEffectMasks* effects,
                                const Operand* op) {
   if (effects && op && op->kind == OPK_REG)
     effect_add(&effects->defs, op->cls, op->v.reg);
 }
 
 EFFECT_ALWAYS_INLINE void effect_use_abivalue(
     OptRegEffectMasks* effects, u8 (*use_count)[OPT_MAX_HARD_REGS],
     const CGABIValue* v) {
   if (!v) return;
   effect_use_operand(effects, use_count, &v->storage);
   for (u32 i = 0; i < v->nparts; ++i)
     effect_use_operand(effects, use_count, &v->parts[i].op);
 }
 
 static void effect_def_abivalue(OptRegEffectMasks* effects,
                                 const CGABIValue* v) {
   if (!v) return;
   effect_def_operand(effects, &v->storage);
   for (u32 i = 0; i < v->nparts; ++i)
     effect_def_operand(effects, &v->parts[i].op);
 }
 
 static void effect_add_masks(OptHardRegSet* set, const u32* masks) {
   if (!set || !masks) return;
   for (u32 c = 0; c < OPT_REG_CLASSES; ++c) set->cls[c] |= masks[c];
 }
 
 u32 opt_call_clobber_mask_for(Func* f, const Inst* in, u8 cls) {
   if (!f || cls >= OPT_REG_CLASSES) return 0;
   if (in && (IROp)in->op == IR_CALL) {
     const IRCallAux* aux = (const IRCallAux*)in->extra.aux;
     if (aux && aux->plan_valid) return aux->plan.clobber_mask[cls];
   }
   return f->opt_caller_saved[cls];
 }
 
 const u32* opt_inst_machine_clobber_masks(Func* f, const Inst* in) {
   if (!f || !in || !f->inst_clobbers || in->id == INST_ID_NONE ||
       in->id >= f->inst_clobbers_cap)
     return NULL;
   return f->inst_clobbers[in->id];
 }
 
 /* This is the sole opcode/ABI authority for physical-register effects. Every
  * detailed, masks-only, and kills-only view below is a projection of this
  * walker; consumers must not reproduce these operand or clobber rules. */
 EFFECT_ALWAYS_INLINE void effect_explicit_operands(
     Func* f, const Inst* in, OptRegEffectMasks* effects,
     u8 (*use_count)[OPT_MAX_HARD_REGS], int collect_uses) {
   for (u32 i = 0; i < in->nopnds; ++i) {
     if (opt_inst_operand_is_def(in, i))
       effect_def_operand(effects, &in->opnds[i]);
     else if (collect_uses)
       effect_use_operand(effects, use_count, &in->opnds[i]);
   }
 
   /* Direct operand roles come from opt_inst_operand_is_def above. Only
    * register-bearing auxiliary descriptions need instruction-specific work. */
   switch ((IROp)in->op) {
     case IR_CALL: {
       const IRCallAux* aux = (const IRCallAux*)in->extra.aux;
       if (aux && aux->use_plan_replay) {
         if (collect_uses)
           effect_use_operand(effects, use_count, &aux->plan.callee);
         for (u32 i = 0; i < aux->plan.nargs; ++i) {
           if (collect_uses)
             effect_use_operand(effects, use_count, &aux->plan.args[i].src);
           if (aux->plan.args[i].dst_kind == CG_CALL_PLAN_REG)
             effect_add(&effects->defs, aux->plan.args[i].cls,
                        aux->plan.args[i].dst_reg);
         }
         for (u32 i = 0; i < aux->plan.nrets; ++i) {
           effect_add(&effects->defs, aux->plan.rets[i].cls,
                      aux->plan.rets[i].src_reg);
           effect_def_operand(effects, &aux->plan.rets[i].dst);
         }
       } else if (aux) {
         if (collect_uses) {
           effect_use_operand(effects, use_count, &aux->desc.callee);
           for (u32 i = 0; i < aux->desc.nargs; ++i)
             effect_use_abivalue(effects, use_count, &aux->desc.args[i]);
         }
         effect_def_abivalue(effects, &aux->desc.ret);
       }
       for (u32 c = 0; c < OPT_REG_CLASSES; ++c)
         effects->clobbers.cls[c] |=
             opt_call_clobber_mask_for(f, in, (u8)c);
       break;
     }
     case IR_RET: {
       const IRRetAux* aux = (const IRRetAux*)in->extra.aux;
       if (collect_uses && aux && aux->present)
         effect_use_abivalue(effects, use_count, &aux->val);
       break;
     }
     case IR_ASM_BLOCK: {
       const IRAsmAux* aux = (const IRAsmAux*)in->extra.aux;
       if (!aux) break;
       if (collect_uses)
         for (u32 i = 0; i < aux->nin; ++i)
           effect_use_operand(effects, use_count, &aux->in_ops[i]);
       for (u32 i = 0; i < aux->nout; ++i)
         effect_def_operand(effects, &aux->out_ops[i]);
       effect_add_masks(&effects->clobbers, aux->clobber_mask);
       break;
     }
     case IR_INTRINSIC: {
       const IRIntrinAux* aux = (const IRIntrinAux*)in->extra.aux;
       if (!aux) break;
       if (collect_uses)
         for (u32 i = 0; i < aux->narg; ++i)
           effect_use_operand(effects, use_count, &aux->args[i]);
       for (u32 i = 0; i < aux->ndst; ++i)
         effect_def_operand(effects, &aux->dsts[i]);
       break;
     }
     default:
       break;
   }
 }
 
 static void effect_add_machine_clobbers(Func* f, const Inst* in,
                                         OptRegEffectMasks* effects) {
   effect_add_masks(&effects->clobbers,
                    opt_inst_machine_clobber_masks(f, in));
 }
 
 EFFECT_ALWAYS_INLINE void effect_build(
     Func* f, const Inst* in, OptRegEffectMasks* effects,
     u8 (*use_count)[OPT_MAX_HARD_REGS], int collect_uses) {
   if (!f || !in) return;
   effect_explicit_operands(f, in, effects, use_count, collect_uses);
   effect_add_machine_clobbers(f, in, effects);
 }
 
 void opt_inst_reg_effects(Func* f, const Inst* in, OptRegEffects* effects) {
   if (!effects) return;
   memset(effects, 0, sizeof *effects);
   effect_build(f, in, &effects->masks, effects->use_count, 1);
 }
 
 void opt_inst_reg_effect_masks(Func* f, const Inst* in,
                                OptRegEffectMasks* masks) {
   if (!masks) return;
   memset(masks, 0, sizeof *masks);
   effect_build(f, in, masks, NULL, 1);
 }
 
 void opt_inst_reg_kills(Func* f, const Inst* in, OptHardRegSet* kills) {
   OptRegEffectMasks effects;
   if (!kills) return;
   memset(&effects, 0, sizeof effects);
   effect_build(f, in, &effects, NULL, 0);
   opt_reg_effect_mask_kills(&effects, kills);
 }
 
 void opt_reg_effect_kills(const OptRegEffects* effects, OptHardRegSet* kills) {
   opt_reg_effect_mask_kills(effects ? &effects->masks : NULL, kills);
 }
 
 void opt_reg_effect_mask_kills(const OptRegEffectMasks* masks,
                                OptHardRegSet* kills) {
   if (!kills) return;
   memset(kills, 0, sizeof *kills);
   if (!masks) return;
   for (u32 c = 0; c < OPT_REG_CLASSES; ++c)
     kills->cls[c] = masks->defs.cls[c] | masks->clobbers.cls[c];
 }
 
 #undef EFFECT_ALWAYS_INLINE