Lines Matching refs:insn
89 static int get_phisources(struct instruction *sources[], int nbr, struct instruction *insn)
94 assert(insn->opcode == OP_PHI);
95 FOR_EACH_PTR(insn->phi_list, phi) {
108 static int if_convert_phi(struct instruction *insn)
116 bb = insn->bb;
117 if (get_phisources(array, 2, insn))
181 insert_select(source, br, insn, p1, p2);
182 kill_instruction(insn);
188 // @insn: the phi-node
199 static pseudo_t trivial_phi(pseudo_t pseudo, struct instruction *insn, struct pseudo_list **list)
201 pseudo_t target = insn->target;
206 FOR_EACH_PTR(insn->phi_list, phi) {
238 static int clean_up_phi(struct instruction *insn)
243 if ((pseudo = trivial_phi(NULL, insn, &list))) {
244 convert_instruction_target(insn, pseudo);
245 kill_instruction(insn);
249 return if_convert_phi(insn);
311 static void kill_asm(struct instruction *insn)
315 FOR_EACH_PTR(insn->asm_rules->inputs, con) {
322 // @insn: the instruction to be killed
330 int kill_insn(struct instruction *insn, int force)
332 if (!insn || !insn->bb)
335 switch (insn->opcode) {
338 kill_use(&insn->src3);
342 kill_use(&insn->src2);
352 kill_use(&insn->src1);
356 kill_use_list(insn->phi_list);
362 struct symbol *fntype = first_symbol(insn->fntypes);
367 kill_use_list(insn->arguments);
368 if (insn->func->type == PSEUDO_REG)
369 kill_use(&insn->func);
373 if (!force && insn->is_volatile)
375 kill_use(&insn->src);
381 kill_use(&insn->src);
382 kill_use(&insn->target);
388 kill_asm(insn);
403 insn->bb = NULL;
407 static inline bool has_target(struct instruction *insn)
409 return opcode_table[insn->opcode].flags & OPF_TARGET;
417 struct instruction *insn;
418 FOR_EACH_PTR_REVERSE(bb->insns, insn) {
419 if (!insn->bb)
421 if (!has_target(insn))
423 if (!has_users(insn->target))
424 kill_instruction(insn);
425 } END_FOR_EACH_PTR_REVERSE(insn);
466 // @insn: the instruction
470 static inline int replace_pseudo(struct instruction *insn, pseudo_t *pp, pseudo_t new)
473 use_pseudo(insn, new, pp);
478 int replace_with_pseudo(struct instruction *insn, pseudo_t pseudo)
480 convert_instruction_target(insn, pseudo);
481 return kill_instruction(insn);
484 static inline int replace_with_value(struct instruction *insn, long long val)
486 return replace_with_pseudo(insn, value_pseudo(val));
491 // @insn: the instruction to be replaced
495 static inline int replace_with_unop(struct instruction *insn, int op, pseudo_t src)
497 insn->opcode = op;
498 replace_pseudo(insn, &insn->src1, src);
499 remove_usage(insn->src2, &insn->src2);
505 // @insn: the instruction to be replaced
509 static inline int replace_binop_value(struct instruction *insn, int op, long long val)
511 insn->opcode = op;
512 insn->src2 = value_pseudo(val);
518 // @insn: the instruction to be replaced
521 static inline int replace_binop(struct instruction *insn, int op, pseudo_t *pa, pseudo_t a, pseudo_t *pb, pseudo_t b)
525 insn->opcode = op;
526 use_pseudo(insn, a, pa);
527 use_pseudo(insn, b, pb);
536 static inline int replace_opcode(struct instruction *insn, int op)
538 insn->opcode = op;
609 static unsigned int operand_size(struct instruction *insn, pseudo_t pseudo)
611 unsigned int size = insn->size;
772 // @insn: the masking instruction
777 static int simplify_mask_or_and(struct instruction *insn, unsigned long long mask,
792 return replace_pseudo(insn, &insn->src1, orb);
794 if (!one_use(insn->src1))
797 struct instruction *or = insn->src1->def;
812 // @insn: the masking instruction
816 static int simplify_mask_or(struct instruction *insn, unsigned long long mask, struct instruction *or)
823 if ((rc = simplify_mask_or_and(insn, mask, src1, src2)))
827 if ((rc = simplify_mask_or_and(insn, mask, src2, src1)))
836 return replace_pseudo(insn, &insn->src1, src1);
840 return replace_pseudo(insn, &insn->src1, value_pseudo(mask));
883 static pseudo_t eval_insn(struct instruction *insn)
885 unsigned size = insn->size;
887 if (opcode_table[insn->opcode].flags & OPF_COMPARE)
888 size = insn->itype->bit_size;
889 return eval_op(insn->opcode, size, insn->src1, insn->src2);
892 static long long check_shift_count(struct instruction *insn, unsigned long long uval)
894 unsigned int size = insn->size;
897 if (insn->tainted)
903 insn->tainted = 1;
907 insn->src2 = value_pseudo(sval);
911 static int simplify_shift(struct instruction *insn, pseudo_t pseudo, long long value)
920 return replace_with_pseudo(insn, pseudo);
921 value = check_shift_count(insn, value);
925 size = insn->size;
926 switch (insn->opcode) {
936 if (def == insn) // cyclic DAG!
942 if (nval > insn->size || nval == 0)
946 insn->opcode = OP_LSR;
958 insn->opcode = OP_LSR;
963 size = operand_size(insn, pseudo);
972 mask = bits_mask(insn->size - value) << value;
976 return replace_with_value(insn, 0);
978 return replace_pseudo(insn, &insn->src1, def->src1);
982 def->src2 = insn->src2;
983 insn->opcode = OP_AND;
984 insn->src2 = value_pseudo(omask >> value);
990 return simplify_mask_shift_or(insn, def, mask);
994 if (def->src2 != insn->src2)
996 mask = bits_mask(insn->size - value);
1008 mask = bits_mask(insn->size) >> value;
1012 return replace_with_value(insn, 0);
1014 return replace_pseudo(insn, &insn->src1, def->src1);
1020 if (def->src2 != insn->src2)
1022 mask = bits_mask(insn->size - value) << value;
1026 return simplify_mask_shift_or(insn, def, mask);
1029 if (def == insn) // cyclic DAG!
1035 if (nval > insn->size)
1046 insn->src2 = value_pseudo(value);
1047 return replace_pseudo(insn, &insn->src1, pseudo->def->src1);
1050 return replace_with_value(insn, 0);
1052 insn->opcode = OP_AND;
1053 insn->src2 = value_pseudo(mask);
1054 return replace_pseudo(insn, &insn->src1, def->src1);
1057 static int simplify_mul_div(struct instruction *insn, long long value)
1059 unsigned long long sbit = 1ULL << (insn->size - 1);
1063 return replace_with_pseudo(insn, insn->src1);
1065 switch (insn->opcode) {
1068 return replace_with_pseudo(insn, insn->src2);
1076 insn->opcode = OP_NEG;
1084 static int simplify_seteq_setne(struct instruction *insn, long long value)
1086 pseudo_t old = insn->src1;
1101 inverse = (insn->opcode == OP_SET_NE) == value;
1102 if (!inverse && def->size == 1 && insn->size == 1) {
1108 return replace_with_pseudo(insn, old);
1115 if (def->size != insn->size)
1121 return replace_with_pseudo(insn, old);
1130 insn->opcode = inverse ? opcode_table[opcode].negate : opcode;
1131 insn->itype = def->itype;
1132 use_pseudo(insn, def->src1, &insn->src1);
1133 use_pseudo(insn, def->src2, &insn->src2);
1134 remove_usage(old, &insn->src1);
1148 insn->itype = def->orig_type;
1149 return replace_pseudo(insn, &insn->src1, def->src);
1170 static int simplify_compare_constant(struct instruction *insn, long long value)
1172 unsigned size = insn->itype->bit_size;
1179 switch (insn->opcode) {
1184 return replace_with_pseudo(insn, value_pseudo(0));
1186 return replace_opcode(insn, OP_SET_NE);
1188 return replace_binop_value(insn, OP_SET_EQ, sign_bit(size));
1190 changed |= replace_binop_value(insn, OP_SET_LE, (value - 1) & bits);
1196 return replace_with_pseudo(insn, value_pseudo(1));
1198 return replace_opcode(insn, OP_SET_EQ);
1200 return replace_binop_value(insn, OP_SET_NE, sign_mask(size));
1202 changed |= replace_binop_value(insn, OP_SET_LT, (value + 1) & bits);
1208 return replace_with_pseudo(insn, value_pseudo(1));
1210 return replace_opcode(insn, OP_SET_EQ);
1212 return replace_binop_value(insn, OP_SET_NE, sign_bit(size));
1214 changed |= replace_binop_value(insn, OP_SET_GT, (value - 1) & bits);
1220 return replace_with_pseudo(insn, value_pseudo(0));
1222 return replace_opcode(insn, OP_SET_NE);
1224 return replace_binop_value(insn, OP_SET_EQ, sign_mask(size));
1226 changed |= replace_binop_value(insn, OP_SET_GE, (value + 1) & bits);
1231 return replace_with_pseudo(insn, value_pseudo(0));
1233 return replace_binop_value(insn, OP_SET_EQ, 0);
1235 return replace_binop_value(insn, OP_SET_NE, value);
1237 changed |= replace_binop_value(insn, OP_SET_BE, (value - 1) & bits);
1241 return replace_with_pseudo(insn, value_pseudo(1));
1243 return replace_binop_value(insn, OP_SET_NE, 0);
1245 return replace_binop_value(insn, OP_SET_EQ, value);
1247 changed |= replace_binop_value(insn, OP_SET_A, (value - 1) & bits);
1251 return replace_opcode(insn, OP_SET_EQ);
1253 return replace_with_pseudo(insn, value_pseudo(1));
1255 return replace_binop_value(insn, OP_SET_NE, bits);
1257 changed |= replace_binop_value(insn, OP_SET_GE, 0);
1261 return replace_opcode(insn, OP_SET_NE);
1263 return replace_with_pseudo(insn, value_pseudo(0));
1265 return replace_binop_value(insn, OP_SET_EQ, bits);
1267 changed |= replace_binop_value(insn, OP_SET_LT, 0);
1271 src1 = insn->src1;
1272 src2 = insn->src2;
1279 switch (insn->opcode) {
1282 return replace_with_value(insn, 0);
1284 return replace_binop_value(insn, OP_SET_NE, 0);
1288 return replace_with_value(insn, 1);
1290 return replace_binop_value(insn, OP_SET_EQ, 0);
1294 if (insn->opcode == OP_SET_LT)
1299 return replace_with_value(insn, 0);
1301 return replace_with_value(insn, 1);
1303 return replace_opcode(insn, OP_SET_EQ);
1307 if (insn->opcode == OP_SET_GE)
1312 return replace_with_value(insn, 1);
1314 return replace_with_value(insn, 0);
1316 return replace_opcode(insn, OP_SET_NE);
1320 return replace_with_value(insn, 1);
1324 return replace_with_value(insn, 1);
1328 return replace_with_value(insn, 0);
1332 return replace_with_value(insn, 0);
1340 switch (insn->opcode) {
1343 return replace_with_value(insn, 0);
1347 return replace_with_value(insn, 1);
1351 return replace_with_value(insn, 0);
1355 return replace_with_value(insn, 0);
1359 return replace_with_value(insn, 1);
1363 return replace_with_value(insn, 1);
1371 return replace_with_value(insn, 1);
1380 return replace_with_value(insn, 0);
1388 insn->itype = def->orig_type;
1389 insn->src2 = value_pseudo(zero_extend(value, osize));
1390 return replace_pseudo(insn, &insn->src1, def->src);
1392 switch (insn->opcode) {
1395 insn->itype = def->orig_type;
1396 replace_binop_value(insn, OP_SET_GE, 0);
1397 return replace_pseudo(insn, &insn->src1, def->src);
1402 insn->itype = def->orig_type;
1403 replace_binop_value(insn, OP_SET_LT, 0);
1404 return replace_pseudo(insn, &insn->src1, def->src);
1409 return replace_with_value(insn, 1);
1411 return replace_with_value(insn, 0);
1415 return replace_with_value(insn, 0);
1417 return replace_with_value(insn, 1);
1423 switch (insn->opcode) {
1426 insn->itype = def->orig_type;
1439 const struct opcode_table *op = &opcode_table[insn->opcode];
1441 insn->opcode = op->sign;
1442 insn->itype = def->orig_type;
1443 return replace_pseudo(insn, &insn->src1, def->src);
1445 switch (insn->opcode) {
1448 return replace_with_value(insn, 1);
1450 return replace_with_value(insn, 0);
1454 return replace_with_value(insn, 0);
1456 return replace_with_value(insn, 1);
1459 return replace_with_value(insn, 1);
1461 return replace_with_value(insn, 0);
1468 static int simplify_constant_mask(struct instruction *insn, unsigned long long mask)
1470 pseudo_t old = insn->src1;
1481 return simplify_mask_or(insn, mask, def);
1493 return replace_with_pseudo(insn, old);
1496 insn->src2 = value_pseudo(nmask);
1504 static int simplify_const_rightadd(struct instruction *def, struct instruction *insn)
1506 unsigned size = insn->size;
1507 pseudo_t src2 = insn->src2;
1513 insn->opcode = OP_SUB;
1514 use_pseudo(insn, def->src2, &insn->src2);
1515 return replace_pseudo(insn, &insn->src1, val);
1522 static int simplify_constant_rightside(struct instruction *insn)
1524 long long value = insn->src2->value;
1525 long long sbit = 1ULL << (insn->size - 1);
1529 switch (insn->opcode) {
1532 return replace_with_pseudo(insn, insn->src2);
1537 insn->opcode = OP_NOT;
1543 return replace_with_pseudo(insn, insn->src1);
1547 insn->opcode = OP_ADD;
1548 insn->src2 = eval_unop(OP_NEG, insn->size, insn->src2);
1553 return replace_with_pseudo(insn, insn->src1);
1554 if (insn->src1->type == PSEUDO_REG) // (x # y) + z
1555 changed |= simplify_const_rightadd(insn->src1->def, insn);
1560 return simplify_shift(insn, insn->src1, value);
1564 return replace_with_value(insn, 0);
1569 return simplify_mul_div(insn, value);
1573 return replace_with_pseudo(insn, insn->src2);
1575 return replace_with_pseudo(insn, insn->src1);
1576 return simplify_constant_mask(insn, value);
1580 if ((changed = simplify_seteq_setne(insn, value)))
1585 return simplify_compare_constant(insn, value);
1590 static int simplify_const_leftsub(struct instruction *insn, struct instruction *def)
1592 unsigned size = insn->size;
1593 pseudo_t src1 = insn->src1;
1598 insn->src1 = eval_op(OP_SUB, size, src1, def->src2);
1599 return replace_pseudo(insn, &insn->src2, def->src1);
1605 insn->opcode = OP_ADD;
1606 use_pseudo(insn, def->src2, &insn->src1);
1607 return replace_pseudo(insn, &insn->src2, val);
1614 static int simplify_constant_leftside(struct instruction *insn)
1616 long long value = insn->src1->value;
1618 switch (insn->opcode) {
1621 return replace_with_pseudo(insn, insn->src2);
1629 return replace_with_pseudo(insn, insn->src1);
1633 return replace_with_unop(insn, OP_NEG, insn->src2);
1634 if (insn->src2->type == PSEUDO_REG)
1635 return simplify_const_leftsub(insn, insn->src2->def);
1641 static int simplify_constant_binop(struct instruction *insn)
1643 pseudo_t res = eval_insn(insn);
1648 return replace_with_pseudo(insn, res);
1651 static int simplify_binop_same_args(struct instruction *insn, pseudo_t arg)
1653 switch (insn->opcode) {
1658 warning(insn->pos, "self-comparison always evaluates to false");
1661 return replace_with_value(insn, 0);
1667 warning(insn->pos, "self-comparison always evaluates to true");
1668 return replace_with_value(insn, 1);
1672 return replace_with_pseudo(insn, arg);
1681 static int simplify_binop(struct instruction *insn)
1683 if (constant(insn->src1)) {
1684 if (constant(insn->src2))
1685 return simplify_constant_binop(insn);
1686 return simplify_constant_leftside(insn);
1688 if (constant(insn->src2))
1689 return simplify_constant_rightside(insn);
1690 if (insn->src1 == insn->src2)
1691 return simplify_binop_same_args(insn, insn->src1);
1738 static int canonicalize_commutative(struct instruction *insn)
1740 if (canonical_order(insn->src1, insn->src2))
1743 switch_pseudo(insn, &insn->src1, insn, &insn->src2);
1747 static int canonicalize_compare(struct instruction *insn)
1749 if (canonical_order(insn->src1, insn->src2))
1752 switch_pseudo(insn, &insn->src1, insn, &insn->src2);
1753 insn->opcode = opcode_table[insn->opcode].swap;
1766 struct instruction *insn;
1768 FOR_EACH_PTR(bb->insns, insn) {
1769 if (insn == x)
1771 if (insn == y)
1773 } END_FOR_EACH_PTR(insn);
1800 static int simplify_associative_binop(struct instruction *insn)
1803 pseudo_t pseudo = insn->src1;
1805 if (!simple_pseudo(insn->src2))
1810 if (def == insn)
1812 if (def->opcode != insn->opcode)
1816 if (constant(def->src2) && constant(insn->src2)) {
1818 insn->src2 = eval_op(insn->opcode, insn->size, insn->src2, def->src2);
1819 return replace_pseudo(insn, &insn->src1, def->src1);
1823 switch_pseudo(def, &def->src1, insn, &insn->src2);
1827 static int simplify_add_one_side(struct instruction *insn, pseudo_t *p1, pseudo_t *p2)
1839 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1844 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
1849 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
1856 return replace_binop(insn, OP_SUB, &insn->src1, src2, &insn->src2, def->src);
1860 return replace_with_pseudo(insn, def->src1);
1866 static int simplify_add(struct instruction *insn)
1868 return simplify_add_one_side(insn, &insn->src1, &insn->src2) ||
1869 simplify_add_one_side(insn, &insn->src2, &insn->src1);
1872 static int simplify_sub(struct instruction *insn)
1874 pseudo_t src1 = insn->src1;
1875 pseudo_t src2 = insn->src2;
1881 return replace_with_pseudo(insn, def->src2);
1883 return replace_with_pseudo(insn, def->src1);
1890 return replace_with_unop(insn, OP_NEG, def->src2);
1892 return replace_with_unop(insn, OP_NEG, def->src1);
1895 insn->opcode = OP_ADD;
1896 return replace_pseudo(insn, &insn->src2, def->src);
1902 static int simplify_compare(struct instruction *insn)
1904 pseudo_t src1 = insn->src1;
1905 pseudo_t src2 = insn->src2;
1914 const struct opcode_table *op = &opcode_table[insn->opcode];
1916 insn->opcode = op->sign;
1917 insn->itype = def->orig_type;
1918 replace_pseudo(insn, &insn->src1, def->src);
1919 return replace_pseudo(insn, &insn->src2, src);
1926 static int simplify_and_one_side(struct instruction *insn, pseudo_t *p1, pseudo_t *p2)
1934 return replace_with_value(insn, 0);
1939 return replace_with_value(insn, 0);
1947 insn->itype = defr->itype;
1948 replace_binop(insn, OP_SET_BE, &insn->src1, defr->src1, &insn->src2, defr->src2);
1957 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1962 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
1967 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
1976 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1985 static int simplify_and(struct instruction *insn)
1987 return simplify_and_one_side(insn, &insn->src1, &insn->src2) ||
1988 simplify_and_one_side(insn, &insn->src2, &insn->src1);
1991 static int simplify_ior_one_side(struct instruction *insn, pseudo_t *p1, pseudo_t *p2)
2001 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2006 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
2011 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
2018 return replace_with_value(insn, bits_mask(insn->size));
2023 return replace_with_value(insn, 1);
2030 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2039 static int simplify_ior(struct instruction *insn)
2041 return simplify_ior_one_side(insn, &insn->src1, &insn->src2) ||
2042 simplify_ior_one_side(insn, &insn->src2, &insn->src1);
2045 static int simplify_xor_one_side(struct instruction *insn, pseudo_t *p1, pseudo_t *p2)
2055 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2060 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
2065 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
2072 return replace_with_value(insn, bits_mask(insn->size));
2077 return replace_with_value(insn, 1);
2084 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2093 static int simplify_xor(struct instruction *insn)
2095 return simplify_xor_one_side(insn, &insn->src1, &insn->src2) ||
2096 simplify_xor_one_side(insn, &insn->src2, &insn->src1);
2099 static int simplify_constant_unop(struct instruction *insn)
2101 long long val = insn->src1->value;
2104 switch (insn->opcode) {
2112 mask = 1ULL << (insn->orig_type->bit_size-1);
2123 mask = 1ULL << (insn->size-1);
2126 return replace_with_value(insn, res);
2129 static int simplify_unop(struct instruction *insn)
2132 pseudo_t src = insn->src;
2135 return simplify_constant_unop(insn);
2137 switch (insn->opcode) {
2143 insn->opcode = OP_SUB; // ~(x + C) --> ~C - x
2144 src = eval_unop(OP_NOT, insn->size, def->src2);
2145 use_pseudo(insn, def->src1, &insn->src2);
2146 return replace_pseudo(insn, &insn->src1, src);
2148 insn->opcode = OP_SUB; // ~(-x) --> x - 1
2149 insn->src2 = value_pseudo(1);
2150 return replace_pseudo(insn, &insn->src1, def->src);
2152 return replace_with_pseudo(insn, def->src);
2156 insn->opcode = OP_ADD; // ~(C - x) --> x + ~C
2157 insn->src2 = eval_unop(OP_NOT, insn->size, def->src1);
2158 return replace_pseudo(insn, &insn->src1, def->src2);
2162 insn->opcode = OP_XOR; // ~(x ^ C) --> x ^ ~C
2163 insn->src2 = eval_unop(OP_NOT, insn->size, def->src2);
2164 return replace_pseudo(insn, &insn->src1, def->src1);
2172 insn->opcode = OP_SUB; // -(x + C) --> (-C - x)
2173 src = eval_unop(OP_NEG, insn->size, def->src2);
2174 use_pseudo(insn, def->src1, &insn->src2);
2175 return replace_pseudo(insn, &insn->src1, src);
2177 return replace_with_pseudo(insn, def->src);
2179 insn->opcode = OP_ADD; // -(~x) --> x + 1
2180 insn->src2 = value_pseudo(1);
2181 return replace_pseudo(insn, &insn->src1, def->src);
2183 insn->opcode = OP_SUB; // -(x - y) --> y - x
2184 use_pseudo(insn, def->src1, &insn->src2);
2185 return replace_pseudo(insn, &insn->src1, def->src2);
2194 static int simplify_one_memop(struct instruction *insn, pseudo_t orig)
2196 pseudo_t addr = insn->src;
2202 kill_use(&insn->src);
2203 use_pseudo(insn, def->src, &insn->src);
2234 warning(insn->pos, "crazy programmer");
2235 replace_pseudo(insn, &insn->src, VOID);
2238 insn->offset += off->value;
2239 replace_pseudo(insn, &insn->src, new);
2248 static int simplify_memop(struct instruction *insn)
2251 pseudo_t orig = insn->src;
2254 one = simplify_one_memop(insn, orig);
2260 static int simplify_cast(struct instruction *insn)
2264 pseudo_t src = insn->src;
2271 return simplify_constant_unop(insn);
2274 size = insn->size;
2282 switch (insn->opcode) {
2288 def->type = insn->type;
2291 insn->opcode = OP_AND;
2294 insn->src2 = value_pseudo(mask);
2314 def->orig_type = insn->orig_type;
2315 def->type = insn->type;
2316 def->size = insn->size;
2317 insn->opcode = OP_AND;
2318 insn->src2 = val;
2323 switch (insn->opcode) {
2325 if (insn->size == 1)
2336 insn->opcode = def->opcode;
2337 insn->itype = def->itype;
2338 use_pseudo(insn, def->src2, &insn->src2);
2339 return replace_pseudo(insn, &insn->src1, def->src1);
2343 switch (insn->opcode) {
2347 insn->opcode = OP_NOT;
2350 def->type = insn->type;
2351 def->size = insn->size;
2358 switch (insn->opcode) {
2360 mask = bits_mask(insn->size);
2361 return simplify_mask_or(insn, mask, def);
2366 if (insn->opcode != OP_TRUNC)
2368 mask = bits_mask(insn->size);
2371 switch (insn->opcode) {
2373 insn->orig_type = def->orig_type;
2374 return replace_pseudo(insn, &insn->src1, def->src);
2383 insn->opcode = OP_ASR;
2384 insn->src2 = def2->src2;
2385 return replace_pseudo(insn, &insn->src1, def2->src1);
2389 insn->opcode = OP_AND;
2390 insn->src2 = value_pseudo((1ULL << def->size) - 1);
2391 return replace_pseudo(insn, &insn->src1, def->src);
2395 switch (insn->opcode) {
2397 insn->opcode = OP_ZEXT;
2400 insn->orig_type = def->orig_type;
2401 return replace_pseudo(insn, &insn->src, def->src);
2405 switch (insn->opcode) {
2409 return replace_with_pseudo(insn, def->src);
2411 insn->opcode = def->opcode;
2412 insn->orig_type = def->orig_type;
2413 return replace_pseudo(insn, &insn->src, def->src);
2415 switch (insn->opcode) {
2417 insn->orig_type = def->orig_type;
2418 return replace_pseudo(insn, &insn->src, def->src);
2426 static int simplify_select(struct instruction *insn)
2431 cond = insn->src1;
2432 src1 = insn->src2;
2433 src2 = insn->src3;
2436 return replace_with_pseudo(insn, cond->value ? src1 : src2);
2438 return replace_with_pseudo(insn, src1);
2451 insn->opcode = opcode;
2452 /* insn->src1 is already cond */
2453 insn->src2 = src1; /* Zero */
2458 return replace_with_pseudo(insn, src1);
2460 return replace_with_pseudo(insn, cond);
2465 return replace_with_pseudo(insn, src2); // SEL(x==y,x,y) --> y
2467 return replace_with_pseudo(insn, src2); // SEL(y==x,x,y) --> y
2471 return replace_with_pseudo(insn, src1); // SEL(x!=y,x,y) --> x
2473 return replace_with_pseudo(insn, src1); // SEL(y!=x,x,y) --> x
2481 return switch_pseudo(insn, &insn->src2, insn, &insn->src3);
2500 return replace_with_pseudo(insn, cond);
2501 return replace_pseudo(insn, &insn->cond, def->cond);
2504 switch_pseudo(insn, &insn->src2, insn, &insn->src3);
2505 return replace_pseudo(insn, &insn->cond, def->cond);
2508 return replace_with_pseudo(insn, src1);
2511 if (is_pow2(def->src2) && is_pow2(src1) && is_zero(src2) && insn->size == def->size && one_use(cond)) {
2513 unsigned s2 = log2_exact(insn->src2->value);
2517 return replace_with_pseudo(insn, cond);
2520 insn->opcode = (s1 < s2) ? OP_SHL : OP_LSR;
2522 insn->src2 = value_pseudo(shift);
2532 swap_select(insn, def, cond, def->src2, value_pseudo(0), src2);
2537 swap_select(insn, def, cond, def->src1, value_pseudo(0), src2);
2547 swap_select(insn, def, cond, value_pseudo(0), def->src2, src1);
2552 swap_select(insn, def, cond, value_pseudo(0), def->src1, src1);
2573 static int simplify_range(struct instruction *insn)
2577 src1 = insn->src1;
2578 src2 = insn->src2;
2579 src3 = insn->src3;
2583 kill_instruction(insn);
2602 static int simplify_branch(struct instruction *insn)
2604 pseudo_t cond = insn->cond;
2608 return convert_to_jump(insn, cond->value ? insn->bb_true : insn->bb_false);
2611 if (insn->bb_true == insn->bb_false)
2612 return convert_to_jump(insn, insn->bb_true);
2620 return simplify_cond_branch(insn, def, def->src2);
2622 return simplify_cond_branch(insn, def, def->src1);
2629 return convert_to_jump(insn, insn->bb_false);
2631 return convert_to_jump(insn, insn->bb_true);
2633 struct basic_block *tmp = insn->bb_true;
2634 insn->bb_true = insn->bb_false;
2635 insn->bb_false = tmp;
2637 return replace_pseudo(insn, &insn->cond, def->src1);
2641 return replace_pseudo(insn, &insn->cond, def->src);
2646 static int simplify_switch(struct instruction *insn)
2648 pseudo_t cond = insn->cond;
2654 val = insn->cond->value;
2656 FOR_EACH_PTR(insn->multijmp_list, jmp) {
2663 warning(insn->pos, "Impossible case statement");
2667 return convert_to_jump(insn, jmp->target);
2679 static int simplify_cgoto(struct instruction *insn)
2681 struct basic_block *target, *bb = insn->bb;
2686 switch (DEF_OPCODE(def, insn->src)) {
2689 insn->opcode = OP_CBR;
2690 insn->bb_true = bbt;
2691 insn->bb_false = bbf;
2692 return replace_pseudo(insn, &insn->src1, def->cond);
2699 FOR_EACH_PTR(insn->multijmp_list, jmp) {
2706 kill_use(&insn->src);
2707 insn->opcode = OP_BR;
2708 insn->bb_true = target;
2714 static int simplify_setval(struct instruction *insn)
2716 struct expression *val = insn->val;
2720 insn->opcode = OP_LABEL;
2721 insn->bb_true = val->symbol->bb_target;
2729 int simplify_instruction(struct instruction *insn)
2734 flags = opcode_table[insn->opcode].flags;
2736 if (!has_users(insn->target))
2737 return kill_instruction(insn);
2740 canonicalize_commutative(insn) ;
2742 canonicalize_compare(insn) ;
2744 if ((changed = simplify_binop(insn)))
2748 if ((changed = simplify_associative_binop(insn)))
2752 if ((changed = simplify_unop(insn)))
2756 switch (insn->opcode) {
2757 case OP_ADD: return simplify_add(insn);
2758 case OP_SUB: return simplify_sub(insn);
2759 case OP_AND: return simplify_and(insn);
2760 case OP_OR: return simplify_ior(insn);
2761 case OP_XOR: return simplify_xor(insn);
2774 return simplify_compare(insn);
2777 return simplify_memop(insn);
2779 return replace_with_pseudo(insn, insn->src);
2782 return simplify_cast(insn);
2791 return replace_with_pseudo(insn, insn->src);
2795 return simplify_setval(insn);
2800 return clean_up_phi(insn);
2804 return simplify_select(insn);
2806 return simplify_branch(insn);
2808 return simplify_switch(insn);
2810 return simplify_cgoto(insn);
2812 return simplify_range(insn);