Lines Matching refs:def
71 struct instruction *def = pseudo->def;
72 if (def->bb == source)
96 struct instruction *def;
101 def = phi->def;
102 assert(def->opcode == OP_PHISOURCE);
103 sources[i++] = def;
207 struct instruction *def;
212 def = phi->def;
213 if (!def->bb)
215 src = def->phi_src; // bypass OP_PHISRC & get the real source
226 if (DEF_OPCODE(def, src) == OP_PHI) {
229 if ((pseudo = trivial_phi(pseudo, def, list)))
275 kill_instruction(p->def);
445 struct instruction *def;
449 def = src->def;
450 if (def->opcode != op)
452 if (def->orig_type->bit_size != osize)
454 return def->src;
459 struct instruction *def;
461 return (DEF_OPCODE(def, p) == OP_NEG) && (def->src == ref);
587 return p->def->opcode;
614 struct instruction *src = pseudo->def;
781 struct instruction *and = ora->def;
797 struct instruction *or = insn->src1->def;
913 struct instruction *def;
932 def = pseudo->def;
933 switch (def->opcode) {
936 if (def == insn) // cyclic DAG!
938 src2 = def->src2;
945 if (def->opcode == OP_LSR)
966 switch(DEF_OPCODE(def, pseudo)) {
970 if (!constant(def->src2))
973 omask = def->src2->value;
978 return replace_pseudo(insn, &insn->src1, def->src1);
981 def->opcode = OP_LSR;
982 def->src2 = insn->src2;
990 return simplify_mask_shift_or(insn, def, mask);
994 if (def->src2 != insn->src2)
1003 switch(DEF_OPCODE(def, pseudo)) {
1006 if (!constant(def->src2))
1009 omask = def->src2->value;
1014 return replace_pseudo(insn, &insn->src1, def->src1);
1020 if (def->src2 != insn->src2)
1026 return simplify_mask_shift_or(insn, def, mask);
1029 if (def == insn) // cyclic DAG!
1031 src2 = def->src2;
1047 return replace_pseudo(insn, &insn->src1, pseudo->def->src1);
1054 return replace_pseudo(insn, &insn->src1, def->src1);
1087 struct instruction *def;
1097 def = old->def;
1098 if (!def)
1102 if (!inverse && def->size == 1 && insn->size == 1) {
1110 opcode = def->opcode;
1115 if (def->size != insn->size)
1117 if (def->src2->type != PSEUDO_VAL)
1119 if (def->src2->value != 1)
1131 insn->itype = def->itype;
1132 use_pseudo(insn, def->src1, &insn->src1);
1133 use_pseudo(insn, def->src2, &insn->src2);
1138 if (value && (def->orig_type->bit_size == 1))
1148 insn->itype = def->orig_type;
1149 return replace_pseudo(insn, &insn->src1, def->src);
1160 osize = def->size;
1161 def->opcode = OP_AND;
1162 def->type = def->orig_type;
1163 def->size = def->type->bit_size;
1164 def->src2 = value_pseudo(bits_mask(osize));
1174 struct instruction *def;
1274 switch (DEF_OPCODE(def, src1)) {
1276 if (!constant(def->src2))
1278 bits = def->src2->value;
1293 value = sign_extend(value, def->size);
1296 if (bits & sign_bit(def->size))
1306 value = sign_extend(value, def->size);
1309 if (bits & sign_bit(def->size))
1337 if (!constant(def->src2))
1339 bits = def->src2->value;
1368 if (bits & sign_bit(def->size)) {
1369 value = sign_extend(value, def->size);
1377 if (bits & sign_bit(def->size)) {
1378 value = sign_extend(value, def->size);
1386 osize = def->orig_type->bit_size;
1388 insn->itype = def->orig_type;
1390 return replace_pseudo(insn, &insn->src1, def->src);
1395 insn->itype = def->orig_type;
1397 return replace_pseudo(insn, &insn->src1, def->src);
1402 insn->itype = def->orig_type;
1404 return replace_pseudo(insn, &insn->src1, def->src);
1422 osize = def->orig_type->bit_size;
1425 if (one_use(def->target)) {
1426 insn->itype = def->orig_type;
1427 def->type = def->orig_type;
1428 def->size = osize;
1429 def->src2 = value_pseudo(bits);
1430 return replace_opcode(def, OP_AND);
1436 osize = def->orig_type->bit_size;
1442 insn->itype = def->orig_type;
1443 return replace_pseudo(insn, &insn->src1, def->src);
1473 struct instruction *def;
1476 switch (DEF_OPCODE(def, old)) {
1481 return simplify_mask_or(insn, mask, def);
1484 return simplify_mask_shift(def, mask);
1486 osize = def->orig_type->bit_size;
1504 static int simplify_const_rightadd(struct instruction *def, struct instruction *insn)
1509 switch (def->opcode) {
1511 if (constant(def->src1)) { // (C - y) + D --> eval(C+D) - y
1512 pseudo_t val = eval_op(OP_ADD, size, def->src1, src2);
1514 use_pseudo(insn, def->src2, &insn->src2);
1555 changed |= simplify_const_rightadd(insn->src1->def, insn);
1590 static int simplify_const_leftsub(struct instruction *insn, struct instruction *def)
1595 switch (def->opcode) {
1597 if (constant(def->src2)) { // C - (y + D) --> eval(C-D) - y
1598 insn->src1 = eval_op(OP_SUB, size, src1, def->src2);
1599 return replace_pseudo(insn, &insn->src2, def->src1);
1603 if (constant(def->src1)) { // C - (D - z) --> z + eval(C-D)
1604 pseudo_t val = eval_op(OP_SUB, size, src1, def->src1);
1606 use_pseudo(insn, def->src2, &insn->src1);
1635 return simplify_const_leftsub(insn, insn->src2->def);
1782 struct instruction *def;
1789 def = src->def;
1790 if (dst == def)
1792 bbs = def->bb;
1795 return insn_before(bbs, def, dst);
1802 struct instruction *def;
1809 def = pseudo->def;
1810 if (def == insn)
1812 if (def->opcode != insn->opcode)
1814 if (!simple_pseudo(def->src2))
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);
1821 if (!one_use(def->target))
1823 switch_pseudo(def, &def->src1, insn, &insn->src2);
1830 struct instruction *def;
1834 switch (DEF_OPCODE(def, src1)) {
1837 if (defr->src2 == def->src2 && can_move_to(def->src2, defr)) {
1839 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1842 if (defr->src1 == def->src1 && can_move_to(def->src1, defr)) {
1844 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
1847 if (defr->src1 == def->src2 && can_move_to(def->src1, defr)) {
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);
1859 if (def->src2 == src2) // (x - y) + y --> x
1860 return replace_with_pseudo(insn, def->src1);
1876 struct instruction *def;
1878 switch (DEF_OPCODE(def, src1)) {
1880 if (def->src1 == src2) // (x + y) - x --> y
1881 return replace_with_pseudo(insn, def->src2);
1882 if (def->src2 == src2) // (x + y) - y --> x
1883 return replace_with_pseudo(insn, def->src1);
1887 switch (DEF_OPCODE(def, src2)) {
1889 if (src1 == def->src1) // x - (x + z) --> -z
1890 return replace_with_unop(insn, OP_NEG, def->src2);
1891 if (src1 == def->src2) // x - (y + x) --> -y
1892 return replace_with_unop(insn, OP_NEG, def->src1);
1896 return replace_pseudo(insn, &insn->src2, def->src);
1906 struct instruction *def = NULL;
1910 switch (DEF_OPCODE(def, src1)) {
1912 osize = def->orig_type->bit_size;
1913 if ((src = is_same_op(src2, def->opcode, osize))) {
1915 if ((def->opcode == OP_ZEXT) && (op->flags & OPF_SIGNED))
1917 insn->itype = def->orig_type;
1918 replace_pseudo(insn, &insn->src1, def->src);
1928 struct instruction *def, *defr = NULL;
1931 switch (DEF_OPCODE(def, src1)) {
1933 if (def->src == *p2)
1937 if (DEF_OPCODE(defr, *p2) == opcode_negate(def->opcode)) {
1938 if (def->src1 == defr->src1 && def->src2 == defr->src2)
1941 if (def->opcode == OP_SET_GE && is_zero(def->src2)) {
1955 if (defr->src2 == def->src2 && can_move_to(def->src2, defr)) {
1957 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1960 if (defr->src1 == def->src1 && can_move_to(def->src1, defr)) {
1962 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
1965 if (defr->src1 == def->src2 && can_move_to(def->src1, defr)) {
1967 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
1973 if (DEF_OPCODE(defr, *p2) == def->opcode && defr->src2 == def->src2) {
1974 if (can_move_to(def->src1, defr)) {
1976 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
1993 struct instruction *def, *defr = NULL;
1996 switch (DEF_OPCODE(def, src1)) {
1999 if (defr->src2 == def->src2 && can_move_to(def->src2, defr)) {
2001 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2004 if (defr->src1 == def->src1 && can_move_to(def->src1, defr)) {
2006 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
2009 if (defr->src1 == def->src2 && can_move_to(def->src1, defr)) {
2011 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
2017 if (def->src == *p2)
2021 if (DEF_OPCODE(defr, *p2) == opcode_negate(def->opcode)) {
2022 if (def->src1 == defr->src1 && def->src2 == defr->src2)
2027 if (DEF_OPCODE(defr, *p2) == def->opcode && defr->src2 == def->src2) {
2028 if (can_move_to(def->src1, defr)) {
2030 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2047 struct instruction *def, *defr = NULL;
2050 switch (DEF_OPCODE(def, src1)) {
2053 if (defr->src2 == def->src2 && can_move_to(def->src2, defr)) {
2055 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2058 if (defr->src1 == def->src1 && can_move_to(def->src1, defr)) {
2060 swap_insn(insn, defr, def->src2, defr->src2, def->src1);
2063 if (defr->src1 == def->src2 && can_move_to(def->src1, defr)) {
2065 swap_insn(insn, defr, def->src1, defr->src2, def->src2);
2071 if (def->src == *p2)
2075 if (DEF_OPCODE(defr, *p2) == opcode_negate(def->opcode)) {
2076 if (def->src1 == defr->src1 && def->src2 == defr->src2)
2081 if (DEF_OPCODE(defr, *p2) == def->opcode && defr->src2 == def->src2) {
2082 if (can_move_to(def->src1, defr)) {
2084 swap_insn(insn, defr, def->src1, defr->src1, def->src2);
2131 struct instruction *def;
2139 switch (DEF_OPCODE(def, src)) {
2141 if (!constant(def->src2))
2144 src = eval_unop(OP_NOT, insn->size, def->src2);
2145 use_pseudo(insn, def->src1, &insn->src2);
2150 return replace_pseudo(insn, &insn->src1, def->src);
2152 return replace_with_pseudo(insn, def->src);
2154 if (!constant(def->src1))
2157 insn->src2 = eval_unop(OP_NOT, insn->size, def->src1);
2158 return replace_pseudo(insn, &insn->src1, def->src2);
2160 if (!constant(def->src2))
2163 insn->src2 = eval_unop(OP_NOT, insn->size, def->src2);
2164 return replace_pseudo(insn, &insn->src1, def->src1);
2168 switch (DEF_OPCODE(def, src)) {
2170 if (!constant(def->src2))
2173 src = eval_unop(OP_NEG, insn->size, def->src2);
2174 use_pseudo(insn, def->src1, &insn->src2);
2177 return replace_with_pseudo(insn, def->src);
2181 return replace_pseudo(insn, &insn->src1, def->src);
2184 use_pseudo(insn, def->src1, &insn->src2);
2185 return replace_pseudo(insn, &insn->src1, def->src2);
2200 struct instruction *def = addr->def;
2201 if (def->opcode == OP_SYMADDR && def->src) {
2203 use_pseudo(insn, def->src, &insn->src);
2206 if (def->opcode == OP_ADD) {
2207 new = def->src1;
2208 off = def->src2;
2212 off = def->src1;
2263 struct instruction *def, *def2;
2275 def = src->def;
2278 val = def->src2;
2286 def->opcode = OP_TRUNC;
2287 def->orig_type = def->type;
2288 def->type = insn->type;
2289 def->size = size;
2298 if (val->value & (1 << (def->size - 1)))
2313 def->opcode = OP_ZEXT;
2314 def->orig_type = insn->orig_type;
2315 def->type = insn->type;
2316 def->size = insn->size;
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);
2348 def->orig_type = def->type;
2349 def->opcode = OP_TRUNC;
2350 def->type = insn->type;
2351 def->size = insn->size;
2361 return simplify_mask_or(insn, mask, def);
2369 return simplify_mask_shift(def, mask);
2373 insn->orig_type = def->orig_type;
2374 return replace_pseudo(insn, &insn->src1, def->src);
2376 if (size != def->orig_type->bit_size)
2378 if (DEF_OPCODE(def2, def->src) != OP_LSR)
2380 if (def2->src2 != value_pseudo(size - def->size))
2387 if (size != def->orig_type->bit_size)
2390 insn->src2 = value_pseudo((1ULL << def->size) - 1);
2391 return replace_pseudo(insn, &insn->src1, def->src);
2400 insn->orig_type = def->orig_type;
2401 return replace_pseudo(insn, &insn->src, def->src);
2407 osize = def->orig_type->bit_size;
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);
2417 insn->orig_type = def->orig_type;
2418 return replace_pseudo(insn, &insn->src, def->src);
2429 struct instruction *def;
2462 switch (DEF_OPCODE(def, cond)) {
2464 if (src1 == def->src1 && src2 == def->src2)
2466 if (src2 == def->src1 && src1 == def->src2)
2470 if (src1 == def->src1 && src2 == def->src2)
2472 if (src2 == def->src1 && src1 == def->src2)
2480 def->opcode = opcode_negate(def->opcode);
2483 if (one_use(cond) && is_zero(def->src2)) {
2486 return replace_opcode(def, OP_SET_GE);
2490 if (constant(def->src2) && constant(def->src3)) {
2491 // Is the def of the conditional another select?
2498 if (!def->src3->value) {
2499 if ((src1 == def->src2) && (src2 == def->src3))
2501 return replace_pseudo(insn, &insn->cond, def->cond);
2503 if (!def->src2->value) {
2505 return replace_pseudo(insn, &insn->cond, def->cond);
2511 if (is_pow2(def->src2) && is_pow2(src1) && is_zero(src2) && insn->size == def->size && one_use(cond)) {
2512 unsigned s1 = log2_exact(def->src2->value);
2528 switch (DEF_OPCODE(def, src1)) {
2530 if ((def->src1 == src2) && can_move_to(cond, def)) {
2532 swap_select(insn, def, cond, def->src2, value_pseudo(0), src2);
2535 if ((def->src2 == src2) && can_move_to(cond, def)) {
2537 swap_select(insn, def, cond, def->src1, value_pseudo(0), src2);
2543 switch (DEF_OPCODE(def, src2)) {
2545 if ((def->src1 == src1) && can_move_to(cond, def)) {
2547 swap_select(insn, def, cond, value_pseudo(0), def->src2, src1);
2550 if ((def->src2 == src1) && can_move_to(cond, def)) {
2552 swap_select(insn, def, cond, value_pseudo(0), def->src1, src1);
2591 static int simplify_cond_branch(struct instruction *br, struct instruction *def, pseudo_t newcond)
2594 if (def->opcode == OP_SET_EQ) {
2616 struct instruction *def = cond->def;
2618 if (def->opcode == OP_SET_NE || def->opcode == OP_SET_EQ) {
2619 if (constant(def->src1) && !def->src1->value)
2620 return simplify_cond_branch(insn, def, def->src2);
2621 if (constant(def->src2) && !def->src2->value)
2622 return simplify_cond_branch(insn, def, def->src1);
2624 if (def->opcode == OP_SEL) {
2625 if (constant(def->src2) && constant(def->src3)) {
2626 long long val1 = def->src2->value;
2627 long long val2 = def->src3->value;
2637 return replace_pseudo(insn, &insn->cond, def->src1);
2640 if (def->opcode == OP_SEXT || def->opcode == OP_ZEXT)
2641 return replace_pseudo(insn, &insn->cond, def->src);
2672 struct instruction *def;
2674 if (DEF_OPCODE(def, pseudo) != OP_LABEL)
2676 return def->bb_true;
2683 struct instruction *def;
2686 switch (DEF_OPCODE(def, insn->src)) {
2688 if ((bbt = is_label(def->src2)) && (bbf = is_label(def->src3))) {
2692 return replace_pseudo(insn, &insn->src1, def->cond);
2696 target = def->bb_true;