simplify.c

   1 /*
   2  * Simplify - do instruction simplification before CSE
   3  *
   4  * Copyright (C) 2004 Linus Torvalds
   5  */
   6
   7 #include <assert.h>
   8
   9 #include "parse.h"
  10 #include "expression.h"
  11 #include "linearize.h"
  12 #include "flow.h"
  13
  14 /* Find the trivial parent for a phi-source */
  15 static struct basic_block *phi_parent(struct basic_block *source, pseudo_t pseudo)
  16 {
  17         /* Can't go upwards if the pseudo is defined in the bb it came from.. */
  18         if (pseudo->type == PSEUDO_REG) {
  19                 struct instruction *def = pseudo->def;
  20                 if (def->bb == source)
  21                         return source;
  22         }
  23         if (bb_list_size(source->children) != 1 || bb_list_size(source->parents) != 1)
  24                 return source;
  25         return first_basic_block(source->parents);
  26 }
  27
  28 static void clear_phi(struct instruction *insn)
  29 {
  30         pseudo_t phi;
  31
  32         insn->bb = NULL;
  33         FOR_EACH_PTR(insn->phi_list, phi) {
  34                 *THIS_ADDRESS(phi) = VOID;
  35         } END_FOR_EACH_PTR(phi);
  36 }
  37
  38 static int if_convert_phi(struct instruction *insn)
  39 {
  40         pseudo_t array[3];
  41         struct basic_block *parents[3];
  42         struct basic_block *bb, *bb1, *bb2, *source;
  43         struct instruction *br;
  44         pseudo_t p1, p2;
  45
  46         bb = insn->bb;
  47         if (linearize_ptr_list((struct ptr_list *)insn->phi_list, (void **)array, 3) != 2)
  48                 return 0;
  49         if (linearize_ptr_list((struct ptr_list *)bb->parents, (void **)parents, 3) != 2)
  50                 return 0;
  51         p1 = array[0]->def->src1;
  52         bb1 = array[0]->def->bb;
  53         p2 = array[1]->def->src1;
  54         bb2 = array[1]->def->bb;
  55
  56         /* Only try the simple "direct parents" case */
  57         if ((bb1 != parents[0] || bb2 != parents[1]) &&
  58             (bb1 != parents[1] || bb2 != parents[0]))
  59                 return 0;
  60
  61         /*
  62          * See if we can find a common source for this..
  63          */
  64         source = phi_parent(bb1, p1);
  65         if (source != phi_parent(bb2, p2))
  66                 return 0;
  67
  68         /*
  69          * Cool. We now know that 'source' is the exclusive
  70          * parent of both phi-nodes, so the exit at the
  71          * end of it fully determines which one it is, and
  72          * we can turn it into a select.
  73          *
  74          * HOWEVER, right now we only handle regular
  75          * conditional branches. No multijumps or computed
  76          * stuff. Verify that here.
  77          */
  78         br = last_instruction(source->insns);
  79         if (!br || br->opcode != OP_BR)
  80                 return 0;
  81
  82         assert(br->cond);
  83         assert(br->bb_false);
  84
  85         /*
  86          * We're in business. Match up true/false with p1/p2.
  87          */
  88         if (br->bb_true == bb2 || br->bb_false == bb1) {
  89                 pseudo_t p = p1;
  90                 p1 = p2;
  91                 p2 = p;
  92         }
  93
  94         /*
  95          * Ok, we can now replace that last
  96          *
  97          *      br cond, a, b
  98          *
  99          * with the sequence
 100          *
 101          *      setcc cond
 102          *      select pseudo, p1, p2
 103          *      br cond, a, b
 104          *
 105          * and remove the phi-node. If it then
 106          * turns out that 'a' or 'b' is entirely
 107          * empty (common case), and now no longer
 108          * a phi-source, we'll be able to simplify
 109          * the conditional branch too.
 110          */
 111         insert_select(source, br, insn, p1, p2);
 112         clear_phi(insn);
 113         return REPEAT_CSE;
 114 }
 115
 116 static int clean_up_phi(struct instruction *insn)
 117 {
 118         pseudo_t phi;
 119         struct instruction *last;
 120         int same;
 121
 122         last = NULL;
 123         same = 1;
 124         FOR_EACH_PTR(insn->phi_list, phi) {
 125                 struct instruction *def;
 126                 if (phi == VOID)
 127                         continue;
 128                 def = phi->def;
 129                 if (def->src1 == VOID || !def->bb)
 130                         continue;
 131                 if (last) {
 132                         if (last->src1 != def->src1)
 133                                 same = 0;
 134                         continue;
 135                 }
 136                 last = def;
 137         } END_FOR_EACH_PTR(phi);
 138
 139         if (same) {
 140                 pseudo_t pseudo = last ? last->src1 : VOID;
 141                 convert_instruction_target(insn, pseudo);
 142                 clear_phi(insn);
 143                 return REPEAT_CSE;
 144         }
 145
 146         return if_convert_phi(insn);
 147 }
 148
 149 static inline void remove_usage(pseudo_t p, pseudo_t *usep)
 150 {
 151         if (has_use_list(p)) {
 152                 delete_ptr_list_entry((struct ptr_list **)&p->users, usep, 1);
 153                 if (!p->users)
 154                         kill_instruction(p->def);
 155         }
 156 }
 157
 158 void kill_use(pseudo_t *usep)
 159 {
 160         if (usep) {
 161                 pseudo_t p = *usep;
 162                 *usep = VOID;
 163                 remove_usage(p, usep);
 164         }
 165 }
 166
 167 void kill_instruction(struct instruction *insn)
 168 {
 169         if (!insn || !insn->bb)
 170                 return;
 171
 172         switch (insn->opcode) {
 173         case OP_BINARY ... OP_BINCMP_END:
 174                 insn->bb = NULL;
 175                 kill_use(&insn->src1);
 176                 kill_use(&insn->src2);
 177                 repeat_phase |= REPEAT_CSE;
 178                 return;
 179
 180         case OP_NOT: case OP_NEG:
 181                 insn->bb = NULL;
 182                 kill_use(&insn->src1);
 183                 repeat_phase |= REPEAT_CSE;
 184                 return;
 185
 186         case OP_PHI:
 187                 insn->bb = NULL;
 188                 repeat_phase |= REPEAT_CSE;
 189                 return;
 190
 191          case OP_SYMADDR:
 192                 insn->bb = NULL;
 193                 repeat_phase |= REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
 194                 return;
 195         }
 196 }
 197
 198 /*
 199  * Kill trivially dead instructions
 200  */
 201 static int dead_insn(struct instruction *insn, pseudo_t *src1, pseudo_t *src2, pseudo_t *src3)
 202 {
 203         pseudo_t *usep;
 204         FOR_EACH_PTR(insn->target->users, usep) {
 205                 if (*usep != VOID)
 206                         return 0;
 207         } END_FOR_EACH_PTR(usep);
 208
 209         insn->bb = NULL;
 210         kill_use(src1);
 211         kill_use(src2);
 212         kill_use(src3);
 213         return REPEAT_CSE;
 214 }
 215
 216 static inline int constant(pseudo_t pseudo)
 217 {
 218         return pseudo->type == PSEUDO_VAL;
 219 }
 220
 221 static int replace_with_pseudo(struct instruction *insn, pseudo_t pseudo)
 222 {
 223         convert_instruction_target(insn, pseudo);
 224         insn->bb = NULL;
 225         return REPEAT_CSE;
 226 }
 227
 228 static int simplify_constant_rightside(struct instruction *insn)
 229 {
 230         long long value = insn->src2->value;
 231
 232         switch (insn->opcode) {
 233         case OP_SUB:
 234                 if (value) {
 235                         insn->opcode = OP_ADD;
 236                         insn->src2 = value_pseudo(-value);
 237                         return REPEAT_CSE;
 238                 }
 239         /* Fallthrough */
 240         case OP_ADD:
 241         case OP_OR: case OP_XOR:
 242         case OP_SHL: case OP_SHR:
 243                 if (!value)
 244                         return replace_with_pseudo(insn, insn->src1);
 245                 return 0;
 246
 247         case OP_AND: case OP_MUL:
 248                 if (!value)
 249                         return replace_with_pseudo(insn, insn->src2);
 250                 return 0;
 251         }
 252         return 0;
 253 }
 254
 255 static int simplify_constant_leftside(struct instruction *insn)
 256 {
 257         long long value = insn->src1->value;
 258
 259         switch (insn->opcode) {
 260         case OP_ADD: case OP_OR: case OP_XOR:
 261                 if (!value)
 262                         return replace_with_pseudo(insn, insn->src2);
 263                 return 0;
 264
 265         case OP_SHL: case OP_SHR:
 266         case OP_AND: case OP_MUL:
 267                 if (!value)
 268                         return replace_with_pseudo(insn, insn->src1);
 269                 return 0;
 270         }
 271         return 0;
 272 }
 273
 274 static int simplify_constant_binop(struct instruction *insn)
 275 {
 276         /* FIXME! Verify signs and sizes!! */
 277         long long left = insn->src1->value;
 278         long long right = insn->src2->value;
 279         long long res, mask;
 280
 281         switch (insn->opcode) {
 282         case OP_ADD:
 283                 res = left + right;
 284                 break;
 285         case OP_SUB:
 286                 res = left - right;
 287                 break;
 288         case OP_MUL:
 289                 /* FIXME! Check sign! */
 290                 res = left * right;
 291                 break;
 292         case OP_DIV:
 293                 if (!right)
 294                         return 0;
 295                 /* FIXME! Check sign! */
 296                 res = left / right;
 297                 break;
 298         case OP_MOD:
 299                 if (!right)
 300                         return 0;
 301                 /* FIXME! Check sign! */
 302                 res = left % right;
 303                 break;
 304         case OP_SHL:
 305                 res = left << right;
 306                 break;
 307         case OP_SHR:
 308                 /* FIXME! Check sign! */
 309                 res = left >> right;
 310                 break;
 311        /* Logical */
 312         case OP_AND:
 313                 res = left & right;
 314                 break;
 315         case OP_OR:
 316                 res = left | right;
 317                 break;
 318         case OP_XOR:
 319                 res = left ^ right;
 320                 break;
 321         case OP_AND_BOOL:
 322                 res = left && right;
 323                 break;
 324         case OP_OR_BOOL:
 325                 res = left || right;
 326                 break;
 327
 328         /* Binary comparison */
 329         case OP_SET_EQ:
 330                 res = left == right;
 331                 break;
 332         case OP_SET_NE:
 333                 res = left != right;
 334                 break;
 335         case OP_SET_LE:
 336                 /* FIXME! Check sign! */
 337                 res = left <= right;
 338                 break;
 339         case OP_SET_GE:
 340                 /* FIXME! Check sign! */
 341                 res = left >= right;
 342                 break;
 343         case OP_SET_LT:
 344                 /* FIXME! Check sign! */
 345                 res = left < right;
 346                 break;
 347         case OP_SET_GT:
 348                 /* FIXME! Check sign! */
 349                 res = left > right;
 350                 break;
 351         case OP_SET_B:
 352                 /* FIXME! Check sign! */
 353                 res = (unsigned long long) left < (unsigned long long) right;
 354                 break;
 355         case OP_SET_A:
 356                 /* FIXME! Check sign! */
 357                 res = (unsigned long long) left > (unsigned long long) right;
 358                 break;
 359         case OP_SET_BE:
 360                 /* FIXME! Check sign! */
 361                 res = (unsigned long long) left <= (unsigned long long) right;
 362                 break;
 363         case OP_SET_AE:
 364                 /* FIXME! Check sign! */
 365                 res = (unsigned long long) left >= (unsigned long long) right;
 366                 break;
 367         default:
 368                 return 0;
 369         }
 370         mask = 1ULL << (insn->size-1);
 371         res &= mask | (mask-1);
 372
 373         /* FIXME!! Sign??? */
 374         replace_with_pseudo(insn, value_pseudo(res));
 375         return REPEAT_CSE;
 376 }
 377
 378 static int simplify_binop(struct instruction *insn)
 379 {
 380         if (dead_insn(insn, &insn->src1, &insn->src2, NULL))
 381                 return REPEAT_CSE;
 382         if (constant(insn->src1)) {
 383                 if (constant(insn->src2))
 384                         return simplify_constant_binop(insn);
 385                 return simplify_constant_leftside(insn);
 386         }
 387         if (constant(insn->src2))
 388                 return simplify_constant_rightside(insn);
 389         return 0;
 390 }
 391
 392 static void switch_pseudo(pseudo_t *pp1, pseudo_t *pp2)
 393 {
 394         pseudo_t p1 = *pp1, p2 = *pp2;
 395
 396         use_pseudo(p2, pp1);
 397         use_pseudo(p1, pp2);
 398         remove_usage(p1, pp1);
 399         remove_usage(p2, pp2);
 400 }
 401
 402 static int canonical_order(pseudo_t p1, pseudo_t p2)
 403 {
 404         /* symbol/constants on the right */
 405         if (p1->type == PSEUDO_VAL)
 406                 return p2->type == PSEUDO_VAL;
 407
 408         if (p1->type == PSEUDO_SYM)
 409                 return p2->type == PSEUDO_SYM || p2->type == PSEUDO_VAL;
 410
 411         return 1;
 412 }
 413
 414 static int simplify_commutative_binop(struct instruction *insn)
 415 {
 416         if (!canonical_order(insn->src1, insn->src2)) {
 417                 switch_pseudo(&insn->src1, &insn->src2);
 418                 return REPEAT_CSE;
 419         }
 420         return 0;
 421 }
 422
 423 static inline int simple_pseudo(pseudo_t pseudo)
 424 {
 425         return pseudo->type == PSEUDO_VAL || pseudo->type == PSEUDO_SYM;
 426 }
 427
 428 static int simplify_associative_binop(struct instruction *insn)
 429 {
 430         struct instruction *def;
 431         pseudo_t pseudo = insn->src1;
 432
 433         if (!simple_pseudo(insn->src2))
 434                 return 0;
 435         if (pseudo->type != PSEUDO_REG)
 436                 return 0;
 437         def = pseudo->def;
 438         if (def == insn)
 439                 return 0;
 440         if (def->opcode != insn->opcode)
 441                 return 0;
 442         if (!simple_pseudo(def->src2))
 443                 return 0;
 444         if (ptr_list_size((struct ptr_list *)def->target->users) != 1)
 445                 return 0;
 446         switch_pseudo(&def->src1, &insn->src2);
 447         return REPEAT_CSE;
 448 }
 449
 450 static int simplify_constant_unop(struct instruction *insn)
 451 {
 452         long long val = insn->src1->value;
 453         long long res, mask;
 454
 455         switch (insn->opcode) {
 456         case OP_NOT:
 457                 res = ~val;
 458                 break;
 459         case OP_NEG:
 460                 res = -val;
 461                 break;
 462         default:
 463                 return 0;
 464         }
 465         mask = 1ULL << (insn->size-1);
 466         res &= mask | (mask-1);
 467
 468         replace_with_pseudo(insn, value_pseudo(res));
 469         return REPEAT_CSE;
 470 }
 471
 472 static int simplify_unop(struct instruction *insn)
 473 {
 474         if (dead_insn(insn, &insn->src1, NULL, NULL))
 475                 return REPEAT_CSE;
 476         if (constant(insn->src1))
 477                 return simplify_constant_unop(insn);
 478         return 0;
 479 }
 480
 481 static int simplify_one_memop(struct instruction *insn, pseudo_t orig)
 482 {
 483         pseudo_t addr = insn->src;
 484         pseudo_t new, off;
 485
 486         if (addr->type == PSEUDO_REG) {
 487                 struct instruction *def = addr->def;
 488                 if (def->opcode == OP_SYMADDR && def->src) {
 489                         kill_use(&insn->src);
 490                         use_pseudo(def->src, &insn->src);
 491                         return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
 492                 }
 493                 if (def->opcode == OP_ADD) {
 494                         new = def->src1;
 495                         off = def->src2;
 496                         if (constant(off))
 497                                 goto offset;
 498                         new = off;
 499                         off = def->src1;
 500                         if (constant(off))
 501                                 goto offset;
 502                         return 0;
 503                 }
 504         }
 505         return 0;
 506
 507 offset:
 508         /* Invalid code */
 509         if (new == orig) {
 510                 if (new == VOID)
 511                         return 0;
 512                 new = VOID;
 513                 warning(insn->bb->pos, "crazy programmer");
 514         }
 515         insn->offset += off->value;
 516         use_pseudo(new, &insn->src);
 517         remove_usage(addr, &insn->src);
 518         return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
 519 }
 520
 521 /*
 522  * We walk the whole chain of adds/subs backwards. That's not
 523  * only more efficient, but it allows us to find looops.
 524  */
 525 static int simplify_memop(struct instruction *insn)
 526 {
 527         int one, ret = 0;
 528         pseudo_t orig = insn->src;
 529
 530         do {
 531                 one = simplify_one_memop(insn, orig);
 532                 ret |= one;
 533         } while (one);
 534         return ret;
 535 }
 536
 537 static int simplify_cast(struct instruction *insn)
 538 {
 539         int orig_size;
 540
 541         if (dead_insn(insn, &insn->src, NULL, NULL))
 542                 return REPEAT_CSE;
 543         if (0 && insn->opcode == OP_PTRCAST)
 544                 return 0;
 545         orig_size = insn->orig_type ? insn->orig_type->bit_size : 0;
 546         if (orig_size < 0)
 547                 orig_size = 0;
 548         if (insn->size != orig_size)
 549                 return 0;
 550         return replace_with_pseudo(insn, insn->src);
 551 }
 552
 553 static int simplify_select(struct instruction *insn)
 554 {
 555         pseudo_t cond, src1, src2;
 556
 557         if (dead_insn(insn, &insn->src1, &insn->src2, &insn->src3))
 558                 return REPEAT_CSE;
 559
 560         cond = insn->src1;
 561         src1 = insn->src2;
 562         src2 = insn->src3;
 563         if (constant(cond) || src1 == src2) {
 564                 pseudo_t *kill, take;
 565                 kill_use(&insn->src1);
 566                 take = cond->value ? src1 : src2;
 567                 kill = cond->value ? &insn->src3 : &insn->src2;
 568                 kill_use(kill);
 569                 replace_with_pseudo(insn, take);
 570                 return REPEAT_CSE;
 571         }
 572         if (constant(src1) && constant(src2)) {
 573                 long long val1 = src1->value;
 574                 long long val2 = src2->value;
 575
 576                 /* The pair 0/1 is special - replace with SETNE/SETEQ */
 577                 if ((val1 | val2) == 1) {
 578                         int opcode = OP_SET_EQ;
 579                         if (val1) {
 580                                 src1 = src2;
 581                                 opcode = OP_SET_NE;
 582                         }
 583                         insn->opcode = opcode;
 584                         /* insn->src1 is already cond */
 585                         insn->src2 = src1; /* Zero */
 586                         return REPEAT_CSE;
 587                 }
 588         }
 589         return 0;
 590 }
 591
 592 /*
 593  * Simplify "set_ne/eq $0 + br"
 594  */
 595 static int simplify_cond_branch(struct instruction *br, pseudo_t cond, struct instruction *def, pseudo_t *pp)
 596 {
 597         use_pseudo(*pp, &br->cond);
 598         remove_usage(cond, &br->cond);
 599         if (def->opcode == OP_SET_EQ) {
 600                 struct basic_block *true = br->bb_true;
 601                 struct basic_block *false = br->bb_false;
 602                 br->bb_false = true;
 603                 br->bb_true = false;
 604         }
 605         return REPEAT_CSE;
 606 }
 607
 608 static int simplify_branch(struct instruction *insn)
 609 {
 610         pseudo_t cond = insn->cond;
 611
 612         if (!cond)
 613                 return 0;
 614
 615         /* Constant conditional */
 616         if (constant(cond)) {
 617                 insert_branch(insn->bb, insn, cond->value ? insn->bb_true : insn->bb_false);
 618                 return REPEAT_CSE;
 619         }
 620
 621         /* Same target? */
 622         if (insn->bb_true == insn->bb_false) {
 623                 struct basic_block *bb = insn->bb;
 624                 struct basic_block *target = insn->bb_false;
 625                 remove_bb_from_list(&target->parents, bb, 1);
 626                 remove_bb_from_list(&bb->children, target, 1);
 627                 insn->bb_false = NULL;
 628                 kill_use(&insn->cond);
 629                 insn->cond = NULL;
 630                 return REPEAT_CSE;
 631         }
 632
 633         /* Conditional on a SETNE $0 or SETEQ $0 */
 634         if (cond->type == PSEUDO_REG) {
 635                 struct instruction *def = cond->def;
 636
 637                 if (def->opcode == OP_SET_NE || def->opcode == OP_SET_EQ) {
 638                         if (constant(def->src1) && !def->src1->value)
 639                                 return simplify_cond_branch(insn, cond, def, &def->src2);
 640                         if (constant(def->src2) && !def->src2->value)
 641                                 return simplify_cond_branch(insn, cond, def, &def->src1);
 642                 }
 643                 if (def->opcode == OP_SEL) {
 644                         if (constant(def->src2) && constant(def->src3)) {
 645                                 long long val1 = def->src2->value;
 646                                 long long val2 = def->src3->value;
 647                                 if (!val1 && !val2) {
 648                                         insert_branch(insn->bb, insn, insn->bb_false);
 649                                         return REPEAT_CSE;
 650                                 }
 651                                 if (val1 && val2) {
 652                                         insert_branch(insn->bb, insn, insn->bb_true);
 653                                         return REPEAT_CSE;
 654                                 }
 655                                 if (val2) {
 656                                         struct basic_block *true = insn->bb_true;
 657                                         struct basic_block *false = insn->bb_false;
 658                                         insn->bb_false = true;
 659                                         insn->bb_true = false;
 660                                 }
 661                                 use_pseudo(def->src1, &insn->cond);
 662                                 remove_usage(cond, &insn->cond);
 663                                 return REPEAT_CSE;
 664                         }
 665                 }
 666                 if (def->opcode == OP_CAST) {
 667                         int orig_size = def->orig_type ? def->orig_type->bit_size : 0;
 668                         if (def->size > orig_size) {
 669                                 use_pseudo(def->src, &insn->cond);
 670                                 remove_usage(cond, &insn->cond);
 671                                 return REPEAT_CSE;
 672                         }
 673                 }
 674         }
 675         return 0;
 676 }
 677
 678 static int simplify_switch(struct instruction *insn)
 679 {
 680         pseudo_t cond = insn->cond;
 681         long long val;
 682         struct multijmp *jmp;
 683
 684         if (!constant(cond))
 685                 return 0;
 686         val = insn->cond->value;
 687
 688         FOR_EACH_PTR(insn->multijmp_list, jmp) {
 689                 /* Default case */
 690                 if (jmp->begin > jmp->end)
 691                         goto found;
 692                 if (val >= jmp->begin && val <= jmp->end)
 693                         goto found;
 694         } END_FOR_EACH_PTR(jmp);
 695         warning(insn->bb->pos, "Impossible case statement");
 696         return 0;
 697
 698 found:
 699         insert_branch(insn->bb, insn, jmp->target);
 700         return REPEAT_CSE;
 701 }
 702
 703 int simplify_instruction(struct instruction *insn)
 704 {
 705         if (!insn->bb)
 706                 return 0;
 707         switch (insn->opcode) {
 708         case OP_ADD:
 709         case OP_AND: case OP_OR: case OP_XOR:
 710         case OP_AND_BOOL: case OP_OR_BOOL:
 711                 if (simplify_binop(insn))
 712                         return REPEAT_CSE;
 713                 if (simplify_commutative_binop(insn))
 714                         return REPEAT_CSE;
 715                 return simplify_associative_binop(insn);
 716
 717         /*
 718          * Multiplication isn't associative in 2's complement,
 719          * but we could do it if signed.
 720          */
 721         case OP_MUL:
 722         case OP_SET_EQ: case OP_SET_NE:
 723                 if (simplify_binop(insn))
 724                         return REPEAT_CSE;
 725                 return simplify_commutative_binop(insn);
 726
 727         case OP_SUB: case OP_DIV: case OP_MOD:
 728         case OP_SHL: case OP_SHR:
 729         case OP_SET_LE: case OP_SET_GE:
 730         case OP_SET_LT: case OP_SET_GT:
 731         case OP_SET_B:  case OP_SET_A:
 732         case OP_SET_BE: case OP_SET_AE:
 733                 return simplify_binop(insn);
 734
 735         case OP_NOT: case OP_NEG:
 736                 return simplify_unop(insn);
 737         case OP_LOAD: case OP_STORE:
 738                 return simplify_memop(insn);
 739         case OP_SYMADDR:
 740                 if (dead_insn(insn, NULL, NULL, NULL))
 741                         return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
 742                 return replace_with_pseudo(insn, insn->symbol);
 743         case OP_PTRCAST:
 744         case OP_CAST:
 745                 return simplify_cast(insn);
 746         case OP_PHI:
 747                 if (dead_insn(insn, NULL, NULL, NULL)) {
 748                         clear_phi(insn);
 749                         return REPEAT_CSE;
 750                 }
 751                 return clean_up_phi(insn);
 752         case OP_PHISOURCE:
 753                 if (dead_insn(insn, &insn->phi_src, NULL, NULL))
 754                         return REPEAT_CSE;
 755                 break;
 756         case OP_SEL:
 757                 return simplify_select(insn);
 758         case OP_BR:
 759                 return simplify_branch(insn);
 760         case OP_SWITCH:
 761                 return simplify_switch(insn);
 762         }
 763         return 0;
 764 }