ir.c

   1 // SPDX-License-Identifier: MIT
   2
   3 #include "ir.h"
   4 #include "linearize.h"
   5 #include <stdlib.h>
   6 #include <assert.h>
   7
   8
   9 static int nbr_phi_operands(struct instruction *insn)
  10 {
  11         pseudo_t p;
  12         int nbr = 0;
  13
  14         if (!insn->phi_list)
  15                 return 0;
  16
  17         FOR_EACH_PTR(insn->phi_list, p) {
  18                 if (p == VOID)
  19                         continue;
  20                 nbr++;
  21         } END_FOR_EACH_PTR(p);
  22
  23         return nbr;
  24 }
  25
  26 static int check_phi_node(struct instruction *insn)
  27 {
  28         struct basic_block *par;
  29         pseudo_t phi;
  30         int err = 0;
  31
  32         if (!has_users(insn->target))
  33                 return err;
  34
  35         if (bb_list_size(insn->bb->parents) != nbr_phi_operands(insn)) {
  36                 sparse_error(insn->pos, "bad number of phi operands in:\n\t%s",
  37                         show_instruction(insn));
  38                 info(insn->pos, "parents: %d", bb_list_size(insn->bb->parents));
  39                 info(insn->pos, "phisrcs: %d", nbr_phi_operands(insn));
  40                 return 1;
  41         }
  42
  43         PREPARE_PTR_LIST(insn->bb->parents, par);
  44         FOR_EACH_PTR(insn->phi_list, phi) {
  45                 struct instruction *src;
  46                 if (phi == VOID)
  47                         continue;
  48                 assert(phi->type == PSEUDO_PHI);
  49                 src = phi->def;
  50                 if (src->bb != par) {
  51                         sparse_error(src->pos, "wrong BB for %s:", show_instruction(src));
  52                         info(src->pos, "expected: %s", show_label(par));
  53                         info(src->pos, "     got: %s", show_label(src->bb));
  54                         err++;
  55                 }
  56                 NEXT_PTR_LIST(par);
  57         } END_FOR_EACH_PTR(phi);
  58         FINISH_PTR_LIST(par);
  59         return err;
  60 }
  61
  62 static int check_user(struct instruction *insn, pseudo_t pseudo)
  63 {
  64         struct instruction *def;
  65
  66         if (!pseudo) {
  67                 show_entry(insn->bb->ep);
  68                 sparse_error(insn->pos, "null pseudo in %s", show_instruction(insn));
  69                 return 1;
  70         }
  71         switch (pseudo->type) {
  72         case PSEUDO_PHI:
  73         case PSEUDO_REG:
  74                 def = pseudo->def;
  75                 if (def && def->bb)
  76                         break;
  77                 show_entry(insn->bb->ep);
  78                 sparse_error(insn->pos, "wrong usage for %s in %s", show_pseudo(pseudo),
  79                         show_instruction(insn));
  80                 return 1;
  81
  82         default:
  83                 break;
  84         }
  85         return 0;
  86 }
  87
  88 static int check_branch(struct entrypoint *ep, struct instruction *insn, struct basic_block *bb)
  89 {
  90         if (bb->ep && lookup_bb(ep->bbs, bb))
  91                 return 0;
  92         sparse_error(insn->pos, "branch to dead BB: %s", show_instruction(insn));
  93         return 1;
  94 }
  95
  96 static int check_switch(struct entrypoint *ep, struct instruction *insn)
  97 {
  98         struct multijmp *jmp;
  99         int err = 0;
 100
 101         FOR_EACH_PTR(insn->multijmp_list, jmp) {
 102                 err = check_branch(ep, insn, jmp->target);
 103                 if (err)
 104                         return err;
 105         } END_FOR_EACH_PTR(jmp);
 106
 107         return err;
 108 }
 109
 110 static int check_return(struct instruction *insn)
 111 {
 112         struct symbol *ctype = insn->type;
 113
 114         if (ctype && ctype->bit_size > 0 && insn->src == VOID) {
 115                 sparse_error(insn->pos, "return without value");
 116                 return 1;
 117         }
 118         return 0;
 119 }
 120
 121 static int validate_insn(struct entrypoint *ep, struct instruction *insn)
 122 {
 123         int err = 0;
 124
 125         switch (insn->opcode) {
 126         case OP_SEL:
 127         case OP_RANGE:
 128                 err += check_user(insn, insn->src3);
 129                 /* fall through */
 130
 131         case OP_BINARY ... OP_BINCMP_END:
 132                 err += check_user(insn, insn->src2);
 133                 /* fall through */
 134
 135         case OP_UNOP ... OP_UNOP_END:
 136         case OP_SLICE:
 137         case OP_SYMADDR:
 138         case OP_PHISOURCE:
 139                 err += check_user(insn, insn->src1);
 140                 break;
 141
 142         case OP_CBR:
 143                 err += check_branch(ep, insn, insn->bb_true);
 144                 err += check_branch(ep, insn, insn->bb_false);
 145                 /* fall through */
 146         case OP_COMPUTEDGOTO:
 147                 err += check_user(insn, insn->cond);
 148                 break;
 149
 150         case OP_PHI:
 151                 err += check_phi_node(insn);
 152                 break;
 153
 154         case OP_CALL:
 155                 // FIXME: ignore for now
 156                 break;
 157
 158         case OP_STORE:
 159                 err += check_user(insn, insn->target);
 160                 /* fall through */
 161
 162         case OP_LOAD:
 163                 err += check_user(insn, insn->src);
 164                 break;
 165
 166         case OP_RET:
 167                 err += check_return(insn);
 168                 break;
 169
 170         case OP_BR:
 171                 err += check_branch(ep, insn, insn->bb_true);
 172                 break;
 173         case OP_SWITCH:
 174                 err += check_switch(ep, insn);
 175                 break;
 176
 177         case OP_ENTRY:
 178         case OP_SETVAL:
 179         default:
 180                 break;
 181         }
 182
 183         return err;
 184 }
 185
 186 int ir_validate(struct entrypoint *ep)
 187 {
 188         struct basic_block *bb;
 189         int err = 0;
 190
 191         if (!dbg_ir || has_error)
 192                 return 0;
 193
 194         FOR_EACH_PTR(ep->bbs, bb) {
 195                 struct instruction *insn;
 196                 FOR_EACH_PTR(bb->insns, insn) {
 197                         if (!insn->bb)
 198                                 continue;
 199                         err += validate_insn(ep, insn);
 200                 } END_FOR_EACH_PTR(insn);
 201         } END_FOR_EACH_PTR(bb);
 202
 203         if (err)
 204                 abort();
 205         return err;
 206 }