gcc/jump.c

   1 /* Optimize jump instructions, for GNU compiler.
   2    Copyright (C) 1987, 88, 89, 91-98, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* This is the jump-optimization pass of the compiler.
  23    It is run two or three times: once before cse, sometimes once after cse,
  24    and once after reload (before final).
  25
  26    jump_optimize deletes unreachable code and labels that are not used.
  27    It also deletes jumps that jump to the following insn,
  28    and simplifies jumps around unconditional jumps and jumps
  29    to unconditional jumps.
  30
  31    Each CODE_LABEL has a count of the times it is used
  32    stored in the LABEL_NUSES internal field, and each JUMP_INSN
  33    has one label that it refers to stored in the
  34    JUMP_LABEL internal field.  With this we can detect labels that
  35    become unused because of the deletion of all the jumps that
  36    formerly used them.  The JUMP_LABEL info is sometimes looked
  37    at by later passes.
  38
  39    Optionally, cross-jumping can be done.  Currently it is done
  40    only the last time (when after reload and before final).
  41    In fact, the code for cross-jumping now assumes that register
  42    allocation has been done, since it uses `rtx_renumbered_equal_p'.
  43
  44    Jump optimization is done after cse when cse's constant-propagation
  45    causes jumps to become unconditional or to be deleted.
  46
  47    Unreachable loops are not detected here, because the labels
  48    have references and the insns appear reachable from the labels.
  49    find_basic_blocks in flow.c finds and deletes such loops.
  50
  51    The subroutines delete_insn, redirect_jump, and invert_jump are used
  52    from other passes as well.  */
  53
  54 #include "config.h"
  55 #include "system.h"
  56 #include "rtl.h"
  57 #include "tm_p.h"
  58 #include "flags.h"
  59 #include "hard-reg-set.h"
  60 #include "regs.h"
  61 #include "insn-config.h"
  62 #include "insn-flags.h"
  63 #include "insn-attr.h"
  64 #include "recog.h"
  65 #include "function.h"
  66 #include "expr.h"
  67 #include "real.h"
  68 #include "except.h"
  69 #include "toplev.h"
  70
  71 /* ??? Eventually must record somehow the labels used by jumps
  72    from nested functions.  */
  73 /* Pre-record the next or previous real insn for each label?
  74    No, this pass is very fast anyway.  */
  75 /* Condense consecutive labels?
  76    This would make life analysis faster, maybe.  */
  77 /* Optimize jump y; x: ... y: jumpif... x?
  78    Don't know if it is worth bothering with.  */
  79 /* Optimize two cases of conditional jump to conditional jump?
  80    This can never delete any instruction or make anything dead,
  81    or even change what is live at any point.
  82    So perhaps let combiner do it.  */
  83
  84 /* Vector indexed by uid.
  85    For each CODE_LABEL, index by its uid to get first unconditional jump
  86    that jumps to the label.
  87    For each JUMP_INSN, index by its uid to get the next unconditional jump
  88    that jumps to the same label.
  89    Element 0 is the start of a chain of all return insns.
  90    (It is safe to use element 0 because insn uid 0 is not used.  */
  91
  92 static rtx *jump_chain;
  93
  94 /* Maximum index in jump_chain.  */
  95
  96 static int max_jump_chain;
  97
  98 /* Set nonzero by jump_optimize if control can fall through
  99    to the end of the function.  */
 100 int can_reach_end;
 101
 102 /* Indicates whether death notes are significant in cross jump analysis.
 103    Normally they are not significant, because of A and B jump to C,
 104    and R dies in A, it must die in B.  But this might not be true after
 105    stack register conversion, and we must compare death notes in that
 106    case.  */
 107
 108 static int cross_jump_death_matters = 0;
 109
 110 static int init_label_info              PROTO((rtx));
 111 static void delete_barrier_successors   PROTO((rtx));
 112 static void mark_all_labels             PROTO((rtx, int));
 113 static rtx delete_unreferenced_labels   PROTO((rtx));
 114 static void delete_noop_moves           PROTO((rtx));
 115 static int calculate_can_reach_end      PROTO((rtx, int, int));
 116 static int duplicate_loop_exit_test     PROTO((rtx));
 117 static void find_cross_jump             PROTO((rtx, rtx, int, rtx *, rtx *));
 118 static void do_cross_jump               PROTO((rtx, rtx, rtx));
 119 static int jump_back_p                  PROTO((rtx, rtx));
 120 static int tension_vector_labels        PROTO((rtx, int));
 121 static void mark_jump_label             PROTO((rtx, rtx, int));
 122 static void delete_computation          PROTO((rtx));
 123 static void delete_from_jump_chain      PROTO((rtx));
 124 static int delete_labelref_insn         PROTO((rtx, rtx, int));
 125 static void mark_modified_reg           PROTO((rtx, rtx, void *));
 126 static void redirect_tablejump          PROTO((rtx, rtx));
 127 static void jump_optimize_1             PROTO ((rtx, int, int, int, int));
 128 #if ! defined(HAVE_cc0) && ! defined(HAVE_conditional_arithmetic)
 129 static rtx find_insert_position         PROTO((rtx, rtx));
 130 #endif
 131 static int returnjump_p_1               PROTO((rtx *, void *));
 132 static void delete_prior_computation    PROTO((rtx, rtx));
 133
 134 /* Main external entry point into the jump optimizer.  See comments before
 135    jump_optimize_1 for descriptions of the arguments.  */
 136 void
 137 jump_optimize (f, cross_jump, noop_moves, after_regscan)
 138      rtx f;
 139      int cross_jump;
 140      int noop_moves;
 141      int after_regscan;
 142 {
 143   jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, 0);
 144 }
 145
 146 /* Alternate entry into the jump optimizer.  This entry point only rebuilds
 147    the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
 148    instructions.  */
 149 void
 150 rebuild_jump_labels (f)
 151      rtx f;
 152 {
 153   jump_optimize_1 (f, 0, 0, 0, 1);
 154 }
 155
 156 \f
 157 /* Delete no-op jumps and optimize jumps to jumps
 158    and jumps around jumps.
 159    Delete unused labels and unreachable code.
 160
 161    If CROSS_JUMP is 1, detect matching code
 162    before a jump and its destination and unify them.
 163    If CROSS_JUMP is 2, do cross-jumping, but pay attention to death notes.
 164
 165    If NOOP_MOVES is nonzero, delete no-op move insns.
 166
 167    If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
 168    after regscan, and it is safe to use regno_first_uid and regno_last_uid.
 169
 170    If MARK_LABELS_ONLY is nonzero, then we only rebuild the jump chain
 171    and JUMP_LABEL field for jumping insns.
 172
 173    If `optimize' is zero, don't change any code,
 174    just determine whether control drops off the end of the function.
 175    This case occurs when we have -W and not -O.
 176    It works because `delete_insn' checks the value of `optimize'
 177    and refrains from actually deleting when that is 0.  */
 178
 179 static void
 180 jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, mark_labels_only)
 181      rtx f;
 182      int cross_jump;
 183      int noop_moves;
 184      int after_regscan;
 185      int mark_labels_only;
 186 {
 187   register rtx insn, next;
 188   int changed;
 189   int old_max_reg;
 190   int first = 1;
 191   int max_uid = 0;
 192   rtx last_insn;
 193
 194   cross_jump_death_matters = (cross_jump == 2);
 195   max_uid = init_label_info (f) + 1;
 196
 197   /* If we are performing cross jump optimizations, then initialize
 198      tables mapping UIDs to EH regions to avoid incorrect movement
 199      of insns from one EH region to another.  */
 200   if (flag_exceptions && cross_jump)
 201     init_insn_eh_region (f, max_uid);
 202
 203   delete_barrier_successors (f);
 204
 205   /* Leave some extra room for labels and duplicate exit test insns
 206      we make.  */
 207   max_jump_chain = max_uid * 14 / 10;
 208   jump_chain = (rtx *) xcalloc (max_jump_chain, sizeof (rtx));
 209
 210   mark_all_labels (f, cross_jump);
 211
 212   /* Keep track of labels used from static data;
 213      they cannot ever be deleted.  */
 214
 215   for (insn = forced_labels; insn; insn = XEXP (insn, 1))
 216     LABEL_NUSES (XEXP (insn, 0))++;
 217
 218   check_exception_handler_labels ();
 219
 220   /* Keep track of labels used for marking handlers for exception
 221      regions; they cannot usually be deleted.  */
 222
 223   for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
 224     LABEL_NUSES (XEXP (insn, 0))++;
 225
 226   /* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL
 227      notes and recompute LABEL_NUSES.  */
 228   if (mark_labels_only)
 229     goto end;
 230
 231   exception_optimize ();
 232
 233   last_insn = delete_unreferenced_labels (f);
 234
 235   if (optimize == 0)
 236     {
 237       /* CAN_REACH_END is persistent for each function.  Once set it should
 238          not be cleared.  This is especially true for the case where we
 239          delete the NOTE_FUNCTION_END note.  CAN_REACH_END is cleared by
 240          the front-end before compiling each function.  */
 241       if (calculate_can_reach_end (last_insn, 1, 0))
 242         can_reach_end = 1;
 243
 244       /* Zero the "deleted" flag of all the "deleted" insns.  */
 245       for (insn = f; insn; insn = NEXT_INSN (insn))
 246         INSN_DELETED_P (insn) = 0;
 247
 248       goto end;
 249     }
 250
 251 #ifdef HAVE_return
 252   if (HAVE_return)
 253     {
 254       /* If we fall through to the epilogue, see if we can insert a RETURN insn
 255          in front of it.  If the machine allows it at this point (we might be
 256          after reload for a leaf routine), it will improve optimization for it
 257          to be there.  */
 258       insn = get_last_insn ();
 259       while (insn && GET_CODE (insn) == NOTE)
 260         insn = PREV_INSN (insn);
 261
 262       if (insn && GET_CODE (insn) != BARRIER)
 263         {
 264           emit_jump_insn (gen_return ());
 265           emit_barrier ();
 266         }
 267     }
 268 #endif
 269
 270   if (noop_moves)
 271     delete_noop_moves (f);
 272
 273   /* If we haven't yet gotten to reload and we have just run regscan,
 274      delete any insn that sets a register that isn't used elsewhere.
 275      This helps some of the optimizations below by having less insns
 276      being jumped around.  */
 277
 278   if (! reload_completed && after_regscan)
 279     for (insn = f; insn; insn = next)
 280       {
 281         rtx set = single_set (insn);
 282
 283         next = NEXT_INSN (insn);
 284
 285         if (set && GET_CODE (SET_DEST (set)) == REG
 286             && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
 287             && REGNO_FIRST_UID (REGNO (SET_DEST (set))) == INSN_UID (insn)
 288             /* We use regno_last_note_uid so as not to delete the setting
 289                of a reg that's used in notes.  A subsequent optimization
 290                might arrange to use that reg for real.  */
 291             && REGNO_LAST_NOTE_UID (REGNO (SET_DEST (set))) == INSN_UID (insn)
 292             && ! side_effects_p (SET_SRC (set))
 293             && ! find_reg_note (insn, REG_RETVAL, 0)
 294             /* An ADDRESSOF expression can turn into a use of the internal arg
 295                pointer, so do not delete the initialization of the internal
 296                arg pointer yet.  If it is truly dead, flow will delete the
 297                initializing insn.  */
 298             && SET_DEST (set) != current_function_internal_arg_pointer)
 299           delete_insn (insn);
 300       }
 301
 302   /* Now iterate optimizing jumps until nothing changes over one pass.  */
 303   changed = 1;
 304   old_max_reg = max_reg_num ();
 305   while (changed)
 306     {
 307       changed = 0;
 308
 309       for (insn = f; insn; insn = next)
 310         {
 311           rtx reallabelprev;
 312           rtx temp, temp1, temp2, temp3, temp4, temp5, temp6;
 313           rtx nlabel;
 314           int this_is_simplejump, this_is_condjump, reversep = 0;
 315           int this_is_condjump_in_parallel;
 316
 317           next = NEXT_INSN (insn);
 318
 319           /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
 320              jump.  Try to optimize by duplicating the loop exit test if so.
 321              This is only safe immediately after regscan, because it uses
 322              the values of regno_first_uid and regno_last_uid.  */
 323           if (after_regscan && GET_CODE (insn) == NOTE
 324               && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
 325               && (temp1 = next_nonnote_insn (insn)) != 0
 326               && simplejump_p (temp1))
 327             {
 328               temp = PREV_INSN (insn);
 329               if (duplicate_loop_exit_test (insn))
 330                 {
 331                   changed = 1;
 332                   next = NEXT_INSN (temp);
 333                   continue;
 334                 }
 335             }
 336
 337           if (GET_CODE (insn) != JUMP_INSN)
 338             continue;
 339
 340           this_is_simplejump = simplejump_p (insn);
 341           this_is_condjump = condjump_p (insn);
 342           this_is_condjump_in_parallel = condjump_in_parallel_p (insn);
 343
 344           /* Tension the labels in dispatch tables.  */
 345
 346           if (GET_CODE (PATTERN (insn)) == ADDR_VEC)
 347             changed |= tension_vector_labels (PATTERN (insn), 0);
 348           if (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
 349             changed |= tension_vector_labels (PATTERN (insn), 1);
 350
 351           /* See if this jump goes to another jump and redirect if so.  */
 352           nlabel = follow_jumps (JUMP_LABEL (insn));
 353           if (nlabel != JUMP_LABEL (insn))
 354             changed |= redirect_jump (insn, nlabel);
 355
 356           /* If a dispatch table always goes to the same place,
 357              get rid of it and replace the insn that uses it.  */
 358
 359           if (GET_CODE (PATTERN (insn)) == ADDR_VEC
 360               || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
 361             {
 362               int i;
 363               rtx pat = PATTERN (insn);
 364               int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC;
 365               int len = XVECLEN (pat, diff_vec_p);
 366               rtx dispatch = prev_real_insn (insn);
 367               rtx set;
 368
 369               for (i = 0; i < len; i++)
 370                 if (XEXP (XVECEXP (pat, diff_vec_p, i), 0)
 371                     != XEXP (XVECEXP (pat, diff_vec_p, 0), 0))
 372                   break;
 373
 374               if (i == len
 375                   && dispatch != 0
 376                   && GET_CODE (dispatch) == JUMP_INSN
 377                   && JUMP_LABEL (dispatch) != 0
 378                   /* Don't mess with a casesi insn.
 379                      XXX according to the comment before computed_jump_p(),
 380                      all casesi insns should be a parallel of the jump
 381                      and a USE of a LABEL_REF.  */
 382                   && ! ((set = single_set (dispatch)) != NULL
 383                         && (GET_CODE (SET_SRC (set)) == IF_THEN_ELSE))
 384                   && next_real_insn (JUMP_LABEL (dispatch)) == insn)
 385                 {
 386                   redirect_tablejump (dispatch,
 387                                       XEXP (XVECEXP (pat, diff_vec_p, 0), 0));
 388                   changed = 1;
 389                 }
 390             }
 391
 392           /* If a jump references the end of the function, try to turn
 393              it into a RETURN insn, possibly a conditional one.  */
 394           if (JUMP_LABEL (insn) != 0
 395               && (next_active_insn (JUMP_LABEL (insn)) == 0
 396                   || GET_CODE (PATTERN (next_active_insn (JUMP_LABEL (insn))))
 397                       == RETURN))
 398             changed |= redirect_jump (insn, NULL_RTX);
 399
 400           reallabelprev = prev_active_insn (JUMP_LABEL (insn));
 401
 402           /* Detect jump to following insn.  */
 403           if (reallabelprev == insn && this_is_condjump)
 404             {
 405               next = next_real_insn (JUMP_LABEL (insn));
 406               delete_jump (insn);
 407               changed = 1;
 408               continue;
 409             }
 410
 411           /* Detect a conditional jump going to the same place
 412              as an immediately following unconditional jump.  */
 413           else if (this_is_condjump
 414                    && (temp = next_active_insn (insn)) != 0
 415                    && simplejump_p (temp)
 416                    && (next_active_insn (JUMP_LABEL (insn))
 417                        == next_active_insn (JUMP_LABEL (temp))))
 418             {
 419               /* Don't mess up test coverage analysis.  */
 420               temp2 = temp;
 421               if (flag_test_coverage && !reload_completed)
 422                 for (temp2 = insn; temp2 != temp; temp2 = NEXT_INSN (temp2))
 423                   if (GET_CODE (temp2) == NOTE && NOTE_LINE_NUMBER (temp2) > 0)
 424                     break;
 425
 426               if (temp2 == temp)
 427                 {
 428                   delete_jump (insn);
 429                   changed = 1;
 430                   continue;
 431                 }
 432             }
 433
 434           /* Detect a conditional jump jumping over an unconditional jump.  */
 435
 436           else if ((this_is_condjump || this_is_condjump_in_parallel)
 437                    && ! this_is_simplejump
 438                    && reallabelprev != 0
 439                    && GET_CODE (reallabelprev) == JUMP_INSN
 440                    && prev_active_insn (reallabelprev) == insn
 441                    && no_labels_between_p (insn, reallabelprev)
 442                    && simplejump_p (reallabelprev))
 443             {
 444               /* When we invert the unconditional jump, we will be
 445                  decrementing the usage count of its old label.
 446                  Make sure that we don't delete it now because that
 447                  might cause the following code to be deleted.  */
 448               rtx prev_uses = prev_nonnote_insn (reallabelprev);
 449               rtx prev_label = JUMP_LABEL (insn);
 450
 451               if (prev_label)
 452                 ++LABEL_NUSES (prev_label);
 453
 454               if (invert_jump (insn, JUMP_LABEL (reallabelprev)))
 455                 {
 456                   /* It is very likely that if there are USE insns before
 457                      this jump, they hold REG_DEAD notes.  These REG_DEAD
 458                      notes are no longer valid due to this optimization,
 459                      and will cause the life-analysis that following passes
 460                      (notably delayed-branch scheduling) to think that
 461                      these registers are dead when they are not.
 462
 463                      To prevent this trouble, we just remove the USE insns
 464                      from the insn chain.  */
 465
 466                   while (prev_uses && GET_CODE (prev_uses) == INSN
 467                          && GET_CODE (PATTERN (prev_uses)) == USE)
 468                     {
 469                       rtx useless = prev_uses;
 470                       prev_uses = prev_nonnote_insn (prev_uses);
 471                       delete_insn (useless);
 472                     }
 473
 474                   delete_insn (reallabelprev);
 475                   changed = 1;
 476                 }
 477
 478               /* We can now safely delete the label if it is unreferenced
 479                  since the delete_insn above has deleted the BARRIER.  */
 480               if (prev_label && --LABEL_NUSES (prev_label) == 0)
 481                 delete_insn (prev_label);
 482
 483               next = NEXT_INSN (insn);
 484             }
 485
 486           /* If we have an unconditional jump preceded by a USE, try to put
 487              the USE before the target and jump there.  This simplifies many
 488              of the optimizations below since we don't have to worry about
 489              dealing with these USE insns.  We only do this if the label
 490              being branch to already has the identical USE or if code
 491              never falls through to that label.  */
 492
 493           else if (this_is_simplejump
 494                    && (temp = prev_nonnote_insn (insn)) != 0
 495                    && GET_CODE (temp) == INSN
 496                    && GET_CODE (PATTERN (temp)) == USE
 497                    && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
 498                    && (GET_CODE (temp1) == BARRIER
 499                        || (GET_CODE (temp1) == INSN
 500                            && rtx_equal_p (PATTERN (temp), PATTERN (temp1))))
 501                    /* Don't do this optimization if we have a loop containing
 502                       only the USE instruction, and the loop start label has
 503                       a usage count of 1.  This is because we will redo this
 504                       optimization everytime through the outer loop, and jump
 505                       opt will never exit.  */
 506                    && ! ((temp2 = prev_nonnote_insn (temp)) != 0
 507                          && temp2 == JUMP_LABEL (insn)
 508                          && LABEL_NUSES (temp2) == 1))
 509             {
 510               if (GET_CODE (temp1) == BARRIER)
 511                 {
 512                   emit_insn_after (PATTERN (temp), temp1);
 513                   temp1 = NEXT_INSN (temp1);
 514                 }
 515
 516               delete_insn (temp);
 517               redirect_jump (insn, get_label_before (temp1));
 518               reallabelprev = prev_real_insn (temp1);
 519               changed = 1;
 520               next = NEXT_INSN (insn);
 521             }
 522
 523           /* Simplify   if (...) x = a; else x = b; by converting it
 524              to         x = b; if (...) x = a;
 525              if B is sufficiently simple, the test doesn't involve X,
 526              and nothing in the test modifies B or X.
 527
 528              If we have small register classes, we also can't do this if X
 529              is a hard register.
 530
 531              If the "x = b;" insn has any REG_NOTES, we don't do this because
 532              of the possibility that we are running after CSE and there is a
 533              REG_EQUAL note that is only valid if the branch has already been
 534              taken.  If we move the insn with the REG_EQUAL note, we may
 535              fold the comparison to always be false in a later CSE pass.
 536              (We could also delete the REG_NOTES when moving the insn, but it
 537              seems simpler to not move it.)  An exception is that we can move
 538              the insn if the only note is a REG_EQUAL or REG_EQUIV whose
 539              value is the same as "b".
 540
 541              INSN is the branch over the `else' part.
 542
 543              We set:
 544
 545              TEMP to the jump insn preceding "x = a;"
 546              TEMP1 to X
 547              TEMP2 to the insn that sets "x = b;"
 548              TEMP3 to the insn that sets "x = a;"
 549              TEMP4 to the set of "x = b";  */
 550
 551           if (this_is_simplejump
 552               && (temp3 = prev_active_insn (insn)) != 0
 553               && GET_CODE (temp3) == INSN
 554               && (temp4 = single_set (temp3)) != 0
 555               && GET_CODE (temp1 = SET_DEST (temp4)) == REG
 556               && (! SMALL_REGISTER_CLASSES
 557                   || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
 558               && (temp2 = next_active_insn (insn)) != 0
 559               && GET_CODE (temp2) == INSN
 560               && (temp4 = single_set (temp2)) != 0
 561               && rtx_equal_p (SET_DEST (temp4), temp1)
 562               && ! side_effects_p (SET_SRC (temp4))
 563               && ! may_trap_p (SET_SRC (temp4))
 564               && (REG_NOTES (temp2) == 0
 565                   || ((REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUAL
 566                        || REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUIV)
 567                       && XEXP (REG_NOTES (temp2), 1) == 0
 568                       && rtx_equal_p (XEXP (REG_NOTES (temp2), 0),
 569                                       SET_SRC (temp4))))
 570               && (temp = prev_active_insn (temp3)) != 0
 571               && condjump_p (temp) && ! simplejump_p (temp)
 572               /* TEMP must skip over the "x = a;" insn */
 573               && prev_real_insn (JUMP_LABEL (temp)) == insn
 574               && no_labels_between_p (insn, JUMP_LABEL (temp))
 575               /* There must be no other entries to the "x = b;" insn.  */
 576               && no_labels_between_p (JUMP_LABEL (temp), temp2)
 577               /* INSN must either branch to the insn after TEMP2 or the insn
 578                  after TEMP2 must branch to the same place as INSN.  */
 579               && (reallabelprev == temp2
 580                   || ((temp5 = next_active_insn (temp2)) != 0
 581                       && simplejump_p (temp5)
 582                       && JUMP_LABEL (temp5) == JUMP_LABEL (insn))))
 583             {
 584               /* The test expression, X, may be a complicated test with
 585                  multiple branches.  See if we can find all the uses of
 586                  the label that TEMP branches to without hitting a CALL_INSN
 587                  or a jump to somewhere else.  */
 588               rtx target = JUMP_LABEL (temp);
 589               int nuses = LABEL_NUSES (target);
 590               rtx p;
 591 #ifdef HAVE_cc0
 592               rtx q;
 593 #endif
 594
 595               /* Set P to the first jump insn that goes around "x = a;".  */
 596               for (p = temp; nuses && p; p = prev_nonnote_insn (p))
 597                 {
 598                   if (GET_CODE (p) == JUMP_INSN)
 599                     {
 600                       if (condjump_p (p) && ! simplejump_p (p)
 601                           && JUMP_LABEL (p) == target)
 602                         {
 603                           nuses--;
 604                           if (nuses == 0)
 605                             break;
 606                         }
 607                       else
 608                         break;
 609                     }
 610                   else if (GET_CODE (p) == CALL_INSN)
 611                     break;
 612                 }
 613
 614 #ifdef HAVE_cc0
 615               /* We cannot insert anything between a set of cc and its use
 616                  so if P uses cc0, we must back up to the previous insn.  */
 617               q = prev_nonnote_insn (p);
 618               if (q && GET_RTX_CLASS (GET_CODE (q)) == 'i'
 619                   && sets_cc0_p (PATTERN (q)))
 620                 p = q;
 621 #endif
 622
 623               if (p)
 624                 p = PREV_INSN (p);
 625
 626               /* If we found all the uses and there was no data conflict, we
 627                  can move the assignment unless we can branch into the middle
 628                  from somewhere.  */
 629               if (nuses == 0 && p
 630                   && no_labels_between_p (p, insn)
 631                   && ! reg_referenced_between_p (temp1, p, NEXT_INSN (temp3))
 632                   && ! reg_set_between_p (temp1, p, temp3)
 633                   && (GET_CODE (SET_SRC (temp4)) == CONST_INT
 634                       || ! modified_between_p (SET_SRC (temp4), p, temp2))
 635                   /* Verify that registers used by the jump are not clobbered
 636                      by the instruction being moved.  */
 637                   && ! regs_set_between_p (PATTERN (temp),
 638                                            PREV_INSN (temp2),
 639                                            NEXT_INSN (temp2)))
 640                 {
 641                   emit_insn_after_with_line_notes (PATTERN (temp2), p, temp2);
 642                   delete_insn (temp2);
 643
 644                   /* Set NEXT to an insn that we know won't go away.  */
 645                   next = next_active_insn (insn);
 646
 647                   /* Delete the jump around the set.  Note that we must do
 648                      this before we redirect the test jumps so that it won't
 649                      delete the code immediately following the assignment
 650                      we moved (which might be a jump).  */
 651
 652                   delete_insn (insn);
 653
 654                   /* We either have two consecutive labels or a jump to
 655                      a jump, so adjust all the JUMP_INSNs to branch to where
 656                      INSN branches to.  */
 657                   for (p = NEXT_INSN (p); p != next; p = NEXT_INSN (p))
 658                     if (GET_CODE (p) == JUMP_INSN)
 659                       redirect_jump (p, target);
 660
 661                   changed = 1;
 662                   next = NEXT_INSN (insn);
 663                   continue;
 664                 }
 665             }
 666
 667           /* Simplify   if (...) { x = a; goto l; } x = b; by converting it
 668              to         x = a; if (...) goto l; x = b;
 669              if A is sufficiently simple, the test doesn't involve X,
 670              and nothing in the test modifies A or X.
 671
 672              If we have small register classes, we also can't do this if X
 673              is a hard register.
 674
 675              If the "x = a;" insn has any REG_NOTES, we don't do this because
 676              of the possibility that we are running after CSE and there is a
 677              REG_EQUAL note that is only valid if the branch has already been
 678              taken.  If we move the insn with the REG_EQUAL note, we may
 679              fold the comparison to always be false in a later CSE pass.
 680              (We could also delete the REG_NOTES when moving the insn, but it
 681              seems simpler to not move it.)  An exception is that we can move
 682              the insn if the only note is a REG_EQUAL or REG_EQUIV whose
 683              value is the same as "a".
 684
 685              INSN is the goto.
 686
 687              We set:
 688
 689              TEMP to the jump insn preceding "x = a;"
 690              TEMP1 to X
 691              TEMP2 to the insn that sets "x = b;"
 692              TEMP3 to the insn that sets "x = a;"
 693              TEMP4 to the set of "x = a";  */
 694
 695           if (this_is_simplejump
 696               && (temp2 = next_active_insn (insn)) != 0
 697               && GET_CODE (temp2) == INSN
 698               && (temp4 = single_set (temp2)) != 0
 699               && GET_CODE (temp1 = SET_DEST (temp4)) == REG
 700               && (! SMALL_REGISTER_CLASSES
 701                   || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
 702               && (temp3 = prev_active_insn (insn)) != 0
 703               && GET_CODE (temp3) == INSN
 704               && (temp4 = single_set (temp3)) != 0
 705               && rtx_equal_p (SET_DEST (temp4), temp1)
 706               && ! side_effects_p (SET_SRC (temp4))
 707               && ! may_trap_p (SET_SRC (temp4))
 708               && (REG_NOTES (temp3) == 0
 709                   || ((REG_NOTE_KIND (REG_NOTES (temp3)) == REG_EQUAL
 710                        || REG_NOTE_KIND (REG_NOTES (temp3)) == REG_EQUIV)
 711                       && XEXP (REG_NOTES (temp3), 1) == 0
 712                       && rtx_equal_p (XEXP (REG_NOTES (temp3), 0),
 713                                       SET_SRC (temp4))))
 714               && (temp = prev_active_insn (temp3)) != 0
 715               && condjump_p (temp) && ! simplejump_p (temp)
 716               /* TEMP must skip over the "x = a;" insn */
 717               && prev_real_insn (JUMP_LABEL (temp)) == insn
 718               && no_labels_between_p (temp, insn))
 719             {
 720               rtx prev_label = JUMP_LABEL (temp);
 721               rtx insert_after = prev_nonnote_insn (temp);
 722
 723 #ifdef HAVE_cc0
 724               /* We cannot insert anything between a set of cc and its use.  */
 725               if (insert_after && GET_RTX_CLASS (GET_CODE (insert_after)) == 'i'
 726                   && sets_cc0_p (PATTERN (insert_after)))
 727                 insert_after = prev_nonnote_insn (insert_after);
 728 #endif
 729               ++LABEL_NUSES (prev_label);
 730
 731               if (insert_after
 732                   && no_labels_between_p (insert_after, temp)
 733                   && ! reg_referenced_between_p (temp1, insert_after, temp3)
 734                   && ! reg_referenced_between_p (temp1, temp3,
 735                                                  NEXT_INSN (temp2))
 736                   && ! reg_set_between_p (temp1, insert_after, temp)
 737                   && ! modified_between_p (SET_SRC (temp4), insert_after, temp)
 738                   /* Verify that registers used by the jump are not clobbered
 739                      by the instruction being moved.  */
 740                   && ! regs_set_between_p (PATTERN (temp),
 741                                            PREV_INSN (temp3),
 742                                            NEXT_INSN (temp3))
 743                   && invert_jump (temp, JUMP_LABEL (insn)))
 744                 {
 745                   emit_insn_after_with_line_notes (PATTERN (temp3),
 746                                                    insert_after, temp3);
 747                   delete_insn (temp3);
 748                   delete_insn (insn);
 749                   /* Set NEXT to an insn that we know won't go away.  */
 750                   next = temp2;
 751                   changed = 1;
 752                 }
 753               if (prev_label && --LABEL_NUSES (prev_label) == 0)
 754                 delete_insn (prev_label);
 755               if (changed)
 756                 continue;
 757             }
 758
 759 #if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
 760
 761           /* If we have if (...) x = exp;  and branches are expensive,
 762              EXP is a single insn, does not have any side effects, cannot
 763              trap, and is not too costly, convert this to
 764              t = exp; if (...) x = t;
 765
 766              Don't do this when we have CC0 because it is unlikely to help
 767              and we'd need to worry about where to place the new insn and
 768              the potential for conflicts.  We also can't do this when we have
 769              notes on the insn for the same reason as above.
 770
 771              If we have conditional arithmetic, this will make this
 772              harder to optimize later and isn't needed, so don't do it
 773              in that case either.
 774
 775              We set:
 776
 777              TEMP to the "x = exp;" insn.
 778              TEMP1 to the single set in the "x = exp;" insn.
 779              TEMP2 to "x".  */
 780
 781           if (! reload_completed
 782               && this_is_condjump && ! this_is_simplejump
 783               && BRANCH_COST >= 3
 784               && (temp = next_nonnote_insn (insn)) != 0
 785               && GET_CODE (temp) == INSN
 786               && REG_NOTES (temp) == 0
 787               && (reallabelprev == temp
 788                   || ((temp2 = next_active_insn (temp)) != 0
 789                       && simplejump_p (temp2)
 790                       && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
 791               && (temp1 = single_set (temp)) != 0
 792               && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
 793               && (! SMALL_REGISTER_CLASSES
 794                   || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 795               && GET_CODE (SET_SRC (temp1)) != REG
 796               && GET_CODE (SET_SRC (temp1)) != SUBREG
 797               && GET_CODE (SET_SRC (temp1)) != CONST_INT
 798               && ! side_effects_p (SET_SRC (temp1))
 799               && ! may_trap_p (SET_SRC (temp1))
 800               && rtx_cost (SET_SRC (temp1), SET) < 10)
 801             {
 802               rtx new = gen_reg_rtx (GET_MODE (temp2));
 803
 804               if ((temp3 = find_insert_position (insn, temp))
 805                   && validate_change (temp, &SET_DEST (temp1), new, 0))
 806                 {
 807                   next = emit_insn_after (gen_move_insn (temp2, new), insn);
 808                   emit_insn_after_with_line_notes (PATTERN (temp),
 809                                                    PREV_INSN (temp3), temp);
 810                   delete_insn (temp);
 811                   reallabelprev = prev_active_insn (JUMP_LABEL (insn));
 812
 813                   if (after_regscan)
 814                     {
 815                       reg_scan_update (temp3, NEXT_INSN (next), old_max_reg);
 816                       old_max_reg = max_reg_num ();
 817                     }
 818                 }
 819             }
 820
 821           /* Similarly, if it takes two insns to compute EXP but they
 822              have the same destination.  Here TEMP3 will be the second
 823              insn and TEMP4 the SET from that insn.  */
 824
 825           if (! reload_completed
 826               && this_is_condjump && ! this_is_simplejump
 827               && BRANCH_COST >= 4
 828               && (temp = next_nonnote_insn (insn)) != 0
 829               && GET_CODE (temp) == INSN
 830               && REG_NOTES (temp) == 0
 831               && (temp3 = next_nonnote_insn (temp)) != 0
 832               && GET_CODE (temp3) == INSN
 833               && REG_NOTES (temp3) == 0
 834               && (reallabelprev == temp3
 835                   || ((temp2 = next_active_insn (temp3)) != 0
 836                       && simplejump_p (temp2)
 837                       && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
 838               && (temp1 = single_set (temp)) != 0
 839               && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
 840               && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
 841               && (! SMALL_REGISTER_CLASSES
 842                   || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 843               && ! side_effects_p (SET_SRC (temp1))
 844               && ! may_trap_p (SET_SRC (temp1))
 845               && rtx_cost (SET_SRC (temp1), SET) < 10
 846               && (temp4 = single_set (temp3)) != 0
 847               && rtx_equal_p (SET_DEST (temp4), temp2)
 848               && ! side_effects_p (SET_SRC (temp4))
 849               && ! may_trap_p (SET_SRC (temp4))
 850               && rtx_cost (SET_SRC (temp4), SET) < 10)
 851             {
 852               rtx new = gen_reg_rtx (GET_MODE (temp2));
 853
 854               if ((temp5 = find_insert_position (insn, temp))
 855                   && (temp6 = find_insert_position (insn, temp3))
 856                   && validate_change (temp, &SET_DEST (temp1), new, 0))
 857                 {
 858                   /* Use the earliest of temp5 and temp6. */
 859                   if (temp5 != insn)
 860                     temp6 = temp5;
 861                   next = emit_insn_after (gen_move_insn (temp2, new), insn);
 862                   emit_insn_after_with_line_notes (PATTERN (temp),
 863                                                    PREV_INSN (temp6), temp);
 864                   emit_insn_after_with_line_notes
 865                     (replace_rtx (PATTERN (temp3), temp2, new),
 866                      PREV_INSN (temp6), temp3);
 867                   delete_insn (temp);
 868                   delete_insn (temp3);
 869                   reallabelprev = prev_active_insn (JUMP_LABEL (insn));
 870
 871                   if (after_regscan)
 872                     {
 873                       reg_scan_update (temp6, NEXT_INSN (next), old_max_reg);
 874                       old_max_reg = max_reg_num ();
 875                     }
 876                 }
 877             }
 878
 879           /* Finally, handle the case where two insns are used to
 880              compute EXP but a temporary register is used.  Here we must
 881              ensure that the temporary register is not used anywhere else.  */
 882
 883           if (! reload_completed
 884               && after_regscan
 885               && this_is_condjump && ! this_is_simplejump
 886               && BRANCH_COST >= 4
 887               && (temp = next_nonnote_insn (insn)) != 0
 888               && GET_CODE (temp) == INSN
 889               && REG_NOTES (temp) == 0
 890               && (temp3 = next_nonnote_insn (temp)) != 0
 891               && GET_CODE (temp3) == INSN
 892               && REG_NOTES (temp3) == 0
 893               && (reallabelprev == temp3
 894                   || ((temp2 = next_active_insn (temp3)) != 0
 895                       && simplejump_p (temp2)
 896                       && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
 897               && (temp1 = single_set (temp)) != 0
 898               && (temp5 = SET_DEST (temp1),
 899                   (GET_CODE (temp5) == REG
 900                    || (GET_CODE (temp5) == SUBREG
 901                        && (temp5 = SUBREG_REG (temp5),
 902                            GET_CODE (temp5) == REG))))
 903               && REGNO (temp5) >= FIRST_PSEUDO_REGISTER
 904               && REGNO_FIRST_UID (REGNO (temp5)) == INSN_UID (temp)
 905               && REGNO_LAST_UID (REGNO (temp5)) == INSN_UID (temp3)
 906               && ! side_effects_p (SET_SRC (temp1))
 907               && ! may_trap_p (SET_SRC (temp1))
 908               && rtx_cost (SET_SRC (temp1), SET) < 10
 909               && (temp4 = single_set (temp3)) != 0
 910               && (temp2 = SET_DEST (temp4), GET_CODE (temp2) == REG)
 911               && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
 912               && (! SMALL_REGISTER_CLASSES
 913                   || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 914               && rtx_equal_p (SET_DEST (temp4), temp2)
 915               && ! side_effects_p (SET_SRC (temp4))
 916               && ! may_trap_p (SET_SRC (temp4))
 917               && rtx_cost (SET_SRC (temp4), SET) < 10)
 918             {
 919               rtx new = gen_reg_rtx (GET_MODE (temp2));
 920
 921               if ((temp5 = find_insert_position (insn, temp))
 922                   && (temp6 = find_insert_position (insn, temp3))
 923                   && validate_change (temp3, &SET_DEST (temp4), new, 0))
 924                 {
 925                   /* Use the earliest of temp5 and temp6. */
 926                   if (temp5 != insn)
 927                     temp6 = temp5;
 928                   next = emit_insn_after (gen_move_insn (temp2, new), insn);
 929                   emit_insn_after_with_line_notes (PATTERN (temp),
 930                                                    PREV_INSN (temp6), temp);
 931                   emit_insn_after_with_line_notes (PATTERN (temp3),
 932                                                    PREV_INSN (temp6), temp3);
 933                   delete_insn (temp);
 934                   delete_insn (temp3);
 935                   reallabelprev = prev_active_insn (JUMP_LABEL (insn));
 936
 937                   if (after_regscan)
 938                     {
 939                       reg_scan_update (temp6, NEXT_INSN (next), old_max_reg);
 940                       old_max_reg = max_reg_num ();
 941                     }
 942                 }
 943             }
 944 #endif /* HAVE_cc0 */
 945
 946 #ifdef HAVE_conditional_arithmetic
 947           /* ??? This is disabled in genconfig, as this simple-minded
 948              transformation can incredibly lengthen register lifetimes.
 949
 950              Consider this example from cexp.c's yyparse:
 951
 952                 234 (set (pc)
 953                       (if_then_else (ne (reg:DI 149) (const_int 0 [0x0]))
 954                         (label_ref 248) (pc)))
 955                 237 (set (reg/i:DI 0 $0) (const_int 1 [0x1]))
 956                 239 (set (pc) (label_ref 2382))
 957                 248 (code_label ("yybackup"))
 958
 959              This will be transformed to:
 960
 961                 237 (set (reg/i:DI 0 $0)
 962                       (if_then_else:DI (eq (reg:DI 149) (const_int 0 [0x0]))
 963                         (const_int 1 [0x1]) (reg/i:DI 0 $0)))
 964                 239 (set (pc)
 965                       (if_then_else (eq (reg:DI 149) (const_int 0 [0x0]))
 966                         (label_ref 2382) (pc)))
 967
 968              which, from this narrow viewpoint looks fine.  Except that
 969              between this and 3 other ocurrences of the same pattern, $0
 970              is now live for basically the entire function, and we'll
 971              get an abort in caller_save.
 972
 973              Any replacement for this code should recall that a set of
 974              a register that is not live need not, and indeed should not,
 975              be conditionalized.  Either that, or delay the transformation
 976              until after register allocation.  */
 977
 978           /* See if this is a conditional jump around a small number of
 979              instructions that we can conditionalize.  Don't do this before
 980              the initial CSE pass or after reload.
 981
 982              We reject any insns that have side effects or may trap.
 983              Strictly speaking, this is not needed since the machine may
 984              support conditionalizing these too, but we won't deal with that
 985              now.  Specifically, this means that we can't conditionalize a
 986              CALL_INSN, which some machines, such as the ARC, can do, but
 987              this is a very minor optimization.  */
 988           if (this_is_condjump && ! this_is_simplejump
 989               && cse_not_expected && optimize > 0 && ! reload_completed
 990               && BRANCH_COST > 2
 991               && can_reverse_comparison_p (XEXP (SET_SRC (PATTERN (insn)), 0),
 992                                            insn))
 993             {
 994               rtx ourcond = XEXP (SET_SRC (PATTERN (insn)), 0);
 995               int num_insns = 0;
 996               char *storage = (char *) oballoc (0);
 997               int last_insn = 0, failed = 0;
 998               rtx changed_jump = 0;
 999
1000               ourcond = gen_rtx (reverse_condition (GET_CODE (ourcond)),
1001                                  VOIDmode, XEXP (ourcond, 0),
1002                                  XEXP (ourcond, 1));
1003
1004               /* Scan forward BRANCH_COST real insns looking for the JUMP_LABEL
1005                  of this insn.  We see if we think we can conditionalize the
1006                  insns we pass.  For now, we only deal with insns that have
1007                  one SET.  We stop after an insn that modifies anything in
1008                  OURCOND, if we have too many insns, or if we have an insn
1009                  with a side effect or that may trip.  Note that we will
1010                  be modifying any unconditional jumps we encounter to be
1011                  conditional; this will have the effect of also doing this
1012                  optimization on the "else" the next time around.  */
1013               for (temp1 = NEXT_INSN (insn);
1014                    num_insns <= BRANCH_COST && ! failed && temp1 != 0
1015                    && GET_CODE (temp1) != CODE_LABEL;
1016                    temp1 = NEXT_INSN (temp1))
1017                 {
1018                   /* Ignore everything but an active insn.  */
1019                   if (GET_RTX_CLASS (GET_CODE (temp1)) != 'i'
1020                       || GET_CODE (PATTERN (temp1)) == USE
1021                       || GET_CODE (PATTERN (temp1)) == CLOBBER)
1022                     continue;
1023
1024                   /* If this was an unconditional jump, record it since we'll
1025                      need to remove the BARRIER if we succeed.  We can only
1026                      have one such jump since there must be a label after
1027                      the BARRIER and it's either ours, in which case it's the
1028                      only one or some other, in which case we'd fail.
1029                      Likewise if it's a CALL_INSN followed by a BARRIER.  */
1030
1031                   if (simplejump_p (temp1)
1032                       || (GET_CODE (temp1) == CALL_INSN
1033                           && NEXT_INSN (temp1) != 0
1034                           && GET_CODE (NEXT_INSN (temp1)) == BARRIER))
1035                     {
1036                       if (changed_jump == 0)
1037                         changed_jump = temp1;
1038                       else
1039                         changed_jump
1040                           = gen_rtx_INSN_LIST (VOIDmode, temp1, changed_jump);
1041                     }
1042
1043                   /* See if we are allowed another insn and if this insn
1044                      if one we think we may be able to handle.  */
1045                   if (++num_insns > BRANCH_COST
1046                       || last_insn
1047                       || (((temp2 = single_set (temp1)) == 0
1048                            || side_effects_p (SET_SRC (temp2))
1049                            || may_trap_p (SET_SRC (temp2)))
1050                           && GET_CODE (temp1) != CALL_INSN))
1051                       failed = 1;
1052                   else if (temp2 != 0)
1053                     validate_change (temp1, &SET_SRC (temp2),
1054                                      gen_rtx_IF_THEN_ELSE
1055                                      (GET_MODE (SET_DEST (temp2)),
1056                                       copy_rtx (ourcond),
1057                                       SET_SRC (temp2), SET_DEST (temp2)),
1058                                      1);
1059                   else
1060                     {
1061                       /* This is a CALL_INSN that doesn't have a SET.  */
1062                       rtx *call_loc = &PATTERN (temp1);
1063
1064                       if (GET_CODE (*call_loc) == PARALLEL)
1065                         call_loc = &XVECEXP (*call_loc, 0, 0);
1066
1067                       validate_change (temp1, call_loc,
1068                                        gen_rtx_IF_THEN_ELSE
1069                                        (VOIDmode, copy_rtx (ourcond),
1070                                         *call_loc, const0_rtx),
1071                                        1);
1072                     }
1073
1074
1075                   if (modified_in_p (ourcond, temp1))
1076                     last_insn = 1;
1077                 }
1078
1079               /* If we've reached our jump label, haven't failed, and all
1080                  the changes above are valid, we can delete this jump
1081                  insn.  Also remove a BARRIER after any jump that used
1082                  to be unconditional and remove any REG_EQUAL or REG_EQUIV
1083                  that might have previously been present on insns we
1084                  made conditional.  */
1085               if (temp1 == JUMP_LABEL (insn) && ! failed
1086                   && apply_change_group ())
1087                 {
1088                   for (temp1 = NEXT_INSN (insn); temp1 != JUMP_LABEL (insn);
1089                        temp1 = NEXT_INSN (temp1))
1090                     if (GET_RTX_CLASS (GET_CODE (temp1)) == 'i')
1091                       for (temp2 = REG_NOTES (temp1); temp2 != 0;
1092                            temp2 = XEXP (temp2, 1))
1093                         if (REG_NOTE_KIND (temp2) == REG_EQUAL
1094                             || REG_NOTE_KIND (temp2) == REG_EQUIV)
1095                           remove_note (temp1, temp2);
1096
1097                   if (changed_jump != 0)
1098                     {
1099                       while (GET_CODE (changed_jump) == INSN_LIST)
1100                         {
1101                           delete_barrier (NEXT_INSN (XEXP (changed_jump, 0)));
1102                           changed_jump = XEXP (changed_jump, 1);
1103                         }
1104
1105                       delete_barrier (NEXT_INSN (changed_jump));
1106                     }
1107
1108                   delete_insn (insn);
1109                   changed = 1;
1110                   continue;
1111                 }
1112               else
1113                 {
1114                   cancel_changes (0);
1115                   obfree (storage);
1116                 }
1117             }
1118 #endif
1119           /* If branches are expensive, convert
1120                 if (foo) bar++;    to    bar += (foo != 0);
1121              and similarly for "bar--;"
1122
1123              INSN is the conditional branch around the arithmetic.  We set:
1124
1125              TEMP is the arithmetic insn.
1126              TEMP1 is the SET doing the arithmetic.
1127              TEMP2 is the operand being incremented or decremented.
1128              TEMP3 to the condition being tested.
1129              TEMP4 to the earliest insn used to find the condition.  */
1130
1131           if ((BRANCH_COST >= 2
1132 #ifdef HAVE_incscc
1133                || HAVE_incscc
1134 #endif
1135 #ifdef HAVE_decscc
1136                || HAVE_decscc
1137 #endif
1138               )
1139               && ! reload_completed
1140               && this_is_condjump && ! this_is_simplejump
1141               && (temp = next_nonnote_insn (insn)) != 0
1142               && (temp1 = single_set (temp)) != 0
1143               && (temp2 = SET_DEST (temp1),
1144                   GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT)
1145               && GET_CODE (SET_SRC (temp1)) == PLUS
1146               && (XEXP (SET_SRC (temp1), 1) == const1_rtx
1147                   || XEXP (SET_SRC (temp1), 1) == constm1_rtx)
1148               && rtx_equal_p (temp2, XEXP (SET_SRC (temp1), 0))
1149               && ! side_effects_p (temp2)
1150               && ! may_trap_p (temp2)
1151               /* INSN must either branch to the insn after TEMP or the insn
1152                  after TEMP must branch to the same place as INSN.  */
1153               && (reallabelprev == temp
1154                   || ((temp3 = next_active_insn (temp)) != 0
1155                       && simplejump_p (temp3)
1156                       && JUMP_LABEL (temp3) == JUMP_LABEL (insn)))
1157               && (temp3 = get_condition (insn, &temp4)) != 0
1158               /* We must be comparing objects whose modes imply the size.
1159                  We could handle BLKmode if (1) emit_store_flag could
1160                  and (2) we could find the size reliably.  */
1161               && GET_MODE (XEXP (temp3, 0)) != BLKmode
1162               && can_reverse_comparison_p (temp3, insn))
1163             {
1164               rtx temp6, target = 0, seq, init_insn = 0, init = temp2;
1165               enum rtx_code code = reverse_condition (GET_CODE (temp3));
1166
1167               start_sequence ();
1168
1169               /* It must be the case that TEMP2 is not modified in the range
1170                  [TEMP4, INSN).  The one exception we make is if the insn
1171                  before INSN sets TEMP2 to something which is also unchanged
1172                  in that range.  In that case, we can move the initialization
1173                  into our sequence.  */
1174
1175               if ((temp5 = prev_active_insn (insn)) != 0
1176                   && no_labels_between_p (temp5, insn)
1177                   && GET_CODE (temp5) == INSN
1178                   && (temp6 = single_set (temp5)) != 0
1179                   && rtx_equal_p (temp2, SET_DEST (temp6))
1180                   && (CONSTANT_P (SET_SRC (temp6))
1181                       || GET_CODE (SET_SRC (temp6)) == REG
1182                       || GET_CODE (SET_SRC (temp6)) == SUBREG))
1183                 {
1184                   emit_insn (PATTERN (temp5));
1185                   init_insn = temp5;
1186                   init = SET_SRC (temp6);
1187                 }
1188
1189               if (CONSTANT_P (init)
1190                   || ! reg_set_between_p (init, PREV_INSN (temp4), insn))
1191                 target = emit_store_flag (gen_reg_rtx (GET_MODE (temp2)), code,
1192                                           XEXP (temp3, 0), XEXP (temp3, 1),
1193                                           VOIDmode,
1194                                           (code == LTU || code == LEU
1195                                            || code == GTU || code == GEU), 1);
1196
1197               /* If we can do the store-flag, do the addition or
1198                  subtraction.  */
1199
1200               if (target)
1201                 target = expand_binop (GET_MODE (temp2),
1202                                        (XEXP (SET_SRC (temp1), 1) == const1_rtx
1203                                         ? add_optab : sub_optab),
1204                                        temp2, target, temp2, 0, OPTAB_WIDEN);
1205
1206               if (target != 0)
1207                 {
1208                   /* Put the result back in temp2 in case it isn't already.
1209                      Then replace the jump, possible a CC0-setting insn in
1210                      front of the jump, and TEMP, with the sequence we have
1211                      made.  */
1212
1213                   if (target != temp2)
1214                     emit_move_insn (temp2, target);
1215
1216                   seq = get_insns ();
1217                   end_sequence ();
1218
1219                   emit_insns_before (seq, temp4);
1220                   delete_insn (temp);
1221
1222                   if (init_insn)
1223                     delete_insn (init_insn);
1224
1225                   next = NEXT_INSN (insn);
1226 #ifdef HAVE_cc0
1227                   delete_insn (prev_nonnote_insn (insn));
1228 #endif
1229                   delete_insn (insn);
1230
1231                   if (after_regscan)
1232                     {
1233                       reg_scan_update (seq, NEXT_INSN (next), old_max_reg);
1234                       old_max_reg = max_reg_num ();
1235                     }
1236
1237                   changed = 1;
1238                   continue;
1239                 }
1240               else
1241                 end_sequence ();
1242             }
1243
1244           /* Try to use a conditional move (if the target has them), or a
1245              store-flag insn.  If the target has conditional arithmetic as
1246              well as conditional move, the above code will have done something.
1247              Note that we prefer the above code since it is more general: the
1248              code below can make changes that require work to undo.
1249
1250              The general case here is:
1251
1252              1) x = a; if (...) x = b; and
1253              2) if (...) x = b;
1254
1255              If the jump would be faster, the machine should not have defined
1256              the movcc or scc insns!.  These cases are often made by the
1257              previous optimization.
1258
1259              The second case is treated as  x = x; if (...) x = b;.
1260
1261              INSN here is the jump around the store.  We set:
1262
1263              TEMP to the "x op= b;" insn.
1264              TEMP1 to X.
1265              TEMP2 to B.
1266              TEMP3 to A (X in the second case).
1267              TEMP4 to the condition being tested.
1268              TEMP5 to the earliest insn used to find the condition.
1269              TEMP6 to the SET of TEMP.  */
1270
1271           if (/* We can't do this after reload has completed.  */
1272               ! reload_completed
1273 #ifdef HAVE_conditional_arithmetic
1274               /* Defer this until after CSE so the above code gets the
1275                  first crack at it.  */
1276               && cse_not_expected
1277 #endif
1278               && this_is_condjump && ! this_is_simplejump
1279               /* Set TEMP to the "x = b;" insn.  */
1280               && (temp = next_nonnote_insn (insn)) != 0
1281               && GET_CODE (temp) == INSN
1282               && (temp6 = single_set (temp)) != NULL_RTX
1283               && GET_CODE (temp1 = SET_DEST (temp6)) == REG
1284               && (! SMALL_REGISTER_CLASSES
1285                   || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
1286               && ! side_effects_p (temp2 = SET_SRC (temp6))
1287               && ! may_trap_p (temp2)
1288               /* Allow either form, but prefer the former if both apply.
1289                  There is no point in using the old value of TEMP1 if
1290                  it is a register, since cse will alias them.  It can
1291                  lose if the old value were a hard register since CSE
1292                  won't replace hard registers.  Avoid using TEMP3 if
1293                  small register classes and it is a hard register.  */
1294               && (((temp3 = reg_set_last (temp1, insn)) != 0
1295                    && ! (SMALL_REGISTER_CLASSES && GET_CODE (temp3) == REG
1296                          && REGNO (temp3) < FIRST_PSEUDO_REGISTER))
1297                   /* Make the latter case look like  x = x; if (...) x = b;  */
1298                   || (temp3 = temp1, 1))
1299               /* INSN must either branch to the insn after TEMP or the insn
1300                  after TEMP must branch to the same place as INSN.  */
1301               && (reallabelprev == temp
1302                   || ((temp4 = next_active_insn (temp)) != 0
1303                       && simplejump_p (temp4)
1304                       && JUMP_LABEL (temp4) == JUMP_LABEL (insn)))
1305               && (temp4 = get_condition (insn, &temp5)) != 0
1306               /* We must be comparing objects whose modes imply the size.
1307                  We could handle BLKmode if (1) emit_store_flag could
1308                  and (2) we could find the size reliably.  */
1309               && GET_MODE (XEXP (temp4, 0)) != BLKmode
1310               /* Even if branches are cheap, the store_flag optimization
1311                  can win when the operation to be performed can be
1312                  expressed directly.  */
1313 #ifdef HAVE_cc0
1314               /* If the previous insn sets CC0 and something else, we can't
1315                  do this since we are going to delete that insn.  */
1316
1317               && ! ((temp6 = prev_nonnote_insn (insn)) != 0
1318                     && GET_CODE (temp6) == INSN
1319                     && (sets_cc0_p (PATTERN (temp6)) == -1
1320                         || (sets_cc0_p (PATTERN (temp6)) == 1
1321                             && FIND_REG_INC_NOTE (temp6, NULL_RTX))))
1322 #endif
1323               )
1324             {
1325 #ifdef HAVE_conditional_move
1326               /* First try a conditional move.  */
1327               {
1328                 enum rtx_code code = GET_CODE (temp4);
1329                 rtx var = temp1;
1330                 rtx cond0, cond1, aval, bval;
1331                 rtx target, new_insn;
1332
1333                 /* Copy the compared variables into cond0 and cond1, so that
1334                    any side effects performed in or after the old comparison,
1335                    will not affect our compare which will come later.  */
1336                 /* ??? Is it possible to just use the comparison in the jump
1337                    insn?  After all, we're going to delete it.  We'd have
1338                    to modify emit_conditional_move to take a comparison rtx
1339                    instead or write a new function.  */
1340                 cond0 = gen_reg_rtx (GET_MODE (XEXP (temp4, 0)));
1341                 /* We want the target to be able to simplify comparisons with
1342                    zero (and maybe other constants as well), so don't create
1343                    pseudos for them.  There's no need to either.  */
1344                 if (GET_CODE (XEXP (temp4, 1)) == CONST_INT
1345                     || GET_CODE (XEXP (temp4, 1)) == CONST_DOUBLE)
1346                   cond1 = XEXP (temp4, 1);
1347                 else
1348                   cond1 = gen_reg_rtx (GET_MODE (XEXP (temp4, 1)));
1349
1350                 /* Careful about copying these values -- an IOR or what may
1351                    need to do other things, like clobber flags.  */
1352                 /* ??? Assume for the moment that AVAL is ok.  */
1353                 aval = temp3;
1354
1355                 start_sequence ();
1356
1357                 /* We're dealing with a single_set insn with no side effects
1358                    on SET_SRC.  We do need to be reasonably certain that if
1359                    we need to force BVAL into a register that we won't
1360                    clobber the flags -- general_operand should suffice.  */
1361                 if (general_operand (temp2, GET_MODE (var)))
1362                   bval = temp2;
1363                 else
1364                   {
1365                     bval = gen_reg_rtx (GET_MODE (var));
1366                     new_insn = copy_rtx (temp);
1367                     temp6 = single_set (new_insn);
1368                     SET_DEST (temp6) = bval;
1369                     emit_insn (PATTERN (new_insn));
1370                   }
1371
1372                 target = emit_conditional_move (var, code,
1373                                                 cond0, cond1, VOIDmode,
1374                                                 aval, bval, GET_MODE (var),
1375                                                 (code == LTU || code == GEU
1376                                                  || code == LEU || code == GTU));
1377
1378                 if (target)
1379                   {
1380                     rtx seq1, seq2, last;
1381                     int copy_ok;
1382
1383                     /* Save the conditional move sequence but don't emit it
1384                        yet.  On some machines, like the alpha, it is possible
1385                        that temp5 == insn, so next generate the sequence that
1386                        saves the compared values and then emit both
1387                        sequences ensuring seq1 occurs before seq2.  */
1388                     seq2 = get_insns ();
1389                     end_sequence ();
1390
1391                     /* "Now that we can't fail..."  Famous last words.
1392                        Generate the copy insns that preserve the compared
1393                        values.  */
1394                     start_sequence ();
1395                     emit_move_insn (cond0, XEXP (temp4, 0));
1396                     if (cond1 != XEXP (temp4, 1))
1397                       emit_move_insn (cond1, XEXP (temp4, 1));
1398                     seq1 = get_insns ();
1399                     end_sequence ();
1400
1401                     /* Validate the sequence -- this may be some weird
1402                        bit-extract-and-test instruction for which there
1403                        exists no complimentary bit-extract insn.  */
1404                     copy_ok = 1;
1405                     for (last = seq1; last ; last = NEXT_INSN (last))
1406                       if (recog_memoized (last) < 0)
1407                         {
1408                           copy_ok = 0;
1409                           break;
1410                         }
1411
1412                     if (copy_ok)
1413                       {
1414                         emit_insns_before (seq1, temp5);
1415
1416                         /* Insert conditional move after insn, to be sure
1417                            that the jump and a possible compare won't be
1418                            separated.  */
1419                         last = emit_insns_after (seq2, insn);
1420
1421                         /* ??? We can also delete the insn that sets X to A.
1422                            Flow will do it too though.  */
1423                         delete_insn (temp);
1424                         next = NEXT_INSN (insn);
1425                         delete_jump (insn);
1426
1427                         if (after_regscan)
1428                           {
1429                             reg_scan_update (seq1, NEXT_INSN (last),
1430                                              old_max_reg);
1431                             old_max_reg = max_reg_num ();
1432                           }
1433
1434                         changed = 1;
1435                         continue;
1436                       }
1437                   }
1438                 else
1439                   end_sequence ();
1440               }
1441 #endif
1442
1443               /* That didn't work, try a store-flag insn.
1444
1445                  We further divide the cases into:
1446
1447                  1) x = a; if (...) x = b; and either A or B is zero,
1448                  2) if (...) x = 0; and jumps are expensive,
1449                  3) x = a; if (...) x = b; and A and B are constants where all
1450                  the set bits in A are also set in B and jumps are expensive,
1451                  4) x = a; if (...) x = b; and A and B non-zero, and jumps are
1452                  more expensive, and
1453                  5) if (...) x = b; if jumps are even more expensive.  */
1454
1455               if (GET_MODE_CLASS (GET_MODE (temp1)) == MODE_INT
1456                   /* We will be passing this as operand into expand_and.  No
1457                      good if it's not valid as an operand.  */
1458                   && general_operand (temp2, GET_MODE (temp2))
1459                   && ((GET_CODE (temp3) == CONST_INT)
1460                       /* Make the latter case look like
1461                          x = x; if (...) x = 0;  */
1462                       || (temp3 = temp1,
1463                           ((BRANCH_COST >= 2
1464                             && temp2 == const0_rtx)
1465                            || BRANCH_COST >= 3)))
1466                   /* If B is zero, OK; if A is zero, can only do (1) if we
1467                      can reverse the condition.  See if (3) applies possibly
1468                      by reversing the condition.  Prefer reversing to (4) when
1469                      branches are very expensive.  */
1470                   && (((BRANCH_COST >= 2
1471                         || STORE_FLAG_VALUE == -1
1472                         || (STORE_FLAG_VALUE == 1
1473                          /* Check that the mask is a power of two,
1474                             so that it can probably be generated
1475                             with a shift.  */
1476                             && GET_CODE (temp3) == CONST_INT
1477                             && exact_log2 (INTVAL (temp3)) >= 0))
1478                        && (reversep = 0, temp2 == const0_rtx))
1479                       || ((BRANCH_COST >= 2
1480                            || STORE_FLAG_VALUE == -1
1481                            || (STORE_FLAG_VALUE == 1
1482                                && GET_CODE (temp2) == CONST_INT
1483                                && exact_log2 (INTVAL (temp2)) >= 0))
1484                           && temp3 == const0_rtx
1485                           && (reversep = can_reverse_comparison_p (temp4, insn)))
1486                       || (BRANCH_COST >= 2
1487                           && GET_CODE (temp2) == CONST_INT
1488                           && GET_CODE (temp3) == CONST_INT
1489                           && ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp2)
1490                               || ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp3)
1491                                   && (reversep = can_reverse_comparison_p (temp4,
1492                                                                            insn)))))
1493                       || BRANCH_COST >= 3)
1494                   )
1495                 {
1496                   enum rtx_code code = GET_CODE (temp4);
1497                   rtx uval, cval, var = temp1;
1498                   int normalizep;
1499                   rtx target;
1500
1501                   /* If necessary, reverse the condition.  */
1502                   if (reversep)
1503                     code = reverse_condition (code), uval = temp2, cval = temp3;
1504                   else
1505                     uval = temp3, cval = temp2;
1506
1507                   /* If CVAL is non-zero, normalize to -1.  Otherwise, if UVAL
1508                      is the constant 1, it is best to just compute the result
1509                      directly.  If UVAL is constant and STORE_FLAG_VALUE
1510                      includes all of its bits, it is best to compute the flag
1511                      value unnormalized and `and' it with UVAL.  Otherwise,
1512                      normalize to -1 and `and' with UVAL.  */
1513                   normalizep = (cval != const0_rtx ? -1
1514                                 : (uval == const1_rtx ? 1
1515                                    : (GET_CODE (uval) == CONST_INT
1516                                       && (INTVAL (uval) & ~STORE_FLAG_VALUE) == 0)
1517                                    ? 0 : -1));
1518
1519                   /* We will be putting the store-flag insn immediately in
1520                      front of the comparison that was originally being done,
1521                      so we know all the variables in TEMP4 will be valid.
1522                      However, this might be in front of the assignment of
1523                      A to VAR.  If it is, it would clobber the store-flag
1524                      we will be emitting.
1525
1526                      Therefore, emit into a temporary which will be copied to
1527                      VAR immediately after TEMP.  */
1528
1529                   start_sequence ();
1530                   target = emit_store_flag (gen_reg_rtx (GET_MODE (var)), code,
1531                                             XEXP (temp4, 0), XEXP (temp4, 1),
1532                                             VOIDmode,
1533                                             (code == LTU || code == LEU
1534                                              || code == GEU || code == GTU),
1535                                             normalizep);
1536                   if (target)
1537                     {
1538                       rtx seq;
1539                       rtx before = insn;
1540
1541                       seq = get_insns ();
1542                       end_sequence ();
1543
1544                       /* Put the store-flag insns in front of the first insn
1545                          used to compute the condition to ensure that we
1546                          use the same values of them as the current
1547                          comparison.  However, the remainder of the insns we
1548                          generate will be placed directly in front of the
1549                          jump insn, in case any of the pseudos we use
1550                          are modified earlier.  */
1551
1552                       emit_insns_before (seq, temp5);
1553
1554                       start_sequence ();
1555
1556                       /* Both CVAL and UVAL are non-zero.  */
1557                       if (cval != const0_rtx && uval != const0_rtx)
1558                         {
1559                           rtx tem1, tem2;
1560
1561                           tem1 = expand_and (uval, target, NULL_RTX);
1562                           if (GET_CODE (cval) == CONST_INT
1563                               && GET_CODE (uval) == CONST_INT
1564                               && (INTVAL (cval) & INTVAL (uval)) == INTVAL (cval))
1565                             tem2 = cval;
1566                           else
1567                             {
1568                               tem2 = expand_unop (GET_MODE (var), one_cmpl_optab,
1569                                                   target, NULL_RTX, 0);
1570                               tem2 = expand_and (cval, tem2,
1571                                                  (GET_CODE (tem2) == REG
1572                                                   ? tem2 : 0));
1573                             }
1574
1575                           /* If we usually make new pseudos, do so here.  This
1576                              turns out to help machines that have conditional
1577                              move insns.  */
1578                           /* ??? Conditional moves have already been handled.
1579                              This may be obsolete.  */
1580
1581                           if (flag_expensive_optimizations)
1582                             target = 0;
1583
1584                           target = expand_binop (GET_MODE (var), ior_optab,
1585                                                  tem1, tem2, target,
1586                                                  1, OPTAB_WIDEN);
1587                         }
1588                       else if (normalizep != 1)
1589                         {
1590                           /* We know that either CVAL or UVAL is zero.  If
1591                              UVAL is zero, negate TARGET and `and' with CVAL.
1592                              Otherwise, `and' with UVAL.  */
1593                           if (uval == const0_rtx)
1594                             {
1595                               target = expand_unop (GET_MODE (var), one_cmpl_optab,
1596                                                     target, NULL_RTX, 0);
1597                               uval = cval;
1598                             }
1599
1600                           target = expand_and (uval, target,
1601                                                (GET_CODE (target) == REG
1602                                                 && ! preserve_subexpressions_p ()
1603                                                 ? target : NULL_RTX));
1604                         }
1605
1606                       emit_move_insn (var, target);
1607                       seq = get_insns ();
1608                       end_sequence ();
1609 #ifdef HAVE_cc0
1610                       /* If INSN uses CC0, we must not separate it from the
1611                          insn that sets cc0.  */
1612                       if (reg_mentioned_p (cc0_rtx, PATTERN (before)))
1613                         before = prev_nonnote_insn (before);
1614 #endif
1615                       emit_insns_before (seq, before);
1616
1617                       delete_insn (temp);
1618                       next = NEXT_INSN (insn);
1619                       delete_jump (insn);
1620
1621                       if (after_regscan)
1622                         {
1623                           reg_scan_update (seq, NEXT_INSN (next), old_max_reg);
1624                           old_max_reg = max_reg_num ();
1625                         }
1626
1627                       changed = 1;
1628                       continue;
1629                     }
1630                   else
1631                     end_sequence ();
1632                 }
1633             }
1634
1635
1636           /* Simplify   if (...) x = 1; else {...}  if (x) ...
1637              We recognize this case scanning backwards as well.
1638
1639              TEMP is the assignment to x;
1640              TEMP1 is the label at the head of the second if.  */
1641           /* ?? This should call get_condition to find the values being
1642              compared, instead of looking for a COMPARE insn when HAVE_cc0
1643              is not defined.  This would allow it to work on the m88k.  */
1644           /* ?? This optimization is only safe before cse is run if HAVE_cc0
1645              is not defined and the condition is tested by a separate compare
1646              insn.  This is because the code below assumes that the result
1647              of the compare dies in the following branch.
1648
1649              Not only that, but there might be other insns between the
1650              compare and branch whose results are live.  Those insns need
1651              to be executed.
1652
1653              A way to fix this is to move the insns at JUMP_LABEL (insn)
1654              to before INSN.  If we are running before flow, they will
1655              be deleted if they aren't needed.   But this doesn't work
1656              well after flow.
1657
1658              This is really a special-case of jump threading, anyway.  The
1659              right thing to do is to replace this and jump threading with
1660              much simpler code in cse.
1661
1662              This code has been turned off in the non-cc0 case in the
1663              meantime.  */
1664
1665 #ifdef HAVE_cc0
1666           else if (this_is_simplejump
1667                    /* Safe to skip USE and CLOBBER insns here
1668                       since they will not be deleted.  */
1669                    && (temp = prev_active_insn (insn))
1670                    && no_labels_between_p (temp, insn)
1671                    && GET_CODE (temp) == INSN
1672                    && GET_CODE (PATTERN (temp)) == SET
1673                    && GET_CODE (SET_DEST (PATTERN (temp))) == REG
1674                    && CONSTANT_P (SET_SRC (PATTERN (temp)))
1675                    && (temp1 = next_active_insn (JUMP_LABEL (insn)))
1676                    /* If we find that the next value tested is `x'
1677                       (TEMP1 is the insn where this happens), win.  */
1678                    && GET_CODE (temp1) == INSN
1679                    && GET_CODE (PATTERN (temp1)) == SET
1680 #ifdef HAVE_cc0
1681                    /* Does temp1 `tst' the value of x?  */
1682                    && SET_SRC (PATTERN (temp1)) == SET_DEST (PATTERN (temp))
1683                    && SET_DEST (PATTERN (temp1)) == cc0_rtx
1684                    && (temp1 = next_nonnote_insn (temp1))
1685 #else
1686                    /* Does temp1 compare the value of x against zero?  */
1687                    && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
1688                    && XEXP (SET_SRC (PATTERN (temp1)), 1) == const0_rtx
1689                    && (XEXP (SET_SRC (PATTERN (temp1)), 0)
1690                        == SET_DEST (PATTERN (temp)))
1691                    && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
1692                    && (temp1 = find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
1693 #endif
1694                    && condjump_p (temp1))
1695             {
1696               /* Get the if_then_else from the condjump.  */
1697               rtx choice = SET_SRC (PATTERN (temp1));
1698               if (GET_CODE (choice) == IF_THEN_ELSE)
1699                 {
1700                   enum rtx_code code = GET_CODE (XEXP (choice, 0));
1701                   rtx val = SET_SRC (PATTERN (temp));
1702                   rtx cond
1703                     = simplify_relational_operation (code, GET_MODE (SET_DEST (PATTERN (temp))),
1704                                                      val, const0_rtx);
1705                   rtx ultimate;
1706
1707                   if (cond == const_true_rtx)
1708                     ultimate = XEXP (choice, 1);
1709                   else if (cond == const0_rtx)
1710                     ultimate = XEXP (choice, 2);
1711                   else
1712                     ultimate = 0;
1713
1714                   if (ultimate == pc_rtx)
1715                     ultimate = get_label_after (temp1);
1716                   else if (ultimate && GET_CODE (ultimate) != RETURN)
1717                     ultimate = XEXP (ultimate, 0);
1718
1719                   if (ultimate && JUMP_LABEL(insn) != ultimate)
1720                     changed |= redirect_jump (insn, ultimate);
1721                 }
1722             }
1723 #endif
1724
1725 #if 0
1726           /* @@ This needs a bit of work before it will be right.
1727
1728              Any type of comparison can be accepted for the first and
1729              second compare.  When rewriting the first jump, we must
1730              compute the what conditions can reach label3, and use the
1731              appropriate code.  We can not simply reverse/swap the code
1732              of the first jump.  In some cases, the second jump must be
1733              rewritten also.
1734
1735              For example,
1736              <  == converts to >  ==
1737              <  != converts to ==  >
1738              etc.
1739
1740              If the code is written to only accept an '==' test for the second
1741              compare, then all that needs to be done is to swap the condition
1742              of the first branch.
1743
1744              It is questionable whether we want this optimization anyways,
1745              since if the user wrote code like this because he/she knew that
1746              the jump to label1 is taken most of the time, then rewriting
1747              this gives slower code.  */
1748           /* @@ This should call get_condition to find the values being
1749              compared, instead of looking for a COMPARE insn when HAVE_cc0
1750              is not defined.  This would allow it to work on the m88k.  */
1751           /* @@ This optimization is only safe before cse is run if HAVE_cc0
1752              is not defined and the condition is tested by a separate compare
1753              insn.  This is because the code below assumes that the result
1754              of the compare dies in the following branch.  */
1755
1756           /* Simplify  test a ~= b
1757                        condjump label1;
1758                        test a == b
1759                        condjump label2;
1760                        jump label3;
1761                        label1:
1762
1763              rewriting as
1764                        test a ~~= b
1765                        condjump label3
1766                        test a == b
1767                        condjump label2
1768                        label1:
1769
1770              where ~= is an inequality, e.g. >, and ~~= is the swapped
1771              inequality, e.g. <.
1772
1773              We recognize this case scanning backwards.
1774
1775              TEMP is the conditional jump to `label2';
1776              TEMP1 is the test for `a == b';
1777              TEMP2 is the conditional jump to `label1';
1778              TEMP3 is the test for `a ~= b'.  */
1779           else if (this_is_simplejump
1780                    && (temp = prev_active_insn (insn))
1781                    && no_labels_between_p (temp, insn)
1782                    && condjump_p (temp)
1783                    && (temp1 = prev_active_insn (temp))
1784                    && no_labels_between_p (temp1, temp)
1785                    && GET_CODE (temp1) == INSN
1786                    && GET_CODE (PATTERN (temp1)) == SET
1787 #ifdef HAVE_cc0
1788                    && sets_cc0_p (PATTERN (temp1)) == 1
1789 #else
1790                    && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
1791                    && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
1792                    && (temp == find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
1793 #endif
1794                    && (temp2 = prev_active_insn (temp1))
1795                    && no_labels_between_p (temp2, temp1)
1796                    && condjump_p (temp2)
1797                    && JUMP_LABEL (temp2) == next_nonnote_insn (NEXT_INSN (insn))
1798                    && (temp3 = prev_active_insn (temp2))
1799                    && no_labels_between_p (temp3, temp2)
1800                    && GET_CODE (PATTERN (temp3)) == SET
1801                    && rtx_equal_p (SET_DEST (PATTERN (temp3)),
1802                                    SET_DEST (PATTERN (temp1)))
1803                    && rtx_equal_p (SET_SRC (PATTERN (temp1)),
1804                                    SET_SRC (PATTERN (temp3)))
1805                    && ! inequality_comparisons_p (PATTERN (temp))
1806                    && inequality_comparisons_p (PATTERN (temp2)))
1807             {
1808               rtx fallthrough_label = JUMP_LABEL (temp2);
1809
1810               ++LABEL_NUSES (fallthrough_label);
1811               if (swap_jump (temp2, JUMP_LABEL (insn)))
1812                 {
1813                   delete_insn (insn);
1814                   changed = 1;
1815                 }
1816
1817               if (--LABEL_NUSES (fallthrough_label) == 0)
1818                 delete_insn (fallthrough_label);
1819             }
1820 #endif
1821           /* Simplify  if (...) {... x = 1;} if (x) ...
1822
1823              We recognize this case backwards.
1824
1825              TEMP is the test of `x';
1826              TEMP1 is the assignment to `x' at the end of the
1827              previous statement.  */
1828           /* @@ This should call get_condition to find the values being
1829              compared, instead of looking for a COMPARE insn when HAVE_cc0
1830              is not defined.  This would allow it to work on the m88k.  */
1831           /* @@ This optimization is only safe before cse is run if HAVE_cc0
1832              is not defined and the condition is tested by a separate compare
1833              insn.  This is because the code below assumes that the result
1834              of the compare dies in the following branch.  */
1835
1836           /* ??? This has to be turned off.  The problem is that the
1837              unconditional jump might indirectly end up branching to the
1838              label between TEMP1 and TEMP.  We can't detect this, in general,
1839              since it may become a jump to there after further optimizations.
1840              If that jump is done, it will be deleted, so we will retry
1841              this optimization in the next pass, thus an infinite loop.
1842
1843              The present code prevents this by putting the jump after the
1844              label, but this is not logically correct.  */
1845 #if 0
1846           else if (this_is_condjump
1847                    /* Safe to skip USE and CLOBBER insns here
1848                       since they will not be deleted.  */
1849                    && (temp = prev_active_insn (insn))
1850                    && no_labels_between_p (temp, insn)
1851                    && GET_CODE (temp) == INSN
1852                    && GET_CODE (PATTERN (temp)) == SET
1853 #ifdef HAVE_cc0
1854                    && sets_cc0_p (PATTERN (temp)) == 1
1855                    && GET_CODE (SET_SRC (PATTERN (temp))) == REG
1856 #else
1857                    /* Temp must be a compare insn, we can not accept a register
1858                       to register move here, since it may not be simply a
1859                       tst insn.  */
1860                    && GET_CODE (SET_SRC (PATTERN (temp))) == COMPARE
1861                    && XEXP (SET_SRC (PATTERN (temp)), 1) == const0_rtx
1862                    && GET_CODE (XEXP (SET_SRC (PATTERN (temp)), 0)) == REG
1863                    && GET_CODE (SET_DEST (PATTERN (temp))) == REG
1864                    && insn == find_next_ref (SET_DEST (PATTERN (temp)), temp)
1865 #endif
1866                    /* May skip USE or CLOBBER insns here
1867                       for checking for opportunity, since we
1868                       take care of them later.  */
1869                    && (temp1 = prev_active_insn (temp))
1870                    && GET_CODE (temp1) == INSN
1871                    && GET_CODE (PATTERN (temp1)) == SET
1872 #ifdef HAVE_cc0
1873                    && SET_SRC (PATTERN (temp)) == SET_DEST (PATTERN (temp1))
1874 #else
1875                    && (XEXP (SET_SRC (PATTERN (temp)), 0)
1876                        == SET_DEST (PATTERN (temp1)))
1877 #endif
1878                    && CONSTANT_P (SET_SRC (PATTERN (temp1)))
1879                    /* If this isn't true, cse will do the job.  */
1880                    && ! no_labels_between_p (temp1, temp))
1881             {
1882               /* Get the if_then_else from the condjump.  */
1883               rtx choice = SET_SRC (PATTERN (insn));
1884               if (GET_CODE (choice) == IF_THEN_ELSE
1885                   && (GET_CODE (XEXP (choice, 0)) == EQ
1886                       || GET_CODE (XEXP (choice, 0)) == NE))
1887                 {
1888                   int want_nonzero = (GET_CODE (XEXP (choice, 0)) == NE);
1889                   rtx last_insn;
1890                   rtx ultimate;
1891                   rtx p;
1892
1893                   /* Get the place that condjump will jump to
1894                      if it is reached from here.  */
1895                   if ((SET_SRC (PATTERN (temp1)) != const0_rtx)
1896                       == want_nonzero)
1897                     ultimate = XEXP (choice, 1);
1898                   else
1899                     ultimate = XEXP (choice, 2);
1900                   /* Get it as a CODE_LABEL.  */
1901                   if (ultimate == pc_rtx)
1902                     ultimate = get_label_after (insn);
1903                   else
1904                     /* Get the label out of the LABEL_REF.  */
1905                     ultimate = XEXP (ultimate, 0);
1906
1907                   /* Insert the jump immediately before TEMP, specifically
1908                      after the label that is between TEMP1 and TEMP.  */
1909                   last_insn = PREV_INSN (temp);
1910
1911                   /* If we would be branching to the next insn, the jump
1912                      would immediately be deleted and the re-inserted in
1913                      a subsequent pass over the code.  So don't do anything
1914                      in that case.  */
1915                   if (next_active_insn (last_insn)
1916                       != next_active_insn (ultimate))
1917                     {
1918                       emit_barrier_after (last_insn);
1919                       p = emit_jump_insn_after (gen_jump (ultimate),
1920                                                 last_insn);
1921                       JUMP_LABEL (p) = ultimate;
1922                       ++LABEL_NUSES (ultimate);
1923                       if (INSN_UID (ultimate) < max_jump_chain
1924                           && INSN_CODE (p) < max_jump_chain)
1925                         {
1926                           jump_chain[INSN_UID (p)]
1927                             = jump_chain[INSN_UID (ultimate)];
1928                           jump_chain[INSN_UID (ultimate)] = p;
1929                         }
1930                       changed = 1;
1931                       continue;
1932                     }
1933                 }
1934             }
1935 #endif
1936 #ifdef HAVE_trap
1937           /* Detect a conditional jump jumping over an unconditional trap.  */
1938           else if (HAVE_trap
1939                    && this_is_condjump && ! this_is_simplejump
1940                    && reallabelprev != 0
1941                    && GET_CODE (reallabelprev) == INSN
1942                    && GET_CODE (PATTERN (reallabelprev)) == TRAP_IF
1943                    && TRAP_CONDITION (PATTERN (reallabelprev)) == const_true_rtx
1944                    && prev_active_insn (reallabelprev) == insn
1945                    && no_labels_between_p (insn, reallabelprev)
1946                    && (temp2 = get_condition (insn, &temp4))
1947                    && can_reverse_comparison_p (temp2, insn))
1948             {
1949               rtx new = gen_cond_trap (reverse_condition (GET_CODE (temp2)),
1950                                        XEXP (temp2, 0), XEXP (temp2, 1),
1951                                        TRAP_CODE (PATTERN (reallabelprev)));
1952
1953               if (new)
1954                 {
1955                   emit_insn_before (new, temp4);
1956                   delete_insn (reallabelprev);
1957                   delete_jump (insn);
1958                   changed = 1;
1959                   continue;
1960                 }
1961             }
1962           /* Detect a jump jumping to an unconditional trap.  */
1963           else if (HAVE_trap && this_is_condjump
1964                    && (temp = next_active_insn (JUMP_LABEL (insn)))
1965                    && GET_CODE (temp) == INSN
1966                    && GET_CODE (PATTERN (temp)) == TRAP_IF
1967                    && (this_is_simplejump
1968                        || (temp2 = get_condition (insn, &temp4))))
1969             {
1970               rtx tc = TRAP_CONDITION (PATTERN (temp));
1971
1972               if (tc == const_true_rtx
1973                   || (! this_is_simplejump && rtx_equal_p (temp2, tc)))
1974                 {
1975                   rtx new;
1976                   /* Replace an unconditional jump to a trap with a trap.  */
1977                   if (this_is_simplejump)
1978                     {
1979                       emit_barrier_after (emit_insn_before (gen_trap (), insn));
1980                       delete_jump (insn);
1981                       changed = 1;
1982                       continue;
1983                     }
1984                   new = gen_cond_trap (GET_CODE (temp2), XEXP (temp2, 0),
1985                                        XEXP (temp2, 1),
1986                                        TRAP_CODE (PATTERN (temp)));
1987                   if (new)
1988                     {
1989                       emit_insn_before (new, temp4);
1990                       delete_jump (insn);
1991                       changed = 1;
1992                       continue;
1993                     }
1994                 }
1995               /* If the trap condition and jump condition are mutually
1996                  exclusive, redirect the jump to the following insn.  */
1997               else if (GET_RTX_CLASS (GET_CODE (tc)) == '<'
1998                        && ! this_is_simplejump
1999                        && swap_condition (GET_CODE (temp2)) == GET_CODE (tc)
2000                        && rtx_equal_p (XEXP (tc, 0), XEXP (temp2, 0))
2001                        && rtx_equal_p (XEXP (tc, 1), XEXP (temp2, 1))
2002                        && redirect_jump (insn, get_label_after (temp)))
2003                 {
2004                   changed = 1;
2005                   continue;
2006                 }
2007             }
2008 #endif
2009           else
2010             {
2011               /* Detect a jump to a jump.  */
2012
2013               /* Look for   if (foo) bar; else break;  */
2014               /* The insns look like this:
2015                  insn = condjump label1;
2016                  ...range1 (some insns)...
2017                  jump label2;
2018                  label1:
2019                  ...range2 (some insns)...
2020                  jump somewhere unconditionally
2021                  label2:  */
2022               {
2023                 rtx label1 = next_label (insn);
2024                 rtx range1end = label1 ? prev_active_insn (label1) : 0;
2025                 /* Don't do this optimization on the first round, so that
2026                    jump-around-a-jump gets simplified before we ask here
2027                    whether a jump is unconditional.
2028
2029                    Also don't do it when we are called after reload since
2030                    it will confuse reorg.  */
2031                 if (! first
2032                     && (reload_completed ? ! flag_delayed_branch : 1)
2033                     /* Make sure INSN is something we can invert.  */
2034                     && condjump_p (insn)
2035                     && label1 != 0
2036                     && JUMP_LABEL (insn) == label1
2037                     && LABEL_NUSES (label1) == 1
2038                     && GET_CODE (range1end) == JUMP_INSN
2039                     && simplejump_p (range1end))
2040                   {
2041                     rtx label2 = next_label (label1);
2042                     rtx range2end = label2 ? prev_active_insn (label2) : 0;
2043                     if (range1end != range2end
2044                         && JUMP_LABEL (range1end) == label2
2045                         && GET_CODE (range2end) == JUMP_INSN
2046                         && GET_CODE (NEXT_INSN (range2end)) == BARRIER
2047                         /* Invert the jump condition, so we
2048                            still execute the same insns in each case.  */
2049                         && invert_jump (insn, label1))
2050                       {
2051                         rtx range1beg = next_active_insn (insn);
2052                         rtx range2beg = next_active_insn (label1);
2053                         rtx range1after, range2after;
2054                         rtx range1before, range2before;
2055                         rtx rangenext;
2056
2057                         /* Include in each range any notes before it, to be
2058                            sure that we get the line number note if any, even
2059                            if there are other notes here.  */
2060                         while (PREV_INSN (range1beg)
2061                                && GET_CODE (PREV_INSN (range1beg)) == NOTE)
2062                           range1beg = PREV_INSN (range1beg);
2063
2064                         while (PREV_INSN (range2beg)
2065                                && GET_CODE (PREV_INSN (range2beg)) == NOTE)
2066                           range2beg = PREV_INSN (range2beg);
2067
2068                         /* Don't move NOTEs for blocks or loops; shift them
2069                            outside the ranges, where they'll stay put.  */
2070                         range1beg = squeeze_notes (range1beg, range1end);
2071                         range2beg = squeeze_notes (range2beg, range2end);
2072
2073                         /* Get current surrounds of the 2 ranges.  */
2074                         range1before = PREV_INSN (range1beg);
2075                         range2before = PREV_INSN (range2beg);
2076                         range1after = NEXT_INSN (range1end);
2077                         range2after = NEXT_INSN (range2end);
2078
2079                         /* Splice range2 where range1 was.  */
2080                         NEXT_INSN (range1before) = range2beg;
2081                         PREV_INSN (range2beg) = range1before;
2082                         NEXT_INSN (range2end) = range1after;
2083                         PREV_INSN (range1after) = range2end;
2084                         /* Splice range1 where range2 was.  */
2085                         NEXT_INSN (range2before) = range1beg;
2086                         PREV_INSN (range1beg) = range2before;
2087                         NEXT_INSN (range1end) = range2after;
2088                         PREV_INSN (range2after) = range1end;
2089
2090                         /* Check for loop notes between the end of
2091                            range2, and the next code label.  If there is one,
2092                            then what we have really seen is
2093                            if (foo) break; end_of_loop;
2094                            and moved the break sequence outside the loop.
2095                            We must move LOOP_END, LOOP_VTOP and LOOP_CONT
2096                            notes (in order) to where the loop really ends now,
2097                            or we will confuse loop optimization.  Stop if we
2098                            find a LOOP_BEG note first, since we don't want to
2099                            move the notes in that case.  */
2100                         for (;range2after != label2; range2after = rangenext)
2101                           {
2102                             rangenext = NEXT_INSN (range2after);
2103                             if (GET_CODE (range2after) == NOTE)
2104                               {
2105                                 int kind = NOTE_LINE_NUMBER (range2after);
2106                                 if (kind == NOTE_INSN_LOOP_END
2107                                     || kind == NOTE_INSN_LOOP_VTOP
2108                                     || kind == NOTE_INSN_LOOP_CONT)
2109                                   {
2110                                     NEXT_INSN (PREV_INSN (range2after))
2111                                       = rangenext;
2112                                     PREV_INSN (rangenext)
2113                                       = PREV_INSN (range2after);
2114                                     PREV_INSN (range2after)
2115                                       = PREV_INSN (range1beg);
2116                                     NEXT_INSN (range2after) = range1beg;
2117                                     NEXT_INSN (PREV_INSN (range1beg))
2118                                       = range2after;
2119                                     PREV_INSN (range1beg) = range2after;
2120                                   }
2121                                 else if (NOTE_LINE_NUMBER (range2after)
2122                                          == NOTE_INSN_LOOP_BEG)
2123                                   break;
2124                               }
2125                           }
2126                         changed = 1;
2127                         continue;
2128                       }
2129                   }
2130               }
2131
2132               /* Now that the jump has been tensioned,
2133                  try cross jumping: check for identical code
2134                  before the jump and before its target label.  */
2135
2136               /* First, cross jumping of conditional jumps:  */
2137
2138               if (cross_jump && condjump_p (insn))
2139                 {
2140                   rtx newjpos, newlpos;
2141                   rtx x = prev_real_insn (JUMP_LABEL (insn));
2142
2143                   /* A conditional jump may be crossjumped
2144                      only if the place it jumps to follows
2145                      an opposing jump that comes back here.  */
2146
2147                   if (x != 0 && ! jump_back_p (x, insn))
2148                     /* We have no opposing jump;
2149                        cannot cross jump this insn.  */
2150                     x = 0;
2151
2152                   newjpos = 0;
2153                   /* TARGET is nonzero if it is ok to cross jump
2154                      to code before TARGET.  If so, see if matches.  */
2155                   if (x != 0)
2156                     find_cross_jump (insn, x, 2,
2157                                      &newjpos, &newlpos);
2158
2159                   if (newjpos != 0)
2160                     {
2161                       do_cross_jump (insn, newjpos, newlpos);
2162                       /* Make the old conditional jump
2163                          into an unconditional one.  */
2164                       SET_SRC (PATTERN (insn))
2165                         = gen_rtx_LABEL_REF (VOIDmode, JUMP_LABEL (insn));
2166                       INSN_CODE (insn) = -1;
2167                       emit_barrier_after (insn);
2168                       /* Add to jump_chain unless this is a new label
2169                          whose UID is too large.  */
2170                       if (INSN_UID (JUMP_LABEL (insn)) < max_jump_chain)
2171                         {
2172                           jump_chain[INSN_UID (insn)]
2173                             = jump_chain[INSN_UID (JUMP_LABEL (insn))];
2174                           jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
2175                         }
2176                       changed = 1;
2177                       next = insn;
2178                     }
2179                 }
2180
2181               /* Cross jumping of unconditional jumps:
2182                  a few differences.  */
2183
2184               if (cross_jump && simplejump_p (insn))
2185                 {
2186                   rtx newjpos, newlpos;
2187                   rtx target;
2188
2189                   newjpos = 0;
2190
2191                   /* TARGET is nonzero if it is ok to cross jump
2192                      to code before TARGET.  If so, see if matches.  */
2193                   find_cross_jump (insn, JUMP_LABEL (insn), 1,
2194                                    &newjpos, &newlpos);
2195
2196                   /* If cannot cross jump to code before the label,
2197                      see if we can cross jump to another jump to
2198                      the same label.  */
2199                   /* Try each other jump to this label.  */
2200                   if (INSN_UID (JUMP_LABEL (insn)) < max_uid)
2201                     for (target = jump_chain[INSN_UID (JUMP_LABEL (insn))];
2202                          target != 0 && newjpos == 0;
2203                          target = jump_chain[INSN_UID (target)])
2204                       if (target != insn
2205                           && JUMP_LABEL (target) == JUMP_LABEL (insn)
2206                           /* Ignore TARGET if it's deleted.  */
2207                           && ! INSN_DELETED_P (target))
2208                         find_cross_jump (insn, target, 2,
2209                                          &newjpos, &newlpos);
2210
2211                   if (newjpos != 0)
2212                     {
2213                       do_cross_jump (insn, newjpos, newlpos);
2214                       changed = 1;
2215                       next = insn;
2216                     }
2217                 }
2218
2219               /* This code was dead in the previous jump.c!  */
2220               if (cross_jump && GET_CODE (PATTERN (insn)) == RETURN)
2221                 {
2222                   /* Return insns all "jump to the same place"
2223                      so we can cross-jump between any two of them.  */
2224
2225                   rtx newjpos, newlpos, target;
2226
2227                   newjpos = 0;
2228
2229                   /* If cannot cross jump to code before the label,
2230                      see if we can cross jump to another jump to
2231                      the same label.  */
2232                   /* Try each other jump to this label.  */
2233                   for (target = jump_chain[0];
2234                        target != 0 && newjpos == 0;
2235                        target = jump_chain[INSN_UID (target)])
2236                     if (target != insn
2237                         && ! INSN_DELETED_P (target)
2238                         && GET_CODE (PATTERN (target)) == RETURN)
2239                       find_cross_jump (insn, target, 2,
2240                                        &newjpos, &newlpos);
2241
2242                   if (newjpos != 0)
2243                     {
2244                       do_cross_jump (insn, newjpos, newlpos);
2245                       changed = 1;
2246                       next = insn;
2247                     }
2248                 }
2249             }
2250         }
2251
2252       first = 0;
2253     }
2254
2255   /* Delete extraneous line number notes.
2256      Note that two consecutive notes for different lines are not really
2257      extraneous.  There should be some indication where that line belonged,
2258      even if it became empty.  */
2259
2260   {
2261     rtx last_note = 0;
2262
2263     for (insn = f; insn; insn = NEXT_INSN (insn))
2264       if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) >= 0)
2265         {
2266           /* Delete this note if it is identical to previous note.  */
2267           if (last_note
2268               && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
2269               && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
2270             {
2271               delete_insn (insn);
2272               continue;
2273             }
2274
2275           last_note = insn;
2276         }
2277   }
2278
2279 #ifdef HAVE_return
2280   if (HAVE_return)
2281     {
2282       /* If we fall through to the epilogue, see if we can insert a RETURN insn
2283          in front of it.  If the machine allows it at this point (we might be
2284          after reload for a leaf routine), it will improve optimization for it
2285          to be there.  We do this both here and at the start of this pass since
2286          the RETURN might have been deleted by some of our optimizations.  */
2287       insn = get_last_insn ();
2288       while (insn && GET_CODE (insn) == NOTE)
2289         insn = PREV_INSN (insn);
2290
2291       if (insn && GET_CODE (insn) != BARRIER)
2292         {
2293           emit_jump_insn (gen_return ());
2294           emit_barrier ();
2295         }
2296     }
2297 #endif
2298
2299   /* CAN_REACH_END is persistent for each function.  Once set it should
2300      not be cleared.  This is especially true for the case where we
2301      delete the NOTE_FUNCTION_END note.  CAN_REACH_END is cleared by
2302      the front-end before compiling each function.  */
2303   if (calculate_can_reach_end (last_insn, 0, 1))
2304     can_reach_end = 1;
2305
2306 end:
2307   /* Clean up.  */
2308   free (jump_chain);
2309   jump_chain = 0;
2310 }
2311 \f
2312 /* Initialize LABEL_NUSES and JUMP_LABEL fields.  Delete any REG_LABEL
2313    notes whose labels don't occur in the insn any more.  Returns the
2314    largest INSN_UID found.  */
2315 static int
2316 init_label_info (f)
2317      rtx f;
2318 {
2319   int largest_uid = 0;
2320   rtx insn;
2321
2322   for (insn = f; insn; insn = NEXT_INSN (insn))
2323     {
2324       if (GET_CODE (insn) == CODE_LABEL)
2325         LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
2326       else if (GET_CODE (insn) == JUMP_INSN)
2327         JUMP_LABEL (insn) = 0;
2328       else if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
2329         {
2330           rtx note, next;
2331
2332           for (note = REG_NOTES (insn); note; note = next)
2333             {
2334               next = XEXP (note, 1);
2335               if (REG_NOTE_KIND (note) == REG_LABEL
2336                   && ! reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
2337                 remove_note (insn, note);
2338             }
2339         }
2340       if (INSN_UID (insn) > largest_uid)
2341         largest_uid = INSN_UID (insn);
2342     }
2343
2344   return largest_uid;
2345 }
2346
2347 /* Delete insns following barriers, up to next label.
2348
2349    Also delete no-op jumps created by gcse.  */
2350 static void
2351 delete_barrier_successors (f)
2352      rtx f;
2353 {
2354   rtx insn;
2355
2356   for (insn = f; insn;)
2357     {
2358       if (GET_CODE (insn) == BARRIER)
2359         {
2360           insn = NEXT_INSN (insn);
2361
2362           never_reached_warning (insn);
2363
2364           while (insn != 0 && GET_CODE (insn) != CODE_LABEL)
2365             {
2366               if (GET_CODE (insn) == NOTE
2367                   && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
2368                 insn = NEXT_INSN (insn);
2369               else
2370                 insn = delete_insn (insn);
2371             }
2372           /* INSN is now the code_label.  */
2373         }
2374       /* Also remove (set (pc) (pc)) insns which can be created by
2375          gcse.  We eliminate such insns now to avoid having them
2376          cause problems later.  */
2377       else if (GET_CODE (insn) == JUMP_INSN
2378                && GET_CODE (PATTERN (insn)) == SET
2379                && SET_SRC (PATTERN (insn)) == pc_rtx
2380                && SET_DEST (PATTERN (insn)) == pc_rtx)
2381         insn = delete_insn (insn);
2382
2383       else
2384         insn = NEXT_INSN (insn);
2385     }
2386 }
2387
2388 /* Mark the label each jump jumps to.
2389    Combine consecutive labels, and count uses of labels.
2390
2391    For each label, make a chain (using `jump_chain')
2392    of all the *unconditional* jumps that jump to it;
2393    also make a chain of all returns.
2394
2395    CROSS_JUMP indicates whether we are doing cross jumping
2396    and if we are whether we will be paying attention to
2397    death notes or not.  */
2398
2399 static void
2400 mark_all_labels (f, cross_jump)
2401      rtx f;
2402      int cross_jump;
2403 {
2404   rtx insn;
2405
2406   for (insn = f; insn; insn = NEXT_INSN (insn))
2407     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
2408       {
2409         mark_jump_label (PATTERN (insn), insn, cross_jump);
2410         if (! INSN_DELETED_P (insn) && GET_CODE (insn) == JUMP_INSN)
2411           {
2412             if (JUMP_LABEL (insn) != 0 && simplejump_p (insn))
2413               {
2414                 jump_chain[INSN_UID (insn)]
2415                   = jump_chain[INSN_UID (JUMP_LABEL (insn))];
2416                 jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
2417               }
2418             if (GET_CODE (PATTERN (insn)) == RETURN)
2419               {
2420                 jump_chain[INSN_UID (insn)] = jump_chain[0];
2421                 jump_chain[0] = insn;
2422               }
2423           }
2424       }
2425 }
2426
2427 /* Delete all labels already not referenced.
2428    Also find and return the last insn.  */
2429
2430 static rtx
2431 delete_unreferenced_labels (f)
2432      rtx f;
2433 {
2434   rtx final = NULL_RTX;
2435   rtx insn;
2436
2437   for (insn = f; insn; )
2438     {
2439       if (GET_CODE (insn) == CODE_LABEL
2440           && LABEL_NUSES (insn) == 0
2441           && LABEL_ALTERNATE_NAME (insn) == NULL)
2442         insn = delete_insn (insn);
2443       else
2444         {
2445           final = insn;
2446           insn = NEXT_INSN (insn);
2447         }
2448     }
2449
2450   return final;
2451 }
2452
2453 /* Delete various simple forms of moves which have no necessary
2454    side effect.  */
2455
2456 static void
2457 delete_noop_moves (f)
2458      rtx f;
2459 {
2460   rtx insn, next;
2461
2462   for (insn = f; insn; )
2463     {
2464       next = NEXT_INSN (insn);
2465
2466       if (GET_CODE (insn) == INSN)
2467         {
2468           register rtx body = PATTERN (insn);
2469
2470 /* Combine stack_adjusts with following push_insns.  */
2471 #ifdef PUSH_ROUNDING
2472           if (GET_CODE (body) == SET
2473               && SET_DEST (body) == stack_pointer_rtx
2474               && GET_CODE (SET_SRC (body)) == PLUS
2475               && XEXP (SET_SRC (body), 0) == stack_pointer_rtx
2476               && GET_CODE (XEXP (SET_SRC (body), 1)) == CONST_INT
2477               && INTVAL (XEXP (SET_SRC (body), 1)) > 0)
2478             {
2479               rtx p;
2480               rtx stack_adjust_insn = insn;
2481               int stack_adjust_amount = INTVAL (XEXP (SET_SRC (body), 1));
2482               int total_pushed = 0;
2483               int pushes = 0;
2484
2485               /* Find all successive push insns.  */
2486               p = insn;
2487               /* Don't convert more than three pushes;
2488                  that starts adding too many displaced addresses
2489                  and the whole thing starts becoming a losing
2490                  proposition.  */
2491               while (pushes < 3)
2492                 {
2493                   rtx pbody, dest;
2494                   p = next_nonnote_insn (p);
2495                   if (p == 0 || GET_CODE (p) != INSN)
2496                     break;
2497                   pbody = PATTERN (p);
2498                   if (GET_CODE (pbody) != SET)
2499                     break;
2500                   dest = SET_DEST (pbody);
2501                   /* Allow a no-op move between the adjust and the push.  */
2502                   if (GET_CODE (dest) == REG
2503                       && GET_CODE (SET_SRC (pbody)) == REG
2504                       && REGNO (dest) == REGNO (SET_SRC (pbody)))
2505                     continue;
2506                   if (! (GET_CODE (dest) == MEM
2507                          && GET_CODE (XEXP (dest, 0)) == POST_INC
2508                          && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
2509                     break;
2510                   pushes++;
2511                   if (total_pushed + GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)))
2512                       > stack_adjust_amount)
2513                     break;
2514                   total_pushed += GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)));
2515                 }
2516
2517               /* Discard the amount pushed from the stack adjust;
2518                  maybe eliminate it entirely.  */
2519               if (total_pushed >= stack_adjust_amount)
2520                 {
2521                   delete_computation (stack_adjust_insn);
2522                   total_pushed = stack_adjust_amount;
2523                 }
2524               else
2525                 XEXP (SET_SRC (PATTERN (stack_adjust_insn)), 1)
2526                   = GEN_INT (stack_adjust_amount - total_pushed);
2527
2528               /* Change the appropriate push insns to ordinary stores.  */
2529               p = insn;
2530               while (total_pushed > 0)
2531                 {
2532                   rtx pbody, dest;
2533                   p = next_nonnote_insn (p);
2534                   if (GET_CODE (p) != INSN)
2535                     break;
2536                   pbody = PATTERN (p);
2537                   if (GET_CODE (pbody) != SET)
2538                     break;
2539                   dest = SET_DEST (pbody);
2540                   /* Allow a no-op move between the adjust and the push.  */
2541                   if (GET_CODE (dest) == REG
2542                       && GET_CODE (SET_SRC (pbody)) == REG
2543                       && REGNO (dest) == REGNO (SET_SRC (pbody)))
2544                     continue;
2545                   if (! (GET_CODE (dest) == MEM
2546                          && GET_CODE (XEXP (dest, 0)) == POST_INC
2547                          && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
2548                     break;
2549                   total_pushed -= GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)));
2550                   /* If this push doesn't fully fit in the space
2551                      of the stack adjust that we deleted,
2552                      make another stack adjust here for what we
2553                      didn't use up.  There should be peepholes
2554                      to recognize the resulting sequence of insns.  */
2555                   if (total_pushed < 0)
2556                     {
2557                       emit_insn_before (gen_add2_insn (stack_pointer_rtx,
2558                                                        GEN_INT (- total_pushed)),
2559                                         p);
2560                       break;
2561                     }
2562                   XEXP (dest, 0)
2563                     = plus_constant (stack_pointer_rtx, total_pushed);
2564                 }
2565             }
2566 #endif
2567
2568           /* Detect and delete no-op move instructions
2569              resulting from not allocating a parameter in a register.  */
2570
2571           if (GET_CODE (body) == SET
2572               && (SET_DEST (body) == SET_SRC (body)
2573                   || (GET_CODE (SET_DEST (body)) == MEM
2574                       && GET_CODE (SET_SRC (body)) == MEM
2575                       && rtx_equal_p (SET_SRC (body), SET_DEST (body))))
2576               && ! (GET_CODE (SET_DEST (body)) == MEM
2577                     && MEM_VOLATILE_P (SET_DEST (body)))
2578               && ! (GET_CODE (SET_SRC (body)) == MEM
2579                     && MEM_VOLATILE_P (SET_SRC (body))))
2580             delete_computation (insn);
2581
2582           /* Detect and ignore no-op move instructions
2583              resulting from smart or fortuitous register allocation.  */
2584
2585           else if (GET_CODE (body) == SET)
2586             {
2587               int sreg = true_regnum (SET_SRC (body));
2588               int dreg = true_regnum (SET_DEST (body));
2589
2590               if (sreg == dreg && sreg >= 0)
2591                 delete_insn (insn);
2592               else if (sreg >= 0 && dreg >= 0)
2593                 {
2594                   rtx trial;
2595                   rtx tem = find_equiv_reg (NULL_RTX, insn, 0,
2596                                             sreg, NULL_PTR, dreg,
2597                                             GET_MODE (SET_SRC (body)));
2598
2599                   if (tem != 0
2600                       && GET_MODE (tem) == GET_MODE (SET_DEST (body)))
2601                     {
2602                       /* DREG may have been the target of a REG_DEAD note in
2603                          the insn which makes INSN redundant.  If so, reorg
2604                          would still think it is dead.  So search for such a
2605                          note and delete it if we find it.  */
2606                       if (! find_regno_note (insn, REG_UNUSED, dreg))
2607                         for (trial = prev_nonnote_insn (insn);
2608                              trial && GET_CODE (trial) != CODE_LABEL;
2609                              trial = prev_nonnote_insn (trial))
2610                           if (find_regno_note (trial, REG_DEAD, dreg))
2611                             {
2612                               remove_death (dreg, trial);
2613                               break;
2614                             }
2615
2616                       /* Deleting insn could lose a death-note for SREG.  */
2617                       if ((trial = find_regno_note (insn, REG_DEAD, sreg)))
2618                         {
2619                           /* Change this into a USE so that we won't emit
2620                              code for it, but still can keep the note.  */
2621                           PATTERN (insn)
2622                             = gen_rtx_USE (VOIDmode, XEXP (trial, 0));
2623                           INSN_CODE (insn) = -1;
2624                           /* Remove all reg notes but the REG_DEAD one.  */
2625                           REG_NOTES (insn) = trial;
2626                           XEXP (trial, 1) = NULL_RTX;
2627                         }
2628                       else
2629                         delete_insn (insn);
2630                     }
2631                 }
2632               else if (dreg >= 0 && CONSTANT_P (SET_SRC (body))
2633                        && find_equiv_reg (SET_SRC (body), insn, 0, dreg,
2634                                           NULL_PTR, 0,
2635                                           GET_MODE (SET_DEST (body))))
2636                 {
2637                   /* This handles the case where we have two consecutive
2638                      assignments of the same constant to pseudos that didn't
2639                      get a hard reg.  Each SET from the constant will be
2640                      converted into a SET of the spill register and an
2641                      output reload will be made following it.  This produces
2642                      two loads of the same constant into the same spill
2643                      register.  */
2644
2645                   rtx in_insn = insn;
2646
2647                   /* Look back for a death note for the first reg.
2648                      If there is one, it is no longer accurate.  */
2649                   while (in_insn && GET_CODE (in_insn) != CODE_LABEL)
2650                     {
2651                       if ((GET_CODE (in_insn) == INSN
2652                            || GET_CODE (in_insn) == JUMP_INSN)
2653                           && find_regno_note (in_insn, REG_DEAD, dreg))
2654                         {
2655                           remove_death (dreg, in_insn);
2656                           break;
2657                         }
2658                       in_insn = PREV_INSN (in_insn);
2659                     }
2660
2661                   /* Delete the second load of the value.  */
2662                   delete_insn (insn);
2663                 }
2664             }
2665           else if (GET_CODE (body) == PARALLEL)
2666             {
2667               /* If each part is a set between two identical registers or
2668                  a USE or CLOBBER, delete the insn.  */
2669               int i, sreg, dreg;
2670               rtx tem;
2671
2672               for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
2673                 {
2674                   tem = XVECEXP (body, 0, i);
2675                   if (GET_CODE (tem) == USE || GET_CODE (tem) == CLOBBER)
2676                     continue;
2677
2678                   if (GET_CODE (tem) != SET
2679                       || (sreg = true_regnum (SET_SRC (tem))) < 0
2680                       || (dreg = true_regnum (SET_DEST (tem))) < 0
2681                       || dreg != sreg)
2682                     break;
2683                 }
2684
2685               if (i < 0)
2686                 delete_insn (insn);
2687             }
2688           /* Also delete insns to store bit fields if they are no-ops.  */
2689           /* Not worth the hair to detect this in the big-endian case.  */
2690           else if (! BYTES_BIG_ENDIAN
2691                    && GET_CODE (body) == SET
2692                    && GET_CODE (SET_DEST (body)) == ZERO_EXTRACT
2693                    && XEXP (SET_DEST (body), 2) == const0_rtx
2694                    && XEXP (SET_DEST (body), 0) == SET_SRC (body)
2695                    && ! (GET_CODE (SET_SRC (body)) == MEM
2696                          && MEM_VOLATILE_P (SET_SRC (body))))
2697             delete_insn (insn);
2698         }
2699       insn = next;
2700     }
2701 }
2702
2703 /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
2704    If so indicate that this function can drop off the end by returning
2705    1, else return 0.
2706
2707    CHECK_DELETED indicates whether we must check if the note being
2708    searched for has the deleted flag set.
2709
2710    DELETE_FINAL_NOTE indicates whether we should delete the note
2711    if we find it.  */
2712
2713 static int
2714 calculate_can_reach_end (last, check_deleted, delete_final_note)
2715      rtx last;
2716      int check_deleted;
2717      int delete_final_note;
2718 {
2719   rtx insn = last;
2720   int n_labels = 1;
2721
2722   while (insn != NULL_RTX)
2723     {
2724       int ok = 0;
2725
2726       /* One label can follow the end-note: the return label.  */
2727       if (GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
2728         ok = 1;
2729       /* Ordinary insns can follow it if returning a structure.  */
2730       else if (GET_CODE (insn) == INSN)
2731         ok = 1;
2732       /* If machine uses explicit RETURN insns, no epilogue,
2733          then one of them follows the note.  */
2734       else if (GET_CODE (insn) == JUMP_INSN
2735                && GET_CODE (PATTERN (insn)) == RETURN)
2736         ok = 1;
2737       /* A barrier can follow the return insn.  */
2738       else if (GET_CODE (insn) == BARRIER)
2739         ok = 1;
2740       /* Other kinds of notes can follow also.  */
2741       else if (GET_CODE (insn) == NOTE
2742                && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
2743         ok = 1;
2744
2745       if (ok != 1)
2746         break;
2747
2748       insn = PREV_INSN (insn);
2749     }
2750
2751   /* See if we backed up to the appropriate type of note.  */
2752   if (insn != NULL_RTX
2753       && GET_CODE (insn) == NOTE
2754       && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END
2755       && (check_deleted == 0
2756           || ! INSN_DELETED_P (insn)))
2757     {
2758       if (delete_final_note)
2759         delete_insn (insn);
2760       return 1;
2761     }
2762
2763   return 0;
2764 }
2765
2766 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
2767    jump.  Assume that this unconditional jump is to the exit test code.  If
2768    the code is sufficiently simple, make a copy of it before INSN,
2769    followed by a jump to the exit of the loop.  Then delete the unconditional
2770    jump after INSN.
2771
2772    Return 1 if we made the change, else 0.
2773
2774    This is only safe immediately after a regscan pass because it uses the
2775    values of regno_first_uid and regno_last_uid.  */
2776
2777 static int
2778 duplicate_loop_exit_test (loop_start)
2779      rtx loop_start;
2780 {
2781   rtx insn, set, reg, p, link;
2782   rtx copy = 0, first_copy = 0;
2783   int num_insns = 0;
2784   rtx exitcode = NEXT_INSN (JUMP_LABEL (next_nonnote_insn (loop_start)));
2785   rtx lastexit;
2786   int max_reg = max_reg_num ();
2787   rtx *reg_map = 0;
2788
2789   /* Scan the exit code.  We do not perform this optimization if any insn:
2790
2791          is a CALL_INSN
2792          is a CODE_LABEL
2793          has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
2794          is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
2795          is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
2796               is not valid.
2797
2798      We also do not do this if we find an insn with ASM_OPERANDS.  While
2799      this restriction should not be necessary, copying an insn with
2800      ASM_OPERANDS can confuse asm_noperands in some cases.
2801
2802      Also, don't do this if the exit code is more than 20 insns.  */
2803
2804   for (insn = exitcode;
2805        insn
2806        && ! (GET_CODE (insn) == NOTE
2807              && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
2808        insn = NEXT_INSN (insn))
2809     {
2810       switch (GET_CODE (insn))
2811         {
2812         case CODE_LABEL:
2813         case CALL_INSN:
2814           return 0;
2815         case NOTE:
2816           /* We could be in front of the wrong NOTE_INSN_LOOP_END if there is
2817              a jump immediately after the loop start that branches outside
2818              the loop but within an outer loop, near the exit test.
2819              If we copied this exit test and created a phony
2820              NOTE_INSN_LOOP_VTOP, this could make instructions immediately
2821              before the exit test look like these could be safely moved
2822              out of the loop even if they actually may be never executed.
2823              This can be avoided by checking here for NOTE_INSN_LOOP_CONT.  */
2824
2825           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
2826               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
2827             return 0;
2828
2829           if (optimize < 2
2830               && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
2831                   || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
2832             /* If we were to duplicate this code, we would not move
2833                the BLOCK notes, and so debugging the moved code would
2834                be difficult.  Thus, we only move the code with -O2 or
2835                higher.  */
2836             return 0;
2837
2838           break;
2839         case JUMP_INSN:
2840         case INSN:
2841           /* The code below would grossly mishandle REG_WAS_0 notes,
2842              so get rid of them here.  */
2843           while ((p = find_reg_note (insn, REG_WAS_0, NULL_RTX)) != 0)
2844             remove_note (insn, p);
2845           if (++num_insns > 20
2846               || find_reg_note (insn, REG_RETVAL, NULL_RTX)
2847               || find_reg_note (insn, REG_LIBCALL, NULL_RTX))
2848             return 0;
2849           break;
2850         default:
2851           break;
2852         }
2853     }
2854
2855   /* Unless INSN is zero, we can do the optimization.  */
2856   if (insn == 0)
2857     return 0;
2858
2859   lastexit = insn;
2860
2861   /* See if any insn sets a register only used in the loop exit code and
2862      not a user variable.  If so, replace it with a new register.  */
2863   for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
2864     if (GET_CODE (insn) == INSN
2865         && (set = single_set (insn)) != 0
2866         && ((reg = SET_DEST (set), GET_CODE (reg) == REG)
2867             || (GET_CODE (reg) == SUBREG
2868                 && (reg = SUBREG_REG (reg), GET_CODE (reg) == REG)))
2869         && REGNO (reg) >= FIRST_PSEUDO_REGISTER
2870         && REGNO_FIRST_UID (REGNO (reg)) == INSN_UID (insn))
2871       {
2872         for (p = NEXT_INSN (insn); p != lastexit; p = NEXT_INSN (p))
2873           if (REGNO_LAST_UID (REGNO (reg)) == INSN_UID (p))
2874             break;
2875
2876         if (p != lastexit)
2877           {
2878             /* We can do the replacement.  Allocate reg_map if this is the
2879                first replacement we found.  */
2880             if (reg_map == 0)
2881               reg_map = (rtx *) xcalloc (max_reg, sizeof (rtx));
2882
2883             REG_LOOP_TEST_P (reg) = 1;
2884
2885             reg_map[REGNO (reg)] = gen_reg_rtx (GET_MODE (reg));
2886           }
2887       }
2888
2889   /* Now copy each insn.  */
2890   for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
2891     {
2892       switch (GET_CODE (insn))
2893         {
2894         case BARRIER:
2895           copy = emit_barrier_before (loop_start);
2896           break;
2897         case NOTE:
2898           /* Only copy line-number notes.  */
2899           if (NOTE_LINE_NUMBER (insn) >= 0)
2900             {
2901               copy = emit_note_before (NOTE_LINE_NUMBER (insn), loop_start);
2902               NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
2903             }
2904           break;
2905
2906         case INSN:
2907           copy = emit_insn_before (copy_insn (PATTERN (insn)), loop_start);
2908           if (reg_map)
2909             replace_regs (PATTERN (copy), reg_map, max_reg, 1);
2910
2911           mark_jump_label (PATTERN (copy), copy, 0);
2912
2913           /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
2914              make them.  */
2915           for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
2916             if (REG_NOTE_KIND (link) != REG_LABEL)
2917               REG_NOTES (copy)
2918                 = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link),
2919                                                XEXP (link, 0),
2920                                                REG_NOTES (copy)));
2921           if (reg_map && REG_NOTES (copy))
2922             replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
2923           break;
2924
2925         case JUMP_INSN:
2926           copy = emit_jump_insn_before (copy_insn (PATTERN (insn)), loop_start);
2927           if (reg_map)
2928             replace_regs (PATTERN (copy), reg_map, max_reg, 1);
2929           mark_jump_label (PATTERN (copy), copy, 0);
2930           if (REG_NOTES (insn))
2931             {
2932               REG_NOTES (copy) = copy_insn_1 (REG_NOTES (insn));
2933               if (reg_map)
2934                 replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
2935             }
2936
2937           /* If this is a simple jump, add it to the jump chain.  */
2938
2939           if (INSN_UID (copy) < max_jump_chain && JUMP_LABEL (copy)
2940               && simplejump_p (copy))
2941             {
2942               jump_chain[INSN_UID (copy)]
2943                 = jump_chain[INSN_UID (JUMP_LABEL (copy))];
2944               jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
2945             }
2946           break;
2947
2948         default:
2949           abort ();
2950         }
2951
2952       /* Record the first insn we copied.  We need it so that we can
2953          scan the copied insns for new pseudo registers.  */
2954       if (! first_copy)
2955         first_copy = copy;
2956     }
2957
2958   /* Now clean up by emitting a jump to the end label and deleting the jump
2959      at the start of the loop.  */
2960   if (! copy || GET_CODE (copy) != BARRIER)
2961     {
2962       copy = emit_jump_insn_before (gen_jump (get_label_after (insn)),
2963                                     loop_start);
2964
2965       /* Record the first insn we copied.  We need it so that we can
2966          scan the copied insns for new pseudo registers.   This may not
2967          be strictly necessary since we should have copied at least one
2968          insn above.  But I am going to be safe.  */
2969       if (! first_copy)
2970         first_copy = copy;
2971
2972       mark_jump_label (PATTERN (copy), copy, 0);
2973       if (INSN_UID (copy) < max_jump_chain
2974           && INSN_UID (JUMP_LABEL (copy)) < max_jump_chain)
2975         {
2976           jump_chain[INSN_UID (copy)]
2977             = jump_chain[INSN_UID (JUMP_LABEL (copy))];
2978           jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
2979         }
2980       emit_barrier_before (loop_start);
2981     }
2982
2983   /* Now scan from the first insn we copied to the last insn we copied
2984      (copy) for new pseudo registers.  Do this after the code to jump to
2985      the end label since that might create a new pseudo too.  */
2986   reg_scan_update (first_copy, copy, max_reg);
2987
2988   /* Mark the exit code as the virtual top of the converted loop.  */
2989   emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode);
2990
2991   delete_insn (next_nonnote_insn (loop_start));
2992
2993   /* Clean up.  */
2994   if (reg_map)
2995     free (reg_map);
2996
2997   return 1;
2998 }
2999 \f
3000 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, and
3001    loop-end notes between START and END out before START.  Assume that
3002    END is not such a note.  START may be such a note.  Returns the value
3003    of the new starting insn, which may be different if the original start
3004    was such a note.  */
3005
3006 rtx
3007 squeeze_notes (start, end)
3008      rtx start, end;
3009 {
3010   rtx insn;
3011   rtx next;
3012
3013   for (insn = start; insn != end; insn = next)
3014     {
3015       next = NEXT_INSN (insn);
3016       if (GET_CODE (insn) == NOTE
3017           && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
3018               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
3019               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
3020               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
3021               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT
3022               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP))
3023         {
3024           if (insn == start)
3025             start = next;
3026           else
3027             {
3028               rtx prev = PREV_INSN (insn);
3029               PREV_INSN (insn) = PREV_INSN (start);
3030               NEXT_INSN (insn) = start;
3031               NEXT_INSN (PREV_INSN (insn)) = insn;
3032               PREV_INSN (NEXT_INSN (insn)) = insn;
3033               NEXT_INSN (prev) = next;
3034               PREV_INSN (next) = prev;
3035             }
3036         }
3037     }
3038
3039   return start;
3040 }
3041 \f
3042 /* Compare the instructions before insn E1 with those before E2
3043    to find an opportunity for cross jumping.
3044    (This means detecting identical sequences of insns followed by
3045    jumps to the same place, or followed by a label and a jump
3046    to that label, and replacing one with a jump to the other.)
3047
3048    Assume E1 is a jump that jumps to label E2
3049    (that is not always true but it might as well be).
3050    Find the longest possible equivalent sequences
3051    and store the first insns of those sequences into *F1 and *F2.
3052    Store zero there if no equivalent preceding instructions are found.
3053
3054    We give up if we find a label in stream 1.
3055    Actually we could transfer that label into stream 2.  */
3056
3057 static void
3058 find_cross_jump (e1, e2, minimum, f1, f2)
3059      rtx e1, e2;
3060      int minimum;
3061      rtx *f1, *f2;
3062 {
3063   register rtx i1 = e1, i2 = e2;
3064   register rtx p1, p2;
3065   int lose = 0;
3066
3067   rtx last1 = 0, last2 = 0;
3068   rtx afterlast1 = 0, afterlast2 = 0;
3069
3070   *f1 = 0;
3071   *f2 = 0;
3072
3073   while (1)
3074     {
3075       i1 = prev_nonnote_insn (i1);
3076
3077       i2 = PREV_INSN (i2);
3078       while (i2 && (GET_CODE (i2) == NOTE || GET_CODE (i2) == CODE_LABEL))
3079         i2 = PREV_INSN (i2);
3080
3081       if (i1 == 0)
3082         break;
3083
3084       /* Don't allow the range of insns preceding E1 or E2
3085          to include the other (E2 or E1).  */
3086       if (i2 == e1 || i1 == e2)
3087         break;
3088
3089       /* If we will get to this code by jumping, those jumps will be
3090          tensioned to go directly to the new label (before I2),
3091          so this cross-jumping won't cost extra.  So reduce the minimum.  */
3092       if (GET_CODE (i1) == CODE_LABEL)
3093         {
3094           --minimum;
3095           break;
3096         }
3097
3098       if (i2 == 0 || GET_CODE (i1) != GET_CODE (i2))
3099         break;
3100
3101       /* Avoid moving insns across EH regions if either of the insns
3102          can throw.  */
3103       if (flag_exceptions
3104           && (asynchronous_exceptions || GET_CODE (i1) == CALL_INSN)
3105           && !in_same_eh_region (i1, i2))
3106         break;
3107
3108       p1 = PATTERN (i1);
3109       p2 = PATTERN (i2);
3110
3111       /* If this is a CALL_INSN, compare register usage information.
3112          If we don't check this on stack register machines, the two
3113          CALL_INSNs might be merged leaving reg-stack.c with mismatching
3114          numbers of stack registers in the same basic block.
3115          If we don't check this on machines with delay slots, a delay slot may
3116          be filled that clobbers a parameter expected by the subroutine.
3117
3118          ??? We take the simple route for now and assume that if they're
3119          equal, they were constructed identically.  */
3120
3121       if (GET_CODE (i1) == CALL_INSN
3122           && ! rtx_equal_p (CALL_INSN_FUNCTION_USAGE (i1),
3123                             CALL_INSN_FUNCTION_USAGE (i2)))
3124         lose = 1;
3125
3126 #ifdef STACK_REGS
3127       /* If cross_jump_death_matters is not 0, the insn's mode
3128          indicates whether or not the insn contains any stack-like
3129          regs.  */
3130
3131       if (!lose && cross_jump_death_matters && stack_regs_mentioned (i1))
3132         {
3133           /* If register stack conversion has already been done, then
3134              death notes must also be compared before it is certain that
3135              the two instruction streams match.  */
3136
3137           rtx note;
3138           HARD_REG_SET i1_regset, i2_regset;
3139
3140           CLEAR_HARD_REG_SET (i1_regset);
3141           CLEAR_HARD_REG_SET (i2_regset);
3142
3143           for (note = REG_NOTES (i1); note; note = XEXP (note, 1))
3144             if (REG_NOTE_KIND (note) == REG_DEAD
3145                 && STACK_REG_P (XEXP (note, 0)))
3146               SET_HARD_REG_BIT (i1_regset, REGNO (XEXP (note, 0)));
3147
3148           for (note = REG_NOTES (i2); note; note = XEXP (note, 1))
3149             if (REG_NOTE_KIND (note) == REG_DEAD
3150                 && STACK_REG_P (XEXP (note, 0)))
3151               SET_HARD_REG_BIT (i2_regset, REGNO (XEXP (note, 0)));
3152
3153           GO_IF_HARD_REG_EQUAL (i1_regset, i2_regset, done);
3154
3155           lose = 1;
3156
3157         done:
3158           ;
3159         }
3160 #endif
3161
3162       /* Don't allow old-style asm or volatile extended asms to be accepted
3163          for cross jumping purposes.  It is conceptually correct to allow
3164          them, since cross-jumping preserves the dynamic instruction order
3165          even though it is changing the static instruction order.  However,
3166          if an asm is being used to emit an assembler pseudo-op, such as
3167          the MIPS `.set reorder' pseudo-op, then the static instruction order
3168          matters and it must be preserved.  */
3169       if (GET_CODE (p1) == ASM_INPUT || GET_CODE (p2) == ASM_INPUT
3170           || (GET_CODE (p1) == ASM_OPERANDS && MEM_VOLATILE_P (p1))
3171           || (GET_CODE (p2) == ASM_OPERANDS && MEM_VOLATILE_P (p2)))
3172         lose = 1;
3173
3174       if (lose || GET_CODE (p1) != GET_CODE (p2)
3175           || ! rtx_renumbered_equal_p (p1, p2))
3176         {
3177           /* The following code helps take care of G++ cleanups.  */
3178           rtx equiv1;
3179           rtx equiv2;
3180
3181           if (!lose && GET_CODE (p1) == GET_CODE (p2)
3182               && ((equiv1 = find_reg_note (i1, REG_EQUAL, NULL_RTX)) != 0
3183                   || (equiv1 = find_reg_note (i1, REG_EQUIV, NULL_RTX)) != 0)
3184               && ((equiv2 = find_reg_note (i2, REG_EQUAL, NULL_RTX)) != 0
3185                   || (equiv2 = find_reg_note (i2, REG_EQUIV, NULL_RTX)) != 0)
3186               /* If the equivalences are not to a constant, they may
3187                  reference pseudos that no longer exist, so we can't
3188                  use them.  */
3189               && CONSTANT_P (XEXP (equiv1, 0))
3190               && rtx_equal_p (XEXP (equiv1, 0), XEXP (equiv2, 0)))
3191             {
3192               rtx s1 = single_set (i1);
3193               rtx s2 = single_set (i2);
3194               if (s1 != 0 && s2 != 0
3195                   && rtx_renumbered_equal_p (SET_DEST (s1), SET_DEST (s2)))
3196                 {
3197                   validate_change (i1, &SET_SRC (s1), XEXP (equiv1, 0), 1);
3198                   validate_change (i2, &SET_SRC (s2), XEXP (equiv2, 0), 1);
3199                   if (! rtx_renumbered_equal_p (p1, p2))
3200                     cancel_changes (0);
3201                   else if (apply_change_group ())
3202                     goto win;
3203                 }
3204             }
3205
3206           /* Insns fail to match; cross jumping is limited to the following
3207              insns.  */
3208
3209 #ifdef HAVE_cc0
3210           /* Don't allow the insn after a compare to be shared by
3211              cross-jumping unless the compare is also shared.
3212              Here, if either of these non-matching insns is a compare,
3213              exclude the following insn from possible cross-jumping.  */
3214           if (sets_cc0_p (p1) || sets_cc0_p (p2))
3215             last1 = afterlast1, last2 = afterlast2, ++minimum;
3216 #endif
3217
3218           /* If cross-jumping here will feed a jump-around-jump
3219              optimization, this jump won't cost extra, so reduce
3220              the minimum.  */
3221           if (GET_CODE (i1) == JUMP_INSN
3222               && JUMP_LABEL (i1)
3223               && prev_real_insn (JUMP_LABEL (i1)) == e1)
3224             --minimum;
3225           break;
3226         }
3227
3228     win:
3229       if (GET_CODE (p1) != USE && GET_CODE (p1) != CLOBBER)
3230         {
3231           /* Ok, this insn is potentially includable in a cross-jump here.  */
3232           afterlast1 = last1, afterlast2 = last2;
3233           last1 = i1, last2 = i2, --minimum;
3234         }
3235     }
3236
3237   if (minimum <= 0 && last1 != 0 && last1 != e1)
3238     *f1 = last1, *f2 = last2;
3239 }
3240
3241 static void
3242 do_cross_jump (insn, newjpos, newlpos)
3243      rtx insn, newjpos, newlpos;
3244 {
3245   /* Find an existing label at this point
3246      or make a new one if there is none.  */
3247   register rtx label = get_label_before (newlpos);
3248
3249   /* Make the same jump insn jump to the new point.  */
3250   if (GET_CODE (PATTERN (insn)) == RETURN)
3251     {
3252       /* Remove from jump chain of returns.  */
3253       delete_from_jump_chain (insn);
3254       /* Change the insn.  */
3255       PATTERN (insn) = gen_jump (label);
3256       INSN_CODE (insn) = -1;
3257       JUMP_LABEL (insn) = label;
3258       LABEL_NUSES (label)++;
3259       /* Add to new the jump chain.  */
3260       if (INSN_UID (label) < max_jump_chain
3261           && INSN_UID (insn) < max_jump_chain)
3262         {
3263           jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (label)];
3264           jump_chain[INSN_UID (label)] = insn;
3265         }
3266     }
3267   else
3268     redirect_jump (insn, label);
3269
3270   /* Delete the matching insns before the jump.  Also, remove any REG_EQUAL
3271      or REG_EQUIV note in the NEWLPOS stream that isn't also present in
3272      the NEWJPOS stream.  */
3273
3274   while (newjpos != insn)
3275     {
3276       rtx lnote;
3277
3278       for (lnote = REG_NOTES (newlpos); lnote; lnote = XEXP (lnote, 1))
3279         if ((REG_NOTE_KIND (lnote) == REG_EQUAL
3280              || REG_NOTE_KIND (lnote) == REG_EQUIV)
3281             && ! find_reg_note (newjpos, REG_EQUAL, XEXP (lnote, 0))
3282             && ! find_reg_note (newjpos, REG_EQUIV, XEXP (lnote, 0)))
3283           remove_note (newlpos, lnote);
3284
3285       delete_insn (newjpos);
3286       newjpos = next_real_insn (newjpos);
3287       newlpos = next_real_insn (newlpos);
3288     }
3289 }
3290 \f
3291 /* Return the label before INSN, or put a new label there.  */
3292
3293 rtx
3294 get_label_before (insn)
3295      rtx insn;
3296 {
3297   rtx label;
3298
3299   /* Find an existing label at this point
3300      or make a new one if there is none.  */
3301   label = prev_nonnote_insn (insn);
3302
3303   if (label == 0 || GET_CODE (label) != CODE_LABEL)
3304     {
3305       rtx prev = PREV_INSN (insn);
3306
3307       label = gen_label_rtx ();
3308       emit_label_after (label, prev);
3309       LABEL_NUSES (label) = 0;
3310     }
3311   return label;
3312 }
3313
3314 /* Return the label after INSN, or put a new label there.  */
3315
3316 rtx
3317 get_label_after (insn)
3318      rtx insn;
3319 {
3320   rtx label;
3321
3322   /* Find an existing label at this point
3323      or make a new one if there is none.  */
3324   label = next_nonnote_insn (insn);
3325
3326   if (label == 0 || GET_CODE (label) != CODE_LABEL)
3327     {
3328       label = gen_label_rtx ();
3329       emit_label_after (label, insn);
3330       LABEL_NUSES (label) = 0;
3331     }
3332   return label;
3333 }
3334 \f
3335 /* Return 1 if INSN is a jump that jumps to right after TARGET
3336    only on the condition that TARGET itself would drop through.
3337    Assumes that TARGET is a conditional jump.  */
3338
3339 static int
3340 jump_back_p (insn, target)
3341      rtx insn, target;
3342 {
3343   rtx cinsn, ctarget;
3344   enum rtx_code codei, codet;
3345
3346   if (simplejump_p (insn) || ! condjump_p (insn)
3347       || simplejump_p (target)
3348       || target != prev_real_insn (JUMP_LABEL (insn)))
3349     return 0;
3350
3351   cinsn = XEXP (SET_SRC (PATTERN (insn)), 0);
3352   ctarget = XEXP (SET_SRC (PATTERN (target)), 0);
3353
3354   codei = GET_CODE (cinsn);
3355   codet = GET_CODE (ctarget);
3356
3357   if (XEXP (SET_SRC (PATTERN (insn)), 1) == pc_rtx)
3358     {
3359       if (! can_reverse_comparison_p (cinsn, insn))
3360         return 0;
3361       codei = reverse_condition (codei);
3362     }
3363
3364   if (XEXP (SET_SRC (PATTERN (target)), 2) == pc_rtx)
3365     {
3366       if (! can_reverse_comparison_p (ctarget, target))
3367         return 0;
3368       codet = reverse_condition (codet);
3369     }
3370
3371   return (codei == codet
3372           && rtx_renumbered_equal_p (XEXP (cinsn, 0), XEXP (ctarget, 0))
3373           && rtx_renumbered_equal_p (XEXP (cinsn, 1), XEXP (ctarget, 1)));
3374 }
3375 \f
3376 /* Given a comparison, COMPARISON, inside a conditional jump insn, INSN,
3377    return non-zero if it is safe to reverse this comparison.  It is if our
3378    floating-point is not IEEE, if this is an NE or EQ comparison, or if
3379    this is known to be an integer comparison.  */
3380
3381 int
3382 can_reverse_comparison_p (comparison, insn)
3383      rtx comparison;
3384      rtx insn;
3385 {
3386   rtx arg0;
3387
3388   /* If this is not actually a comparison, we can't reverse it.  */
3389   if (GET_RTX_CLASS (GET_CODE (comparison)) != '<')
3390     return 0;
3391
3392   if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3393       /* If this is an NE comparison, it is safe to reverse it to an EQ
3394          comparison and vice versa, even for floating point.  If no operands
3395          are NaNs, the reversal is valid.  If some operand is a NaN, EQ is
3396          always false and NE is always true, so the reversal is also valid.  */
3397       || flag_fast_math
3398       || GET_CODE (comparison) == NE
3399       || GET_CODE (comparison) == EQ)
3400     return 1;
3401
3402   arg0 = XEXP (comparison, 0);
3403
3404   /* Make sure ARG0 is one of the actual objects being compared.  If we
3405      can't do this, we can't be sure the comparison can be reversed.
3406
3407      Handle cc0 and a MODE_CC register.  */
3408   if ((GET_CODE (arg0) == REG && GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC)
3409 #ifdef HAVE_cc0
3410       || arg0 == cc0_rtx
3411 #endif
3412       )
3413     {
3414       rtx prev = prev_nonnote_insn (insn);
3415       rtx set;
3416
3417       /* First see if the condition code mode alone if enough to say we can
3418          reverse the condition.  If not, then search backwards for a set of
3419          ARG0. We do not need to check for an insn clobbering it since valid
3420          code will contain set a set with no intervening clobber.  But
3421          stop when we reach a label.  */
3422 #ifdef REVERSIBLE_CC_MODE
3423       if (GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC
3424           && REVERSIBLE_CC_MODE (GET_MODE (arg0)))
3425         return 1;
3426 #endif
3427
3428       for (prev = prev_nonnote_insn (insn);
3429            prev != 0 && GET_CODE (prev) != CODE_LABEL;
3430            prev = prev_nonnote_insn (prev))
3431         if ((set = single_set (prev)) != 0
3432             && rtx_equal_p (SET_DEST (set), arg0))
3433           {
3434             arg0 = SET_SRC (set);
3435
3436             if (GET_CODE (arg0) == COMPARE)
3437               arg0 = XEXP (arg0, 0);
3438             break;
3439           }
3440     }
3441
3442   /* We can reverse this if ARG0 is a CONST_INT or if its mode is
3443      not VOIDmode and neither a MODE_CC nor MODE_FLOAT type.  */
3444   return (GET_CODE (arg0) == CONST_INT
3445           || (GET_MODE (arg0) != VOIDmode
3446               && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_CC
3447               && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_FLOAT));
3448 }
3449
3450 /* Given an rtx-code for a comparison, return the code
3451    for the negated comparison.
3452    WATCH OUT!  reverse_condition is not safe to use on a jump
3453    that might be acting on the results of an IEEE floating point comparison,
3454    because of the special treatment of non-signaling nans in comparisons.
3455    Use can_reverse_comparison_p to be sure.  */
3456
3457 enum rtx_code
3458 reverse_condition (code)
3459      enum rtx_code code;
3460 {
3461   switch (code)
3462     {
3463     case EQ:
3464       return NE;
3465
3466     case NE:
3467       return EQ;
3468
3469     case GT:
3470       return LE;
3471
3472     case GE:
3473       return LT;
3474
3475     case LT:
3476       return GE;
3477
3478     case LE:
3479       return GT;
3480
3481     case GTU:
3482       return LEU;
3483
3484     case GEU:
3485       return LTU;
3486
3487     case LTU:
3488       return GEU;
3489
3490     case LEU:
3491       return GTU;
3492
3493     default:
3494       abort ();
3495       return UNKNOWN;
3496     }
3497 }
3498
3499 /* Similar, but return the code when two operands of a comparison are swapped.
3500    This IS safe for IEEE floating-point.  */
3501
3502 enum rtx_code
3503 swap_condition (code)
3504      enum rtx_code code;
3505 {
3506   switch (code)
3507     {
3508     case EQ:
3509     case NE:
3510       return code;
3511
3512     case GT:
3513       return LT;
3514
3515     case GE:
3516       return LE;
3517
3518     case LT:
3519       return GT;
3520
3521     case LE:
3522       return GE;
3523
3524     case GTU:
3525       return LTU;
3526
3527     case GEU:
3528       return LEU;
3529
3530     case LTU:
3531       return GTU;
3532
3533     case LEU:
3534       return GEU;
3535
3536     default:
3537       abort ();
3538       return UNKNOWN;
3539     }
3540 }
3541
3542 /* Given a comparison CODE, return the corresponding unsigned comparison.
3543    If CODE is an equality comparison or already an unsigned comparison,
3544    CODE is returned.  */
3545
3546 enum rtx_code
3547 unsigned_condition (code)
3548      enum rtx_code code;
3549 {
3550   switch (code)
3551     {
3552     case EQ:
3553     case NE:
3554     case GTU:
3555     case GEU:
3556     case LTU:
3557     case LEU:
3558       return code;
3559
3560     case GT:
3561       return GTU;
3562
3563     case GE:
3564       return GEU;
3565
3566     case LT:
3567       return LTU;
3568
3569     case LE:
3570       return LEU;
3571
3572     default:
3573       abort ();
3574     }
3575 }
3576
3577 /* Similarly, return the signed version of a comparison.  */
3578
3579 enum rtx_code
3580 signed_condition (code)
3581      enum rtx_code code;
3582 {
3583   switch (code)
3584     {
3585     case EQ:
3586     case NE:
3587     case GT:
3588     case GE:
3589     case LT:
3590     case LE:
3591       return code;
3592
3593     case GTU:
3594       return GT;
3595
3596     case GEU:
3597       return GE;
3598
3599     case LTU:
3600       return LT;
3601
3602     case LEU:
3603       return LE;
3604
3605     default:
3606       abort ();
3607     }
3608 }
3609 \f
3610 /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
3611    truth of CODE1 implies the truth of CODE2.  */
3612
3613 int
3614 comparison_dominates_p (code1, code2)
3615      enum rtx_code code1, code2;
3616 {
3617   if (code1 == code2)
3618     return 1;
3619
3620   switch (code1)
3621     {
3622     case EQ:
3623       if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU)
3624         return 1;
3625       break;
3626
3627     case LT:
3628       if (code2 == LE || code2 == NE)
3629         return 1;
3630       break;
3631
3632     case GT:
3633       if (code2 == GE || code2 == NE)
3634         return 1;
3635       break;
3636
3637     case LTU:
3638       if (code2 == LEU || code2 == NE)
3639         return 1;
3640       break;
3641
3642     case GTU:
3643       if (code2 == GEU || code2 == NE)
3644         return 1;
3645       break;
3646
3647     default:
3648       break;
3649     }
3650
3651   return 0;
3652 }
3653 \f
3654 /* Return 1 if INSN is an unconditional jump and nothing else.  */
3655
3656 int
3657 simplejump_p (insn)
3658      rtx insn;
3659 {
3660   return (GET_CODE (insn) == JUMP_INSN
3661           && GET_CODE (PATTERN (insn)) == SET
3662           && GET_CODE (SET_DEST (PATTERN (insn))) == PC
3663           && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
3664 }
3665
3666 /* Return nonzero if INSN is a (possibly) conditional jump
3667    and nothing more.  */
3668
3669 int
3670 condjump_p (insn)
3671      rtx insn;
3672 {
3673   register rtx x = PATTERN (insn);
3674
3675   if (GET_CODE (x) != SET
3676       || GET_CODE (SET_DEST (x)) != PC)
3677     return 0;
3678
3679   x = SET_SRC (x);
3680   if (GET_CODE (x) == LABEL_REF)
3681     return 1;
3682   else return (GET_CODE (x) == IF_THEN_ELSE
3683                && ((GET_CODE (XEXP (x, 2)) == PC
3684                     && (GET_CODE (XEXP (x, 1)) == LABEL_REF
3685                         || GET_CODE (XEXP (x, 1)) == RETURN))
3686                    || (GET_CODE (XEXP (x, 1)) == PC
3687                        && (GET_CODE (XEXP (x, 2)) == LABEL_REF
3688                            || GET_CODE (XEXP (x, 2)) == RETURN))));
3689
3690   return 0;
3691 }
3692
3693 /* Return nonzero if INSN is a (possibly) conditional jump inside a
3694    PARALLEL.  */
3695
3696 int
3697 condjump_in_parallel_p (insn)
3698      rtx insn;
3699 {
3700   register rtx x = PATTERN (insn);
3701
3702   if (GET_CODE (x) != PARALLEL)
3703     return 0;
3704   else
3705     x = XVECEXP (x, 0, 0);
3706
3707   if (GET_CODE (x) != SET)
3708     return 0;
3709   if (GET_CODE (SET_DEST (x)) != PC)
3710     return 0;
3711   if (GET_CODE (SET_SRC (x)) == LABEL_REF)
3712     return 1;
3713   if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
3714     return 0;
3715   if (XEXP (SET_SRC (x), 2) == pc_rtx
3716       && (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
3717           || GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
3718     return 1;
3719   if (XEXP (SET_SRC (x), 1) == pc_rtx
3720       && (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
3721           || GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
3722     return 1;
3723   return 0;
3724 }
3725
3726 /* Return the label of a conditional jump.  */
3727
3728 rtx
3729 condjump_label (insn)
3730      rtx insn;
3731 {
3732   register rtx x = PATTERN (insn);
3733
3734   if (GET_CODE (x) == PARALLEL)
3735     x = XVECEXP (x, 0, 0);
3736   if (GET_CODE (x) != SET)
3737     return NULL_RTX;
3738   if (GET_CODE (SET_DEST (x)) != PC)
3739     return NULL_RTX;
3740   x = SET_SRC (x);
3741   if (GET_CODE (x) == LABEL_REF)
3742     return x;
3743   if (GET_CODE (x) != IF_THEN_ELSE)
3744     return NULL_RTX;
3745   if (XEXP (x, 2) == pc_rtx && GET_CODE (XEXP (x, 1)) == LABEL_REF)
3746     return XEXP (x, 1);
3747   if (XEXP (x, 1) == pc_rtx && GET_CODE (XEXP (x, 2)) == LABEL_REF)
3748     return XEXP (x, 2);
3749   return NULL_RTX;
3750 }
3751
3752 /* Return true if INSN is a (possibly conditional) return insn.  */
3753
3754 static int
3755 returnjump_p_1 (loc, data)
3756      rtx *loc;
3757      void *data ATTRIBUTE_UNUSED;
3758 {
3759   rtx x = *loc;
3760   return GET_CODE (x) == RETURN;
3761 }
3762
3763 int
3764 returnjump_p (insn)
3765      rtx insn;
3766 {
3767   return for_each_rtx (&PATTERN (insn), returnjump_p_1, NULL);
3768 }
3769
3770 /* Return true if INSN is a jump that only transfers control and
3771    nothing more.  */
3772
3773 int
3774 onlyjump_p (insn)
3775      rtx insn;
3776 {
3777   rtx set;
3778
3779   if (GET_CODE (insn) != JUMP_INSN)
3780     return 0;
3781
3782   set = single_set (insn);
3783   if (set == NULL)
3784     return 0;
3785   if (GET_CODE (SET_DEST (set)) != PC)
3786     return 0;
3787   if (side_effects_p (SET_SRC (set)))
3788     return 0;
3789
3790   return 1;
3791 }
3792
3793 #ifdef HAVE_cc0
3794
3795 /* Return 1 if X is an RTX that does nothing but set the condition codes
3796    and CLOBBER or USE registers.
3797    Return -1 if X does explicitly set the condition codes,
3798    but also does other things.  */
3799
3800 int
3801 sets_cc0_p (x)
3802      rtx x ATTRIBUTE_UNUSED;
3803 {
3804   if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
3805     return 1;
3806   if (GET_CODE (x) == PARALLEL)
3807     {
3808       int i;
3809       int sets_cc0 = 0;
3810       int other_things = 0;
3811       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
3812         {
3813           if (GET_CODE (XVECEXP (x, 0, i)) == SET
3814               && SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
3815             sets_cc0 = 1;
3816           else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
3817             other_things = 1;
3818         }
3819       return ! sets_cc0 ? 0 : other_things ? -1 : 1;
3820     }
3821   return 0;
3822 }
3823 #endif
3824 \f
3825 /* Follow any unconditional jump at LABEL;
3826    return the ultimate label reached by any such chain of jumps.
3827    If LABEL is not followed by a jump, return LABEL.
3828    If the chain loops or we can't find end, return LABEL,
3829    since that tells caller to avoid changing the insn.
3830
3831    If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
3832    a USE or CLOBBER.  */
3833
3834 rtx
3835 follow_jumps (label)
3836      rtx label;
3837 {
3838   register rtx insn;
3839   register rtx next;
3840   register rtx value = label;
3841   register int depth;
3842
3843   for (depth = 0;
3844        (depth < 10
3845         && (insn = next_active_insn (value)) != 0
3846         && GET_CODE (insn) == JUMP_INSN
3847         && ((JUMP_LABEL (insn) != 0 && simplejump_p (insn))
3848             || GET_CODE (PATTERN (insn)) == RETURN)
3849         && (next = NEXT_INSN (insn))
3850         && GET_CODE (next) == BARRIER);
3851        depth++)
3852     {
3853       /* Don't chain through the insn that jumps into a loop
3854          from outside the loop,
3855          since that would create multiple loop entry jumps
3856          and prevent loop optimization.  */
3857       rtx tem;
3858       if (!reload_completed)
3859         for (tem = value; tem != insn; tem = NEXT_INSN (tem))
3860           if (GET_CODE (tem) == NOTE
3861               && (NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG
3862                   /* ??? Optional.  Disables some optimizations, but makes
3863                      gcov output more accurate with -O.  */
3864                   || (flag_test_coverage && NOTE_LINE_NUMBER (tem) > 0)))
3865             return value;
3866
3867       /* If we have found a cycle, make the insn jump to itself.  */
3868       if (JUMP_LABEL (insn) == label)
3869         return label;
3870
3871       tem = next_active_insn (JUMP_LABEL (insn));
3872       if (tem && (GET_CODE (PATTERN (tem)) == ADDR_VEC
3873                   || GET_CODE (PATTERN (tem)) == ADDR_DIFF_VEC))
3874         break;
3875
3876       value = JUMP_LABEL (insn);
3877     }
3878   if (depth == 10)
3879     return label;
3880   return value;
3881 }
3882
3883 /* Assuming that field IDX of X is a vector of label_refs,
3884    replace each of them by the ultimate label reached by it.
3885    Return nonzero if a change is made.
3886    If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG.  */
3887
3888 static int
3889 tension_vector_labels (x, idx)
3890      register rtx x;
3891      register int idx;
3892 {
3893   int changed = 0;
3894   register int i;
3895   for (i = XVECLEN (x, idx) - 1; i >= 0; i--)
3896     {
3897       register rtx olabel = XEXP (XVECEXP (x, idx, i), 0);
3898       register rtx nlabel = follow_jumps (olabel);
3899       if (nlabel && nlabel != olabel)
3900         {
3901           XEXP (XVECEXP (x, idx, i), 0) = nlabel;
3902           ++LABEL_NUSES (nlabel);
3903           if (--LABEL_NUSES (olabel) == 0)
3904             delete_insn (olabel);
3905           changed = 1;
3906         }
3907     }
3908   return changed;
3909 }
3910 \f
3911 /* Find all CODE_LABELs referred to in X, and increment their use counts.
3912    If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
3913    in INSN, then store one of them in JUMP_LABEL (INSN).
3914    If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
3915    referenced in INSN, add a REG_LABEL note containing that label to INSN.
3916    Also, when there are consecutive labels, canonicalize on the last of them.
3917
3918    Note that two labels separated by a loop-beginning note
3919    must be kept distinct if we have not yet done loop-optimization,
3920    because the gap between them is where loop-optimize
3921    will want to move invariant code to.  CROSS_JUMP tells us
3922    that loop-optimization is done with.
3923
3924    Once reload has completed (CROSS_JUMP non-zero), we need not consider
3925    two labels distinct if they are separated by only USE or CLOBBER insns.  */
3926
3927 static void
3928 mark_jump_label (x, insn, cross_jump)
3929      register rtx x;
3930      rtx insn;
3931      int cross_jump;
3932 {
3933   register RTX_CODE code = GET_CODE (x);
3934   register int i;
3935   register const char *fmt;
3936
3937   switch (code)
3938     {
3939     case PC:
3940     case CC0:
3941     case REG:
3942     case SUBREG:
3943     case CONST_INT:
3944     case SYMBOL_REF:
3945     case CONST_DOUBLE:
3946     case CLOBBER:
3947     case CALL:
3948       return;
3949
3950     case MEM:
3951       /* If this is a constant-pool reference, see if it is a label.  */
3952       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
3953           && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
3954         mark_jump_label (get_pool_constant (XEXP (x, 0)), insn, cross_jump);
3955       break;
3956
3957     case LABEL_REF:
3958       {
3959         rtx label = XEXP (x, 0);
3960         rtx olabel = label;
3961         rtx note;
3962         rtx next;
3963
3964         if (GET_CODE (label) != CODE_LABEL)
3965           abort ();
3966
3967         /* Ignore references to labels of containing functions.  */
3968         if (LABEL_REF_NONLOCAL_P (x))
3969           break;
3970
3971         /* If there are other labels following this one,
3972            replace it with the last of the consecutive labels.  */
3973         for (next = NEXT_INSN (label); next; next = NEXT_INSN (next))
3974           {
3975             if (GET_CODE (next) == CODE_LABEL)
3976               label = next;
3977             else if (cross_jump && GET_CODE (next) == INSN
3978                      && (GET_CODE (PATTERN (next)) == USE
3979                          || GET_CODE (PATTERN (next)) == CLOBBER))
3980               continue;
3981             else if (GET_CODE (next) != NOTE)
3982               break;
3983             else if (! cross_jump
3984                      && (NOTE_LINE_NUMBER (next) == NOTE_INSN_LOOP_BEG
3985                          || NOTE_LINE_NUMBER (next) == NOTE_INSN_FUNCTION_END
3986                          /* ??? Optional.  Disables some optimizations, but
3987                             makes gcov output more accurate with -O.  */
3988                          || (flag_test_coverage && NOTE_LINE_NUMBER (next) > 0)))
3989               break;
3990           }
3991
3992         XEXP (x, 0) = label;
3993         if (! insn || ! INSN_DELETED_P (insn))
3994           ++LABEL_NUSES (label);
3995
3996         if (insn)
3997           {
3998             if (GET_CODE (insn) == JUMP_INSN)
3999               JUMP_LABEL (insn) = label;
4000
4001             /* If we've changed OLABEL and we had a REG_LABEL note
4002                for it, update it as well.  */
4003             else if (label != olabel
4004                      && (note = find_reg_note (insn, REG_LABEL, olabel)) != 0)
4005               XEXP (note, 0) = label;
4006
4007             /* Otherwise, add a REG_LABEL note for LABEL unless there already
4008                is one.  */
4009             else if (! find_reg_note (insn, REG_LABEL, label))
4010               {
4011                 /* This code used to ignore labels which refered to dispatch
4012                    tables to avoid flow.c generating worse code.
4013
4014                    However, in the presense of global optimizations like
4015                    gcse which call find_basic_blocks without calling
4016                    life_analysis, not recording such labels will lead
4017                    to compiler aborts because of inconsistencies in the
4018                    flow graph.  So we go ahead and record the label.
4019
4020                    It may also be the case that the optimization argument
4021                    is no longer valid because of the more accurate cfg
4022                    we build in find_basic_blocks -- it no longer pessimizes
4023                    code when it finds a REG_LABEL note.  */
4024                 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_LABEL, label,
4025                                                       REG_NOTES (insn));
4026               }
4027           }
4028         return;
4029       }
4030
4031   /* Do walk the labels in a vector, but not the first operand of an
4032      ADDR_DIFF_VEC.  Don't set the JUMP_LABEL of a vector.  */
4033     case ADDR_VEC:
4034     case ADDR_DIFF_VEC:
4035       if (! INSN_DELETED_P (insn))
4036         {
4037           int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
4038
4039           for (i = 0; i < XVECLEN (x, eltnum); i++)
4040             mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, cross_jump);
4041         }
4042       return;
4043
4044     default:
4045       break;
4046     }
4047
4048   fmt = GET_RTX_FORMAT (code);
4049   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4050     {
4051       if (fmt[i] == 'e')
4052         mark_jump_label (XEXP (x, i), insn, cross_jump);
4053       else if (fmt[i] == 'E')
4054         {
4055           register int j;
4056           for (j = 0; j < XVECLEN (x, i); j++)
4057             mark_jump_label (XVECEXP (x, i, j), insn, cross_jump);
4058         }
4059     }
4060 }
4061
4062 /* If all INSN does is set the pc, delete it,
4063    and delete the insn that set the condition codes for it
4064    if that's what the previous thing was.  */
4065
4066 void
4067 delete_jump (insn)
4068      rtx insn;
4069 {
4070   register rtx set = single_set (insn);
4071
4072   if (set && GET_CODE (SET_DEST (set)) == PC)
4073     delete_computation (insn);
4074 }
4075
4076 /* Verify INSN is a BARRIER and delete it.  */
4077
4078 void
4079 delete_barrier (insn)
4080      rtx insn;
4081 {
4082   if (GET_CODE (insn) != BARRIER)
4083     abort ();
4084
4085   delete_insn (insn);
4086 }
4087
4088 /* Recursively delete prior insns that compute the value (used only by INSN
4089    which the caller is deleting) stored in the register mentioned by NOTE
4090    which is a REG_DEAD note associated with INSN.  */
4091
4092 static void
4093 delete_prior_computation (note, insn)
4094      rtx note;
4095      rtx insn;
4096 {
4097   rtx our_prev;
4098   rtx reg = XEXP (note, 0);
4099
4100   for (our_prev = prev_nonnote_insn (insn);
4101        our_prev && (GET_CODE (our_prev) == INSN
4102                     || GET_CODE (our_prev) == CALL_INSN);
4103        our_prev = prev_nonnote_insn (our_prev))
4104     {
4105       rtx pat = PATTERN (our_prev);
4106
4107       /* If we reach a CALL which is not calling a const function
4108          or the callee pops the arguments, then give up.  */
4109       if (GET_CODE (our_prev) == CALL_INSN
4110           && (! CONST_CALL_P (our_prev)
4111               || GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != CALL))
4112         break;
4113
4114       /* If we reach a SEQUENCE, it is too complex to try to
4115          do anything with it, so give up.  */
4116       if (GET_CODE (pat) == SEQUENCE)
4117         break;
4118
4119       if (GET_CODE (pat) == USE
4120           && GET_CODE (XEXP (pat, 0)) == INSN)
4121         /* reorg creates USEs that look like this.  We leave them
4122            alone because reorg needs them for its own purposes.  */
4123         break;
4124
4125       if (reg_set_p (reg, pat))
4126         {
4127           if (side_effects_p (pat) && GET_CODE (our_prev) != CALL_INSN)
4128             break;
4129
4130           if (GET_CODE (pat) == PARALLEL)
4131             {
4132               /* If we find a SET of something else, we can't
4133                  delete the insn.  */
4134
4135               int i;
4136
4137               for (i = 0; i < XVECLEN (pat, 0); i++)
4138                 {
4139                   rtx part = XVECEXP (pat, 0, i);
4140
4141                   if (GET_CODE (part) == SET
4142                       && SET_DEST (part) != reg)
4143                     break;
4144                 }
4145
4146               if (i == XVECLEN (pat, 0))
4147                 delete_computation (our_prev);
4148             }
4149           else if (GET_CODE (pat) == SET
4150                    && GET_CODE (SET_DEST (pat)) == REG)
4151             {
4152               int dest_regno = REGNO (SET_DEST (pat));
4153               int dest_endregno
4154                     = dest_regno + (dest_regno < FIRST_PSEUDO_REGISTER
4155                       ? HARD_REGNO_NREGS (dest_regno,
4156                                 GET_MODE (SET_DEST (pat))) : 1);
4157               int regno = REGNO (reg);
4158               int endregno = regno + (regno < FIRST_PSEUDO_REGISTER
4159                              ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1);
4160
4161               if (dest_regno >= regno
4162                   && dest_endregno <= endregno)
4163                 delete_computation (our_prev);
4164
4165               /* We may have a multi-word hard register and some, but not
4166                  all, of the words of the register are needed in subsequent
4167                  insns.  Write REG_UNUSED notes for those parts that were not
4168                  needed.  */
4169               else if (dest_regno <= regno
4170                        && dest_endregno >= endregno)
4171                 {
4172                   int i;
4173
4174                   REG_NOTES (our_prev)
4175                     = gen_rtx_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (our_prev));
4176
4177                   for (i = dest_regno; i < dest_endregno; i++)
4178                     if (! find_regno_note (our_prev, REG_UNUSED, i))
4179                       break;
4180
4181                   if (i == dest_endregno)
4182                     delete_computation (our_prev);
4183                 }
4184             }
4185
4186           break;
4187         }
4188
4189       /* If PAT references the register that dies here, it is an
4190          additional use.  Hence any prior SET isn't dead.  However, this
4191          insn becomes the new place for the REG_DEAD note.  */
4192       if (reg_overlap_mentioned_p (reg, pat))
4193         {
4194           XEXP (note, 1) = REG_NOTES (our_prev);
4195           REG_NOTES (our_prev) = note;
4196           break;
4197         }
4198     }
4199 }
4200
4201 /* Delete INSN and recursively delete insns that compute values used only
4202    by INSN.  This uses the REG_DEAD notes computed during flow analysis.
4203    If we are running before flow.c, we need do nothing since flow.c will
4204    delete dead code.  We also can't know if the registers being used are
4205    dead or not at this point.
4206
4207    Otherwise, look at all our REG_DEAD notes.  If a previous insn does
4208    nothing other than set a register that dies in this insn, we can delete
4209    that insn as well.
4210
4211    On machines with CC0, if CC0 is used in this insn, we may be able to
4212    delete the insn that set it.  */
4213
4214 static void
4215 delete_computation (insn)
4216      rtx insn;
4217 {
4218   rtx note, next;
4219   rtx set;
4220
4221 #ifdef HAVE_cc0
4222   if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
4223     {
4224       rtx prev = prev_nonnote_insn (insn);
4225       /* We assume that at this stage
4226          CC's are always set explicitly
4227          and always immediately before the jump that
4228          will use them.  So if the previous insn
4229          exists to set the CC's, delete it
4230          (unless it performs auto-increments, etc.).  */
4231       if (prev && GET_CODE (prev) == INSN
4232           && sets_cc0_p (PATTERN (prev)))
4233         {
4234           if (sets_cc0_p (PATTERN (prev)) > 0
4235               && ! side_effects_p (PATTERN (prev)))
4236             delete_computation (prev);
4237           else
4238             /* Otherwise, show that cc0 won't be used.  */
4239             REG_NOTES (prev) = gen_rtx_EXPR_LIST (REG_UNUSED,
4240                                                   cc0_rtx, REG_NOTES (prev));
4241         }
4242     }
4243 #endif
4244
4245 #ifdef INSN_SCHEDULING
4246   /* ?!? The schedulers do not keep REG_DEAD notes accurate after
4247      reload has completed.  The schedulers need to be fixed.  Until
4248      they are, we must not rely on the death notes here.  */
4249   if (reload_completed && flag_schedule_insns_after_reload)
4250     {
4251       delete_insn (insn);
4252       return;
4253     }
4254 #endif
4255
4256   /* The REG_DEAD note may have been omitted for a register
4257      which is both set and used by the insn.  */
4258   set = single_set (insn);
4259   if (set && GET_CODE (SET_DEST (set)) == REG)
4260     {
4261     int dest_regno = REGNO (SET_DEST (set));
4262     int dest_endregno
4263           = dest_regno + (dest_regno < FIRST_PSEUDO_REGISTER
4264             ? HARD_REGNO_NREGS (dest_regno,
4265                                 GET_MODE (SET_DEST (set))) : 1);
4266     int i;
4267
4268     for (i = dest_regno; i < dest_endregno; i++)
4269       {
4270         if (! refers_to_regno_p (i, i + 1, SET_SRC (set), NULL_PTR)
4271             || find_regno_note (insn, REG_DEAD, i))
4272           continue;
4273
4274         note = gen_rtx_EXPR_LIST (REG_DEAD, (i < FIRST_PSEUDO_REGISTER
4275                                              ? gen_rtx_REG (reg_raw_mode[i], i)
4276                                              : SET_DEST (set)), NULL_RTX);
4277         delete_prior_computation (note, insn);
4278       }
4279     }
4280
4281   for (note = REG_NOTES (insn); note; note = next)
4282     {
4283       next = XEXP (note, 1);
4284
4285       if (REG_NOTE_KIND (note) != REG_DEAD
4286           /* Verify that the REG_NOTE is legitimate.  */
4287           || GET_CODE (XEXP (note, 0)) != REG)
4288         continue;
4289
4290       delete_prior_computation (note, insn);
4291     }
4292
4293   delete_insn (insn);
4294 }
4295 \f
4296 /* Delete insn INSN from the chain of insns and update label ref counts.
4297    May delete some following insns as a consequence; may even delete
4298    a label elsewhere and insns that follow it.
4299
4300    Returns the first insn after INSN that was not deleted.  */
4301
4302 rtx
4303 delete_insn (insn)
4304      register rtx insn;
4305 {
4306   register rtx next = NEXT_INSN (insn);
4307   register rtx prev = PREV_INSN (insn);
4308   register int was_code_label = (GET_CODE (insn) == CODE_LABEL);
4309   register int dont_really_delete = 0;
4310
4311   while (next && INSN_DELETED_P (next))
4312     next = NEXT_INSN (next);
4313
4314   /* This insn is already deleted => return first following nondeleted.  */
4315   if (INSN_DELETED_P (insn))
4316     return next;
4317
4318   if (was_code_label)
4319     remove_node_from_expr_list (insn, &nonlocal_goto_handler_labels);
4320
4321   /* Don't delete user-declared labels.  Convert them to special NOTEs
4322      instead.  */
4323   if (was_code_label && LABEL_NAME (insn) != 0
4324       && optimize && ! dont_really_delete)
4325     {
4326       PUT_CODE (insn, NOTE);
4327       NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED_LABEL;
4328       NOTE_SOURCE_FILE (insn) = 0;
4329       dont_really_delete = 1;
4330     }
4331   else
4332     /* Mark this insn as deleted.  */
4333     INSN_DELETED_P (insn) = 1;
4334
4335   /* If this is an unconditional jump, delete it from the jump chain.  */
4336   if (simplejump_p (insn))
4337     delete_from_jump_chain (insn);
4338
4339   /* If instruction is followed by a barrier,
4340      delete the barrier too.  */
4341
4342   if (next != 0 && GET_CODE (next) == BARRIER)
4343     {
4344       INSN_DELETED_P (next) = 1;
4345       next = NEXT_INSN (next);
4346     }
4347
4348   /* Patch out INSN (and the barrier if any) */
4349
4350   if (optimize && ! dont_really_delete)
4351     {
4352       if (prev)
4353         {
4354           NEXT_INSN (prev) = next;
4355           if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
4356             NEXT_INSN (XVECEXP (PATTERN (prev), 0,
4357                                 XVECLEN (PATTERN (prev), 0) - 1)) = next;
4358         }
4359
4360       if (next)
4361         {
4362           PREV_INSN (next) = prev;
4363           if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
4364             PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
4365         }
4366
4367       if (prev && NEXT_INSN (prev) == 0)
4368         set_last_insn (prev);
4369     }
4370
4371   /* If deleting a jump, decrement the count of the label,
4372      and delete the label if it is now unused.  */
4373
4374   if (GET_CODE (insn) == JUMP_INSN && JUMP_LABEL (insn))
4375     {
4376       rtx lab = JUMP_LABEL (insn), lab_next;
4377
4378       if (--LABEL_NUSES (lab) == 0)
4379         {
4380           /* This can delete NEXT or PREV,
4381              either directly if NEXT is JUMP_LABEL (INSN),
4382              or indirectly through more levels of jumps.  */
4383           delete_insn (lab);
4384
4385           /* I feel a little doubtful about this loop,
4386              but I see no clean and sure alternative way
4387              to find the first insn after INSN that is not now deleted.
4388              I hope this works.  */
4389           while (next && INSN_DELETED_P (next))
4390             next = NEXT_INSN (next);
4391           return next;
4392         }
4393       else if ((lab_next = next_nonnote_insn (lab)) != NULL
4394                && GET_CODE (lab_next) == JUMP_INSN
4395                && (GET_CODE (PATTERN (lab_next)) == ADDR_VEC
4396                    || GET_CODE (PATTERN (lab_next)) == ADDR_DIFF_VEC))
4397         {
4398           /* If we're deleting the tablejump, delete the dispatch table.
4399              We may not be able to kill the label immediately preceeding
4400              just yet, as it might be referenced in code leading up to
4401              the tablejump.  */
4402           delete_insn (lab_next);
4403         }
4404     }
4405
4406   /* Likewise if we're deleting a dispatch table.  */
4407
4408   if (GET_CODE (insn) == JUMP_INSN
4409       && (GET_CODE (PATTERN (insn)) == ADDR_VEC
4410           || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
4411     {
4412       rtx pat = PATTERN (insn);
4413       int i, diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;
4414       int len = XVECLEN (pat, diff_vec_p);
4415
4416       for (i = 0; i < len; i++)
4417         if (--LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0)) == 0)
4418           delete_insn (XEXP (XVECEXP (pat, diff_vec_p, i), 0));
4419       while (next && INSN_DELETED_P (next))
4420         next = NEXT_INSN (next);
4421       return next;
4422     }
4423
4424   while (prev && (INSN_DELETED_P (prev) || GET_CODE (prev) == NOTE))
4425     prev = PREV_INSN (prev);
4426
4427   /* If INSN was a label and a dispatch table follows it,
4428      delete the dispatch table.  The tablejump must have gone already.
4429      It isn't useful to fall through into a table.  */
4430
4431   if (was_code_label
4432       && NEXT_INSN (insn) != 0
4433       && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
4434       && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
4435           || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
4436     next = delete_insn (NEXT_INSN (insn));
4437
4438   /* If INSN was a label, delete insns following it if now unreachable.  */
4439
4440   if (was_code_label && prev && GET_CODE (prev) == BARRIER)
4441     {
4442       register RTX_CODE code;
4443       while (next != 0
4444              && (GET_RTX_CLASS (code = GET_CODE (next)) == 'i'
4445                  || code == NOTE || code == BARRIER
4446                  || (code == CODE_LABEL && INSN_DELETED_P (next))))
4447         {
4448           if (code == NOTE
4449               && NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
4450             next = NEXT_INSN (next);
4451           /* Keep going past other deleted labels to delete what follows.  */
4452           else if (code == CODE_LABEL && INSN_DELETED_P (next))
4453             next = NEXT_INSN (next);
4454           else
4455             /* Note: if this deletes a jump, it can cause more
4456                deletion of unreachable code, after a different label.
4457                As long as the value from this recursive call is correct,
4458                this invocation functions correctly.  */
4459             next = delete_insn (next);
4460         }
4461     }
4462
4463   return next;
4464 }
4465
4466 /* Advance from INSN till reaching something not deleted
4467    then return that.  May return INSN itself.  */
4468
4469 rtx
4470 next_nondeleted_insn (insn)
4471      rtx insn;
4472 {
4473   while (INSN_DELETED_P (insn))
4474     insn = NEXT_INSN (insn);
4475   return insn;
4476 }
4477 \f
4478 /* Delete a range of insns from FROM to TO, inclusive.
4479    This is for the sake of peephole optimization, so assume
4480    that whatever these insns do will still be done by a new
4481    peephole insn that will replace them.  */
4482
4483 void
4484 delete_for_peephole (from, to)
4485      register rtx from, to;
4486 {
4487   register rtx insn = from;
4488
4489   while (1)
4490     {
4491       register rtx next = NEXT_INSN (insn);
4492       register rtx prev = PREV_INSN (insn);
4493
4494       if (GET_CODE (insn) != NOTE)
4495         {
4496           INSN_DELETED_P (insn) = 1;
4497
4498           /* Patch this insn out of the chain.  */
4499           /* We don't do this all at once, because we
4500              must preserve all NOTEs.  */
4501           if (prev)
4502             NEXT_INSN (prev) = next;
4503
4504           if (next)
4505             PREV_INSN (next) = prev;
4506         }
4507
4508       if (insn == to)
4509         break;
4510       insn = next;
4511     }
4512
4513   /* Note that if TO is an unconditional jump
4514      we *do not* delete the BARRIER that follows,
4515      since the peephole that replaces this sequence
4516      is also an unconditional jump in that case.  */
4517 }
4518 \f
4519 /* We have determined that INSN is never reached, and are about to
4520    delete it.  Print a warning if the user asked for one.
4521
4522    To try to make this warning more useful, this should only be called
4523    once per basic block not reached, and it only warns when the basic
4524    block contains more than one line from the current function, and
4525    contains at least one operation.  CSE and inlining can duplicate insns,
4526    so it's possible to get spurious warnings from this.  */
4527
4528 void
4529 never_reached_warning (avoided_insn)
4530      rtx avoided_insn;
4531 {
4532   rtx insn;
4533   rtx a_line_note = NULL;
4534   int two_avoided_lines = 0;
4535   int contains_insn = 0;
4536
4537   if (! warn_notreached)
4538     return;
4539
4540   /* Scan forwards, looking at LINE_NUMBER notes, until
4541      we hit a LABEL or we run out of insns.  */
4542
4543   for (insn = avoided_insn; insn != NULL; insn = NEXT_INSN (insn))
4544     {
4545        if (GET_CODE (insn) == CODE_LABEL)
4546          break;
4547        else if (GET_CODE (insn) == NOTE         /* A line number note? */
4548                 && NOTE_LINE_NUMBER (insn) >= 0)
4549         {
4550           if (a_line_note == NULL)
4551             a_line_note = insn;
4552           else
4553             two_avoided_lines |= (NOTE_LINE_NUMBER (a_line_note)
4554                                   != NOTE_LINE_NUMBER (insn));
4555         }
4556        else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
4557          contains_insn = 1;
4558     }
4559   if (two_avoided_lines && contains_insn)
4560     warning_with_file_and_line (NOTE_SOURCE_FILE (a_line_note),
4561                                 NOTE_LINE_NUMBER (a_line_note),
4562                                 "will never be executed");
4563 }
4564 \f
4565 /* Invert the condition of the jump JUMP, and make it jump
4566    to label NLABEL instead of where it jumps now.  */
4567
4568 int
4569 invert_jump (jump, nlabel)
4570      rtx jump, nlabel;
4571 {
4572   /* We have to either invert the condition and change the label or
4573      do neither.  Either operation could fail.  We first try to invert
4574      the jump. If that succeeds, we try changing the label.  If that fails,
4575      we invert the jump back to what it was.  */
4576
4577   if (! invert_exp (PATTERN (jump), jump))
4578     return 0;
4579
4580   if (redirect_jump (jump, nlabel))
4581     {
4582       if (flag_branch_probabilities)
4583         {
4584           rtx note = find_reg_note (jump, REG_BR_PROB, 0);
4585
4586           /* An inverted jump means that a probability taken becomes a
4587              probability not taken.  Subtract the branch probability from the
4588              probability base to convert it back to a taken probability.
4589              (We don't flip the probability on a branch that's never taken.  */
4590           if (note && XINT (XEXP (note, 0), 0) >= 0)
4591             XINT (XEXP (note, 0), 0) = REG_BR_PROB_BASE - XINT (XEXP (note, 0), 0);
4592         }
4593
4594       return 1;
4595     }
4596
4597   if (! invert_exp (PATTERN (jump), jump))
4598     /* This should just be putting it back the way it was.  */
4599     abort ();
4600
4601   return  0;
4602 }
4603
4604 /* Invert the jump condition of rtx X contained in jump insn, INSN.
4605
4606    Return 1 if we can do so, 0 if we cannot find a way to do so that
4607    matches a pattern.  */
4608
4609 int
4610 invert_exp (x, insn)
4611      rtx x;
4612      rtx insn;
4613 {
4614   register RTX_CODE code;
4615   register int i;
4616   register const char *fmt;
4617
4618   code = GET_CODE (x);
4619
4620   if (code == IF_THEN_ELSE)
4621     {
4622       register rtx comp = XEXP (x, 0);
4623       register rtx tem;
4624
4625       /* We can do this in two ways:  The preferable way, which can only
4626          be done if this is not an integer comparison, is to reverse
4627          the comparison code.  Otherwise, swap the THEN-part and ELSE-part
4628          of the IF_THEN_ELSE.  If we can't do either, fail.  */
4629
4630       if (can_reverse_comparison_p (comp, insn)
4631           && validate_change (insn, &XEXP (x, 0),
4632                               gen_rtx_fmt_ee (reverse_condition (GET_CODE (comp)),
4633                                               GET_MODE (comp), XEXP (comp, 0),
4634                                               XEXP (comp, 1)), 0))
4635         return 1;
4636
4637       tem = XEXP (x, 1);
4638       validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
4639       validate_change (insn, &XEXP (x, 2), tem, 1);
4640       return apply_change_group ();
4641     }
4642
4643   fmt = GET_RTX_FORMAT (code);
4644   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4645     {
4646       if (fmt[i] == 'e')
4647         if (! invert_exp (XEXP (x, i), insn))
4648           return 0;
4649       if (fmt[i] == 'E')
4650         {
4651           register int j;
4652           for (j = 0; j < XVECLEN (x, i); j++)
4653             if (!invert_exp (XVECEXP (x, i, j), insn))
4654               return 0;
4655         }
4656     }
4657
4658   return 1;
4659 }
4660 \f
4661 /* Make jump JUMP jump to label NLABEL instead of where it jumps now.
4662    If the old jump target label is unused as a result,
4663    it and the code following it may be deleted.
4664
4665    If NLABEL is zero, we are to turn the jump into a (possibly conditional)
4666    RETURN insn.
4667
4668    The return value will be 1 if the change was made, 0 if it wasn't (this
4669    can only occur for NLABEL == 0).  */
4670
4671 int
4672 redirect_jump (jump, nlabel)
4673      rtx jump, nlabel;
4674 {
4675   register rtx olabel = JUMP_LABEL (jump);
4676
4677   if (nlabel == olabel)
4678     return 1;
4679
4680   if (! redirect_exp (&PATTERN (jump), olabel, nlabel, jump))
4681     return 0;
4682
4683   /* If this is an unconditional branch, delete it from the jump_chain of
4684      OLABEL and add it to the jump_chain of NLABEL (assuming both labels
4685      have UID's in range and JUMP_CHAIN is valid).  */
4686   if (jump_chain && (simplejump_p (jump)
4687                      || GET_CODE (PATTERN (jump)) == RETURN))
4688     {
4689       int label_index = nlabel ? INSN_UID (nlabel) : 0;
4690
4691       delete_from_jump_chain (jump);
4692       if (label_index < max_jump_chain
4693           && INSN_UID (jump) < max_jump_chain)
4694         {
4695           jump_chain[INSN_UID (jump)] = jump_chain[label_index];
4696           jump_chain[label_index] = jump;
4697         }
4698     }
4699
4700   JUMP_LABEL (jump) = nlabel;
4701   if (nlabel)
4702     ++LABEL_NUSES (nlabel);
4703
4704   if (olabel && --LABEL_NUSES (olabel) == 0)
4705     delete_insn (olabel);
4706
4707   return 1;
4708 }
4709
4710 /* Delete the instruction JUMP from any jump chain it might be on.  */
4711
4712 static void
4713 delete_from_jump_chain (jump)
4714      rtx jump;
4715 {
4716   int index;
4717   rtx olabel = JUMP_LABEL (jump);
4718
4719   /* Handle unconditional jumps.  */
4720   if (jump_chain && olabel != 0
4721       && INSN_UID (olabel) < max_jump_chain
4722       && simplejump_p (jump))
4723     index = INSN_UID (olabel);
4724   /* Handle return insns.  */
4725   else if (jump_chain && GET_CODE (PATTERN (jump)) == RETURN)
4726     index = 0;
4727   else return;
4728
4729   if (jump_chain[index] == jump)
4730     jump_chain[index] = jump_chain[INSN_UID (jump)];
4731   else
4732     {
4733       rtx insn;
4734
4735       for (insn = jump_chain[index];
4736            insn != 0;
4737            insn = jump_chain[INSN_UID (insn)])
4738         if (jump_chain[INSN_UID (insn)] == jump)
4739           {
4740             jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (jump)];
4741             break;
4742           }
4743     }
4744 }
4745
4746 /* If NLABEL is nonzero, throughout the rtx at LOC,
4747    alter (LABEL_REF OLABEL) to (LABEL_REF NLABEL).  If OLABEL is
4748    zero, alter (RETURN) to (LABEL_REF NLABEL).
4749
4750    If NLABEL is zero, alter (LABEL_REF OLABEL) to (RETURN) and check
4751    validity with validate_change.  Convert (set (pc) (label_ref olabel))
4752    to (return).
4753
4754    Return 0 if we found a change we would like to make but it is invalid.
4755    Otherwise, return 1.  */
4756
4757 int
4758 redirect_exp (loc, olabel, nlabel, insn)
4759      rtx *loc;
4760      rtx olabel, nlabel;
4761      rtx insn;
4762 {
4763   register rtx x = *loc;
4764   register RTX_CODE code = GET_CODE (x);
4765   register int i;
4766   register const char *fmt;
4767
4768   if (code == LABEL_REF)
4769     {
4770       if (XEXP (x, 0) == olabel)
4771         {
4772           if (nlabel)
4773             XEXP (x, 0) = nlabel;
4774           else
4775             return validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 0);
4776           return 1;
4777         }
4778     }
4779   else if (code == RETURN && olabel == 0)
4780     {
4781       x = gen_rtx_LABEL_REF (VOIDmode, nlabel);
4782       if (loc == &PATTERN (insn))
4783         x = gen_rtx_SET (VOIDmode, pc_rtx, x);
4784       return validate_change (insn, loc, x, 0);
4785     }
4786
4787   if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
4788       && GET_CODE (SET_SRC (x)) == LABEL_REF
4789       && XEXP (SET_SRC (x), 0) == olabel)
4790     return validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 0);
4791
4792   fmt = GET_RTX_FORMAT (code);
4793   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4794     {
4795       if (fmt[i] == 'e')
4796         if (! redirect_exp (&XEXP (x, i), olabel, nlabel, insn))
4797           return 0;
4798       if (fmt[i] == 'E')
4799         {
4800           register int j;
4801           for (j = 0; j < XVECLEN (x, i); j++)
4802             if (! redirect_exp (&XVECEXP (x, i, j), olabel, nlabel, insn))
4803               return 0;
4804         }
4805     }
4806
4807   return 1;
4808 }
4809 \f
4810 /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
4811
4812    If the old jump target label (before the dispatch table) becomes unused,
4813    it and the dispatch table may be deleted.  In that case, find the insn
4814    before the jump references that label and delete it and logical successors
4815    too.  */
4816
4817 static void
4818 redirect_tablejump (jump, nlabel)
4819      rtx jump, nlabel;
4820 {
4821   register rtx olabel = JUMP_LABEL (jump);
4822
4823   /* Add this jump to the jump_chain of NLABEL.  */
4824   if (jump_chain && INSN_UID (nlabel) < max_jump_chain
4825       && INSN_UID (jump) < max_jump_chain)
4826     {
4827       jump_chain[INSN_UID (jump)] = jump_chain[INSN_UID (nlabel)];
4828       jump_chain[INSN_UID (nlabel)] = jump;
4829     }
4830
4831   PATTERN (jump) = gen_jump (nlabel);
4832   JUMP_LABEL (jump) = nlabel;
4833   ++LABEL_NUSES (nlabel);
4834   INSN_CODE (jump) = -1;
4835
4836   if (--LABEL_NUSES (olabel) == 0)
4837     {
4838       delete_labelref_insn (jump, olabel, 0);
4839       delete_insn (olabel);
4840     }
4841 }
4842
4843 /* Find the insn referencing LABEL that is a logical predecessor of INSN.
4844    If we found one, delete it and then delete this insn if DELETE_THIS is
4845    non-zero.  Return non-zero if INSN or a predecessor references LABEL.  */
4846
4847 static int
4848 delete_labelref_insn (insn, label, delete_this)
4849      rtx insn, label;
4850      int delete_this;
4851 {
4852   int deleted = 0;
4853   rtx link;
4854
4855   if (GET_CODE (insn) != NOTE
4856       && reg_mentioned_p (label, PATTERN (insn)))
4857     {
4858       if (delete_this)
4859         {
4860           delete_insn (insn);
4861           deleted = 1;
4862         }
4863       else
4864         return 1;
4865     }
4866
4867   for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
4868     if (delete_labelref_insn (XEXP (link, 0), label, 1))
4869       {
4870         if (delete_this)
4871           {
4872             delete_insn (insn);
4873             deleted = 1;
4874           }
4875         else
4876           return 1;
4877       }
4878
4879   return deleted;
4880 }
4881 \f
4882 /* Like rtx_equal_p except that it considers two REGs as equal
4883    if they renumber to the same value and considers two commutative
4884    operations to be the same if the order of the operands has been
4885    reversed.
4886
4887    ??? Addition is not commutative on the PA due to the weird implicit
4888    space register selection rules for memory addresses.  Therefore, we
4889    don't consider a + b == b + a.
4890
4891    We could/should make this test a little tighter.  Possibly only
4892    disabling it on the PA via some backend macro or only disabling this
4893    case when the PLUS is inside a MEM.  */
4894
4895 int
4896 rtx_renumbered_equal_p (x, y)
4897      rtx x, y;
4898 {
4899   register int i;
4900   register RTX_CODE code = GET_CODE (x);
4901   register const char *fmt;
4902
4903   if (x == y)
4904     return 1;
4905
4906   if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
4907       && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
4908                                   && GET_CODE (SUBREG_REG (y)) == REG)))
4909     {
4910       int reg_x = -1, reg_y = -1;
4911       int word_x = 0, word_y = 0;
4912
4913       if (GET_MODE (x) != GET_MODE (y))
4914         return 0;
4915
4916       /* If we haven't done any renumbering, don't
4917          make any assumptions.  */
4918       if (reg_renumber == 0)
4919         return rtx_equal_p (x, y);
4920
4921       if (code == SUBREG)
4922         {
4923           reg_x = REGNO (SUBREG_REG (x));
4924           word_x = SUBREG_WORD (x);
4925
4926           if (reg_renumber[reg_x] >= 0)
4927             {
4928               reg_x = reg_renumber[reg_x] + word_x;
4929               word_x = 0;
4930             }
4931         }
4932
4933       else
4934         {
4935           reg_x = REGNO (x);
4936           if (reg_renumber[reg_x] >= 0)
4937             reg_x = reg_renumber[reg_x];
4938         }
4939
4940       if (GET_CODE (y) == SUBREG)
4941         {
4942           reg_y = REGNO (SUBREG_REG (y));
4943           word_y = SUBREG_WORD (y);
4944
4945           if (reg_renumber[reg_y] >= 0)
4946             {
4947               reg_y = reg_renumber[reg_y];
4948               word_y = 0;
4949             }
4950         }
4951
4952       else
4953         {
4954           reg_y = REGNO (y);
4955           if (reg_renumber[reg_y] >= 0)
4956             reg_y = reg_renumber[reg_y];
4957         }
4958
4959       return reg_x >= 0 && reg_x == reg_y && word_x == word_y;
4960     }
4961
4962   /* Now we have disposed of all the cases
4963      in which different rtx codes can match.  */
4964   if (code != GET_CODE (y))
4965     return 0;
4966
4967   switch (code)
4968     {
4969     case PC:
4970     case CC0:
4971     case ADDR_VEC:
4972     case ADDR_DIFF_VEC:
4973       return 0;
4974
4975     case CONST_INT:
4976       return INTVAL (x) == INTVAL (y);
4977
4978     case LABEL_REF:
4979       /* We can't assume nonlocal labels have their following insns yet.  */
4980       if (LABEL_REF_NONLOCAL_P (x) || LABEL_REF_NONLOCAL_P (y))
4981         return XEXP (x, 0) == XEXP (y, 0);
4982
4983       /* Two label-refs are equivalent if they point at labels
4984          in the same position in the instruction stream.  */
4985       return (next_real_insn (XEXP (x, 0))
4986               == next_real_insn (XEXP (y, 0)));
4987
4988     case SYMBOL_REF:
4989       return XSTR (x, 0) == XSTR (y, 0);
4990
4991     case CODE_LABEL:
4992       /* If we didn't match EQ equality above, they aren't the same.  */
4993       return 0;
4994
4995     default:
4996       break;
4997     }
4998
4999   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.  */
5000
5001   if (GET_MODE (x) != GET_MODE (y))
5002     return 0;
5003
5004   /* For commutative operations, the RTX match if the operand match in any
5005      order.  Also handle the simple binary and unary cases without a loop.
5006
5007      ??? Don't consider PLUS a commutative operator; see comments above.  */
5008   if ((code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
5009       && code != PLUS)
5010     return ((rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
5011              && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)))
5012             || (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 1))
5013                 && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 0))));
5014   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
5015     return (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
5016             && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)));
5017   else if (GET_RTX_CLASS (code) == '1')
5018     return rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0));
5019
5020   /* Compare the elements.  If any pair of corresponding elements
5021      fail to match, return 0 for the whole things.  */
5022
5023   fmt = GET_RTX_FORMAT (code);
5024   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5025     {
5026       register int j;
5027       switch (fmt[i])
5028         {
5029         case 'w':
5030           if (XWINT (x, i) != XWINT (y, i))
5031             return 0;
5032           break;
5033
5034         case 'i':
5035           if (XINT (x, i) != XINT (y, i))
5036             return 0;
5037           break;
5038
5039         case 's':
5040           if (strcmp (XSTR (x, i), XSTR (y, i)))
5041             return 0;
5042           break;
5043
5044         case 'e':
5045           if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
5046             return 0;
5047           break;
5048
5049         case 'u':
5050           if (XEXP (x, i) != XEXP (y, i))
5051             return 0;
5052           /* fall through.  */
5053         case '0':
5054           break;
5055
5056         case 'E':
5057           if (XVECLEN (x, i) != XVECLEN (y, i))
5058             return 0;
5059           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
5060             if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
5061               return 0;
5062           break;
5063
5064         default:
5065           abort ();
5066         }
5067     }
5068   return 1;
5069 }
5070 \f
5071 /* If X is a hard register or equivalent to one or a subregister of one,
5072    return the hard register number.  If X is a pseudo register that was not
5073    assigned a hard register, return the pseudo register number.  Otherwise,
5074    return -1.  Any rtx is valid for X.  */
5075
5076 int
5077 true_regnum (x)
5078      rtx x;
5079 {
5080   if (GET_CODE (x) == REG)
5081     {
5082       if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
5083         return reg_renumber[REGNO (x)];
5084       return REGNO (x);
5085     }
5086   if (GET_CODE (x) == SUBREG)
5087     {
5088       int base = true_regnum (SUBREG_REG (x));
5089       if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
5090         return SUBREG_WORD (x) + base;
5091     }
5092   return -1;
5093 }
5094 \f
5095 /* Optimize code of the form:
5096
5097         for (x = a[i]; x; ...)
5098           ...
5099         for (x = a[i]; x; ...)
5100           ...
5101       foo:
5102
5103    Loop optimize will change the above code into
5104
5105         if (x = a[i])
5106           for (;;)
5107              { ...; if (! (x = ...)) break; }
5108         if (x = a[i])
5109           for (;;)
5110              { ...; if (! (x = ...)) break; }
5111       foo:
5112
5113    In general, if the first test fails, the program can branch
5114    directly to `foo' and skip the second try which is doomed to fail.
5115    We run this after loop optimization and before flow analysis.  */
5116
5117 /* When comparing the insn patterns, we track the fact that different
5118    pseudo-register numbers may have been used in each computation.
5119    The following array stores an equivalence -- same_regs[I] == J means
5120    that pseudo register I was used in the first set of tests in a context
5121    where J was used in the second set.  We also count the number of such
5122    pending equivalences.  If nonzero, the expressions really aren't the
5123    same.  */
5124
5125 static int *same_regs;
5126
5127 static int num_same_regs;
5128
5129 /* Track any registers modified between the target of the first jump and
5130    the second jump.  They never compare equal.  */
5131
5132 static char *modified_regs;
5133
5134 /* Record if memory was modified.  */
5135
5136 static int modified_mem;
5137
5138 /* Called via note_stores on each insn between the target of the first
5139    branch and the second branch.  It marks any changed registers.  */
5140
5141 static void
5142 mark_modified_reg (dest, x, data)
5143      rtx dest;
5144      rtx x ATTRIBUTE_UNUSED;
5145      void *data ATTRIBUTE_UNUSED;
5146 {
5147   int regno, i;
5148
5149   if (GET_CODE (dest) == SUBREG)
5150     dest = SUBREG_REG (dest);
5151
5152   if (GET_CODE (dest) == MEM)
5153     modified_mem = 1;
5154
5155   if (GET_CODE (dest) != REG)
5156     return;
5157
5158   regno = REGNO (dest);
5159   if (regno >= FIRST_PSEUDO_REGISTER)
5160     modified_regs[regno] = 1;
5161   else
5162     for (i = 0; i < HARD_REGNO_NREGS (regno, GET_MODE (dest)); i++)
5163       modified_regs[regno + i] = 1;
5164 }
5165
5166 /* F is the first insn in the chain of insns.  */
5167
5168 void
5169 thread_jumps (f, max_reg, flag_before_loop)
5170      rtx f;
5171      int max_reg;
5172      int flag_before_loop;
5173 {
5174   /* Basic algorithm is to find a conditional branch,
5175      the label it may branch to, and the branch after
5176      that label.  If the two branches test the same condition,
5177      walk back from both branch paths until the insn patterns
5178      differ, or code labels are hit.  If we make it back to
5179      the target of the first branch, then we know that the first branch
5180      will either always succeed or always fail depending on the relative
5181      senses of the two branches.  So adjust the first branch accordingly
5182      in this case.  */
5183
5184   rtx label, b1, b2, t1, t2;
5185   enum rtx_code code1, code2;
5186   rtx b1op0, b1op1, b2op0, b2op1;
5187   int changed = 1;
5188   int i;
5189   int *all_reset;
5190
5191   /* Allocate register tables and quick-reset table.  */
5192   modified_regs = (char *) xmalloc (max_reg * sizeof (char));
5193   same_regs = (int *) xmalloc (max_reg * sizeof (int));
5194   all_reset = (int *) xmalloc (max_reg * sizeof (int));
5195   for (i = 0; i < max_reg; i++)
5196     all_reset[i] = -1;
5197
5198   while (changed)
5199     {
5200       changed = 0;
5201
5202       for (b1 = f; b1; b1 = NEXT_INSN (b1))
5203         {
5204           /* Get to a candidate branch insn.  */
5205           if (GET_CODE (b1) != JUMP_INSN
5206               || ! condjump_p (b1) || simplejump_p (b1)
5207               || JUMP_LABEL (b1) == 0)
5208             continue;
5209
5210           bzero (modified_regs, max_reg * sizeof (char));
5211           modified_mem = 0;
5212
5213           bcopy ((char *) all_reset, (char *) same_regs,
5214                  max_reg * sizeof (int));
5215           num_same_regs = 0;
5216
5217           label = JUMP_LABEL (b1);
5218
5219           /* Look for a branch after the target.  Record any registers and
5220              memory modified between the target and the branch.  Stop when we
5221              get to a label since we can't know what was changed there.  */
5222           for (b2 = NEXT_INSN (label); b2; b2 = NEXT_INSN (b2))
5223             {
5224               if (GET_CODE (b2) == CODE_LABEL)
5225                 break;
5226
5227               else if (GET_CODE (b2) == JUMP_INSN)
5228                 {
5229                   /* If this is an unconditional jump and is the only use of
5230                      its target label, we can follow it.  */
5231                   if (simplejump_p (b2)
5232                       && JUMP_LABEL (b2) != 0
5233                       && LABEL_NUSES (JUMP_LABEL (b2)) == 1)
5234                     {
5235                       b2 = JUMP_LABEL (b2);
5236                       continue;
5237                     }
5238                   else
5239                     break;
5240                 }
5241
5242               if (GET_CODE (b2) != CALL_INSN && GET_CODE (b2) != INSN)
5243                 continue;
5244
5245               if (GET_CODE (b2) == CALL_INSN)
5246                 {
5247                   modified_mem = 1;
5248                   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5249                     if (call_used_regs[i] && ! fixed_regs[i]
5250                         && i != STACK_POINTER_REGNUM
5251                         && i != FRAME_POINTER_REGNUM
5252                         && i != HARD_FRAME_POINTER_REGNUM
5253                         && i != ARG_POINTER_REGNUM)
5254                       modified_regs[i] = 1;
5255                 }
5256
5257               note_stores (PATTERN (b2), mark_modified_reg, NULL);
5258             }
5259
5260           /* Check the next candidate branch insn from the label
5261              of the first.  */
5262           if (b2 == 0
5263               || GET_CODE (b2) != JUMP_INSN
5264               || b2 == b1
5265               || ! condjump_p (b2)
5266               || simplejump_p (b2))
5267             continue;
5268
5269           /* Get the comparison codes and operands, reversing the
5270              codes if appropriate.  If we don't have comparison codes,
5271              we can't do anything.  */
5272           b1op0 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 0);
5273           b1op1 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 1);
5274           code1 = GET_CODE (XEXP (SET_SRC (PATTERN (b1)), 0));
5275           if (XEXP (SET_SRC (PATTERN (b1)), 1) == pc_rtx)
5276             code1 = reverse_condition (code1);
5277
5278           b2op0 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 0);
5279           b2op1 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 1);
5280           code2 = GET_CODE (XEXP (SET_SRC (PATTERN (b2)), 0));
5281           if (XEXP (SET_SRC (PATTERN (b2)), 1) == pc_rtx)
5282             code2 = reverse_condition (code2);
5283
5284           /* If they test the same things and knowing that B1 branches
5285              tells us whether or not B2 branches, check if we
5286              can thread the branch.  */
5287           if (rtx_equal_for_thread_p (b1op0, b2op0, b2)
5288               && rtx_equal_for_thread_p (b1op1, b2op1, b2)
5289               && (comparison_dominates_p (code1, code2)
5290                   || (comparison_dominates_p (code1, reverse_condition (code2))
5291                       && can_reverse_comparison_p (XEXP (SET_SRC (PATTERN (b1)),
5292                                                          0),
5293                                                    b1))))
5294             {
5295               t1 = prev_nonnote_insn (b1);
5296               t2 = prev_nonnote_insn (b2);
5297
5298               while (t1 != 0 && t2 != 0)
5299                 {
5300                   if (t2 == label)
5301                     {
5302                       /* We have reached the target of the first branch.
5303                          If there are no pending register equivalents,
5304                          we know that this branch will either always
5305                          succeed (if the senses of the two branches are
5306                          the same) or always fail (if not).  */
5307                       rtx new_label;
5308
5309                       if (num_same_regs != 0)
5310                         break;
5311
5312                       if (comparison_dominates_p (code1, code2))
5313                         new_label = JUMP_LABEL (b2);
5314                       else
5315                         new_label = get_label_after (b2);
5316
5317                       if (JUMP_LABEL (b1) != new_label)
5318                         {
5319                           rtx prev = PREV_INSN (new_label);
5320
5321                           if (flag_before_loop
5322                               && GET_CODE (prev) == NOTE
5323                               && NOTE_LINE_NUMBER (prev) == NOTE_INSN_LOOP_BEG)
5324                             {
5325                               /* Don't thread to the loop label.  If a loop
5326                                  label is reused, loop optimization will
5327                                  be disabled for that loop.  */
5328                               new_label = gen_label_rtx ();
5329                               emit_label_after (new_label, PREV_INSN (prev));
5330                             }
5331                           changed |= redirect_jump (b1, new_label);
5332                         }
5333                       break;
5334                     }
5335
5336                   /* If either of these is not a normal insn (it might be
5337                      a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail.  (NOTEs
5338                      have already been skipped above.)  Similarly, fail
5339                      if the insns are different.  */
5340                   if (GET_CODE (t1) != INSN || GET_CODE (t2) != INSN
5341                       || recog_memoized (t1) != recog_memoized (t2)
5342                       || ! rtx_equal_for_thread_p (PATTERN (t1),
5343                                                    PATTERN (t2), t2))
5344                     break;
5345
5346                   t1 = prev_nonnote_insn (t1);
5347                   t2 = prev_nonnote_insn (t2);
5348                 }
5349             }
5350         }
5351     }
5352
5353   /* Clean up.  */
5354   free (modified_regs);
5355   free (same_regs);
5356   free (all_reset);
5357 }
5358 \f
5359 /* This is like RTX_EQUAL_P except that it knows about our handling of
5360    possibly equivalent registers and knows to consider volatile and
5361    modified objects as not equal.
5362
5363    YINSN is the insn containing Y.  */
5364
5365 int
5366 rtx_equal_for_thread_p (x, y, yinsn)
5367      rtx x, y;
5368      rtx yinsn;
5369 {
5370   register int i;
5371   register int j;
5372   register enum rtx_code code;
5373   register const char *fmt;
5374
5375   code = GET_CODE (x);
5376   /* Rtx's of different codes cannot be equal.  */
5377   if (code != GET_CODE (y))
5378     return 0;
5379
5380   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
5381      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
5382
5383   if (GET_MODE (x) != GET_MODE (y))
5384     return 0;
5385
5386   /* For floating-point, consider everything unequal.  This is a bit
5387      pessimistic, but this pass would only rarely do anything for FP
5388      anyway.  */
5389   if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
5390       && FLOAT_MODE_P (GET_MODE (x)) && ! flag_fast_math)
5391     return 0;
5392
5393   /* For commutative operations, the RTX match if the operand match in any
5394      order.  Also handle the simple binary and unary cases without a loop.  */
5395   if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
5396     return ((rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn)
5397              && rtx_equal_for_thread_p (XEXP (x, 1), XEXP (y, 1), yinsn))
5398             || (rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 1), yinsn)
5399                 && rtx_equal_for_thread_p (XEXP (x, 1), XEXP (y, 0), yinsn)));
5400   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
5401     return (rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn)
5402             && rtx_equal_for_thread_p (XEXP (x, 1), XEXP (y, 1), yinsn));
5403   else if (GET_RTX_CLASS (code) == '1')
5404     return rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn);
5405
5406   /* Handle special-cases first.  */
5407   switch (code)
5408     {
5409     case REG:
5410       if (REGNO (x) == REGNO (y) && ! modified_regs[REGNO (x)])
5411         return 1;
5412
5413       /* If neither is user variable or hard register, check for possible
5414          equivalence.  */
5415       if (REG_USERVAR_P (x) || REG_USERVAR_P (y)
5416           || REGNO (x) < FIRST_PSEUDO_REGISTER
5417           || REGNO (y) < FIRST_PSEUDO_REGISTER)
5418         return 0;
5419
5420       if (same_regs[REGNO (x)] == -1)
5421         {
5422           same_regs[REGNO (x)] = REGNO (y);
5423           num_same_regs++;
5424
5425           /* If this is the first time we are seeing a register on the `Y'
5426              side, see if it is the last use.  If not, we can't thread the
5427              jump, so mark it as not equivalent.  */
5428           if (REGNO_LAST_UID (REGNO (y)) != INSN_UID (yinsn))
5429             return 0;
5430
5431           return 1;
5432         }
5433       else
5434         return (same_regs[REGNO (x)] == REGNO (y));
5435
5436       break;
5437
5438     case MEM:
5439       /* If memory modified or either volatile, not equivalent.
5440          Else, check address.  */
5441       if (modified_mem || MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
5442         return 0;
5443
5444       return rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn);
5445
5446     case ASM_INPUT:
5447       if (MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
5448         return 0;
5449
5450       break;
5451
5452     case SET:
5453       /* Cancel a pending `same_regs' if setting equivalenced registers.
5454          Then process source.  */
5455       if (GET_CODE (SET_DEST (x)) == REG
5456           && GET_CODE (SET_DEST (y)) == REG)
5457         {
5458           if (same_regs[REGNO (SET_DEST (x))] == REGNO (SET_DEST (y)))
5459             {
5460               same_regs[REGNO (SET_DEST (x))] = -1;
5461               num_same_regs--;
5462             }
5463           else if (REGNO (SET_DEST (x)) != REGNO (SET_DEST (y)))
5464             return 0;
5465         }
5466       else
5467         if (rtx_equal_for_thread_p (SET_DEST (x), SET_DEST (y), yinsn) == 0)
5468           return 0;
5469
5470       return rtx_equal_for_thread_p (SET_SRC (x), SET_SRC (y), yinsn);
5471
5472     case LABEL_REF:
5473       return XEXP (x, 0) == XEXP (y, 0);
5474
5475     case SYMBOL_REF:
5476       return XSTR (x, 0) == XSTR (y, 0);
5477
5478     default:
5479       break;
5480     }
5481
5482   if (x == y)
5483     return 1;
5484
5485   fmt = GET_RTX_FORMAT (code);
5486   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5487     {
5488       switch (fmt[i])
5489         {
5490         case 'w':
5491           if (XWINT (x, i) != XWINT (y, i))
5492             return 0;
5493           break;
5494
5495         case 'n':
5496         case 'i':
5497           if (XINT (x, i) != XINT (y, i))
5498             return 0;
5499           break;
5500
5501         case 'V':
5502         case 'E':
5503           /* Two vectors must have the same length.  */
5504           if (XVECLEN (x, i) != XVECLEN (y, i))
5505             return 0;
5506
5507           /* And the corresponding elements must match.  */
5508           for (j = 0; j < XVECLEN (x, i); j++)
5509             if (rtx_equal_for_thread_p (XVECEXP (x, i, j),
5510                                         XVECEXP (y, i, j), yinsn) == 0)
5511               return 0;
5512           break;
5513
5514         case 'e':
5515           if (rtx_equal_for_thread_p (XEXP (x, i), XEXP (y, i), yinsn) == 0)
5516             return 0;
5517           break;
5518
5519         case 'S':
5520         case 's':
5521           if (strcmp (XSTR (x, i), XSTR (y, i)))
5522             return 0;
5523           break;
5524
5525         case 'u':
5526           /* These are just backpointers, so they don't matter.  */
5527           break;
5528
5529         case '0':
5530         case 't':
5531           break;
5532
5533           /* It is believed that rtx's at this level will never
5534              contain anything but integers and other rtx's,
5535              except for within LABEL_REFs and SYMBOL_REFs.  */
5536         default:
5537           abort ();
5538         }
5539     }
5540   return 1;
5541 }
5542 \f
5543
5544 #if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
5545 /* Return the insn that NEW can be safely inserted in front of starting at
5546    the jump insn INSN.  Return 0 if it is not safe to do this jump
5547    optimization.  Note that NEW must contain a single set. */
5548
5549 static rtx
5550 find_insert_position (insn, new)
5551      rtx insn;
5552      rtx new;
5553 {
5554   int i;
5555   rtx prev;
5556
5557   /* If NEW does not clobber, it is safe to insert NEW before INSN. */
5558   if (GET_CODE (PATTERN (new)) != PARALLEL)
5559     return insn;
5560
5561   for (i = XVECLEN (PATTERN (new), 0) - 1; i >= 0; i--)
5562     if (GET_CODE (XVECEXP (PATTERN (new), 0, i)) == CLOBBER
5563         && reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0),
5564                                     insn))
5565       break;
5566
5567   if (i < 0)
5568     return insn;
5569
5570   /* There is a good chance that the previous insn PREV sets the thing
5571      being clobbered (often the CC in a hard reg).  If PREV does not
5572      use what NEW sets, we can insert NEW before PREV. */
5573
5574   prev = prev_active_insn (insn);
5575   for (i = XVECLEN (PATTERN (new), 0) - 1; i >= 0; i--)
5576     if (GET_CODE (XVECEXP (PATTERN (new), 0, i)) == CLOBBER
5577         && reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0),
5578                                     insn)
5579         && ! modified_in_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0),
5580                             prev))
5581       return 0;
5582
5583   return reg_mentioned_p (SET_DEST (single_set (new)), prev) ? 0 : prev;
5584 }
5585 #endif /* !HAVE_cc0 */