Return to jump.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/jump.c, revision 1.1

1.1     ! root        1: /* Optimize jump instructions, for GNU compiler.
        !             2:    Copyright (C) 1987, 88, 89, 91, 92, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: 
        !            21: /* This is the jump-optimization pass of the compiler.
        !            22:    It is run two or three times: once before cse, sometimes once after cse,
        !            23:    and once after reload (before final).
        !            24: 
        !            25:    jump_optimize deletes unreachable code and labels that are not used.
        !            26:    It also deletes jumps that jump to the following insn,
        !            27:    and simplifies jumps around unconditional jumps and jumps
        !            28:    to unconditional jumps.
        !            29: 
        !            30:    Each CODE_LABEL has a count of the times it is used
        !            31:    stored in the LABEL_NUSES internal field, and each JUMP_INSN
        !            32:    has one label that it refers to stored in the
        !            33:    JUMP_LABEL internal field.  With this we can detect labels that
        !            34:    become unused because of the deletion of all the jumps that
        !            35:    formerly used them.  The JUMP_LABEL info is sometimes looked
        !            36:    at by later passes.
        !            37: 
        !            38:    Optionally, cross-jumping can be done.  Currently it is done
        !            39:    only the last time (when after reload and before final).
        !            40:    In fact, the code for cross-jumping now assumes that register
        !            41:    allocation has been done, since it uses `rtx_renumbered_equal_p'.
        !            42: 
        !            43:    Jump optimization is done after cse when cse's constant-propagation
        !            44:    causes jumps to become unconditional or to be deleted.
        !            45: 
        !            46:    Unreachable loops are not detected here, because the labels
        !            47:    have references and the insns appear reachable from the labels.
        !            48:    find_basic_blocks in flow.c finds and deletes such loops.
        !            49: 
        !            50:    The subroutines delete_insn, redirect_jump, and invert_jump are used
        !            51:    from other passes as well.  */
        !            52: 
        !            53: #include "config.h"
        !            54: #include "rtl.h"
        !            55: #include "flags.h"
        !            56: #include "hard-reg-set.h"
        !            57: #include "regs.h"
        !            58: #include "expr.h"
        !            59: #include "insn-config.h"
        !            60: #include "insn-flags.h"
        !            61: #include "real.h"
        !            62: 
        !            63: /* ??? Eventually must record somehow the labels used by jumps
        !            64:    from nested functions.  */
        !            65: /* Pre-record the next or previous real insn for each label?
        !            66:    No, this pass is very fast anyway.  */
        !            67: /* Condense consecutive labels?
        !            68:    This would make life analysis faster, maybe.  */
        !            69: /* Optimize jump y; x: ... y: jumpif... x?
        !            70:    Don't know if it is worth bothering with.  */
        !            71: /* Optimize two cases of conditional jump to conditional jump?
        !            72:    This can never delete any instruction or make anything dead,
        !            73:    or even change what is live at any point.
        !            74:    So perhaps let combiner do it.  */
        !            75: 
        !            76: /* Vector indexed by uid.
        !            77:    For each CODE_LABEL, index by its uid to get first unconditional jump
        !            78:    that jumps to the label.
        !            79:    For each JUMP_INSN, index by its uid to get the next unconditional jump
        !            80:    that jumps to the same label.
        !            81:    Element 0 is the start of a chain of all return insns.
        !            82:    (It is safe to use element 0 because insn uid 0 is not used.  */
        !            83: 
        !            84: static rtx *jump_chain;
        !            85: 
        !            86: /* List of labels referred to from initializers.
        !            87:    These can never be deleted.  */
        !            88: rtx forced_labels;
        !            89: 
        !            90: /* Maximum index in jump_chain.  */
        !            91: 
        !            92: static int max_jump_chain;
        !            93: 
        !            94: /* Set nonzero by jump_optimize if control can fall through
        !            95:    to the end of the function.  */
        !            96: int can_reach_end;
        !            97: 
        !            98: /* Indicates whether death notes are significant in cross jump analysis.
        !            99:    Normally they are not significant, because of A and B jump to C,
        !           100:    and R dies in A, it must die in B.  But this might not be true after
        !           101:    stack register conversion, and we must compare death notes in that
        !           102:    case. */
        !           103: 
        !           104: static int cross_jump_death_matters = 0;
        !           105: 
        !           106: static int duplicate_loop_exit_test ();
        !           107: void redirect_tablejump ();
        !           108: static int delete_labelref_insn ();
        !           109: static void mark_jump_label ();
        !           110: void delete_jump ();
        !           111: void delete_computation ();
        !           112: static void delete_from_jump_chain ();
        !           113: static int tension_vector_labels ();
        !           114: static void find_cross_jump ();
        !           115: static void do_cross_jump ();
        !           116: static int jump_back_p ();
        !           117: 
        !           118: extern rtx gen_jump ();
        !           119: 
        !           120: /* Delete no-op jumps and optimize jumps to jumps
        !           121:    and jumps around jumps.
        !           122:    Delete unused labels and unreachable code.
        !           123: 
        !           124:    If CROSS_JUMP is 1, detect matching code
        !           125:    before a jump and its destination and unify them.
        !           126:    If CROSS_JUMP is 2, do cross-jumping, but pay attention to death notes.
        !           127: 
        !           128:    If NOOP_MOVES is nonzero, delete no-op move insns.
        !           129: 
        !           130:    If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
        !           131:    after regscan, and it is safe to use regno_first_uid and regno_last_uid.
        !           132: 
        !           133:    If `optimize' is zero, don't change any code,
        !           134:    just determine whether control drops off the end of the function.
        !           135:    This case occurs when we have -W and not -O.
        !           136:    It works because `delete_insn' checks the value of `optimize'
        !           137:    and refrains from actually deleting when that is 0.  */
        !           138: 
        !           139: void
        !           140: jump_optimize (f, cross_jump, noop_moves, after_regscan)
        !           141:      rtx f;
        !           142:      int cross_jump;
        !           143:      int noop_moves;
        !           144:      int after_regscan;
        !           145: {
        !           146:   register rtx insn, next;
        !           147:   int changed;
        !           148:   int first = 1;
        !           149:   int max_uid = 0;
        !           150:   rtx last_insn;
        !           151: 
        !           152:   cross_jump_death_matters = (cross_jump == 2);
        !           153: 
        !           154:   /* Initialize LABEL_NUSES and JUMP_LABEL fields.  */
        !           155: 
        !           156:   for (insn = f; insn; insn = NEXT_INSN (insn))
        !           157:     {
        !           158:       if (GET_CODE (insn) == CODE_LABEL)
        !           159:        LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
        !           160:       else if (GET_CODE (insn) == JUMP_INSN)
        !           161:        JUMP_LABEL (insn) = 0;
        !           162:       if (INSN_UID (insn) > max_uid)
        !           163:        max_uid = INSN_UID (insn);
        !           164:     }
        !           165: 
        !           166:   max_uid++;
        !           167: 
        !           168:   /* Delete insns following barriers, up to next label.  */
        !           169: 
        !           170:   for (insn = f; insn;)
        !           171:     {
        !           172:       if (GET_CODE (insn) == BARRIER)
        !           173:        {
        !           174:          insn = NEXT_INSN (insn);
        !           175:          while (insn != 0 && GET_CODE (insn) != CODE_LABEL)
        !           176:            {
        !           177:              if (GET_CODE (insn) == NOTE
        !           178:                  && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
        !           179:                insn = NEXT_INSN (insn);
        !           180:              else
        !           181:                insn = delete_insn (insn);
        !           182:            }
        !           183:          /* INSN is now the code_label.  */
        !           184:        }
        !           185:       else
        !           186:        insn = NEXT_INSN (insn);
        !           187:     }
        !           188: 
        !           189:   /* Leave some extra room for labels and duplicate exit test insns
        !           190:      we make.  */
        !           191:   max_jump_chain = max_uid * 14 / 10;
        !           192:   jump_chain = (rtx *) alloca (max_jump_chain * sizeof (rtx));
        !           193:   bzero (jump_chain, max_jump_chain * sizeof (rtx));
        !           194: 
        !           195:   /* Mark the label each jump jumps to.
        !           196:      Combine consecutive labels, and count uses of labels.
        !           197: 
        !           198:      For each label, make a chain (using `jump_chain')
        !           199:      of all the *unconditional* jumps that jump to it;
        !           200:      also make a chain of all returns.  */
        !           201: 
        !           202:   for (insn = f; insn; insn = NEXT_INSN (insn))
        !           203:     if ((GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == INSN
        !           204:         || GET_CODE (insn) == CALL_INSN)
        !           205:        && ! INSN_DELETED_P (insn))
        !           206:       {
        !           207:        mark_jump_label (PATTERN (insn), insn, cross_jump);
        !           208:        if (GET_CODE (insn) == JUMP_INSN)
        !           209:          {
        !           210:            if (JUMP_LABEL (insn) != 0 && simplejump_p (insn))
        !           211:              {
        !           212:                jump_chain[INSN_UID (insn)]
        !           213:                  = jump_chain[INSN_UID (JUMP_LABEL (insn))];
        !           214:                jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
        !           215:              }
        !           216:            if (GET_CODE (PATTERN (insn)) == RETURN)
        !           217:              {
        !           218:                jump_chain[INSN_UID (insn)] = jump_chain[0];
        !           219:                jump_chain[0] = insn;
        !           220:              }
        !           221:          }
        !           222:       }
        !           223: 
        !           224:   /* Keep track of labels used from static data;
        !           225:      they cannot ever be deleted.  */
        !           226: 
        !           227:   for (insn = forced_labels; insn; insn = XEXP (insn, 1))
        !           228:     LABEL_NUSES (XEXP (insn, 0))++;
        !           229: 
        !           230:   /* Delete all labels already not referenced.
        !           231:      Also find the last insn.  */
        !           232: 
        !           233:   last_insn = 0;
        !           234:   for (insn = f; insn; )
        !           235:     {
        !           236:       if (GET_CODE (insn) == CODE_LABEL && LABEL_NUSES (insn) == 0)
        !           237:        insn = delete_insn (insn);
        !           238:       else
        !           239:        {
        !           240:          last_insn = insn;
        !           241:          insn = NEXT_INSN (insn);
        !           242:        }
        !           243:     }
        !           244: 
        !           245:   if (!optimize)
        !           246:     {
        !           247:       /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
        !           248:         If so record that this function can drop off the end.  */
        !           249: 
        !           250:       insn = last_insn;
        !           251:       {
        !           252:        int n_labels = 1;
        !           253:        while (insn
        !           254:               /* One label can follow the end-note: the return label.  */
        !           255:               && ((GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
        !           256:                   /* Ordinary insns can follow it if returning a structure.  */
        !           257:                   || GET_CODE (insn) == INSN
        !           258:                   /* If machine uses explicit RETURN insns, no epilogue,
        !           259:                      then one of them follows the note.  */
        !           260:                   || (GET_CODE (insn) == JUMP_INSN
        !           261:                       && GET_CODE (PATTERN (insn)) == RETURN)
        !           262:                   /* Other kinds of notes can follow also.  */
        !           263:                   || (GET_CODE (insn) == NOTE
        !           264:                       && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)))
        !           265:          insn = PREV_INSN (insn);
        !           266:       }
        !           267: 
        !           268:       /* Report if control can fall through at the end of the function.  */
        !           269:       if (insn && GET_CODE (insn) == NOTE
        !           270:          && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END
        !           271:          && ! INSN_DELETED_P (insn))
        !           272:        can_reach_end = 1;
        !           273: 
        !           274:       /* Zero the "deleted" flag of all the "deleted" insns.  */
        !           275:       for (insn = f; insn; insn = NEXT_INSN (insn))
        !           276:        INSN_DELETED_P (insn) = 0;
        !           277:       return;
        !           278:     }
        !           279: 
        !           280: #ifdef HAVE_return
        !           281:   if (HAVE_return)
        !           282:     {
        !           283:       /* If we fall through to the epilogue, see if we can insert a RETURN insn
        !           284:         in front of it.  If the machine allows it at this point (we might be
        !           285:         after reload for a leaf routine), it will improve optimization for it
        !           286:         to be there.  */
        !           287:       insn = get_last_insn ();
        !           288:       while (insn && GET_CODE (insn) == NOTE)
        !           289:        insn = PREV_INSN (insn);
        !           290: 
        !           291:       if (insn && GET_CODE (insn) != BARRIER)
        !           292:        {
        !           293:          emit_jump_insn (gen_return ());
        !           294:          emit_barrier ();
        !           295:        }
        !           296:     }
        !           297: #endif
        !           298: 
        !           299:   if (noop_moves)
        !           300:     for (insn = f; insn; )
        !           301:       {
        !           302:        next = NEXT_INSN (insn);
        !           303: 
        !           304:        if (GET_CODE (insn) == INSN)
        !           305:          {
        !           306:            register rtx body = PATTERN (insn);
        !           307: 
        !           308: /* Combine stack_adjusts with following push_insns.  */
        !           309: #ifdef PUSH_ROUNDING
        !           310:            if (GET_CODE (body) == SET
        !           311:                && SET_DEST (body) == stack_pointer_rtx
        !           312:                && GET_CODE (SET_SRC (body)) == PLUS
        !           313:                && XEXP (SET_SRC (body), 0) == stack_pointer_rtx
        !           314:                && GET_CODE (XEXP (SET_SRC (body), 1)) == CONST_INT
        !           315:                && INTVAL (XEXP (SET_SRC (body), 1)) > 0)
        !           316:              {
        !           317:                rtx p;
        !           318:                rtx stack_adjust_insn = insn;
        !           319:                int stack_adjust_amount = INTVAL (XEXP (SET_SRC (body), 1));
        !           320:                int total_pushed = 0;
        !           321:                int pushes = 0;
        !           322: 
        !           323:                /* Find all successive push insns.  */
        !           324:                p = insn;
        !           325:                /* Don't convert more than three pushes;
        !           326:                   that starts adding too many displaced addresses
        !           327:                   and the whole thing starts becoming a losing
        !           328:                   proposition.  */
        !           329:                while (pushes < 3)
        !           330:                  {
        !           331:                    rtx pbody, dest;
        !           332:                    p = next_nonnote_insn (p);
        !           333:                    if (p == 0 || GET_CODE (p) != INSN)
        !           334:                      break;
        !           335:                    pbody = PATTERN (p);
        !           336:                    if (GET_CODE (pbody) != SET)
        !           337:                      break;
        !           338:                    dest = SET_DEST (pbody);
        !           339:                    /* Allow a no-op move between the adjust and the push.  */
        !           340:                    if (GET_CODE (dest) == REG
        !           341:                        && GET_CODE (SET_SRC (pbody)) == REG
        !           342:                        && REGNO (dest) == REGNO (SET_SRC (pbody)))
        !           343:                      continue;
        !           344:                    if (! (GET_CODE (dest) == MEM
        !           345:                           && GET_CODE (XEXP (dest, 0)) == POST_INC
        !           346:                           && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
        !           347:                      break;
        !           348:                    pushes++;
        !           349:                    if (total_pushed + GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)))
        !           350:                        > stack_adjust_amount)
        !           351:                      break;
        !           352:                    total_pushed += GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)));
        !           353:                  }
        !           354: 
        !           355:                /* Discard the amount pushed from the stack adjust;
        !           356:                   maybe eliminate it entirely.  */
        !           357:                if (total_pushed >= stack_adjust_amount)
        !           358:                  {
        !           359:                    delete_insn (stack_adjust_insn);
        !           360:                    total_pushed = stack_adjust_amount;
        !           361:                  }
        !           362:                else
        !           363:                  XEXP (SET_SRC (PATTERN (stack_adjust_insn)), 1)
        !           364:                    = GEN_INT (stack_adjust_amount - total_pushed);
        !           365: 
        !           366:                /* Change the appropriate push insns to ordinary stores.  */
        !           367:                p = insn;
        !           368:                while (total_pushed > 0)
        !           369:                  {
        !           370:                    rtx pbody, dest;
        !           371:                    p = next_nonnote_insn (p);
        !           372:                    if (GET_CODE (p) != INSN)
        !           373:                      break;
        !           374:                    pbody = PATTERN (p);
        !           375:                    if (GET_CODE (pbody) == SET)
        !           376:                      break;
        !           377:                    dest = SET_DEST (pbody);
        !           378:                    if (! (GET_CODE (dest) == MEM
        !           379:                           && GET_CODE (XEXP (dest, 0)) == POST_INC
        !           380:                           && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
        !           381:                      break;
        !           382:                    total_pushed -= GET_MODE_SIZE (GET_MODE (SET_DEST (pbody)));
        !           383:                    /* If this push doesn't fully fit in the space
        !           384:                       of the stack adjust that we deleted,
        !           385:                       make another stack adjust here for what we
        !           386:                       didn't use up.  There should be peepholes
        !           387:                       to recognize the resulting sequence of insns.  */
        !           388:                    if (total_pushed < 0)
        !           389:                      {
        !           390:                        emit_insn_before (gen_add2_insn (stack_pointer_rtx,
        !           391:                                                         GEN_INT (- total_pushed)),
        !           392:                                          p);
        !           393:                        break;
        !           394:                      }
        !           395:                    XEXP (dest, 0)
        !           396:                      = plus_constant (stack_pointer_rtx, total_pushed);
        !           397:                  }
        !           398:              }
        !           399: #endif
        !           400: 
        !           401:            /* Detect and delete no-op move instructions
        !           402:               resulting from not allocating a parameter in a register.  */
        !           403: 
        !           404:            if (GET_CODE (body) == SET
        !           405:                && (SET_DEST (body) == SET_SRC (body)
        !           406:                    || (GET_CODE (SET_DEST (body)) == MEM
        !           407:                        && GET_CODE (SET_SRC (body)) == MEM
        !           408:                        && rtx_equal_p (SET_SRC (body), SET_DEST (body))))
        !           409:                && ! (GET_CODE (SET_DEST (body)) == MEM
        !           410:                      && MEM_VOLATILE_P (SET_DEST (body)))
        !           411:                && ! (GET_CODE (SET_SRC (body)) == MEM
        !           412:                      && MEM_VOLATILE_P (SET_SRC (body))))
        !           413:              delete_insn (insn);
        !           414: 
        !           415:            /* Detect and ignore no-op move instructions
        !           416:               resulting from smart or fortuitous register allocation.  */
        !           417: 
        !           418:            else if (GET_CODE (body) == SET)
        !           419:              {
        !           420:                int sreg = true_regnum (SET_SRC (body));
        !           421:                int dreg = true_regnum (SET_DEST (body));
        !           422: 
        !           423:                if (sreg == dreg && sreg >= 0)
        !           424:                  delete_insn (insn);
        !           425:                else if (sreg >= 0 && dreg >= 0)
        !           426:                  {
        !           427:                    rtx trial;
        !           428:                    rtx tem = find_equiv_reg (NULL_RTX, insn, 0,
        !           429:                                              sreg, NULL_PTR, dreg,
        !           430:                                              GET_MODE (SET_SRC (body)));
        !           431: 
        !           432: #ifdef PRESERVE_DEATH_INFO_REGNO_P
        !           433:                    /* Deleting insn could lose a death-note for SREG or DREG
        !           434:                       so don't do it if final needs accurate death-notes.  */
        !           435:                    if (! PRESERVE_DEATH_INFO_REGNO_P (sreg)
        !           436:                        && ! PRESERVE_DEATH_INFO_REGNO_P (dreg))
        !           437: #endif
        !           438:                      {
        !           439:                        /* DREG may have been the target of a REG_DEAD note in
        !           440:                           the insn which makes INSN redundant.  If so, reorg
        !           441:                           would still think it is dead.  So search for such a
        !           442:                           note and delete it if we find it.  */
        !           443:                        for (trial = prev_nonnote_insn (insn);
        !           444:                             trial && GET_CODE (trial) != CODE_LABEL;
        !           445:                             trial = prev_nonnote_insn (trial))
        !           446:                          if (find_regno_note (trial, REG_DEAD, dreg))
        !           447:                            {
        !           448:                              remove_death (dreg, trial);
        !           449:                              break;
        !           450:                            }
        !           451: 
        !           452:                        if (tem != 0
        !           453:                            && GET_MODE (tem) == GET_MODE (SET_DEST (body)))
        !           454:                          delete_insn (insn);
        !           455:                      }
        !           456:                  }
        !           457:                else if (dreg >= 0 && CONSTANT_P (SET_SRC (body))
        !           458:                         && find_equiv_reg (SET_SRC (body), insn, 0, dreg,
        !           459:                                            NULL_PTR, 0,
        !           460:                                            GET_MODE (SET_DEST (body))))
        !           461:                  {
        !           462:                    /* This handles the case where we have two consecutive
        !           463:                       assignments of the same constant to pseudos that didn't
        !           464:                       get a hard reg.  Each SET from the constant will be
        !           465:                       converted into a SET of the spill register and an
        !           466:                       output reload will be made following it.  This produces
        !           467:                       two loads of the same constant into the same spill
        !           468:                       register.  */
        !           469: 
        !           470:                    rtx in_insn = insn;
        !           471: 
        !           472:                    /* Look back for a death note for the first reg.
        !           473:                       If there is one, it is no longer accurate.  */
        !           474:                    while (in_insn && GET_CODE (in_insn) != CODE_LABEL)
        !           475:                      {
        !           476:                        if ((GET_CODE (in_insn) == INSN
        !           477:                             || GET_CODE (in_insn) == JUMP_INSN)
        !           478:                            && find_regno_note (in_insn, REG_DEAD, dreg))
        !           479:                          {
        !           480:                            remove_death (dreg, in_insn);
        !           481:                            break;
        !           482:                          }
        !           483:                        in_insn = PREV_INSN (in_insn);
        !           484:                      }
        !           485: 
        !           486:                    /* Delete the second load of the value.  */
        !           487:                    delete_insn (insn);
        !           488:                  }
        !           489:              }
        !           490:            else if (GET_CODE (body) == PARALLEL)
        !           491:              {
        !           492:                /* If each part is a set between two identical registers or
        !           493:                   a USE or CLOBBER, delete the insn. */
        !           494:                int i, sreg, dreg;
        !           495:                rtx tem;
        !           496: 
        !           497:                for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
        !           498:                  {
        !           499:                    tem = XVECEXP (body, 0, i);
        !           500:                    if (GET_CODE (tem) == USE || GET_CODE (tem) == CLOBBER)
        !           501:                      continue;
        !           502: 
        !           503:                    if (GET_CODE (tem) != SET
        !           504:                        || (sreg = true_regnum (SET_SRC (tem))) < 0
        !           505:                        || (dreg = true_regnum (SET_DEST (tem))) < 0
        !           506:                        || dreg != sreg)
        !           507:                      break;
        !           508:                  }
        !           509:                  
        !           510:                if (i < 0)
        !           511:                  delete_insn (insn);
        !           512:              }
        !           513: #if !BYTES_BIG_ENDIAN /* Not worth the hair to detect this
        !           514:                         in the big-endian case.  */
        !           515:            /* Also delete insns to store bit fields if they are no-ops.  */
        !           516:            else if (GET_CODE (body) == SET
        !           517:                     && GET_CODE (SET_DEST (body)) == ZERO_EXTRACT
        !           518:                     && XEXP (SET_DEST (body), 2) == const0_rtx
        !           519:                     && XEXP (SET_DEST (body), 0) == SET_SRC (body)
        !           520:                     && ! (GET_CODE (SET_SRC (body)) == MEM
        !           521:                           && MEM_VOLATILE_P (SET_SRC (body))))
        !           522:              delete_insn (insn);
        !           523: #endif /* not BYTES_BIG_ENDIAN */
        !           524:          }
        !           525:       insn = next;
        !           526:     }
        !           527: 
        !           528:   /* If we haven't yet gotten to reload and we have just run regscan,
        !           529:      delete any insn that sets a register that isn't used elsewhere.
        !           530:      This helps some of the optimizations below by having less insns
        !           531:      being jumped around.  */
        !           532: 
        !           533:   if (! reload_completed && after_regscan)
        !           534:     for (insn = f; insn; insn = next)
        !           535:       {
        !           536:        rtx set = single_set (insn);
        !           537: 
        !           538:        next = NEXT_INSN (insn);
        !           539: 
        !           540:        if (set && GET_CODE (SET_DEST (set)) == REG
        !           541:            && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
        !           542:            && regno_first_uid[REGNO (SET_DEST (set))] == INSN_UID (insn)
        !           543:            /* We use regno_last_note_uid so as not to delete the setting
        !           544:               of a reg that's used in notes.  A subsequent optimization
        !           545:               might arrange to use that reg for real.  */             
        !           546:            && regno_last_note_uid[REGNO (SET_DEST (set))] == INSN_UID (insn)
        !           547:            && ! side_effects_p (SET_SRC (set)))
        !           548:          delete_insn (insn);
        !           549:       }
        !           550: 
        !           551:   /* Now iterate optimizing jumps until nothing changes over one pass.  */
        !           552:   changed = 1;
        !           553:   while (changed)
        !           554:     {
        !           555:       changed = 0;
        !           556: 
        !           557:       for (insn = f; insn; insn = next)
        !           558:        {
        !           559:          rtx reallabelprev;
        !           560:          rtx temp, temp1, temp2, temp3, temp4, temp5, temp6;
        !           561:          rtx nlabel;
        !           562:          int this_is_simplejump, this_is_condjump, reversep;
        !           563: #if 0
        !           564:          /* If NOT the first iteration, if this is the last jump pass
        !           565:             (just before final), do the special peephole optimizations.
        !           566:             Avoiding the first iteration gives ordinary jump opts
        !           567:             a chance to work before peephole opts.  */
        !           568: 
        !           569:          if (reload_completed && !first && !flag_no_peephole)
        !           570:            if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
        !           571:              peephole (insn);
        !           572: #endif
        !           573: 
        !           574:          /* That could have deleted some insns after INSN, so check now
        !           575:             what the following insn is.  */
        !           576: 
        !           577:          next = NEXT_INSN (insn);
        !           578: 
        !           579:          /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
        !           580:             jump.  Try to optimize by duplicating the loop exit test if so.
        !           581:             This is only safe immediately after regscan, because it uses
        !           582:             the values of regno_first_uid and regno_last_uid.  */
        !           583:          if (after_regscan && GET_CODE (insn) == NOTE
        !           584:              && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
        !           585:              && (temp1 = next_nonnote_insn (insn)) != 0
        !           586:              && simplejump_p (temp1))
        !           587:            {
        !           588:              temp = PREV_INSN (insn);
        !           589:              if (duplicate_loop_exit_test (insn))
        !           590:                {
        !           591:                  changed = 1;
        !           592:                  next = NEXT_INSN (temp);
        !           593:                  continue;
        !           594:                }
        !           595:            }
        !           596: 
        !           597:          if (GET_CODE (insn) != JUMP_INSN)
        !           598:            continue;
        !           599: 
        !           600:          this_is_simplejump = simplejump_p (insn);
        !           601:          this_is_condjump = condjump_p (insn);
        !           602: 
        !           603:          /* Tension the labels in dispatch tables.  */
        !           604: 
        !           605:          if (GET_CODE (PATTERN (insn)) == ADDR_VEC)
        !           606:            changed |= tension_vector_labels (PATTERN (insn), 0);
        !           607:          if (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
        !           608:            changed |= tension_vector_labels (PATTERN (insn), 1);
        !           609: 
        !           610:          /* If a dispatch table always goes to the same place,
        !           611:             get rid of it and replace the insn that uses it.  */
        !           612: 
        !           613:          if (GET_CODE (PATTERN (insn)) == ADDR_VEC
        !           614:              || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
        !           615:            {
        !           616:              int i;
        !           617:              rtx pat = PATTERN (insn);
        !           618:              int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC;
        !           619:              int len = XVECLEN (pat, diff_vec_p);
        !           620:              rtx dispatch = prev_real_insn (insn);
        !           621: 
        !           622:              for (i = 0; i < len; i++)
        !           623:                if (XEXP (XVECEXP (pat, diff_vec_p, i), 0)
        !           624:                    != XEXP (XVECEXP (pat, diff_vec_p, 0), 0))
        !           625:                  break;
        !           626:              if (i == len
        !           627:                  && dispatch != 0
        !           628:                  && GET_CODE (dispatch) == JUMP_INSN
        !           629:                  && JUMP_LABEL (dispatch) != 0
        !           630:                  /* Don't mess with a casesi insn.  */
        !           631:                  && !(GET_CODE (PATTERN (dispatch)) == SET
        !           632:                       && (GET_CODE (SET_SRC (PATTERN (dispatch)))
        !           633:                           == IF_THEN_ELSE))
        !           634:                  && next_real_insn (JUMP_LABEL (dispatch)) == insn)
        !           635:                {
        !           636:                  redirect_tablejump (dispatch,
        !           637:                                      XEXP (XVECEXP (pat, diff_vec_p, 0), 0));
        !           638:                  changed = 1;
        !           639:                }
        !           640:            }
        !           641: 
        !           642:          reallabelprev = prev_active_insn (JUMP_LABEL (insn));
        !           643: 
        !           644:          /* If a jump references the end of the function, try to turn
        !           645:             it into a RETURN insn, possibly a conditional one.  */
        !           646:          if (JUMP_LABEL (insn)
        !           647:              && (next_active_insn (JUMP_LABEL (insn)) == 0
        !           648:                  || GET_CODE (PATTERN (next_active_insn (JUMP_LABEL (insn))))
        !           649:                      == RETURN))
        !           650:            changed |= redirect_jump (insn, NULL_RTX);
        !           651: 
        !           652:          /* Detect jump to following insn.  */
        !           653:          if (reallabelprev == insn && condjump_p (insn))
        !           654:            {
        !           655:              delete_jump (insn);
        !           656:              changed = 1;
        !           657:              continue;
        !           658:            }
        !           659: 
        !           660:          /* If we have an unconditional jump preceded by a USE, try to put
        !           661:             the USE before the target and jump there.  This simplifies many
        !           662:             of the optimizations below since we don't have to worry about
        !           663:             dealing with these USE insns.  We only do this if the label
        !           664:             being branch to already has the identical USE or if code
        !           665:             never falls through to that label.  */
        !           666: 
        !           667:          if (this_is_simplejump
        !           668:              && (temp = prev_nonnote_insn (insn)) != 0
        !           669:              && GET_CODE (temp) == INSN && GET_CODE (PATTERN (temp)) == USE
        !           670:              && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
        !           671:              && (GET_CODE (temp1) == BARRIER
        !           672:                  || (GET_CODE (temp1) == INSN
        !           673:                      && rtx_equal_p (PATTERN (temp), PATTERN (temp1)))))
        !           674:            {
        !           675:              if (GET_CODE (temp1) == BARRIER)
        !           676:                {
        !           677:                  emit_insn_after (PATTERN (temp), temp1);
        !           678:                  temp1 = NEXT_INSN (temp1);
        !           679:                }
        !           680: 
        !           681:              delete_insn (temp);
        !           682:              redirect_jump (insn, get_label_before (temp1));
        !           683:              reallabelprev = prev_real_insn (temp1);
        !           684:              changed = 1;
        !           685:            }
        !           686: 
        !           687:          /* Simplify   if (...) x = a; else x = b; by converting it
        !           688:             to         x = b; if (...) x = a;
        !           689:             if B is sufficiently simple, the test doesn't involve X,
        !           690:             and nothing in the test modifies B or X.
        !           691: 
        !           692:             If we have small register classes, we also can't do this if X
        !           693:             is a hard register.
        !           694: 
        !           695:             If the "x = b;" insn has any REG_NOTES, we don't do this because
        !           696:             of the possibility that we are running after CSE and there is a
        !           697:             REG_EQUAL note that is only valid if the branch has already been
        !           698:             taken.  If we move the insn with the REG_EQUAL note, we may
        !           699:             fold the comparison to always be false in a later CSE pass.
        !           700:             (We could also delete the REG_NOTES when moving the insn, but it
        !           701:             seems simpler to not move it.)  An exception is that we can move
        !           702:             the insn if the only note is a REG_EQUAL or REG_EQUIV whose
        !           703:             value is the same as "b".
        !           704: 
        !           705:             INSN is the branch over the `else' part. 
        !           706: 
        !           707:             We set:
        !           708: 
        !           709:             TEMP to the jump insn preceding "x = a;"
        !           710:             TEMP1 to X
        !           711:             TEMP2 to the insn that sets "x = b;"
        !           712:             TEMP3 to the insn that sets "x = a;"
        !           713:             TEMP4 to the set of "x = b";  */
        !           714: 
        !           715:          if (this_is_simplejump
        !           716:              && (temp3 = prev_active_insn (insn)) != 0
        !           717:              && GET_CODE (temp3) == INSN
        !           718:              && (temp4 = single_set (temp3)) != 0
        !           719:              && GET_CODE (temp1 = SET_DEST (temp4)) == REG
        !           720: #ifdef SMALL_REGISTER_CLASSES
        !           721:              && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
        !           722: #endif
        !           723:              && (temp2 = next_active_insn (insn)) != 0
        !           724:              && GET_CODE (temp2) == INSN
        !           725:              && (temp4 = single_set (temp2)) != 0
        !           726:              && rtx_equal_p (SET_DEST (temp4), temp1)
        !           727:              && (GET_CODE (SET_SRC (temp4)) == REG
        !           728:                  || GET_CODE (SET_SRC (temp4)) == SUBREG
        !           729:                  || CONSTANT_P (SET_SRC (temp4)))
        !           730:              && (REG_NOTES (temp2) == 0
        !           731:                  || ((REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUAL
        !           732:                       || REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUIV)
        !           733:                      && XEXP (REG_NOTES (temp2), 1) == 0
        !           734:                      && rtx_equal_p (XEXP (REG_NOTES (temp2), 0),
        !           735:                                      SET_SRC (temp4))))
        !           736:              && (temp = prev_active_insn (temp3)) != 0
        !           737:              && condjump_p (temp) && ! simplejump_p (temp)
        !           738:              /* TEMP must skip over the "x = a;" insn */
        !           739:              && prev_real_insn (JUMP_LABEL (temp)) == insn
        !           740:              && no_labels_between_p (insn, JUMP_LABEL (temp))
        !           741:              /* There must be no other entries to the "x = b;" insn.  */
        !           742:              && no_labels_between_p (JUMP_LABEL (temp), temp2)
        !           743:              /* INSN must either branch to the insn after TEMP2 or the insn
        !           744:                 after TEMP2 must branch to the same place as INSN.  */
        !           745:              && (reallabelprev == temp2
        !           746:                  || ((temp5 = next_active_insn (temp2)) != 0
        !           747:                      && simplejump_p (temp5)
        !           748:                      && JUMP_LABEL (temp5) == JUMP_LABEL (insn))))
        !           749:            {
        !           750:              /* The test expression, X, may be a complicated test with
        !           751:                 multiple branches.  See if we can find all the uses of
        !           752:                 the label that TEMP branches to without hitting a CALL_INSN
        !           753:                 or a jump to somewhere else.  */
        !           754:              rtx target = JUMP_LABEL (temp);
        !           755:              int nuses = LABEL_NUSES (target);
        !           756:              rtx p, q;
        !           757: 
        !           758:              /* Set P to the first jump insn that goes around "x = a;".  */
        !           759:              for (p = temp; nuses && p; p = prev_nonnote_insn (p))
        !           760:                {
        !           761:                  if (GET_CODE (p) == JUMP_INSN)
        !           762:                    {
        !           763:                      if (condjump_p (p) && ! simplejump_p (p)
        !           764:                          && JUMP_LABEL (p) == target)
        !           765:                        {
        !           766:                          nuses--;
        !           767:                          if (nuses == 0)
        !           768:                            break;
        !           769:                        }
        !           770:                      else
        !           771:                        break;
        !           772:                    }
        !           773:                  else if (GET_CODE (p) == CALL_INSN)
        !           774:                    break;
        !           775:                }
        !           776: 
        !           777: #ifdef HAVE_cc0
        !           778:              /* We cannot insert anything between a set of cc and its use
        !           779:                 so if P uses cc0, we must back up to the previous insn.  */
        !           780:              q = prev_nonnote_insn (p);
        !           781:              if (q && GET_RTX_CLASS (GET_CODE (q)) == 'i'
        !           782:                  && sets_cc0_p (PATTERN (q)))
        !           783:                p = q;
        !           784: #endif
        !           785: 
        !           786:              if (p)
        !           787:                p = PREV_INSN (p);
        !           788: 
        !           789:              /* If we found all the uses and there was no data conflict, we
        !           790:                 can move the assignment unless we can branch into the middle
        !           791:                 from somewhere.  */
        !           792:              if (nuses == 0 && p
        !           793:                  && no_labels_between_p (p, insn)
        !           794:                  && ! reg_referenced_between_p (temp1, p, NEXT_INSN (temp3))
        !           795:                  && ! reg_set_between_p (temp1, p, temp3)
        !           796:                  && (GET_CODE (SET_SRC (temp4)) == CONST_INT
        !           797:                      || ! reg_set_between_p (SET_SRC (temp4), p, temp2)))
        !           798:                {
        !           799:                  emit_insn_after_with_line_notes (PATTERN (temp2), p, temp2);
        !           800:                  delete_insn (temp2);
        !           801: 
        !           802:                  /* Set NEXT to an insn that we know won't go away.  */
        !           803:                  next = next_active_insn (insn);
        !           804: 
        !           805:                  /* Delete the jump around the set.  Note that we must do
        !           806:                     this before we redirect the test jumps so that it won't
        !           807:                     delete the code immediately following the assignment
        !           808:                     we moved (which might be a jump).  */
        !           809: 
        !           810:                  delete_insn (insn);
        !           811: 
        !           812:                  /* We either have two consecutive labels or a jump to
        !           813:                     a jump, so adjust all the JUMP_INSNs to branch to where
        !           814:                     INSN branches to.  */
        !           815:                  for (p = NEXT_INSN (p); p != next; p = NEXT_INSN (p))
        !           816:                    if (GET_CODE (p) == JUMP_INSN)
        !           817:                      redirect_jump (p, target);
        !           818: 
        !           819:                  changed = 1;
        !           820:                  continue;
        !           821:                }
        !           822:            }
        !           823: 
        !           824: #ifndef HAVE_cc0
        !           825:          /* If we have if (...) x = exp;  and branches are expensive,
        !           826:             EXP is a single insn, does not have any side effects, cannot
        !           827:             trap, and is not too costly, convert this to
        !           828:             t = exp; if (...) x = t;
        !           829: 
        !           830:             Don't do this when we have CC0 because it is unlikely to help
        !           831:             and we'd need to worry about where to place the new insn and
        !           832:             the potential for conflicts.  We also can't do this when we have
        !           833:             notes on the insn for the same reason as above.
        !           834: 
        !           835:             We set:
        !           836: 
        !           837:             TEMP to the "x = exp;" insn.
        !           838:             TEMP1 to the single set in the "x = exp; insn.
        !           839:             TEMP2 to "x".  */
        !           840: 
        !           841:          if (! reload_completed
        !           842:              && this_is_condjump && ! this_is_simplejump
        !           843:              && BRANCH_COST >= 3
        !           844:              && (temp = next_nonnote_insn (insn)) != 0
        !           845:              && GET_CODE (temp) == INSN
        !           846:              && REG_NOTES (temp) == 0
        !           847:              && (reallabelprev == temp
        !           848:                  || ((temp2 = next_active_insn (temp)) != 0
        !           849:                      && simplejump_p (temp2)
        !           850:                      && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
        !           851:              && (temp1 = single_set (temp)) != 0
        !           852:              && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
        !           853:              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
        !           854: #ifdef SMALL_REGISTER_CLASSES
        !           855:              && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
        !           856: #endif
        !           857:              && GET_CODE (SET_SRC (temp1)) != REG
        !           858:              && GET_CODE (SET_SRC (temp1)) != SUBREG
        !           859:              && GET_CODE (SET_SRC (temp1)) != CONST_INT
        !           860:              && ! side_effects_p (SET_SRC (temp1))
        !           861:              && ! may_trap_p (SET_SRC (temp1))
        !           862:              && rtx_cost (SET_SRC (temp1)) < 10)
        !           863:            {
        !           864:              rtx new = gen_reg_rtx (GET_MODE (temp2));
        !           865: 
        !           866:              if (validate_change (temp, &SET_DEST (temp1), new, 0))
        !           867:                {
        !           868:                  next = emit_insn_after (gen_move_insn (temp2, new), insn);
        !           869:                  emit_insn_after_with_line_notes (PATTERN (temp), 
        !           870:                                                   PREV_INSN (insn), temp);
        !           871:                  delete_insn (temp);
        !           872:                }
        !           873:            }
        !           874: 
        !           875:          /* Similarly, if it takes two insns to compute EXP but they
        !           876:             have the same destination.  Here TEMP3 will be the second
        !           877:             insn and TEMP4 the SET from that insn.  */
        !           878: 
        !           879:          if (! reload_completed
        !           880:              && this_is_condjump && ! this_is_simplejump
        !           881:              && BRANCH_COST >= 4
        !           882:              && (temp = next_nonnote_insn (insn)) != 0
        !           883:              && GET_CODE (temp) == INSN
        !           884:              && REG_NOTES (temp) == 0
        !           885:              && (temp3 = next_nonnote_insn (temp)) != 0
        !           886:              && GET_CODE (temp3) == INSN
        !           887:              && REG_NOTES (temp3) == 0
        !           888:              && (reallabelprev == temp3
        !           889:                  || ((temp2 = next_active_insn (temp3)) != 0
        !           890:                      && simplejump_p (temp2)
        !           891:                      && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
        !           892:              && (temp1 = single_set (temp)) != 0
        !           893:              && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
        !           894:              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
        !           895: #ifdef SMALL_REGISTER_CLASSES
        !           896:              && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
        !           897: #endif
        !           898:              && ! side_effects_p (SET_SRC (temp1))
        !           899:              && ! may_trap_p (SET_SRC (temp1))
        !           900:              && rtx_cost (SET_SRC (temp1)) < 10
        !           901:              && (temp4 = single_set (temp3)) != 0
        !           902:              && rtx_equal_p (SET_DEST (temp4), temp2)
        !           903:              && ! side_effects_p (SET_SRC (temp4))
        !           904:              && ! may_trap_p (SET_SRC (temp4))
        !           905:              && rtx_cost (SET_SRC (temp4)) < 10)
        !           906:            {
        !           907:              rtx new = gen_reg_rtx (GET_MODE (temp2));
        !           908: 
        !           909:              if (validate_change (temp, &SET_DEST (temp1), new, 0))
        !           910:                {
        !           911:                  next = emit_insn_after (gen_move_insn (temp2, new), insn);
        !           912:                  emit_insn_after_with_line_notes (PATTERN (temp),
        !           913:                                                   PREV_INSN (insn), temp);
        !           914:                  emit_insn_after_with_line_notes
        !           915:                    (replace_rtx (PATTERN (temp3), temp2, new),
        !           916:                     PREV_INSN (insn), temp3);
        !           917:                  delete_insn (temp);
        !           918:                  delete_insn (temp3);
        !           919:                }
        !           920:            }
        !           921: 
        !           922:          /* Finally, handle the case where two insns are used to 
        !           923:             compute EXP but a temporary register is used.  Here we must
        !           924:             ensure that the temporary register is not used anywhere else. */
        !           925: 
        !           926:          if (! reload_completed
        !           927:              && after_regscan
        !           928:              && this_is_condjump && ! this_is_simplejump
        !           929:              && BRANCH_COST >= 4
        !           930:              && (temp = next_nonnote_insn (insn)) != 0
        !           931:              && GET_CODE (temp) == INSN
        !           932:              && REG_NOTES (temp) == 0
        !           933:              && (temp3 = next_nonnote_insn (temp)) != 0
        !           934:              && GET_CODE (temp3) == INSN
        !           935:              && REG_NOTES (temp3) == 0
        !           936:              && (reallabelprev == temp3
        !           937:                  || ((temp2 = next_active_insn (temp3)) != 0
        !           938:                      && simplejump_p (temp2)
        !           939:                      && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
        !           940:              && (temp1 = single_set (temp)) != 0
        !           941:              && (temp5 = SET_DEST (temp1), GET_CODE (temp5) == REG)
        !           942:              && REGNO (temp5) >= FIRST_PSEUDO_REGISTER
        !           943:              && regno_first_uid[REGNO (temp5)] == INSN_UID (temp)
        !           944:              && regno_last_uid[REGNO (temp5)] == INSN_UID (temp3)
        !           945:              && ! side_effects_p (SET_SRC (temp1))
        !           946:              && ! may_trap_p (SET_SRC (temp1))
        !           947:              && rtx_cost (SET_SRC (temp1)) < 10
        !           948:              && (temp4 = single_set (temp3)) != 0
        !           949:              && (temp2 = SET_DEST (temp4), GET_CODE (temp2) == REG)
        !           950:              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
        !           951: #ifdef SMALL_REGISTER_CLASSES
        !           952:              && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
        !           953: #endif
        !           954:              && rtx_equal_p (SET_DEST (temp4), temp2)
        !           955:              && ! side_effects_p (SET_SRC (temp4))
        !           956:              && ! may_trap_p (SET_SRC (temp4))
        !           957:              && rtx_cost (SET_SRC (temp4)) < 10)
        !           958:            {
        !           959:              rtx new = gen_reg_rtx (GET_MODE (temp2));
        !           960: 
        !           961:              if (validate_change (temp3, &SET_DEST (temp4), new, 0))
        !           962:                {
        !           963:                  next = emit_insn_after (gen_move_insn (temp2, new), insn);
        !           964:                  emit_insn_after_with_line_notes (PATTERN (temp),
        !           965:                                                   PREV_INSN (insn), temp);
        !           966:                  emit_insn_after_with_line_notes (PATTERN (temp3),
        !           967:                                                   PREV_INSN (insn), temp3);
        !           968:                  delete_insn (temp);
        !           969:                  delete_insn (temp3);
        !           970:                }
        !           971:            }
        !           972: #endif /* HAVE_cc0 */
        !           973: 
        !           974:          /* We deal with four cases:
        !           975: 
        !           976:             1) x = a; if (...) x = b; and either A or B is zero,
        !           977:             2) if (...) x = 0; and jumps are expensive,
        !           978:             3) x = a; if (...) x = b; and A and B are constants where all the
        !           979:                set bits in A are also set in B and jumps are expensive, and
        !           980:             4) x = a; if (...) x = b; and A and B non-zero, and jumps are
        !           981:                more expensive.
        !           982:             5) if (...) x = b; if jumps are even more expensive.
        !           983: 
        !           984:             In each of these try to use a store-flag insn to avoid the jump.
        !           985:             (If the jump would be faster, the machine should not have
        !           986:             defined the scc insns!).  These cases are often made by the
        !           987:             previous optimization.
        !           988: 
        !           989:             INSN here is the jump around the store.  We set:
        !           990: 
        !           991:             TEMP to the "x = b;" insn.
        !           992:             TEMP1 to X.
        !           993:             TEMP2 to B (const0_rtx in the second case).
        !           994:             TEMP3 to A (X in the second case).
        !           995:             TEMP4 to the condition being tested.
        !           996:             TEMP5 to the earliest insn used to find the condition.  */
        !           997: 
        !           998:          if (/* We can't do this after reload has completed.  */
        !           999:              ! reload_completed
        !          1000:              && this_is_condjump && ! this_is_simplejump
        !          1001:              /* Set TEMP to the "x = b;" insn.  */
        !          1002:              && (temp = next_nonnote_insn (insn)) != 0
        !          1003:              && GET_CODE (temp) == INSN
        !          1004:              && GET_CODE (PATTERN (temp)) == SET
        !          1005:              && GET_CODE (temp1 = SET_DEST (PATTERN (temp))) == REG
        !          1006: #ifdef SMALL_REGISTER_CLASSES
        !          1007:              && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
        !          1008: #endif
        !          1009:              && GET_MODE_CLASS (GET_MODE (temp1)) == MODE_INT
        !          1010:              && (GET_CODE (temp2 = SET_SRC (PATTERN (temp))) == REG
        !          1011:                  || GET_CODE (temp2) == SUBREG
        !          1012:                  || GET_CODE (temp2) == CONST_INT)
        !          1013:              /* Allow either form, but prefer the former if both apply. 
        !          1014:                 There is no point in using the old value of TEMP1 if
        !          1015:                 it is a register, since cse will alias them.  It can
        !          1016:                 lose if the old value were a hard register since CSE
        !          1017:                 won't replace hard registers.  */
        !          1018:              && (((temp3 = reg_set_last (temp1, insn)) != 0
        !          1019:                   && GET_CODE (temp3) == CONST_INT)
        !          1020:                  /* Make the latter case look like  x = x; if (...) x = 0;  */
        !          1021:                  || (temp3 = temp1,
        !          1022:                      ((BRANCH_COST >= 2
        !          1023:                        && temp2 == const0_rtx)
        !          1024: #ifdef HAVE_conditional_move
        !          1025:                       || 1
        !          1026: #endif
        !          1027:                       || BRANCH_COST >= 3)))
        !          1028:              /* INSN must either branch to the insn after TEMP or the insn
        !          1029:                 after TEMP must branch to the same place as INSN.  */
        !          1030:              && (reallabelprev == temp
        !          1031:                  || ((temp4 = next_active_insn (temp)) != 0
        !          1032:                      && simplejump_p (temp4)
        !          1033:                      && JUMP_LABEL (temp4) == JUMP_LABEL (insn)))
        !          1034:              && (temp4 = get_condition (insn, &temp5)) != 0
        !          1035:              /* We must be comparing objects whose modes imply the size.
        !          1036:                 We could handle BLKmode if (1) emit_store_flag could
        !          1037:                 and (2) we could find the size reliably.  */
        !          1038:              && GET_MODE (XEXP (temp4, 0)) != BLKmode
        !          1039: 
        !          1040:              /* If B is zero, OK; if A is zero, can only do (1) if we
        !          1041:                 can reverse the condition.  See if (3) applies possibly
        !          1042:                 by reversing the condition.  Prefer reversing to (4) when
        !          1043:                 branches are very expensive.  */
        !          1044:              && ((reversep = 0, temp2 == const0_rtx)
        !          1045:                  || (temp3 == const0_rtx
        !          1046:                      && (reversep = can_reverse_comparison_p (temp4, insn)))
        !          1047:                  || (BRANCH_COST >= 2
        !          1048:                      && GET_CODE (temp2) == CONST_INT
        !          1049:                      && GET_CODE (temp3) == CONST_INT
        !          1050:                      && ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp2)
        !          1051:                          || ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp3)
        !          1052:                              && (reversep = can_reverse_comparison_p (temp4,
        !          1053:                                                                       insn)))))
        !          1054: #ifdef HAVE_conditional_move
        !          1055:                  || 1
        !          1056: #endif
        !          1057:                  || BRANCH_COST >= 3)
        !          1058: #ifdef HAVE_cc0
        !          1059:              /* If the previous insn sets CC0 and something else, we can't
        !          1060:                 do this since we are going to delete that insn.  */
        !          1061: 
        !          1062:              && ! ((temp6 = prev_nonnote_insn (insn)) != 0
        !          1063:                    && GET_CODE (temp6) == INSN
        !          1064:                    && (sets_cc0_p (PATTERN (temp6)) == -1
        !          1065:                        || (sets_cc0_p (PATTERN (temp6)) == 1
        !          1066:                            && FIND_REG_INC_NOTE (temp6, NULL_RTX))))
        !          1067: #endif
        !          1068:              )
        !          1069:            {
        !          1070:              enum rtx_code code = GET_CODE (temp4);
        !          1071:              rtx uval, cval, var = temp1;
        !          1072:              int normalizep;
        !          1073:              rtx target;
        !          1074: 
        !          1075:              /* If necessary, reverse the condition.  */
        !          1076:              if (reversep)
        !          1077:                code = reverse_condition (code), uval = temp2, cval = temp3;
        !          1078:              else
        !          1079:                uval = temp3, cval = temp2;
        !          1080: 
        !          1081:              /* See if we can do this with a store-flag insn. */
        !          1082:              start_sequence ();
        !          1083: 
        !          1084:              /* If CVAL is non-zero, normalize to -1.  Otherwise,
        !          1085:                 if UVAL is the constant 1, it is best to just compute
        !          1086:                 the result directly.  If UVAL is constant and STORE_FLAG_VALUE
        !          1087:                 includes all of its bits, it is best to compute the flag
        !          1088:                 value unnormalized and `and' it with UVAL.  Otherwise,
        !          1089:                 normalize to -1 and `and' with UVAL.  */
        !          1090:              normalizep = (cval != const0_rtx ? -1
        !          1091:                            : (uval == const1_rtx ? 1
        !          1092:                               : (GET_CODE (uval) == CONST_INT
        !          1093:                                  && (INTVAL (uval) & ~STORE_FLAG_VALUE) == 0)
        !          1094:                               ? 0 : -1));
        !          1095: 
        !          1096:              /* We will be putting the store-flag insn immediately in
        !          1097:                 front of the comparison that was originally being done,
        !          1098:                 so we know all the variables in TEMP4 will be valid.
        !          1099:                 However, this might be in front of the assignment of
        !          1100:                 A to VAR.  If it is, it would clobber the store-flag
        !          1101:                 we will be emitting.
        !          1102: 
        !          1103:                 Therefore, emit into a temporary which will be copied to
        !          1104:                 VAR immediately after TEMP.  */
        !          1105: 
        !          1106:              target = emit_store_flag (gen_reg_rtx (GET_MODE (var)), code,
        !          1107:                                        XEXP (temp4, 0), XEXP (temp4, 1),
        !          1108:                                        VOIDmode,
        !          1109:                                        (code == LTU || code == LEU 
        !          1110:                                         || code == GEU || code == GTU),
        !          1111:                                        normalizep);
        !          1112:              if (target)
        !          1113:                {
        !          1114:                  rtx before = insn;
        !          1115:                  rtx seq;
        !          1116: 
        !          1117:                  /* Put the store-flag insns in front of the first insn
        !          1118:                     used to compute the condition to ensure that we
        !          1119:                     use the same values of them as the current 
        !          1120:                     comparison.  However, the remainder of the insns we
        !          1121:                     generate will be placed directly in front of the
        !          1122:                     jump insn, in case any of the pseudos we use
        !          1123:                     are modified earlier.  */
        !          1124: 
        !          1125:                  seq = get_insns ();
        !          1126:                  end_sequence ();
        !          1127: 
        !          1128:                  emit_insns_before (seq, temp5);
        !          1129: 
        !          1130:                  start_sequence ();
        !          1131: 
        !          1132:                  /* Both CVAL and UVAL are non-zero.  */
        !          1133:                  if (cval != const0_rtx && uval != const0_rtx)
        !          1134:                    {
        !          1135:                      rtx tem1, tem2;
        !          1136: 
        !          1137:                      tem1 = expand_and (uval, target, NULL_RTX);
        !          1138:                      if (GET_CODE (cval) == CONST_INT
        !          1139:                          && GET_CODE (uval) == CONST_INT
        !          1140:                          && (INTVAL (cval) & INTVAL (uval)) == INTVAL (cval))
        !          1141:                        tem2 = cval;
        !          1142:                      else
        !          1143:                        {
        !          1144:                          tem2 = expand_unop (GET_MODE (var), one_cmpl_optab,
        !          1145:                                              target, NULL_RTX, 0);
        !          1146:                          tem2 = expand_and (cval, tem2,
        !          1147:                                             (GET_CODE (tem2) == REG
        !          1148:                                              ? tem2 : 0));
        !          1149:                        }
        !          1150: 
        !          1151:                      /* If we usually make new pseudos, do so here.  This
        !          1152:                         turns out to help machines that have conditional
        !          1153:                         move insns.  */
        !          1154: 
        !          1155:                      if (flag_expensive_optimizations)
        !          1156:                        target = 0;
        !          1157: 
        !          1158:                      target = expand_binop (GET_MODE (var), ior_optab,
        !          1159:                                             tem1, tem2, target,
        !          1160:                                             1, OPTAB_WIDEN);
        !          1161:                    }
        !          1162:                  else if (normalizep != 1)
        !          1163:                    {
        !          1164:                      /* We know that either CVAL or UVAL is zero.  If
        !          1165:                         UVAL is zero, negate TARGET and `and' with CVAL.
        !          1166:                         Otherwise, `and' with UVAL.  */
        !          1167:                      if (uval == const0_rtx)
        !          1168:                        {
        !          1169:                          target = expand_unop (GET_MODE (var), one_cmpl_optab,
        !          1170:                                                target, NULL_RTX, 0);
        !          1171:                          uval = cval;
        !          1172:                        }
        !          1173: 
        !          1174:                      target = expand_and (uval, target,
        !          1175:                                           (GET_CODE (target) == REG
        !          1176:                                            && ! preserve_subexpressions_p ()
        !          1177:                                            ? target : NULL_RTX));
        !          1178:                    }
        !          1179:                  
        !          1180:                  emit_move_insn (var, target);
        !          1181:                  seq = get_insns ();
        !          1182:                  end_sequence ();
        !          1183: 
        !          1184: #ifdef HAVE_cc0
        !          1185:                  /* If INSN uses CC0, we must not separate it from the
        !          1186:                     insn that sets cc0.  */
        !          1187: 
        !          1188:                  if (reg_mentioned_p (cc0_rtx, PATTERN (before)))
        !          1189:                    before = prev_nonnote_insn (before);
        !          1190: #endif
        !          1191: 
        !          1192:                  emit_insns_before (seq, before);
        !          1193: 
        !          1194:                  delete_insn (temp);
        !          1195:                  next = NEXT_INSN (insn);
        !          1196: 
        !          1197:                  delete_jump (insn);
        !          1198:                  changed = 1;
        !          1199:                  continue;
        !          1200:                }
        !          1201:              else
        !          1202:                end_sequence ();
        !          1203:            }
        !          1204: 
        !          1205:          /* If branches are expensive, convert
        !          1206:                if (foo) bar++;    to    bar += (foo != 0);
        !          1207:             and similarly for "bar--;" 
        !          1208: 
        !          1209:             INSN is the conditional branch around the arithmetic.  We set:
        !          1210: 
        !          1211:             TEMP is the arithmetic insn.
        !          1212:             TEMP1 is the SET doing the arithmetic.
        !          1213:             TEMP2 is the operand being incremented or decremented.
        !          1214:             TEMP3 to the condition being tested.
        !          1215:             TEMP4 to the earliest insn used to find the condition.  */
        !          1216: 
        !          1217:          if ((BRANCH_COST >= 2
        !          1218: #ifdef HAVE_incscc
        !          1219:               || HAVE_incscc
        !          1220: #endif
        !          1221: #ifdef HAVE_decscc
        !          1222:               || HAVE_decscc
        !          1223: #endif
        !          1224:              )
        !          1225:              && ! reload_completed
        !          1226:              && this_is_condjump && ! this_is_simplejump
        !          1227:              && (temp = next_nonnote_insn (insn)) != 0
        !          1228:              && (temp1 = single_set (temp)) != 0
        !          1229:              && (temp2 = SET_DEST (temp1),
        !          1230:                  GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT)
        !          1231:              && GET_CODE (SET_SRC (temp1)) == PLUS
        !          1232:              && (XEXP (SET_SRC (temp1), 1) == const1_rtx
        !          1233:                  || XEXP (SET_SRC (temp1), 1) == constm1_rtx)
        !          1234:              && rtx_equal_p (temp2, XEXP (SET_SRC (temp1), 0))
        !          1235:              /* INSN must either branch to the insn after TEMP or the insn
        !          1236:                 after TEMP must branch to the same place as INSN.  */
        !          1237:              && (reallabelprev == temp
        !          1238:                  || ((temp3 = next_active_insn (temp)) != 0
        !          1239:                      && simplejump_p (temp3)
        !          1240:                      && JUMP_LABEL (temp3) == JUMP_LABEL (insn)))
        !          1241:              && (temp3 = get_condition (insn, &temp4)) != 0
        !          1242:              /* We must be comparing objects whose modes imply the size.
        !          1243:                 We could handle BLKmode if (1) emit_store_flag could
        !          1244:                 and (2) we could find the size reliably.  */
        !          1245:              && GET_MODE (XEXP (temp3, 0)) != BLKmode
        !          1246:              && can_reverse_comparison_p (temp3, insn))
        !          1247:            {
        !          1248:              rtx temp6, target = 0, seq, init_insn = 0, init = temp2;
        !          1249:              enum rtx_code code = reverse_condition (GET_CODE (temp3));
        !          1250: 
        !          1251:              start_sequence ();
        !          1252: 
        !          1253:              /* It must be the case that TEMP2 is not modified in the range
        !          1254:                 [TEMP4, INSN).  The one exception we make is if the insn
        !          1255:                 before INSN sets TEMP2 to something which is also unchanged
        !          1256:                 in that range.  In that case, we can move the initialization
        !          1257:                 into our sequence.  */
        !          1258: 
        !          1259:              if ((temp5 = prev_active_insn (insn)) != 0
        !          1260:                  && GET_CODE (temp5) == INSN
        !          1261:                  && (temp6 = single_set (temp5)) != 0
        !          1262:                  && rtx_equal_p (temp2, SET_DEST (temp6))
        !          1263:                  && (CONSTANT_P (SET_SRC (temp6))
        !          1264:                      || GET_CODE (SET_SRC (temp6)) == REG
        !          1265:                      || GET_CODE (SET_SRC (temp6)) == SUBREG))
        !          1266:                {
        !          1267:                  emit_insn (PATTERN (temp5));
        !          1268:                  init_insn = temp5;
        !          1269:                  init = SET_SRC (temp6);
        !          1270:                }
        !          1271: 
        !          1272:              if (CONSTANT_P (init)
        !          1273:                  || ! reg_set_between_p (init, PREV_INSN (temp4), insn))
        !          1274:                target = emit_store_flag (gen_reg_rtx (GET_MODE (temp2)), code,
        !          1275:                                          XEXP (temp3, 0), XEXP (temp3, 1),
        !          1276:                                          VOIDmode,
        !          1277:                                          (code == LTU || code == LEU
        !          1278:                                           || code == GTU || code == GEU), 1);
        !          1279: 
        !          1280:              /* If we can do the store-flag, do the addition or
        !          1281:                 subtraction.  */
        !          1282: 
        !          1283:              if (target)
        !          1284:                target = expand_binop (GET_MODE (temp2),
        !          1285:                                       (XEXP (SET_SRC (temp1), 1) == const1_rtx
        !          1286:                                        ? add_optab : sub_optab),
        !          1287:                                       temp2, target, temp2, 0, OPTAB_WIDEN);
        !          1288: 
        !          1289:              if (target != 0)
        !          1290:                {
        !          1291:                  /* Put the result back in temp2 in case it isn't already.
        !          1292:                     Then replace the jump, possible a CC0-setting insn in
        !          1293:                     front of the jump, and TEMP, with the sequence we have
        !          1294:                     made.  */
        !          1295: 
        !          1296:                  if (target != temp2)
        !          1297:                    emit_move_insn (temp2, target);
        !          1298: 
        !          1299:                  seq = get_insns ();
        !          1300:                  end_sequence ();
        !          1301: 
        !          1302:                  emit_insns_before (seq, temp4);
        !          1303:                  delete_insn (temp);
        !          1304: 
        !          1305:                  if (init_insn)
        !          1306:                    delete_insn (init_insn);
        !          1307: 
        !          1308:                  next = NEXT_INSN (insn);
        !          1309: #ifdef HAVE_cc0
        !          1310:                  delete_insn (prev_nonnote_insn (insn));
        !          1311: #endif
        !          1312:                  delete_insn (insn);
        !          1313:                  changed = 1;
        !          1314:                  continue;
        !          1315:                }
        !          1316:              else
        !          1317:                end_sequence ();
        !          1318:            }
        !          1319: 
        !          1320:          /* Simplify   if (...) x = 1; else {...}  if (x) ...
        !          1321:             We recognize this case scanning backwards as well.
        !          1322: 
        !          1323:             TEMP is the assignment to x;
        !          1324:             TEMP1 is the label at the head of the second if.  */
        !          1325:          /* ?? This should call get_condition to find the values being
        !          1326:             compared, instead of looking for a COMPARE insn when HAVE_cc0
        !          1327:             is not defined.  This would allow it to work on the m88k.  */
        !          1328:          /* ?? This optimization is only safe before cse is run if HAVE_cc0
        !          1329:             is not defined and the condition is tested by a separate compare
        !          1330:             insn.  This is because the code below assumes that the result
        !          1331:             of the compare dies in the following branch.
        !          1332: 
        !          1333:             Not only that, but there might be other insns between the
        !          1334:             compare and branch whose results are live.  Those insns need
        !          1335:             to be executed.
        !          1336: 
        !          1337:             A way to fix this is to move the insns at JUMP_LABEL (insn)
        !          1338:             to before INSN.  If we are running before flow, they will
        !          1339:             be deleted if they aren't needed.   But this doesn't work
        !          1340:             well after flow.
        !          1341: 
        !          1342:             This is really a special-case of jump threading, anyway.  The
        !          1343:             right thing to do is to replace this and jump threading with
        !          1344:             much simpler code in cse.
        !          1345: 
        !          1346:             This code has been turned off in the non-cc0 case in the
        !          1347:             meantime.  */
        !          1348: 
        !          1349: #ifdef HAVE_cc0
        !          1350:          else if (this_is_simplejump
        !          1351:                   /* Safe to skip USE and CLOBBER insns here
        !          1352:                      since they will not be deleted.  */
        !          1353:                   && (temp = prev_active_insn (insn))
        !          1354:                   && no_labels_between_p (temp, insn)
        !          1355:                   && GET_CODE (temp) == INSN
        !          1356:                   && GET_CODE (PATTERN (temp)) == SET
        !          1357:                   && GET_CODE (SET_DEST (PATTERN (temp))) == REG
        !          1358:                   && CONSTANT_P (SET_SRC (PATTERN (temp)))
        !          1359:                   && (temp1 = next_active_insn (JUMP_LABEL (insn)))
        !          1360:                   /* If we find that the next value tested is `x'
        !          1361:                      (TEMP1 is the insn where this happens), win.  */
        !          1362:                   && GET_CODE (temp1) == INSN
        !          1363:                   && GET_CODE (PATTERN (temp1)) == SET
        !          1364: #ifdef HAVE_cc0
        !          1365:                   /* Does temp1 `tst' the value of x?  */
        !          1366:                   && SET_SRC (PATTERN (temp1)) == SET_DEST (PATTERN (temp))
        !          1367:                   && SET_DEST (PATTERN (temp1)) == cc0_rtx
        !          1368:                   && (temp1 = next_nonnote_insn (temp1))
        !          1369: #else
        !          1370:                   /* Does temp1 compare the value of x against zero?  */
        !          1371:                   && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
        !          1372:                   && XEXP (SET_SRC (PATTERN (temp1)), 1) == const0_rtx
        !          1373:                   && (XEXP (SET_SRC (PATTERN (temp1)), 0)
        !          1374:                       == SET_DEST (PATTERN (temp)))
        !          1375:                   && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
        !          1376:                   && (temp1 = find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
        !          1377: #endif
        !          1378:                   && condjump_p (temp1))
        !          1379:            {
        !          1380:              /* Get the if_then_else from the condjump.  */
        !          1381:              rtx choice = SET_SRC (PATTERN (temp1));
        !          1382:              if (GET_CODE (choice) == IF_THEN_ELSE)
        !          1383:                {
        !          1384:                  enum rtx_code code = GET_CODE (XEXP (choice, 0));
        !          1385:                  rtx val = SET_SRC (PATTERN (temp));
        !          1386:                  rtx cond
        !          1387:                    = simplify_relational_operation (code, GET_MODE (SET_DEST (PATTERN (temp))),
        !          1388:                                                     val, const0_rtx);
        !          1389:                  rtx ultimate;
        !          1390: 
        !          1391:                  if (cond == const_true_rtx)
        !          1392:                    ultimate = XEXP (choice, 1);
        !          1393:                  else if (cond == const0_rtx)
        !          1394:                    ultimate = XEXP (choice, 2);
        !          1395:                  else
        !          1396:                    ultimate = 0;
        !          1397: 
        !          1398:                  if (ultimate == pc_rtx)
        !          1399:                    ultimate = get_label_after (temp1);
        !          1400:                  else if (ultimate && GET_CODE (ultimate) != RETURN)
        !          1401:                    ultimate = XEXP (ultimate, 0);
        !          1402: 
        !          1403:                  if (ultimate)
        !          1404:                    changed |= redirect_jump (insn, ultimate);
        !          1405:                }
        !          1406:            }
        !          1407: #endif
        !          1408: 
        !          1409: #if 0
        !          1410:          /* @@ This needs a bit of work before it will be right.
        !          1411: 
        !          1412:             Any type of comparison can be accepted for the first and
        !          1413:             second compare.  When rewriting the first jump, we must
        !          1414:             compute the what conditions can reach label3, and use the
        !          1415:             appropriate code.  We can not simply reverse/swap the code
        !          1416:             of the first jump.  In some cases, the second jump must be
        !          1417:             rewritten also.
        !          1418: 
        !          1419:             For example, 
        !          1420:             <  == converts to >  ==
        !          1421:             <  != converts to ==  >
        !          1422:             etc.
        !          1423: 
        !          1424:             If the code is written to only accept an '==' test for the second
        !          1425:             compare, then all that needs to be done is to swap the condition
        !          1426:             of the first branch.
        !          1427: 
        !          1428:             It is questionable whether we want this optimization anyways,
        !          1429:             since if the user wrote code like this because he/she knew that
        !          1430:             the jump to label1 is taken most of the time, then rewriting
        !          1431:             this gives slower code.  */
        !          1432:          /* @@ This should call get_condition to find the values being
        !          1433:             compared, instead of looking for a COMPARE insn when HAVE_cc0
        !          1434:             is not defined.  This would allow it to work on the m88k.  */
        !          1435:          /* @@ This optimization is only safe before cse is run if HAVE_cc0
        !          1436:             is not defined and the condition is tested by a separate compare
        !          1437:             insn.  This is because the code below assumes that the result
        !          1438:             of the compare dies in the following branch.  */
        !          1439: 
        !          1440:          /* Simplify  test a ~= b
        !          1441:                       condjump label1;
        !          1442:                       test a == b
        !          1443:                       condjump label2;
        !          1444:                       jump label3;
        !          1445:                       label1:
        !          1446: 
        !          1447:             rewriting as
        !          1448:                       test a ~~= b
        !          1449:                       condjump label3
        !          1450:                       test a == b
        !          1451:                       condjump label2
        !          1452:                       label1:
        !          1453: 
        !          1454:             where ~= is an inequality, e.g. >, and ~~= is the swapped
        !          1455:             inequality, e.g. <.
        !          1456: 
        !          1457:             We recognize this case scanning backwards.
        !          1458: 
        !          1459:             TEMP is the conditional jump to `label2';
        !          1460:             TEMP1 is the test for `a == b';
        !          1461:             TEMP2 is the conditional jump to `label1';
        !          1462:             TEMP3 is the test for `a ~= b'.  */
        !          1463:          else if (this_is_simplejump
        !          1464:                   && (temp = prev_active_insn (insn))
        !          1465:                   && no_labels_between_p (temp, insn)
        !          1466:                   && condjump_p (temp)
        !          1467:                   && (temp1 = prev_active_insn (temp))
        !          1468:                   && no_labels_between_p (temp1, temp)
        !          1469:                   && GET_CODE (temp1) == INSN
        !          1470:                   && GET_CODE (PATTERN (temp1)) == SET
        !          1471: #ifdef HAVE_cc0
        !          1472:                   && sets_cc0_p (PATTERN (temp1)) == 1
        !          1473: #else
        !          1474:                   && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
        !          1475:                   && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
        !          1476:                   && (temp == find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
        !          1477: #endif
        !          1478:                   && (temp2 = prev_active_insn (temp1))
        !          1479:                   && no_labels_between_p (temp2, temp1)
        !          1480:                   && condjump_p (temp2)
        !          1481:                   && JUMP_LABEL (temp2) == next_nonnote_insn (NEXT_INSN (insn))
        !          1482:                   && (temp3 = prev_active_insn (temp2))
        !          1483:                   && no_labels_between_p (temp3, temp2)
        !          1484:                   && GET_CODE (PATTERN (temp3)) == SET
        !          1485:                   && rtx_equal_p (SET_DEST (PATTERN (temp3)),
        !          1486:                                   SET_DEST (PATTERN (temp1)))
        !          1487:                   && rtx_equal_p (SET_SRC (PATTERN (temp1)),
        !          1488:                                   SET_SRC (PATTERN (temp3)))
        !          1489:                   && ! inequality_comparisons_p (PATTERN (temp))
        !          1490:                   && inequality_comparisons_p (PATTERN (temp2)))
        !          1491:            {
        !          1492:              rtx fallthrough_label = JUMP_LABEL (temp2);
        !          1493: 
        !          1494:              ++LABEL_NUSES (fallthrough_label);
        !          1495:              if (swap_jump (temp2, JUMP_LABEL (insn)))
        !          1496:                {
        !          1497:                  delete_insn (insn);
        !          1498:                  changed = 1;
        !          1499:                }
        !          1500: 
        !          1501:              if (--LABEL_NUSES (fallthrough_label) == 0)
        !          1502:                delete_insn (fallthrough_label);
        !          1503:            }
        !          1504: #endif
        !          1505:          /* Simplify  if (...) {... x = 1;} if (x) ...
        !          1506: 
        !          1507:             We recognize this case backwards.
        !          1508: 
        !          1509:             TEMP is the test of `x';
        !          1510:             TEMP1 is the assignment to `x' at the end of the
        !          1511:             previous statement.  */
        !          1512:          /* @@ This should call get_condition to find the values being
        !          1513:             compared, instead of looking for a COMPARE insn when HAVE_cc0
        !          1514:             is not defined.  This would allow it to work on the m88k.  */
        !          1515:          /* @@ This optimization is only safe before cse is run if HAVE_cc0
        !          1516:             is not defined and the condition is tested by a separate compare
        !          1517:             insn.  This is because the code below assumes that the result
        !          1518:             of the compare dies in the following branch.  */
        !          1519: 
        !          1520:          /* ??? This has to be turned off.  The problem is that the
        !          1521:             unconditional jump might indirectly end up branching to the
        !          1522:             label between TEMP1 and TEMP.  We can't detect this, in general,
        !          1523:             since it may become a jump to there after further optimizations.
        !          1524:             If that jump is done, it will be deleted, so we will retry
        !          1525:             this optimization in the next pass, thus an infinite loop.
        !          1526: 
        !          1527:             The present code prevents this by putting the jump after the
        !          1528:             label, but this is not logically correct.  */
        !          1529: #if 0
        !          1530:          else if (this_is_condjump
        !          1531:                   /* Safe to skip USE and CLOBBER insns here
        !          1532:                      since they will not be deleted.  */
        !          1533:                   && (temp = prev_active_insn (insn))
        !          1534:                   && no_labels_between_p (temp, insn)
        !          1535:                   && GET_CODE (temp) == INSN
        !          1536:                   && GET_CODE (PATTERN (temp)) == SET
        !          1537: #ifdef HAVE_cc0
        !          1538:                   && sets_cc0_p (PATTERN (temp)) == 1
        !          1539:                   && GET_CODE (SET_SRC (PATTERN (temp))) == REG
        !          1540: #else
        !          1541:                   /* Temp must be a compare insn, we can not accept a register
        !          1542:                      to register move here, since it may not be simply a
        !          1543:                      tst insn.  */
        !          1544:                   && GET_CODE (SET_SRC (PATTERN (temp))) == COMPARE
        !          1545:                   && XEXP (SET_SRC (PATTERN (temp)), 1) == const0_rtx
        !          1546:                   && GET_CODE (XEXP (SET_SRC (PATTERN (temp)), 0)) == REG
        !          1547:                   && GET_CODE (SET_DEST (PATTERN (temp))) == REG
        !          1548:                   && insn == find_next_ref (SET_DEST (PATTERN (temp)), temp)
        !          1549: #endif
        !          1550:                   /* May skip USE or CLOBBER insns here
        !          1551:                      for checking for opportunity, since we
        !          1552:                      take care of them later.  */
        !          1553:                   && (temp1 = prev_active_insn (temp))
        !          1554:                   && GET_CODE (temp1) == INSN
        !          1555:                   && GET_CODE (PATTERN (temp1)) == SET
        !          1556: #ifdef HAVE_cc0
        !          1557:                   && SET_SRC (PATTERN (temp)) == SET_DEST (PATTERN (temp1))
        !          1558: #else
        !          1559:                   && (XEXP (SET_SRC (PATTERN (temp)), 0)
        !          1560:                       == SET_DEST (PATTERN (temp1)))
        !          1561: #endif
        !          1562:                   && CONSTANT_P (SET_SRC (PATTERN (temp1)))
        !          1563:                   /* If this isn't true, cse will do the job.  */
        !          1564:                   && ! no_labels_between_p (temp1, temp))
        !          1565:            {
        !          1566:              /* Get the if_then_else from the condjump.  */
        !          1567:              rtx choice = SET_SRC (PATTERN (insn));
        !          1568:              if (GET_CODE (choice) == IF_THEN_ELSE
        !          1569:                  && (GET_CODE (XEXP (choice, 0)) == EQ
        !          1570:                      || GET_CODE (XEXP (choice, 0)) == NE))
        !          1571:                {
        !          1572:                  int want_nonzero = (GET_CODE (XEXP (choice, 0)) == NE);
        !          1573:                  rtx last_insn;
        !          1574:                  rtx ultimate;
        !          1575:                  rtx p;
        !          1576: 
        !          1577:                  /* Get the place that condjump will jump to
        !          1578:                     if it is reached from here.  */
        !          1579:                  if ((SET_SRC (PATTERN (temp1)) != const0_rtx)
        !          1580:                      == want_nonzero)
        !          1581:                    ultimate = XEXP (choice, 1);
        !          1582:                  else
        !          1583:                    ultimate = XEXP (choice, 2);
        !          1584:                  /* Get it as a CODE_LABEL.  */
        !          1585:                  if (ultimate == pc_rtx)
        !          1586:                    ultimate = get_label_after (insn);
        !          1587:                  else
        !          1588:                    /* Get the label out of the LABEL_REF.  */
        !          1589:                    ultimate = XEXP (ultimate, 0);
        !          1590: 
        !          1591:                  /* Insert the jump immediately before TEMP, specifically
        !          1592:                     after the label that is between TEMP1 and TEMP.  */
        !          1593:                  last_insn = PREV_INSN (temp);
        !          1594: 
        !          1595:                  /* If we would be branching to the next insn, the jump
        !          1596:                     would immediately be deleted and the re-inserted in
        !          1597:                     a subsequent pass over the code.  So don't do anything
        !          1598:                     in that case.  */
        !          1599:                  if (next_active_insn (last_insn)
        !          1600:                      != next_active_insn (ultimate))
        !          1601:                    {
        !          1602:                      emit_barrier_after (last_insn);
        !          1603:                      p = emit_jump_insn_after (gen_jump (ultimate),
        !          1604:                                                last_insn);
        !          1605:                      JUMP_LABEL (p) = ultimate;
        !          1606:                      ++LABEL_NUSES (ultimate);
        !          1607:                      if (INSN_UID (ultimate) < max_jump_chain
        !          1608:                          && INSN_CODE (p) < max_jump_chain)
        !          1609:                        {
        !          1610:                          jump_chain[INSN_UID (p)]
        !          1611:                            = jump_chain[INSN_UID (ultimate)];
        !          1612:                          jump_chain[INSN_UID (ultimate)] = p;
        !          1613:                        }
        !          1614:                      changed = 1;
        !          1615:                      continue;
        !          1616:                    }
        !          1617:                }
        !          1618:            }
        !          1619: #endif
        !          1620:          /* Detect a conditional jump going to the same place
        !          1621:             as an immediately following unconditional jump.  */
        !          1622:          else if (this_is_condjump
        !          1623:                   && (temp = next_active_insn (insn)) != 0
        !          1624:                   && simplejump_p (temp)
        !          1625:                   && (next_active_insn (JUMP_LABEL (insn))
        !          1626:                       == next_active_insn (JUMP_LABEL (temp))))
        !          1627:            {
        !          1628:              delete_jump (insn);
        !          1629:              changed = 1;
        !          1630:              continue;
        !          1631:            }
        !          1632:          /* Detect a conditional jump jumping over an unconditional jump.  */
        !          1633: 
        !          1634:          else if (this_is_condjump && ! this_is_simplejump
        !          1635:                   && reallabelprev != 0
        !          1636:                   && GET_CODE (reallabelprev) == JUMP_INSN
        !          1637:                   && prev_active_insn (reallabelprev) == insn
        !          1638:                   && no_labels_between_p (insn, reallabelprev)
        !          1639:                   && simplejump_p (reallabelprev))
        !          1640:            {
        !          1641:              /* When we invert the unconditional jump, we will be
        !          1642:                 decrementing the usage count of its old label.
        !          1643:                 Make sure that we don't delete it now because that
        !          1644:                 might cause the following code to be deleted.  */
        !          1645:              rtx prev_uses = prev_nonnote_insn (reallabelprev);
        !          1646:              rtx prev_label = JUMP_LABEL (insn);
        !          1647: 
        !          1648:              if (prev_label)
        !          1649:                ++LABEL_NUSES (prev_label);
        !          1650: 
        !          1651:              if (invert_jump (insn, JUMP_LABEL (reallabelprev)))
        !          1652:                {
        !          1653:                  /* It is very likely that if there are USE insns before
        !          1654:                     this jump, they hold REG_DEAD notes.  These REG_DEAD
        !          1655:                     notes are no longer valid due to this optimization,
        !          1656:                     and will cause the life-analysis that following passes
        !          1657:                     (notably delayed-branch scheduling) to think that
        !          1658:                     these registers are dead when they are not.
        !          1659: 
        !          1660:                     To prevent this trouble, we just remove the USE insns
        !          1661:                     from the insn chain.  */
        !          1662: 
        !          1663:                  while (prev_uses && GET_CODE (prev_uses) == INSN
        !          1664:                         && GET_CODE (PATTERN (prev_uses)) == USE)
        !          1665:                    {
        !          1666:                      rtx useless = prev_uses;
        !          1667:                      prev_uses = prev_nonnote_insn (prev_uses);
        !          1668:                      delete_insn (useless);
        !          1669:                    }
        !          1670: 
        !          1671:                  delete_insn (reallabelprev);
        !          1672:                  next = insn;
        !          1673:                  changed = 1;
        !          1674:                }
        !          1675: 
        !          1676:              /* We can now safely delete the label if it is unreferenced
        !          1677:                 since the delete_insn above has deleted the BARRIER.  */
        !          1678:              if (prev_label && --LABEL_NUSES (prev_label) == 0)
        !          1679:                delete_insn (prev_label);
        !          1680:              continue;
        !          1681:            }
        !          1682:          else
        !          1683:            {
        !          1684:              /* Detect a jump to a jump.  */
        !          1685: 
        !          1686:              nlabel = follow_jumps (JUMP_LABEL (insn));
        !          1687:              if (nlabel != JUMP_LABEL (insn)
        !          1688:                  && redirect_jump (insn, nlabel))
        !          1689:                {
        !          1690:                  changed = 1;
        !          1691:                  next = insn;
        !          1692:                }
        !          1693: 
        !          1694:              /* Look for   if (foo) bar; else break;  */
        !          1695:              /* The insns look like this:
        !          1696:                 insn = condjump label1;
        !          1697:                 ...range1 (some insns)...
        !          1698:                 jump label2;
        !          1699:                 label1:
        !          1700:                 ...range2 (some insns)...
        !          1701:                 jump somewhere unconditionally
        !          1702:                 label2:  */
        !          1703:              {
        !          1704:                rtx label1 = next_label (insn);
        !          1705:                rtx range1end = label1 ? prev_active_insn (label1) : 0;
        !          1706:                /* Don't do this optimization on the first round, so that
        !          1707:                   jump-around-a-jump gets simplified before we ask here
        !          1708:                   whether a jump is unconditional.
        !          1709: 
        !          1710:                   Also don't do it when we are called after reload since
        !          1711:                   it will confuse reorg.  */
        !          1712:                if (! first
        !          1713:                    && (reload_completed ? ! flag_delayed_branch : 1)
        !          1714:                    /* Make sure INSN is something we can invert.  */
        !          1715:                    && condjump_p (insn)
        !          1716:                    && label1 != 0
        !          1717:                    && JUMP_LABEL (insn) == label1
        !          1718:                    && LABEL_NUSES (label1) == 1
        !          1719:                    && GET_CODE (range1end) == JUMP_INSN
        !          1720:                    && simplejump_p (range1end))
        !          1721:                  {
        !          1722:                    rtx label2 = next_label (label1);
        !          1723:                    rtx range2end = label2 ? prev_active_insn (label2) : 0;
        !          1724:                    if (range1end != range2end
        !          1725:                        && JUMP_LABEL (range1end) == label2
        !          1726:                        && GET_CODE (range2end) == JUMP_INSN
        !          1727:                        && GET_CODE (NEXT_INSN (range2end)) == BARRIER
        !          1728:                        /* Invert the jump condition, so we
        !          1729:                           still execute the same insns in each case.  */
        !          1730:                        && invert_jump (insn, label1))
        !          1731:                      {
        !          1732:                        rtx range1beg = next_active_insn (insn);
        !          1733:                        rtx range2beg = next_active_insn (label1);
        !          1734:                        rtx range1after, range2after;
        !          1735:                        rtx range1before, range2before;
        !          1736: 
        !          1737:                        /* Include in each range any notes before it, to be
        !          1738:                           sure that we get the line number note if any, even
        !          1739:                           if there are other notes here.  */
        !          1740:                        while (PREV_INSN (range1beg)
        !          1741:                               && GET_CODE (PREV_INSN (range1beg)) == NOTE)
        !          1742:                          range1beg = PREV_INSN (range1beg);
        !          1743: 
        !          1744:                        while (PREV_INSN (range2beg)
        !          1745:                               && GET_CODE (PREV_INSN (range2beg)) == NOTE)
        !          1746:                          range2beg = PREV_INSN (range2beg);
        !          1747: 
        !          1748:                        /* Don't move NOTEs for blocks or loops; shift them
        !          1749:                           outside the ranges, where they'll stay put.  */
        !          1750:                        range1beg = squeeze_notes (range1beg, range1end);
        !          1751:                        range2beg = squeeze_notes (range2beg, range2end);
        !          1752: 
        !          1753:                        /* Get current surrounds of the 2 ranges.  */
        !          1754:                        range1before = PREV_INSN (range1beg);
        !          1755:                        range2before = PREV_INSN (range2beg);
        !          1756:                        range1after = NEXT_INSN (range1end);
        !          1757:                        range2after = NEXT_INSN (range2end);
        !          1758: 
        !          1759:                        /* Splice range2 where range1 was.  */
        !          1760:                        NEXT_INSN (range1before) = range2beg;
        !          1761:                        PREV_INSN (range2beg) = range1before;
        !          1762:                        NEXT_INSN (range2end) = range1after;
        !          1763:                        PREV_INSN (range1after) = range2end;
        !          1764:                        /* Splice range1 where range2 was.  */
        !          1765:                        NEXT_INSN (range2before) = range1beg;
        !          1766:                        PREV_INSN (range1beg) = range2before;
        !          1767:                        NEXT_INSN (range1end) = range2after;
        !          1768:                        PREV_INSN (range2after) = range1end;
        !          1769:                        changed = 1;
        !          1770:                        continue;
        !          1771:                      }
        !          1772:                  }
        !          1773:              }
        !          1774: 
        !          1775:              /* Now that the jump has been tensioned,
        !          1776:                 try cross jumping: check for identical code
        !          1777:                 before the jump and before its target label. */
        !          1778: 
        !          1779:              /* First, cross jumping of conditional jumps:  */
        !          1780: 
        !          1781:              if (cross_jump && condjump_p (insn))
        !          1782:                {
        !          1783:                  rtx newjpos, newlpos;
        !          1784:                  rtx x = prev_real_insn (JUMP_LABEL (insn));
        !          1785: 
        !          1786:                  /* A conditional jump may be crossjumped
        !          1787:                     only if the place it jumps to follows
        !          1788:                     an opposing jump that comes back here.  */
        !          1789: 
        !          1790:                  if (x != 0 && ! jump_back_p (x, insn))
        !          1791:                    /* We have no opposing jump;
        !          1792:                       cannot cross jump this insn.  */
        !          1793:                    x = 0;
        !          1794: 
        !          1795:                  newjpos = 0;
        !          1796:                  /* TARGET is nonzero if it is ok to cross jump
        !          1797:                     to code before TARGET.  If so, see if matches.  */
        !          1798:                  if (x != 0)
        !          1799:                    find_cross_jump (insn, x, 2,
        !          1800:                                     &newjpos, &newlpos);
        !          1801: 
        !          1802:                  if (newjpos != 0)
        !          1803:                    {
        !          1804:                      do_cross_jump (insn, newjpos, newlpos);
        !          1805:                      /* Make the old conditional jump
        !          1806:                         into an unconditional one.  */
        !          1807:                      SET_SRC (PATTERN (insn))
        !          1808:                        = gen_rtx (LABEL_REF, VOIDmode, JUMP_LABEL (insn));
        !          1809:                      INSN_CODE (insn) = -1;
        !          1810:                      emit_barrier_after (insn);
        !          1811:                      /* Add to jump_chain unless this is a new label
        !          1812:                         whose UID is too large. */
        !          1813:                      if (INSN_UID (JUMP_LABEL (insn)) < max_jump_chain)
        !          1814:                        {
        !          1815:                          jump_chain[INSN_UID (insn)]
        !          1816:                            = jump_chain[INSN_UID (JUMP_LABEL (insn))];
        !          1817:                          jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
        !          1818:                        }
        !          1819:                      changed = 1;
        !          1820:                      next = insn;
        !          1821:                    }
        !          1822:                }
        !          1823: 
        !          1824:              /* Cross jumping of unconditional jumps:
        !          1825:                 a few differences.  */
        !          1826: 
        !          1827:              if (cross_jump && simplejump_p (insn))
        !          1828:                {
        !          1829:                  rtx newjpos, newlpos;
        !          1830:                  rtx target;
        !          1831: 
        !          1832:                  newjpos = 0;
        !          1833: 
        !          1834:                  /* TARGET is nonzero if it is ok to cross jump
        !          1835:                     to code before TARGET.  If so, see if matches.  */
        !          1836:                  find_cross_jump (insn, JUMP_LABEL (insn), 1,
        !          1837:                                   &newjpos, &newlpos);
        !          1838: 
        !          1839:                  /* If cannot cross jump to code before the label,
        !          1840:                     see if we can cross jump to another jump to
        !          1841:                     the same label.  */
        !          1842:                  /* Try each other jump to this label.  */
        !          1843:                  if (INSN_UID (JUMP_LABEL (insn)) < max_uid)
        !          1844:                    for (target = jump_chain[INSN_UID (JUMP_LABEL (insn))];
        !          1845:                         target != 0 && newjpos == 0;
        !          1846:                         target = jump_chain[INSN_UID (target)])
        !          1847:                      if (target != insn
        !          1848:                          && JUMP_LABEL (target) == JUMP_LABEL (insn)
        !          1849:                          /* Ignore TARGET if it's deleted.  */
        !          1850:                          && ! INSN_DELETED_P (target))
        !          1851:                        find_cross_jump (insn, target, 2,
        !          1852:                                         &newjpos, &newlpos);
        !          1853: 
        !          1854:                  if (newjpos != 0)
        !          1855:                    {
        !          1856:                      do_cross_jump (insn, newjpos, newlpos);
        !          1857:                      changed = 1;
        !          1858:                      next = insn;
        !          1859:                    }
        !          1860:                }
        !          1861: 
        !          1862:              /* This code was dead in the previous jump.c!  */
        !          1863:              if (cross_jump && GET_CODE (PATTERN (insn)) == RETURN)
        !          1864:                {
        !          1865:                  /* Return insns all "jump to the same place"
        !          1866:                     so we can cross-jump between any two of them.  */
        !          1867: 
        !          1868:                  rtx newjpos, newlpos, target;
        !          1869: 
        !          1870:                  newjpos = 0;
        !          1871: 
        !          1872:                  /* If cannot cross jump to code before the label,
        !          1873:                     see if we can cross jump to another jump to
        !          1874:                     the same label.  */
        !          1875:                  /* Try each other jump to this label.  */
        !          1876:                  for (target = jump_chain[0];
        !          1877:                       target != 0 && newjpos == 0;
        !          1878:                       target = jump_chain[INSN_UID (target)])
        !          1879:                    if (target != insn
        !          1880:                        && ! INSN_DELETED_P (target)
        !          1881:                        && GET_CODE (PATTERN (target)) == RETURN)
        !          1882:                      find_cross_jump (insn, target, 2,
        !          1883:                                       &newjpos, &newlpos);
        !          1884: 
        !          1885:                  if (newjpos != 0)
        !          1886:                    {
        !          1887:                      do_cross_jump (insn, newjpos, newlpos);
        !          1888:                      changed = 1;
        !          1889:                      next = insn;
        !          1890:                    }
        !          1891:                }
        !          1892:            }
        !          1893:        }
        !          1894: 
        !          1895:       first = 0;
        !          1896:     }
        !          1897: 
        !          1898:   /* Delete extraneous line number notes.
        !          1899:      Note that two consecutive notes for different lines are not really
        !          1900:      extraneous.  There should be some indication where that line belonged,
        !          1901:      even if it became empty.  */
        !          1902: 
        !          1903:   {
        !          1904:     rtx last_note = 0;
        !          1905: 
        !          1906:     for (insn = f; insn; insn = NEXT_INSN (insn))
        !          1907:       if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) >= 0)
        !          1908:        {
        !          1909:          /* Delete this note if it is identical to previous note.  */
        !          1910:          if (last_note
        !          1911:              && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
        !          1912:              && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
        !          1913:            {
        !          1914:              delete_insn (insn);
        !          1915:              continue;
        !          1916:            }
        !          1917: 
        !          1918:          last_note = insn;
        !          1919:        }
        !          1920:   }
        !          1921: 
        !          1922: #ifdef HAVE_return
        !          1923:   if (HAVE_return)
        !          1924:     {
        !          1925:       /* If we fall through to the epilogue, see if we can insert a RETURN insn
        !          1926:         in front of it.  If the machine allows it at this point (we might be
        !          1927:         after reload for a leaf routine), it will improve optimization for it
        !          1928:         to be there.  We do this both here and at the start of this pass since
        !          1929:         the RETURN might have been deleted by some of our optimizations.  */
        !          1930:       insn = get_last_insn ();
        !          1931:       while (insn && GET_CODE (insn) == NOTE)
        !          1932:        insn = PREV_INSN (insn);
        !          1933: 
        !          1934:       if (insn && GET_CODE (insn) != BARRIER)
        !          1935:        {
        !          1936:          emit_jump_insn (gen_return ());
        !          1937:          emit_barrier ();
        !          1938:        }
        !          1939:     }
        !          1940: #endif
        !          1941: 
        !          1942:   /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
        !          1943:      If so, delete it, and record that this function can drop off the end.  */
        !          1944: 
        !          1945:   insn = last_insn;
        !          1946:   {
        !          1947:     int n_labels = 1;
        !          1948:     while (insn
        !          1949:           /* One label can follow the end-note: the return label.  */
        !          1950:           && ((GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
        !          1951:               /* Ordinary insns can follow it if returning a structure.  */
        !          1952:               || GET_CODE (insn) == INSN
        !          1953:               /* If machine uses explicit RETURN insns, no epilogue,
        !          1954:                  then one of them follows the note.  */
        !          1955:               || (GET_CODE (insn) == JUMP_INSN
        !          1956:                   && GET_CODE (PATTERN (insn)) == RETURN)
        !          1957:               /* Other kinds of notes can follow also.  */
        !          1958:               || (GET_CODE (insn) == NOTE
        !          1959:                   && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)))
        !          1960:       insn = PREV_INSN (insn);
        !          1961:   }
        !          1962: 
        !          1963:   /* Report if control can fall through at the end of the function.  */
        !          1964:   if (insn && GET_CODE (insn) == NOTE
        !          1965:       && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END)
        !          1966:     {
        !          1967:       can_reach_end = 1;
        !          1968:       delete_insn (insn);
        !          1969:     }
        !          1970: 
        !          1971:   /* Show JUMP_CHAIN no longer valid.  */
        !          1972:   jump_chain = 0;
        !          1973: }
        !          1974: 
        !          1975: /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
        !          1976:    jump.  Assume that this unconditional jump is to the exit test code.  If
        !          1977:    the code is sufficiently simple, make a copy of it before INSN,
        !          1978:    followed by a jump to the exit of the loop.  Then delete the unconditional
        !          1979:    jump after INSN.
        !          1980: 
        !          1981:    Note that it is possible we can get confused here if the jump immediately
        !          1982:    after the loop start branches outside the loop but within an outer loop.
        !          1983:    If we are near the exit of that loop, we will copy its exit test.  This
        !          1984:    will not generate incorrect code, but could suppress some optimizations.
        !          1985:    However, such cases are degenerate loops anyway.
        !          1986: 
        !          1987:    Return 1 if we made the change, else 0.
        !          1988: 
        !          1989:    This is only safe immediately after a regscan pass because it uses the
        !          1990:    values of regno_first_uid and regno_last_uid.  */
        !          1991: 
        !          1992: static int
        !          1993: duplicate_loop_exit_test (loop_start)
        !          1994:      rtx loop_start;
        !          1995: {
        !          1996:   rtx insn, set, p;
        !          1997:   rtx copy, link;
        !          1998:   int num_insns = 0;
        !          1999:   rtx exitcode = NEXT_INSN (JUMP_LABEL (next_nonnote_insn (loop_start)));
        !          2000:   rtx lastexit;
        !          2001:   int max_reg = max_reg_num ();
        !          2002:   rtx *reg_map = 0;
        !          2003: 
        !          2004:   /* Scan the exit code.  We do not perform this optimization if any insn:
        !          2005: 
        !          2006:          is a CALL_INSN
        !          2007:         is a CODE_LABEL
        !          2008:         has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
        !          2009:         is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
        !          2010:         is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
        !          2011:              are not valid
        !          2012: 
        !          2013:      Also, don't do this if the exit code is more than 20 insns.  */
        !          2014: 
        !          2015:   for (insn = exitcode;
        !          2016:        insn
        !          2017:        && ! (GET_CODE (insn) == NOTE
        !          2018:             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
        !          2019:        insn = NEXT_INSN (insn))
        !          2020:     {
        !          2021:       switch (GET_CODE (insn))
        !          2022:        {
        !          2023:        case CODE_LABEL:
        !          2024:        case CALL_INSN:
        !          2025:          return 0;
        !          2026:        case NOTE:
        !          2027:          if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
        !          2028:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
        !          2029:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
        !          2030:            return 0;
        !          2031:          break;
        !          2032:        case JUMP_INSN:
        !          2033:        case INSN:
        !          2034:          if (++num_insns > 20
        !          2035:              || find_reg_note (insn, REG_RETVAL, NULL_RTX)
        !          2036:              || find_reg_note (insn, REG_LIBCALL, NULL_RTX))
        !          2037:            return 0;
        !          2038:          break;
        !          2039:        }
        !          2040:     }
        !          2041: 
        !          2042:   /* Unless INSN is zero, we can do the optimization.  */
        !          2043:   if (insn == 0)
        !          2044:     return 0;
        !          2045: 
        !          2046:   lastexit = insn;
        !          2047: 
        !          2048:   /* See if any insn sets a register only used in the loop exit code and
        !          2049:      not a user variable.  If so, replace it with a new register.  */
        !          2050:   for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
        !          2051:     if (GET_CODE (insn) == INSN
        !          2052:        && (set = single_set (insn)) != 0
        !          2053:        && GET_CODE (SET_DEST (set)) == REG
        !          2054:        && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
        !          2055:        && regno_first_uid[REGNO (SET_DEST (set))] == INSN_UID (insn))
        !          2056:       {
        !          2057:        for (p = NEXT_INSN (insn); p != lastexit; p = NEXT_INSN (p))
        !          2058:          if (regno_last_uid[REGNO (SET_DEST (set))] == INSN_UID (p))
        !          2059:            break;
        !          2060: 
        !          2061:        if (p != lastexit)
        !          2062:          {
        !          2063:            /* We can do the replacement.  Allocate reg_map if this is the
        !          2064:               first replacement we found.  */
        !          2065:            if (reg_map == 0)
        !          2066:              {
        !          2067:                reg_map = (rtx *) alloca (max_reg * sizeof (rtx));
        !          2068:                bzero (reg_map, max_reg * sizeof (rtx));
        !          2069:              }
        !          2070: 
        !          2071:            REG_LOOP_TEST_P (SET_DEST (set)) = 1;
        !          2072: 
        !          2073:            reg_map[REGNO (SET_DEST (set))]
        !          2074:              = gen_reg_rtx (GET_MODE (SET_DEST (set)));
        !          2075:          }
        !          2076:       }
        !          2077: 
        !          2078:   /* Now copy each insn.  */
        !          2079:   for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
        !          2080:     switch (GET_CODE (insn))
        !          2081:       {
        !          2082:       case BARRIER:
        !          2083:        copy = emit_barrier_before (loop_start);
        !          2084:        break;
        !          2085:       case NOTE:
        !          2086:        /* Only copy line-number notes.  */
        !          2087:        if (NOTE_LINE_NUMBER (insn) >= 0)
        !          2088:          {
        !          2089:            copy = emit_note_before (NOTE_LINE_NUMBER (insn), loop_start);
        !          2090:            NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
        !          2091:          }
        !          2092:        break;
        !          2093: 
        !          2094:       case INSN:
        !          2095:        copy = emit_insn_before (copy_rtx (PATTERN (insn)), loop_start);
        !          2096:        if (reg_map)
        !          2097:          replace_regs (PATTERN (copy), reg_map, max_reg, 1);
        !          2098: 
        !          2099:        mark_jump_label (PATTERN (copy), copy, 0);
        !          2100: 
        !          2101:        /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
        !          2102:           make them.  */
        !          2103:        for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
        !          2104:          if (REG_NOTE_KIND (link) != REG_LABEL)
        !          2105:            REG_NOTES (copy)
        !          2106:              = copy_rtx (gen_rtx (EXPR_LIST, REG_NOTE_KIND (link),
        !          2107:                                   XEXP (link, 0), REG_NOTES (copy)));
        !          2108:        if (reg_map && REG_NOTES (copy))
        !          2109:          replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
        !          2110:        break;
        !          2111: 
        !          2112:       case JUMP_INSN:
        !          2113:        copy = emit_jump_insn_before (copy_rtx (PATTERN (insn)), loop_start);
        !          2114:        if (reg_map)
        !          2115:          replace_regs (PATTERN (copy), reg_map, max_reg, 1);
        !          2116:        mark_jump_label (PATTERN (copy), copy, 0);
        !          2117:        if (REG_NOTES (insn))
        !          2118:          {
        !          2119:            REG_NOTES (copy) = copy_rtx (REG_NOTES (insn));
        !          2120:            if (reg_map)
        !          2121:              replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
        !          2122:          }
        !          2123:        
        !          2124:        /* If this is a simple jump, add it to the jump chain.  */
        !          2125: 
        !          2126:        if (INSN_UID (copy) < max_jump_chain && JUMP_LABEL (copy)
        !          2127:            && simplejump_p (copy))
        !          2128:          {
        !          2129:            jump_chain[INSN_UID (copy)]
        !          2130:              = jump_chain[INSN_UID (JUMP_LABEL (copy))];
        !          2131:            jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
        !          2132:          }
        !          2133:        break;
        !          2134: 
        !          2135:       default:
        !          2136:        abort ();
        !          2137:       }
        !          2138: 
        !          2139:   /* Now clean up by emitting a jump to the end label and deleting the jump
        !          2140:      at the start of the loop.  */
        !          2141:   if (GET_CODE (copy) != BARRIER)
        !          2142:     {
        !          2143:       copy = emit_jump_insn_before (gen_jump (get_label_after (insn)),
        !          2144:                                    loop_start);
        !          2145:       mark_jump_label (PATTERN (copy), copy, 0);
        !          2146:       if (INSN_UID (copy) < max_jump_chain
        !          2147:          && INSN_UID (JUMP_LABEL (copy)) < max_jump_chain)
        !          2148:        {
        !          2149:          jump_chain[INSN_UID (copy)]
        !          2150:            = jump_chain[INSN_UID (JUMP_LABEL (copy))];
        !          2151:          jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
        !          2152:        }
        !          2153:       emit_barrier_before (loop_start);
        !          2154:     }
        !          2155: 
        !          2156:   delete_insn (next_nonnote_insn (loop_start));
        !          2157: 
        !          2158:   /* Mark the exit code as the virtual top of the converted loop.  */
        !          2159:   emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode);
        !          2160: 
        !          2161:   return 1;
        !          2162: }
        !          2163: 
        !          2164: /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, and
        !          2165:    loop-end notes between START and END out before START.  Assume that
        !          2166:    END is not such a note.  START may be such a note.  Returns the value
        !          2167:    of the new starting insn, which may be different if the original start
        !          2168:    was such a note.  */
        !          2169: 
        !          2170: rtx
        !          2171: squeeze_notes (start, end)
        !          2172:      rtx start, end;
        !          2173: {
        !          2174:   rtx insn;
        !          2175:   rtx next;
        !          2176: 
        !          2177:   for (insn = start; insn != end; insn = next)
        !          2178:     {
        !          2179:       next = NEXT_INSN (insn);
        !          2180:       if (GET_CODE (insn) == NOTE
        !          2181:          && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
        !          2182:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
        !          2183:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
        !          2184:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
        !          2185:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT
        !          2186:              || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP))
        !          2187:        {
        !          2188:          if (insn == start)
        !          2189:            start = next;
        !          2190:          else
        !          2191:            {
        !          2192:              rtx prev = PREV_INSN (insn);
        !          2193:              PREV_INSN (insn) = PREV_INSN (start);
        !          2194:              NEXT_INSN (insn) = start;
        !          2195:              NEXT_INSN (PREV_INSN (insn)) = insn;
        !          2196:              PREV_INSN (NEXT_INSN (insn)) = insn;
        !          2197:              NEXT_INSN (prev) = next;
        !          2198:              PREV_INSN (next) = prev;
        !          2199:            }
        !          2200:        }
        !          2201:     }
        !          2202: 
        !          2203:   return start;
        !          2204: }
        !          2205: 
        !          2206: /* Compare the instructions before insn E1 with those before E2
        !          2207:    to find an opportunity for cross jumping.
        !          2208:    (This means detecting identical sequences of insns followed by
        !          2209:    jumps to the same place, or followed by a label and a jump
        !          2210:    to that label, and replacing one with a jump to the other.)
        !          2211: 
        !          2212:    Assume E1 is a jump that jumps to label E2
        !          2213:    (that is not always true but it might as well be).
        !          2214:    Find the longest possible equivalent sequences
        !          2215:    and store the first insns of those sequences into *F1 and *F2.
        !          2216:    Store zero there if no equivalent preceding instructions are found.
        !          2217: 
        !          2218:    We give up if we find a label in stream 1.
        !          2219:    Actually we could transfer that label into stream 2.  */
        !          2220: 
        !          2221: static void
        !          2222: find_cross_jump (e1, e2, minimum, f1, f2)
        !          2223:      rtx e1, e2;
        !          2224:      int minimum;
        !          2225:      rtx *f1, *f2;
        !          2226: {
        !          2227:   register rtx i1 = e1, i2 = e2;
        !          2228:   register rtx p1, p2;
        !          2229:   int lose = 0;
        !          2230: 
        !          2231:   rtx last1 = 0, last2 = 0;
        !          2232:   rtx afterlast1 = 0, afterlast2 = 0;
        !          2233:   rtx prev1;
        !          2234: 
        !          2235:   *f1 = 0;
        !          2236:   *f2 = 0;
        !          2237: 
        !          2238:   while (1)
        !          2239:     {
        !          2240:       i1 = prev_nonnote_insn (i1);
        !          2241: 
        !          2242:       i2 = PREV_INSN (i2);
        !          2243:       while (i2 && (GET_CODE (i2) == NOTE || GET_CODE (i2) == CODE_LABEL))
        !          2244:        i2 = PREV_INSN (i2);
        !          2245: 
        !          2246:       if (i1 == 0)
        !          2247:        break;
        !          2248: 
        !          2249:       /* Don't allow the range of insns preceding E1 or E2
        !          2250:         to include the other (E2 or E1).  */
        !          2251:       if (i2 == e1 || i1 == e2)
        !          2252:        break;
        !          2253: 
        !          2254:       /* If we will get to this code by jumping, those jumps will be
        !          2255:         tensioned to go directly to the new label (before I2),
        !          2256:         so this cross-jumping won't cost extra.  So reduce the minimum.  */
        !          2257:       if (GET_CODE (i1) == CODE_LABEL)
        !          2258:        {
        !          2259:          --minimum;
        !          2260:          break;
        !          2261:        }
        !          2262: 
        !          2263:       if (i2 == 0 || GET_CODE (i1) != GET_CODE (i2))
        !          2264:        break;
        !          2265: 
        !          2266:       p1 = PATTERN (i1);
        !          2267:       p2 = PATTERN (i2);
        !          2268:        
        !          2269: #ifdef STACK_REGS
        !          2270:       /* If cross_jump_death_matters is not 0, the insn's mode
        !          2271:         indicates whether or not the insn contains any stack-like
        !          2272:         regs. */
        !          2273: 
        !          2274:       if (cross_jump_death_matters && GET_MODE (i1) == QImode)
        !          2275:        {
        !          2276:          /* If register stack conversion has already been done, then
        !          2277:             death notes must also be compared before it is certain that
        !          2278:             the two instruction streams match. */
        !          2279: 
        !          2280:          rtx note;
        !          2281:          HARD_REG_SET i1_regset, i2_regset;
        !          2282: 
        !          2283:          CLEAR_HARD_REG_SET (i1_regset);
        !          2284:          CLEAR_HARD_REG_SET (i2_regset);
        !          2285: 
        !          2286:          for (note = REG_NOTES (i1); note; note = XEXP (note, 1))
        !          2287:            if (REG_NOTE_KIND (note) == REG_DEAD
        !          2288:                && STACK_REG_P (XEXP (note, 0)))
        !          2289:              SET_HARD_REG_BIT (i1_regset, REGNO (XEXP (note, 0)));
        !          2290: 
        !          2291:          for (note = REG_NOTES (i2); note; note = XEXP (note, 1))
        !          2292:            if (REG_NOTE_KIND (note) == REG_DEAD
        !          2293:                && STACK_REG_P (XEXP (note, 0)))
        !          2294:              SET_HARD_REG_BIT (i2_regset, REGNO (XEXP (note, 0)));
        !          2295: 
        !          2296:          GO_IF_HARD_REG_EQUAL (i1_regset, i2_regset, done);
        !          2297: 
        !          2298:          lose = 1;
        !          2299: 
        !          2300:        done:
        !          2301:          ;
        !          2302:        }
        !          2303: #endif
        !          2304: 
        !          2305:       if (lose  || GET_CODE (p1) != GET_CODE (p2)
        !          2306:          || ! rtx_renumbered_equal_p (p1, p2))
        !          2307:        {
        !          2308:          /* The following code helps take care of G++ cleanups.  */
        !          2309:          rtx equiv1;
        !          2310:          rtx equiv2;
        !          2311: 
        !          2312:          if (!lose && GET_CODE (p1) == GET_CODE (p2)
        !          2313:              && ((equiv1 = find_reg_note (i1, REG_EQUAL, NULL_RTX)) != 0
        !          2314:                  || (equiv1 = find_reg_note (i1, REG_EQUIV, NULL_RTX)) != 0)
        !          2315:              && ((equiv2 = find_reg_note (i2, REG_EQUAL, NULL_RTX)) != 0
        !          2316:                  || (equiv2 = find_reg_note (i2, REG_EQUIV, NULL_RTX)) != 0)
        !          2317:              /* If the equivalences are not to a constant, they may
        !          2318:                 reference pseudos that no longer exist, so we can't
        !          2319:                 use them.  */
        !          2320:              && CONSTANT_P (XEXP (equiv1, 0))
        !          2321:              && rtx_equal_p (XEXP (equiv1, 0), XEXP (equiv2, 0)))
        !          2322:            {
        !          2323:              rtx s1 = single_set (i1);
        !          2324:              rtx s2 = single_set (i2);
        !          2325:              if (s1 != 0 && s2 != 0
        !          2326:                  && rtx_renumbered_equal_p (SET_DEST (s1), SET_DEST (s2)))
        !          2327:                {
        !          2328:                  validate_change (i1, &SET_SRC (s1), XEXP (equiv1, 0), 1);
        !          2329:                  validate_change (i2, &SET_SRC (s2), XEXP (equiv2, 0), 1);
        !          2330:                  if (! rtx_renumbered_equal_p (p1, p2))
        !          2331:                    cancel_changes (0);
        !          2332:                  else if (apply_change_group ())
        !          2333:                    goto win;
        !          2334:                }
        !          2335:            }
        !          2336: 
        !          2337:          /* Insns fail to match; cross jumping is limited to the following
        !          2338:             insns.  */
        !          2339: 
        !          2340: #ifdef HAVE_cc0
        !          2341:          /* Don't allow the insn after a compare to be shared by
        !          2342:             cross-jumping unless the compare is also shared.
        !          2343:             Here, if either of these non-matching insns is a compare,
        !          2344:             exclude the following insn from possible cross-jumping.  */
        !          2345:          if (sets_cc0_p (p1) || sets_cc0_p (p2))
        !          2346:            last1 = afterlast1, last2 = afterlast2, ++minimum;
        !          2347: #endif
        !          2348: 
        !          2349:          /* If cross-jumping here will feed a jump-around-jump
        !          2350:             optimization, this jump won't cost extra, so reduce
        !          2351:             the minimum.  */
        !          2352:          if (GET_CODE (i1) == JUMP_INSN
        !          2353:              && JUMP_LABEL (i1)
        !          2354:              && prev_real_insn (JUMP_LABEL (i1)) == e1)
        !          2355:            --minimum;
        !          2356:          break;
        !          2357:        }
        !          2358: 
        !          2359:     win:
        !          2360:       if (GET_CODE (p1) != USE && GET_CODE (p1) != CLOBBER)
        !          2361:        {
        !          2362:          /* Ok, this insn is potentially includable in a cross-jump here.  */
        !          2363:          afterlast1 = last1, afterlast2 = last2;
        !          2364:          last1 = i1, last2 = i2, --minimum;
        !          2365:        }
        !          2366:     }
        !          2367: 
        !          2368:   /* We have to be careful that we do not cross-jump into the middle of
        !          2369:      USE-CALL_INSN-CLOBBER sequence.  This sequence is used instead of
        !          2370:      putting the USE and CLOBBERs inside the CALL_INSN.  The delay slot
        !          2371:      scheduler needs to know what registers are used and modified by the
        !          2372:      CALL_INSN and needs the adjacent USE and CLOBBERs to do so.
        !          2373: 
        !          2374:      ??? At some point we should probably change this so that these are
        !          2375:      part of the CALL_INSN.  The way we are doing it now is a kludge that
        !          2376:      is now causing trouble.  */
        !          2377: 
        !          2378:   if (last1 != 0 && GET_CODE (last1) == CALL_INSN
        !          2379:       && (prev1 = prev_nonnote_insn (last1))
        !          2380:       && GET_CODE (prev1) == INSN
        !          2381:       && GET_CODE (PATTERN (prev1)) == USE)
        !          2382:     {
        !          2383:       /* Remove this CALL_INSN from the range we can cross-jump.  */
        !          2384:       last1 = next_real_insn (last1);
        !          2385:       last2 = next_real_insn (last2);
        !          2386: 
        !          2387:       minimum++;
        !          2388:     }
        !          2389: 
        !          2390:   /* Skip past CLOBBERS since they may be right after a CALL_INSN.  It
        !          2391:      isn't worth checking for the CALL_INSN.  */
        !          2392:   while (last1 != 0 && GET_CODE (PATTERN (last1)) == CLOBBER)
        !          2393:     last1 = next_real_insn (last1), last2 = next_real_insn (last2);
        !          2394: 
        !          2395:   if (minimum <= 0 && last1 != 0 && last1 != e1)
        !          2396:     *f1 = last1, *f2 = last2;
        !          2397: }
        !          2398: 
        !          2399: static void
        !          2400: do_cross_jump (insn, newjpos, newlpos)
        !          2401:      rtx insn, newjpos, newlpos;
        !          2402: {
        !          2403:   /* Find an existing label at this point
        !          2404:      or make a new one if there is none.  */
        !          2405:   register rtx label = get_label_before (newlpos);
        !          2406: 
        !          2407:   /* Make the same jump insn jump to the new point.  */
        !          2408:   if (GET_CODE (PATTERN (insn)) == RETURN)
        !          2409:     {
        !          2410:       /* Remove from jump chain of returns.  */
        !          2411:       delete_from_jump_chain (insn);
        !          2412:       /* Change the insn.  */
        !          2413:       PATTERN (insn) = gen_jump (label);
        !          2414:       INSN_CODE (insn) = -1;
        !          2415:       JUMP_LABEL (insn) = label;
        !          2416:       LABEL_NUSES (label)++;
        !          2417:       /* Add to new the jump chain.  */
        !          2418:       if (INSN_UID (label) < max_jump_chain
        !          2419:          && INSN_UID (insn) < max_jump_chain)
        !          2420:        {
        !          2421:          jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (label)];
        !          2422:          jump_chain[INSN_UID (label)] = insn;
        !          2423:        }
        !          2424:     }
        !          2425:   else
        !          2426:     redirect_jump (insn, label);
        !          2427: 
        !          2428:   /* Delete the matching insns before the jump.  Also, remove any REG_EQUAL
        !          2429:      or REG_EQUIV note in the NEWLPOS stream that isn't also present in
        !          2430:      the NEWJPOS stream.  */
        !          2431: 
        !          2432:   while (newjpos != insn)
        !          2433:     {
        !          2434:       rtx lnote;
        !          2435: 
        !          2436:       for (lnote = REG_NOTES (newlpos); lnote; lnote = XEXP (lnote, 1))
        !          2437:        if ((REG_NOTE_KIND (lnote) == REG_EQUAL
        !          2438:             || REG_NOTE_KIND (lnote) == REG_EQUIV)
        !          2439:            && ! find_reg_note (newjpos, REG_EQUAL, XEXP (lnote, 0))
        !          2440:            && ! find_reg_note (newjpos, REG_EQUIV, XEXP (lnote, 0)))
        !          2441:          remove_note (newlpos, lnote);
        !          2442: 
        !          2443:       delete_insn (newjpos);
        !          2444:       newjpos = next_real_insn (newjpos);
        !          2445:       newlpos = next_real_insn (newlpos);
        !          2446:     }
        !          2447: }
        !          2448: 
        !          2449: /* Return the label before INSN, or put a new label there.  */
        !          2450: 
        !          2451: rtx
        !          2452: get_label_before (insn)
        !          2453:      rtx insn;
        !          2454: {
        !          2455:   rtx label;
        !          2456: 
        !          2457:   /* Find an existing label at this point
        !          2458:      or make a new one if there is none.  */
        !          2459:   label = prev_nonnote_insn (insn);
        !          2460: 
        !          2461:   if (label == 0 || GET_CODE (label) != CODE_LABEL)
        !          2462:     {
        !          2463:       rtx prev = PREV_INSN (insn);
        !          2464: 
        !          2465:       /* Don't put a label between a CALL_INSN and USE insns that precede
        !          2466:         it.  */
        !          2467: 
        !          2468:       if (GET_CODE (insn) == CALL_INSN
        !          2469:          || (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE
        !          2470:              && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
        !          2471:        while (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == USE)
        !          2472:          prev = PREV_INSN (prev);
        !          2473: 
        !          2474:       label = gen_label_rtx ();
        !          2475:       emit_label_after (label, prev);
        !          2476:       LABEL_NUSES (label) = 0;
        !          2477:     }
        !          2478:   return label;
        !          2479: }
        !          2480: 
        !          2481: /* Return the label after INSN, or put a new label there.  */
        !          2482: 
        !          2483: rtx
        !          2484: get_label_after (insn)
        !          2485:      rtx insn;
        !          2486: {
        !          2487:   rtx label;
        !          2488: 
        !          2489:   /* Find an existing label at this point
        !          2490:      or make a new one if there is none.  */
        !          2491:   label = next_nonnote_insn (insn);
        !          2492: 
        !          2493:   if (label == 0 || GET_CODE (label) != CODE_LABEL)
        !          2494:     {
        !          2495:       /* Don't put a label between a CALL_INSN and CLOBBER insns
        !          2496:         following it. */
        !          2497: 
        !          2498:       if (GET_CODE (insn) == CALL_INSN
        !          2499:          || (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE
        !          2500:              && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
        !          2501:        while (GET_CODE (NEXT_INSN (insn)) == INSN
        !          2502:               && GET_CODE (PATTERN (NEXT_INSN (insn))) == CLOBBER)
        !          2503:          insn = NEXT_INSN (insn);
        !          2504: 
        !          2505:       label = gen_label_rtx ();
        !          2506:       emit_label_after (label, insn);
        !          2507:       LABEL_NUSES (label) = 0;
        !          2508:     }
        !          2509:   return label;
        !          2510: }
        !          2511: 
        !          2512: /* Return 1 if INSN is a jump that jumps to right after TARGET
        !          2513:    only on the condition that TARGET itself would drop through.
        !          2514:    Assumes that TARGET is a conditional jump.  */
        !          2515: 
        !          2516: static int
        !          2517: jump_back_p (insn, target)
        !          2518:      rtx insn, target;
        !          2519: {
        !          2520:   rtx cinsn, ctarget;
        !          2521:   enum rtx_code codei, codet;
        !          2522: 
        !          2523:   if (simplejump_p (insn) || ! condjump_p (insn)
        !          2524:       || simplejump_p (target)
        !          2525:       || target != prev_real_insn (JUMP_LABEL (insn)))
        !          2526:     return 0;
        !          2527: 
        !          2528:   cinsn = XEXP (SET_SRC (PATTERN (insn)), 0);
        !          2529:   ctarget = XEXP (SET_SRC (PATTERN (target)), 0);
        !          2530: 
        !          2531:   codei = GET_CODE (cinsn);
        !          2532:   codet = GET_CODE (ctarget);
        !          2533: 
        !          2534:   if (XEXP (SET_SRC (PATTERN (insn)), 1) == pc_rtx)
        !          2535:     {
        !          2536:       if (! can_reverse_comparison_p (cinsn, insn))
        !          2537:        return 0;
        !          2538:       codei = reverse_condition (codei);
        !          2539:     }
        !          2540: 
        !          2541:   if (XEXP (SET_SRC (PATTERN (target)), 2) == pc_rtx)
        !          2542:     {
        !          2543:       if (! can_reverse_comparison_p (ctarget, target))
        !          2544:        return 0;
        !          2545:       codet = reverse_condition (codet);
        !          2546:     }
        !          2547: 
        !          2548:   return (codei == codet
        !          2549:          && rtx_renumbered_equal_p (XEXP (cinsn, 0), XEXP (ctarget, 0))
        !          2550:          && rtx_renumbered_equal_p (XEXP (cinsn, 1), XEXP (ctarget, 1)));
        !          2551: }
        !          2552: 
        !          2553: /* Given a comparison, COMPARISON, inside a conditional jump insn, INSN,
        !          2554:    return non-zero if it is safe to reverse this comparison.  It is if our
        !          2555:    floating-point is not IEEE, if this is an NE or EQ comparison, or if
        !          2556:    this is known to be an integer comparison.  */
        !          2557: 
        !          2558: int
        !          2559: can_reverse_comparison_p (comparison, insn)
        !          2560:      rtx comparison;
        !          2561:      rtx insn;
        !          2562: {
        !          2563:   rtx arg0;
        !          2564: 
        !          2565:   /* If this is not actually a comparison, we can't reverse it.  */
        !          2566:   if (GET_RTX_CLASS (GET_CODE (comparison)) != '<')
        !          2567:     return 0;
        !          2568: 
        !          2569:   if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
        !          2570:       /* If this is an NE comparison, it is safe to reverse it to an EQ
        !          2571:         comparison and vice versa, even for floating point.  If no operands
        !          2572:         are NaNs, the reversal is valid.  If some operand is a NaN, EQ is
        !          2573:         always false and NE is always true, so the reversal is also valid.  */
        !          2574:       || GET_CODE (comparison) == NE
        !          2575:       || GET_CODE (comparison) == EQ)
        !          2576:     return 1;
        !          2577: 
        !          2578:   arg0 = XEXP (comparison, 0);
        !          2579: 
        !          2580:   /* Make sure ARG0 is one of the actual objects being compared.  If we
        !          2581:      can't do this, we can't be sure the comparison can be reversed. 
        !          2582: 
        !          2583:      Handle cc0 and a MODE_CC register.  */
        !          2584:   if ((GET_CODE (arg0) == REG && GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC)
        !          2585: #ifdef HAVE_cc0
        !          2586:       || arg0 == cc0_rtx
        !          2587: #endif
        !          2588:       )
        !          2589:     {
        !          2590:       rtx prev = prev_nonnote_insn (insn);
        !          2591:       rtx set = single_set (prev);
        !          2592: 
        !          2593:       if (set == 0 || SET_DEST (set) != arg0)
        !          2594:        return 0;
        !          2595: 
        !          2596:       arg0 = SET_SRC (set);
        !          2597: 
        !          2598:       if (GET_CODE (arg0) == COMPARE)
        !          2599:        arg0 = XEXP (arg0, 0);
        !          2600:     }
        !          2601: 
        !          2602:   /* We can reverse this if ARG0 is a CONST_INT or if its mode is
        !          2603:      not VOIDmode and neither a MODE_CC nor MODE_FLOAT type.  */
        !          2604:   return (GET_CODE (arg0) == CONST_INT
        !          2605:          || (GET_MODE (arg0) != VOIDmode
        !          2606:              && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_CC
        !          2607:              && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_FLOAT));
        !          2608: }
        !          2609: 
        !          2610: /* Given an rtx-code for a comparison, return the code
        !          2611:    for the negated comparison.
        !          2612:    WATCH OUT!  reverse_condition is not safe to use on a jump
        !          2613:    that might be acting on the results of an IEEE floating point comparison,
        !          2614:    because of the special treatment of non-signaling nans in comparisons.  
        !          2615:    Use can_reverse_comparison_p to be sure.  */
        !          2616: 
        !          2617: enum rtx_code
        !          2618: reverse_condition (code)
        !          2619:      enum rtx_code code;
        !          2620: {
        !          2621:   switch (code)
        !          2622:     {
        !          2623:     case EQ:
        !          2624:       return NE;
        !          2625: 
        !          2626:     case NE:
        !          2627:       return EQ;
        !          2628: 
        !          2629:     case GT:
        !          2630:       return LE;
        !          2631: 
        !          2632:     case GE:
        !          2633:       return LT;
        !          2634: 
        !          2635:     case LT:
        !          2636:       return GE;
        !          2637: 
        !          2638:     case LE:
        !          2639:       return GT;
        !          2640: 
        !          2641:     case GTU:
        !          2642:       return LEU;
        !          2643: 
        !          2644:     case GEU:
        !          2645:       return LTU;
        !          2646: 
        !          2647:     case LTU:
        !          2648:       return GEU;
        !          2649: 
        !          2650:     case LEU:
        !          2651:       return GTU;
        !          2652: 
        !          2653:     default:
        !          2654:       abort ();
        !          2655:       return UNKNOWN;
        !          2656:     }
        !          2657: }
        !          2658: 
        !          2659: /* Similar, but return the code when two operands of a comparison are swapped.
        !          2660:    This IS safe for IEEE floating-point.  */
        !          2661: 
        !          2662: enum rtx_code
        !          2663: swap_condition (code)
        !          2664:      enum rtx_code code;
        !          2665: {
        !          2666:   switch (code)
        !          2667:     {
        !          2668:     case EQ:
        !          2669:     case NE:
        !          2670:       return code;
        !          2671: 
        !          2672:     case GT:
        !          2673:       return LT;
        !          2674: 
        !          2675:     case GE:
        !          2676:       return LE;
        !          2677: 
        !          2678:     case LT:
        !          2679:       return GT;
        !          2680: 
        !          2681:     case LE:
        !          2682:       return GE;
        !          2683: 
        !          2684:     case GTU:
        !          2685:       return LTU;
        !          2686: 
        !          2687:     case GEU:
        !          2688:       return LEU;
        !          2689: 
        !          2690:     case LTU:
        !          2691:       return GTU;
        !          2692: 
        !          2693:     case LEU:
        !          2694:       return GEU;
        !          2695: 
        !          2696:     default:
        !          2697:       abort ();
        !          2698:       return UNKNOWN;
        !          2699:     }
        !          2700: }
        !          2701: 
        !          2702: /* Given a comparison CODE, return the corresponding unsigned comparison.
        !          2703:    If CODE is an equality comparison or already an unsigned comparison,
        !          2704:    CODE is returned.  */
        !          2705: 
        !          2706: enum rtx_code
        !          2707: unsigned_condition (code)
        !          2708:      enum rtx_code code;
        !          2709: {
        !          2710:   switch (code)
        !          2711:     {
        !          2712:     case EQ:
        !          2713:     case NE:
        !          2714:     case GTU:
        !          2715:     case GEU:
        !          2716:     case LTU:
        !          2717:     case LEU:
        !          2718:       return code;
        !          2719: 
        !          2720:     case GT:
        !          2721:       return GTU;
        !          2722: 
        !          2723:     case GE:
        !          2724:       return GEU;
        !          2725: 
        !          2726:     case LT:
        !          2727:       return LTU;
        !          2728: 
        !          2729:     case LE:
        !          2730:       return LEU;
        !          2731: 
        !          2732:     default:
        !          2733:       abort ();
        !          2734:     }
        !          2735: }
        !          2736: 
        !          2737: /* Similarly, return the signed version of a comparison.  */
        !          2738: 
        !          2739: enum rtx_code
        !          2740: signed_condition (code)
        !          2741:      enum rtx_code code;
        !          2742: {
        !          2743:   switch (code)
        !          2744:     {
        !          2745:     case EQ:
        !          2746:     case NE:
        !          2747:     case GT:
        !          2748:     case GE:
        !          2749:     case LT:
        !          2750:     case LE:
        !          2751:       return code;
        !          2752: 
        !          2753:     case GTU:
        !          2754:       return GT;
        !          2755: 
        !          2756:     case GEU:
        !          2757:       return GE;
        !          2758: 
        !          2759:     case LTU:
        !          2760:       return LT;
        !          2761: 
        !          2762:     case LEU:
        !          2763:       return LE;
        !          2764: 
        !          2765:     default:
        !          2766:       abort ();
        !          2767:     }
        !          2768: }
        !          2769: 
        !          2770: /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
        !          2771:    truth of CODE1 implies the truth of CODE2.  */
        !          2772: 
        !          2773: int
        !          2774: comparison_dominates_p (code1, code2)
        !          2775:      enum rtx_code code1, code2;
        !          2776: {
        !          2777:   if (code1 == code2)
        !          2778:     return 1;
        !          2779: 
        !          2780:   switch (code1)
        !          2781:     {
        !          2782:     case EQ:
        !          2783:       if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU)
        !          2784:        return 1;
        !          2785:       break;
        !          2786: 
        !          2787:     case LT:
        !          2788:       if (code2 == LE)
        !          2789:        return 1;
        !          2790:       break;
        !          2791: 
        !          2792:     case GT:
        !          2793:       if (code2 == GE)
        !          2794:        return 1;
        !          2795:       break;
        !          2796: 
        !          2797:     case LTU:
        !          2798:       if (code2 == LEU)
        !          2799:        return 1;
        !          2800:       break;
        !          2801: 
        !          2802:     case GTU:
        !          2803:       if (code2 == GEU)
        !          2804:        return 1;
        !          2805:       break;
        !          2806:     }
        !          2807: 
        !          2808:   return 0;
        !          2809: }
        !          2810: 
        !          2811: /* Return 1 if INSN is an unconditional jump and nothing else.  */
        !          2812: 
        !          2813: int
        !          2814: simplejump_p (insn)
        !          2815:      rtx insn;
        !          2816: {
        !          2817:   return (GET_CODE (insn) == JUMP_INSN
        !          2818:          && GET_CODE (PATTERN (insn)) == SET
        !          2819:          && GET_CODE (SET_DEST (PATTERN (insn))) == PC
        !          2820:          && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
        !          2821: }
        !          2822: 
        !          2823: /* Return nonzero if INSN is a (possibly) conditional jump
        !          2824:    and nothing more.  */
        !          2825: 
        !          2826: int
        !          2827: condjump_p (insn)
        !          2828:      rtx insn;
        !          2829: {
        !          2830:   register rtx x = PATTERN (insn);
        !          2831:   if (GET_CODE (x) != SET)
        !          2832:     return 0;
        !          2833:   if (GET_CODE (SET_DEST (x)) != PC)
        !          2834:     return 0;
        !          2835:   if (GET_CODE (SET_SRC (x)) == LABEL_REF)
        !          2836:     return 1;
        !          2837:   if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
        !          2838:     return 0;
        !          2839:   if (XEXP (SET_SRC (x), 2) == pc_rtx
        !          2840:       && (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
        !          2841:          || GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
        !          2842:     return 1;
        !          2843:   if (XEXP (SET_SRC (x), 1) == pc_rtx
        !          2844:       && (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
        !          2845:          || GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
        !          2846:     return 1;
        !          2847:   return 0;
        !          2848: }
        !          2849: 
        !          2850: /* Return 1 if X is an RTX that does nothing but set the condition codes
        !          2851:    and CLOBBER or USE registers.
        !          2852:    Return -1 if X does explicitly set the condition codes,
        !          2853:    but also does other things.  */
        !          2854: 
        !          2855: int
        !          2856: sets_cc0_p (x)
        !          2857:      rtx x;
        !          2858: {
        !          2859: #ifdef HAVE_cc0
        !          2860:   if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
        !          2861:     return 1;
        !          2862:   if (GET_CODE (x) == PARALLEL)
        !          2863:     {
        !          2864:       int i;
        !          2865:       int sets_cc0 = 0;
        !          2866:       int other_things = 0;
        !          2867:       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
        !          2868:        {
        !          2869:          if (GET_CODE (XVECEXP (x, 0, i)) == SET
        !          2870:              && SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
        !          2871:            sets_cc0 = 1;
        !          2872:          else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
        !          2873:            other_things = 1;
        !          2874:        }
        !          2875:       return ! sets_cc0 ? 0 : other_things ? -1 : 1;
        !          2876:     }
        !          2877:   return 0;
        !          2878: #else
        !          2879:   abort ();
        !          2880: #endif
        !          2881: }
        !          2882: 
        !          2883: /* Follow any unconditional jump at LABEL;
        !          2884:    return the ultimate label reached by any such chain of jumps.
        !          2885:    If LABEL is not followed by a jump, return LABEL.
        !          2886:    If the chain loops or we can't find end, return LABEL,
        !          2887:    since that tells caller to avoid changing the insn.
        !          2888: 
        !          2889:    If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
        !          2890:    a USE or CLOBBER.  */
        !          2891: 
        !          2892: rtx
        !          2893: follow_jumps (label)
        !          2894:      rtx label;
        !          2895: {
        !          2896:   register rtx insn;
        !          2897:   register rtx next;
        !          2898:   register rtx value = label;
        !          2899:   register int depth;
        !          2900: 
        !          2901:   for (depth = 0;
        !          2902:        (depth < 10
        !          2903:        && (insn = next_active_insn (value)) != 0
        !          2904:        && GET_CODE (insn) == JUMP_INSN
        !          2905:        && (JUMP_LABEL (insn) != 0 || GET_CODE (PATTERN (insn)) == RETURN)
        !          2906:        && (next = NEXT_INSN (insn))
        !          2907:        && GET_CODE (next) == BARRIER);
        !          2908:        depth++)
        !          2909:     {
        !          2910:       /* Don't chain through the insn that jumps into a loop
        !          2911:         from outside the loop,
        !          2912:         since that would create multiple loop entry jumps
        !          2913:         and prevent loop optimization.  */
        !          2914:       rtx tem;
        !          2915:       if (!reload_completed)
        !          2916:        for (tem = value; tem != insn; tem = NEXT_INSN (tem))
        !          2917:          if (GET_CODE (tem) == NOTE
        !          2918:              && NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG)
        !          2919:            return value;
        !          2920: 
        !          2921:       /* If we have found a cycle, make the insn jump to itself.  */
        !          2922:       if (JUMP_LABEL (insn) == label)
        !          2923:        return label;
        !          2924:       value = JUMP_LABEL (insn);
        !          2925:     }
        !          2926:   if (depth == 10)
        !          2927:     return label;
        !          2928:   return value;
        !          2929: }
        !          2930: 
        !          2931: /* Assuming that field IDX of X is a vector of label_refs,
        !          2932:    replace each of them by the ultimate label reached by it.
        !          2933:    Return nonzero if a change is made.
        !          2934:    If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG.  */
        !          2935: 
        !          2936: static int
        !          2937: tension_vector_labels (x, idx)
        !          2938:      register rtx x;
        !          2939:      register int idx;
        !          2940: {
        !          2941:   int changed = 0;
        !          2942:   register int i;
        !          2943:   for (i = XVECLEN (x, idx) - 1; i >= 0; i--)
        !          2944:     {
        !          2945:       register rtx olabel = XEXP (XVECEXP (x, idx, i), 0);
        !          2946:       register rtx nlabel = follow_jumps (olabel);
        !          2947:       if (nlabel && nlabel != olabel)
        !          2948:        {
        !          2949:          XEXP (XVECEXP (x, idx, i), 0) = nlabel;
        !          2950:          ++LABEL_NUSES (nlabel);
        !          2951:          if (--LABEL_NUSES (olabel) == 0)
        !          2952:            delete_insn (olabel);
        !          2953:          changed = 1;
        !          2954:        }
        !          2955:     }
        !          2956:   return changed;
        !          2957: }
        !          2958: 
        !          2959: /* Find all CODE_LABELs referred to in X, and increment their use counts.
        !          2960:    If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
        !          2961:    in INSN, then store one of them in JUMP_LABEL (INSN).
        !          2962:    If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
        !          2963:    referenced in INSN, add a REG_LABEL note containing that label to INSN.
        !          2964:    Also, when there are consecutive labels, canonicalize on the last of them.
        !          2965: 
        !          2966:    Note that two labels separated by a loop-beginning note
        !          2967:    must be kept distinct if we have not yet done loop-optimization,
        !          2968:    because the gap between them is where loop-optimize
        !          2969:    will want to move invariant code to.  CROSS_JUMP tells us
        !          2970:    that loop-optimization is done with.
        !          2971: 
        !          2972:    Once reload has completed (CROSS_JUMP non-zero), we need not consider
        !          2973:    two labels distinct if they are separated by only USE or CLOBBER insns.  */
        !          2974: 
        !          2975: static void
        !          2976: mark_jump_label (x, insn, cross_jump)
        !          2977:      register rtx x;
        !          2978:      rtx insn;
        !          2979:      int cross_jump;
        !          2980: {
        !          2981:   register RTX_CODE code = GET_CODE (x);
        !          2982:   register int i;
        !          2983:   register char *fmt;
        !          2984: 
        !          2985:   switch (code)
        !          2986:     {
        !          2987:     case PC:
        !          2988:     case CC0:
        !          2989:     case REG:
        !          2990:     case SUBREG:
        !          2991:     case CONST_INT:
        !          2992:     case SYMBOL_REF:
        !          2993:     case CONST_DOUBLE:
        !          2994:     case CLOBBER:
        !          2995:     case CALL:
        !          2996:       return;
        !          2997: 
        !          2998:     case MEM:
        !          2999:       /* If this is a constant-pool reference, see if it is a label.  */
        !          3000:       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
        !          3001:          && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
        !          3002:        mark_jump_label (get_pool_constant (XEXP (x, 0)), insn, cross_jump);
        !          3003:       break;
        !          3004: 
        !          3005:     case LABEL_REF:
        !          3006:       {
        !          3007:        register rtx label = XEXP (x, 0);
        !          3008:        register rtx next;
        !          3009:        if (GET_CODE (label) != CODE_LABEL)
        !          3010:          abort ();
        !          3011:        /* Ignore references to labels of containing functions.  */
        !          3012:        if (LABEL_REF_NONLOCAL_P (x))
        !          3013:          break;
        !          3014:        /* If there are other labels following this one,
        !          3015:           replace it with the last of the consecutive labels.  */
        !          3016:        for (next = NEXT_INSN (label); next; next = NEXT_INSN (next))
        !          3017:          {
        !          3018:            if (GET_CODE (next) == CODE_LABEL)
        !          3019:              label = next;
        !          3020:            else if (cross_jump && GET_CODE (next) == INSN
        !          3021:                     && (GET_CODE (PATTERN (next)) == USE
        !          3022:                         || GET_CODE (PATTERN (next)) == CLOBBER))
        !          3023:              continue;
        !          3024:            else if (GET_CODE (next) != NOTE)
        !          3025:              break;
        !          3026:            else if (! cross_jump
        !          3027:                     && (NOTE_LINE_NUMBER (next) == NOTE_INSN_LOOP_BEG
        !          3028:                         || NOTE_LINE_NUMBER (next) == NOTE_INSN_FUNCTION_END))
        !          3029:              break;
        !          3030:          }
        !          3031:        XEXP (x, 0) = label;
        !          3032:        ++LABEL_NUSES (label);
        !          3033:        if (insn)
        !          3034:          {
        !          3035:            if (GET_CODE (insn) == JUMP_INSN)
        !          3036:              JUMP_LABEL (insn) = label;
        !          3037:            else if (! find_reg_note (insn, REG_LABEL, label))
        !          3038:              {
        !          3039:                rtx next = next_real_insn (label);
        !          3040:                /* Don't record labels that refer to dispatch tables.
        !          3041:                   This is not necessary, since the tablejump
        !          3042:                   references the same label.
        !          3043:                   And if we did record them, flow.c would make worse code.  */
        !          3044:                if (next == 0
        !          3045:                    || ! (GET_CODE (next) == JUMP_INSN
        !          3046:                          && (GET_CODE (PATTERN (next)) == ADDR_VEC
        !          3047:                              || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC)))
        !          3048:                  {
        !          3049:                    REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_LABEL, label,
        !          3050:                                                REG_NOTES (insn));
        !          3051:                    /* Record in the note whether label is nonlocal.  */
        !          3052:                    LABEL_REF_NONLOCAL_P (REG_NOTES (insn))
        !          3053:                      = LABEL_REF_NONLOCAL_P (x);
        !          3054:                  }
        !          3055:              }
        !          3056:          }
        !          3057:        return;
        !          3058:       }
        !          3059: 
        !          3060:   /* Do walk the labels in a vector, but not the first operand of an
        !          3061:      ADDR_DIFF_VEC.  Don't set the JUMP_LABEL of a vector.  */
        !          3062:     case ADDR_VEC:
        !          3063:     case ADDR_DIFF_VEC:
        !          3064:       {
        !          3065:        int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
        !          3066: 
        !          3067:        for (i = 0; i < XVECLEN (x, eltnum); i++)
        !          3068:          mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, cross_jump);
        !          3069:        return;
        !          3070:       }
        !          3071:     }
        !          3072: 
        !          3073:   fmt = GET_RTX_FORMAT (code);
        !          3074:   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
        !          3075:     {
        !          3076:       if (fmt[i] == 'e')
        !          3077:        mark_jump_label (XEXP (x, i), insn, cross_jump);
        !          3078:       else if (fmt[i] == 'E')
        !          3079:        {
        !          3080:          register int j;
        !          3081:          for (j = 0; j < XVECLEN (x, i); j++)
        !          3082:            mark_jump_label (XVECEXP (x, i, j), insn, cross_jump);
        !          3083:        }
        !          3084:     }
        !          3085: }
        !          3086: 
        !          3087: /* If all INSN does is set the pc, delete it,
        !          3088:    and delete the insn that set the condition codes for it
        !          3089:    if that's what the previous thing was.  */
        !          3090: 
        !          3091: void
        !          3092: delete_jump (insn)
        !          3093:      rtx insn;
        !          3094: {
        !          3095:   register rtx set = single_set (insn);
        !          3096: 
        !          3097:   if (set && GET_CODE (SET_DEST (set)) == PC)
        !          3098:     delete_computation (insn);
        !          3099: }
        !          3100: 
        !          3101: /* Delete INSN and recursively delete insns that compute values used only
        !          3102:    by INSN.  This uses the REG_DEAD notes computed during flow analysis.
        !          3103:    If we are running before flow.c, we need do nothing since flow.c will
        !          3104:    delete dead code.  We also can't know if the registers being used are
        !          3105:    dead or not at this point.
        !          3106: 
        !          3107:    Otherwise, look at all our REG_DEAD notes.  If a previous insn does
        !          3108:    nothing other than set a register that dies in this insn, we can delete
        !          3109:    that insn as well.
        !          3110: 
        !          3111:    On machines with CC0, if CC0 is used in this insn, we may be able to
        !          3112:    delete the insn that set it.  */
        !          3113: 
        !          3114: void
        !          3115: delete_computation (insn)
        !          3116:      rtx insn;
        !          3117: {
        !          3118:   rtx note, next;
        !          3119: 
        !          3120: #ifdef HAVE_cc0
        !          3121:   if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
        !          3122:     {
        !          3123:       rtx prev = prev_nonnote_insn (insn);
        !          3124:       /* We assume that at this stage
        !          3125:         CC's are always set explicitly
        !          3126:         and always immediately before the jump that
        !          3127:         will use them.  So if the previous insn
        !          3128:         exists to set the CC's, delete it
        !          3129:         (unless it performs auto-increments, etc.).  */
        !          3130:       if (prev && GET_CODE (prev) == INSN
        !          3131:          && sets_cc0_p (PATTERN (prev)))
        !          3132:        {
        !          3133:          if (sets_cc0_p (PATTERN (prev)) > 0
        !          3134:              && !FIND_REG_INC_NOTE (prev, NULL_RTX))
        !          3135:            delete_computation (prev);
        !          3136:          else
        !          3137:            /* Otherwise, show that cc0 won't be used.  */
        !          3138:            REG_NOTES (prev) = gen_rtx (EXPR_LIST, REG_UNUSED,
        !          3139:                                        cc0_rtx, REG_NOTES (prev));
        !          3140:        }
        !          3141:     }
        !          3142: #endif
        !          3143: 
        !          3144:   for (note = REG_NOTES (insn); note; note = next)
        !          3145:     {
        !          3146:       rtx our_prev;
        !          3147: 
        !          3148:       next = XEXP (note, 1);
        !          3149: 
        !          3150:       if (REG_NOTE_KIND (note) != REG_DEAD
        !          3151:          /* Verify that the REG_NOTE is legitimate.  */
        !          3152:          || GET_CODE (XEXP (note, 0)) != REG)
        !          3153:        continue;
        !          3154: 
        !          3155:       for (our_prev = prev_nonnote_insn (insn);
        !          3156:           our_prev && GET_CODE (our_prev) == INSN;
        !          3157:           our_prev = prev_nonnote_insn (our_prev))
        !          3158:        {
        !          3159:          /* If we reach a SEQUENCE, it is too complex to try to
        !          3160:             do anything with it, so give up.  */
        !          3161:          if (GET_CODE (PATTERN (our_prev)) == SEQUENCE)
        !          3162:            break;
        !          3163: 
        !          3164:          if (GET_CODE (PATTERN (our_prev)) == USE
        !          3165:              && GET_CODE (XEXP (PATTERN (our_prev), 0)) == INSN)
        !          3166:            /* reorg creates USEs that look like this.  We leave them
        !          3167:               alone because reorg needs them for its own purposes.  */
        !          3168:            break;
        !          3169: 
        !          3170:          if (reg_set_p (XEXP (note, 0), PATTERN (our_prev)))
        !          3171:            {
        !          3172:              if (FIND_REG_INC_NOTE (our_prev, NULL_RTX))
        !          3173:                break;
        !          3174: 
        !          3175:              if (GET_CODE (PATTERN (our_prev)) == PARALLEL)
        !          3176:                {
        !          3177:                  /* If we find a SET of something else, we can't
        !          3178:                     delete the insn.  */
        !          3179: 
        !          3180:                  int i;
        !          3181: 
        !          3182:                  for (i = 0; i < XVECLEN (PATTERN (our_prev), 0); i++)
        !          3183:                    {
        !          3184:                      rtx part = XVECEXP (PATTERN (our_prev), 0, i);
        !          3185: 
        !          3186:                      if (GET_CODE (part) == SET
        !          3187:                          && SET_DEST (part) != XEXP (note, 0))
        !          3188:                        break;
        !          3189:                    }
        !          3190: 
        !          3191:                  if (i == XVECLEN (PATTERN (our_prev), 0))
        !          3192:                    delete_computation (our_prev);
        !          3193:                }
        !          3194:              else if (GET_CODE (PATTERN (our_prev)) == SET
        !          3195:                       && SET_DEST (PATTERN (our_prev)) == XEXP (note, 0))
        !          3196:                delete_computation (our_prev);
        !          3197: 
        !          3198:              break;
        !          3199:            }
        !          3200: 
        !          3201:          /* If OUR_PREV references the register that dies here, it is an
        !          3202:             additional use.  Hence any prior SET isn't dead.  However, this
        !          3203:             insn becomes the new place for the REG_DEAD note.  */
        !          3204:          if (reg_overlap_mentioned_p (XEXP (note, 0),
        !          3205:                                       PATTERN (our_prev)))
        !          3206:            {
        !          3207:              XEXP (note, 1) = REG_NOTES (our_prev);
        !          3208:              REG_NOTES (our_prev) = note;
        !          3209:              break;
        !          3210:            }
        !          3211:        }
        !          3212:     }
        !          3213: 
        !          3214:   delete_insn (insn);
        !          3215: }
        !          3216: 
        !          3217: /* Delete insn INSN from the chain of insns and update label ref counts.
        !          3218:    May delete some following insns as a consequence; may even delete
        !          3219:    a label elsewhere and insns that follow it.
        !          3220: 
        !          3221:    Returns the first insn after INSN that was not deleted.  */
        !          3222: 
        !          3223: rtx
        !          3224: delete_insn (insn)
        !          3225:      register rtx insn;
        !          3226: {
        !          3227:   register rtx next = NEXT_INSN (insn);
        !          3228:   register rtx prev = PREV_INSN (insn);
        !          3229:   register int was_code_label = (GET_CODE (insn) == CODE_LABEL);
        !          3230:   register int dont_really_delete = 0;
        !          3231: 
        !          3232:   while (next && INSN_DELETED_P (next))
        !          3233:     next = NEXT_INSN (next);
        !          3234: 
        !          3235:   /* This insn is already deleted => return first following nondeleted.  */
        !          3236:   if (INSN_DELETED_P (insn))
        !          3237:     return next;
        !          3238: 
        !          3239:   /* Don't delete user-declared labels.  Convert them to special NOTEs
        !          3240:      instead.  */
        !          3241:   if (was_code_label && LABEL_NAME (insn) != 0
        !          3242:       && optimize && ! dont_really_delete)
        !          3243:     {
        !          3244:       PUT_CODE (insn, NOTE);
        !          3245:       NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED_LABEL;
        !          3246:       NOTE_SOURCE_FILE (insn) = 0;
        !          3247:       dont_really_delete = 1;
        !          3248:     }
        !          3249:   else
        !          3250:     /* Mark this insn as deleted.  */
        !          3251:     INSN_DELETED_P (insn) = 1;
        !          3252: 
        !          3253:   /* If this is an unconditional jump, delete it from the jump chain.  */
        !          3254:   if (simplejump_p (insn))
        !          3255:     delete_from_jump_chain (insn);
        !          3256: 
        !          3257:   /* If instruction is followed by a barrier,
        !          3258:      delete the barrier too.  */
        !          3259: 
        !          3260:   if (next != 0 && GET_CODE (next) == BARRIER)
        !          3261:     {
        !          3262:       INSN_DELETED_P (next) = 1;
        !          3263:       next = NEXT_INSN (next);
        !          3264:     }
        !          3265: 
        !          3266:   /* Patch out INSN (and the barrier if any) */
        !          3267: 
        !          3268:   if (optimize && ! dont_really_delete)
        !          3269:     {
        !          3270:       if (prev)
        !          3271:        {
        !          3272:          NEXT_INSN (prev) = next;
        !          3273:          if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
        !          3274:            NEXT_INSN (XVECEXP (PATTERN (prev), 0,
        !          3275:                                XVECLEN (PATTERN (prev), 0) - 1)) = next;
        !          3276:        }
        !          3277: 
        !          3278:       if (next)
        !          3279:        {
        !          3280:          PREV_INSN (next) = prev;
        !          3281:          if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
        !          3282:            PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
        !          3283:        }
        !          3284: 
        !          3285:       if (prev && NEXT_INSN (prev) == 0)
        !          3286:        set_last_insn (prev);
        !          3287:     }
        !          3288: 
        !          3289:   /* If deleting a jump, decrement the count of the label,
        !          3290:      and delete the label if it is now unused.  */
        !          3291: 
        !          3292:   if (GET_CODE (insn) == JUMP_INSN && JUMP_LABEL (insn))
        !          3293:     if (--LABEL_NUSES (JUMP_LABEL (insn)) == 0)
        !          3294:       {
        !          3295:        /* This can delete NEXT or PREV,
        !          3296:           either directly if NEXT is JUMP_LABEL (INSN),
        !          3297:           or indirectly through more levels of jumps.  */
        !          3298:        delete_insn (JUMP_LABEL (insn));
        !          3299:        /* I feel a little doubtful about this loop,
        !          3300:           but I see no clean and sure alternative way
        !          3301:           to find the first insn after INSN that is not now deleted.
        !          3302:           I hope this works.  */
        !          3303:        while (next && INSN_DELETED_P (next))
        !          3304:          next = NEXT_INSN (next);
        !          3305:        return next;
        !          3306:       }
        !          3307: 
        !          3308:   while (prev && (INSN_DELETED_P (prev) || GET_CODE (prev) == NOTE))
        !          3309:     prev = PREV_INSN (prev);
        !          3310: 
        !          3311:   /* If INSN was a label and a dispatch table follows it,
        !          3312:      delete the dispatch table.  The tablejump must have gone already.
        !          3313:      It isn't useful to fall through into a table.  */
        !          3314: 
        !          3315:   if (was_code_label
        !          3316:       && NEXT_INSN (insn) != 0
        !          3317:       && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
        !          3318:       && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
        !          3319:          || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
        !          3320:     next = delete_insn (NEXT_INSN (insn));
        !          3321: 
        !          3322:   /* If INSN was a label, delete insns following it if now unreachable.  */
        !          3323: 
        !          3324:   if (was_code_label && prev && GET_CODE (prev) == BARRIER)
        !          3325:     {
        !          3326:       register RTX_CODE code;
        !          3327:       while (next != 0
        !          3328:             && ((code = GET_CODE (next)) == INSN
        !          3329:                 || code == JUMP_INSN || code == CALL_INSN
        !          3330:                 || code == NOTE
        !          3331:                 || (code == CODE_LABEL && INSN_DELETED_P (next))))
        !          3332:        {
        !          3333:          if (code == NOTE
        !          3334:              && NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
        !          3335:            next = NEXT_INSN (next);
        !          3336:          /* Keep going past other deleted labels to delete what follows.  */
        !          3337:          else if (code == CODE_LABEL && INSN_DELETED_P (next))
        !          3338:            next = NEXT_INSN (next);
        !          3339:          else
        !          3340:            /* Note: if this deletes a jump, it can cause more
        !          3341:               deletion of unreachable code, after a different label.
        !          3342:               As long as the value from this recursive call is correct,
        !          3343:               this invocation functions correctly.  */
        !          3344:            next = delete_insn (next);
        !          3345:        }
        !          3346:     }
        !          3347: 
        !          3348:   return next;
        !          3349: }
        !          3350: 
        !          3351: /* Advance from INSN till reaching something not deleted
        !          3352:    then return that.  May return INSN itself.  */
        !          3353: 
        !          3354: rtx
        !          3355: next_nondeleted_insn (insn)
        !          3356:      rtx insn;
        !          3357: {
        !          3358:   while (INSN_DELETED_P (insn))
        !          3359:     insn = NEXT_INSN (insn);
        !          3360:   return insn;
        !          3361: }
        !          3362: 
        !          3363: /* Delete a range of insns from FROM to TO, inclusive.
        !          3364:    This is for the sake of peephole optimization, so assume
        !          3365:    that whatever these insns do will still be done by a new
        !          3366:    peephole insn that will replace them.  */
        !          3367: 
        !          3368: void
        !          3369: delete_for_peephole (from, to)
        !          3370:      register rtx from, to;
        !          3371: {
        !          3372:   register rtx insn = from;
        !          3373: 
        !          3374:   while (1)
        !          3375:     {
        !          3376:       register rtx next = NEXT_INSN (insn);
        !          3377:       register rtx prev = PREV_INSN (insn);
        !          3378: 
        !          3379:       if (GET_CODE (insn) != NOTE)
        !          3380:        {
        !          3381:          INSN_DELETED_P (insn) = 1;
        !          3382: 
        !          3383:          /* Patch this insn out of the chain.  */
        !          3384:          /* We don't do this all at once, because we
        !          3385:             must preserve all NOTEs.  */
        !          3386:          if (prev)
        !          3387:            NEXT_INSN (prev) = next;
        !          3388: 
        !          3389:          if (next)
        !          3390:            PREV_INSN (next) = prev;
        !          3391:        }
        !          3392: 
        !          3393:       if (insn == to)
        !          3394:        break;
        !          3395:       insn = next;
        !          3396:     }
        !          3397: 
        !          3398:   /* Note that if TO is an unconditional jump
        !          3399:      we *do not* delete the BARRIER that follows,
        !          3400:      since the peephole that replaces this sequence
        !          3401:      is also an unconditional jump in that case.  */
        !          3402: }
        !          3403: 
        !          3404: /* Invert the condition of the jump JUMP, and make it jump
        !          3405:    to label NLABEL instead of where it jumps now.  */
        !          3406: 
        !          3407: int
        !          3408: invert_jump (jump, nlabel)
        !          3409:      rtx jump, nlabel;
        !          3410: {
        !          3411:   register rtx olabel = JUMP_LABEL (jump);
        !          3412: 
        !          3413:   /* We have to either invert the condition and change the label or
        !          3414:      do neither.  Either operation could fail.  We first try to invert
        !          3415:      the jump. If that succeeds, we try changing the label.  If that fails,
        !          3416:      we invert the jump back to what it was.  */
        !          3417: 
        !          3418:   if (! invert_exp (PATTERN (jump), jump))
        !          3419:     return 0;
        !          3420: 
        !          3421:   if (redirect_jump (jump, nlabel))
        !          3422:     return 1;
        !          3423: 
        !          3424:   if (! invert_exp (PATTERN (jump), jump))
        !          3425:     /* This should just be putting it back the way it was.  */
        !          3426:     abort ();
        !          3427: 
        !          3428:   return  0;
        !          3429: }
        !          3430: 
        !          3431: /* Invert the jump condition of rtx X contained in jump insn, INSN. 
        !          3432: 
        !          3433:    Return 1 if we can do so, 0 if we cannot find a way to do so that
        !          3434:    matches a pattern.  */
        !          3435: 
        !          3436: int
        !          3437: invert_exp (x, insn)
        !          3438:      rtx x;
        !          3439:      rtx insn;
        !          3440: {
        !          3441:   register RTX_CODE code;
        !          3442:   register int i;
        !          3443:   register char *fmt;
        !          3444: 
        !          3445:   code = GET_CODE (x);
        !          3446: 
        !          3447:   if (code == IF_THEN_ELSE)
        !          3448:     {
        !          3449:       register rtx comp = XEXP (x, 0);
        !          3450:       register rtx tem;
        !          3451: 
        !          3452:       /* We can do this in two ways:  The preferable way, which can only
        !          3453:         be done if this is not an integer comparison, is to reverse
        !          3454:         the comparison code.  Otherwise, swap the THEN-part and ELSE-part
        !          3455:         of the IF_THEN_ELSE.  If we can't do either, fail.  */
        !          3456: 
        !          3457:       if (can_reverse_comparison_p (comp, insn)
        !          3458:          && validate_change (insn, &XEXP (x, 0),
        !          3459:                              gen_rtx (reverse_condition (GET_CODE (comp)),
        !          3460:                                       GET_MODE (comp), XEXP (comp, 0),
        !          3461:                                       XEXP (comp, 1)), 0))
        !          3462:        return 1;
        !          3463:                                       
        !          3464:       tem = XEXP (x, 1);
        !          3465:       validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
        !          3466:       validate_change (insn, &XEXP (x, 2), tem, 1);
        !          3467:       return apply_change_group ();
        !          3468:     }
        !          3469: 
        !          3470:   fmt = GET_RTX_FORMAT (code);
        !          3471:   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
        !          3472:     {
        !          3473:       if (fmt[i] == 'e')
        !          3474:        if (! invert_exp (XEXP (x, i), insn))
        !          3475:          return 0;
        !          3476:       if (fmt[i] == 'E')
        !          3477:        {
        !          3478:          register int j;
        !          3479:          for (j = 0; j < XVECLEN (x, i); j++)
        !          3480:            if (!invert_exp (XVECEXP (x, i, j), insn))
        !          3481:              return 0;
        !          3482:        }
        !          3483:     }
        !          3484: 
        !          3485:   return 1;
        !          3486: }
        !          3487: 
        !          3488: /* Make jump JUMP jump to label NLABEL instead of where it jumps now.
        !          3489:    If the old jump target label is unused as a result,
        !          3490:    it and the code following it may be deleted.
        !          3491: 
        !          3492:    If NLABEL is zero, we are to turn the jump into a (possibly conditional)
        !          3493:    RETURN insn.
        !          3494: 
        !          3495:    The return value will be 1 if the change was made, 0 if it wasn't (this
        !          3496:    can only occur for NLABEL == 0).  */
        !          3497: 
        !          3498: int
        !          3499: redirect_jump (jump, nlabel)
        !          3500:      rtx jump, nlabel;
        !          3501: {
        !          3502:   register rtx olabel = JUMP_LABEL (jump);
        !          3503: 
        !          3504:   if (nlabel == olabel)
        !          3505:     return 1;
        !          3506: 
        !          3507:   if (! redirect_exp (&PATTERN (jump), olabel, nlabel, jump))
        !          3508:     return 0;
        !          3509: 
        !          3510:   /* If this is an unconditional branch, delete it from the jump_chain of
        !          3511:      OLABEL and add it to the jump_chain of NLABEL (assuming both labels
        !          3512:      have UID's in range and JUMP_CHAIN is valid).  */
        !          3513:   if (jump_chain && (simplejump_p (jump)
        !          3514:                     || GET_CODE (PATTERN (jump)) == RETURN))
        !          3515:     {
        !          3516:       int label_index = nlabel ? INSN_UID (nlabel) : 0;
        !          3517: 
        !          3518:       delete_from_jump_chain (jump);
        !          3519:       if (label_index < max_jump_chain
        !          3520:          && INSN_UID (jump) < max_jump_chain)
        !          3521:        {
        !          3522:          jump_chain[INSN_UID (jump)] = jump_chain[label_index];
        !          3523:          jump_chain[label_index] = jump;
        !          3524:        }
        !          3525:     }
        !          3526: 
        !          3527:   JUMP_LABEL (jump) = nlabel;
        !          3528:   if (nlabel)
        !          3529:     ++LABEL_NUSES (nlabel);
        !          3530: 
        !          3531:   if (olabel && --LABEL_NUSES (olabel) == 0)
        !          3532:     delete_insn (olabel);
        !          3533: 
        !          3534:   return 1;
        !          3535: }
        !          3536: 
        !          3537: /* Delete the instruction JUMP from any jump chain it might be on.  */
        !          3538: 
        !          3539: static void
        !          3540: delete_from_jump_chain (jump)
        !          3541:      rtx jump;
        !          3542: {
        !          3543:   int index;
        !          3544:   rtx olabel = JUMP_LABEL (jump);
        !          3545: 
        !          3546:   /* Handle unconditional jumps.  */
        !          3547:   if (jump_chain && olabel != 0
        !          3548:       && INSN_UID (olabel) < max_jump_chain
        !          3549:       && simplejump_p (jump))
        !          3550:     index = INSN_UID (olabel);
        !          3551:   /* Handle return insns.  */
        !          3552:   else if (jump_chain && GET_CODE (PATTERN (jump)) == RETURN)
        !          3553:     index = 0;
        !          3554:   else return;
        !          3555: 
        !          3556:   if (jump_chain[index] == jump)
        !          3557:     jump_chain[index] = jump_chain[INSN_UID (jump)];
        !          3558:   else
        !          3559:     {
        !          3560:       rtx insn;
        !          3561: 
        !          3562:       for (insn = jump_chain[index];
        !          3563:           insn != 0;
        !          3564:           insn = jump_chain[INSN_UID (insn)])
        !          3565:        if (jump_chain[INSN_UID (insn)] == jump)
        !          3566:          {
        !          3567:            jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (jump)];
        !          3568:            break;
        !          3569:          }
        !          3570:     }
        !          3571: }
        !          3572: 
        !          3573: /* If NLABEL is nonzero, throughout the rtx at LOC,
        !          3574:    alter (LABEL_REF OLABEL) to (LABEL_REF NLABEL).  If OLABEL is
        !          3575:    zero, alter (RETURN) to (LABEL_REF NLABEL).
        !          3576: 
        !          3577:    If NLABEL is zero, alter (LABEL_REF OLABEL) to (RETURN) and check
        !          3578:    validity with validate_change.  Convert (set (pc) (label_ref olabel))
        !          3579:    to (return).
        !          3580: 
        !          3581:    Return 0 if we found a change we would like to make but it is invalid.
        !          3582:    Otherwise, return 1.  */
        !          3583: 
        !          3584: int
        !          3585: redirect_exp (loc, olabel, nlabel, insn)
        !          3586:      rtx *loc;
        !          3587:      rtx olabel, nlabel;
        !          3588:      rtx insn;
        !          3589: {
        !          3590:   register rtx x = *loc;
        !          3591:   register RTX_CODE code = GET_CODE (x);
        !          3592:   register int i;
        !          3593:   register char *fmt;
        !          3594: 
        !          3595:   if (code == LABEL_REF)
        !          3596:     {
        !          3597:       if (XEXP (x, 0) == olabel)
        !          3598:        {
        !          3599:          if (nlabel)
        !          3600:            XEXP (x, 0) = nlabel;
        !          3601:          else
        !          3602:            return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0);
        !          3603:          return 1;
        !          3604:        }
        !          3605:     }
        !          3606:   else if (code == RETURN && olabel == 0)
        !          3607:     {
        !          3608:       x = gen_rtx (LABEL_REF, VOIDmode, nlabel);
        !          3609:       if (loc == &PATTERN (insn))
        !          3610:        x = gen_rtx (SET, VOIDmode, pc_rtx, x);
        !          3611:       return validate_change (insn, loc, x, 0);
        !          3612:     }
        !          3613: 
        !          3614:   if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
        !          3615:       && GET_CODE (SET_SRC (x)) == LABEL_REF
        !          3616:       && XEXP (SET_SRC (x), 0) == olabel)
        !          3617:     return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0);
        !          3618: 
        !          3619:   fmt = GET_RTX_FORMAT (code);
        !          3620:   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
        !          3621:     {
        !          3622:       if (fmt[i] == 'e')
        !          3623:        if (! redirect_exp (&XEXP (x, i), olabel, nlabel, insn))
        !          3624:          return 0;
        !          3625:       if (fmt[i] == 'E')
        !          3626:        {
        !          3627:          register int j;
        !          3628:          for (j = 0; j < XVECLEN (x, i); j++)
        !          3629:            if (! redirect_exp (&XVECEXP (x, i, j), olabel, nlabel, insn))
        !          3630:              return 0;
        !          3631:        }
        !          3632:     }
        !          3633: 
        !          3634:   return 1;
        !          3635: }
        !          3636: 
        !          3637: /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
        !          3638: 
        !          3639:    If the old jump target label (before the dispatch table) becomes unused,
        !          3640:    it and the dispatch table may be deleted.  In that case, find the insn
        !          3641:    before the jump references that label and delete it and logical successors
        !          3642:    too.  */
        !          3643: 
        !          3644: void
        !          3645: redirect_tablejump (jump, nlabel)
        !          3646:      rtx jump, nlabel;
        !          3647: {
        !          3648:   register rtx olabel = JUMP_LABEL (jump);
        !          3649: 
        !          3650:   /* Add this jump to the jump_chain of NLABEL.  */
        !          3651:   if (jump_chain && INSN_UID (nlabel) < max_jump_chain
        !          3652:       && INSN_UID (jump) < max_jump_chain)
        !          3653:     {
        !          3654:       jump_chain[INSN_UID (jump)] = jump_chain[INSN_UID (nlabel)];
        !          3655:       jump_chain[INSN_UID (nlabel)] = jump;
        !          3656:     }
        !          3657: 
        !          3658:   PATTERN (jump) = gen_jump (nlabel);
        !          3659:   JUMP_LABEL (jump) = nlabel;
        !          3660:   ++LABEL_NUSES (nlabel);
        !          3661:   INSN_CODE (jump) = -1;
        !          3662: 
        !          3663:   if (--LABEL_NUSES (olabel) == 0)
        !          3664:     {
        !          3665:       delete_labelref_insn (jump, olabel, 0);
        !          3666:       delete_insn (olabel);
        !          3667:     }
        !          3668: }
        !          3669: 
        !          3670: /* Find the insn referencing LABEL that is a logical predecessor of INSN.
        !          3671:    If we found one, delete it and then delete this insn if DELETE_THIS is
        !          3672:    non-zero.  Return non-zero if INSN or a predecessor references LABEL.  */
        !          3673: 
        !          3674: static int
        !          3675: delete_labelref_insn (insn, label, delete_this)
        !          3676:      rtx insn, label;
        !          3677:      int delete_this;
        !          3678: {
        !          3679:   int deleted = 0;
        !          3680:   rtx link;
        !          3681: 
        !          3682:   if (GET_CODE (insn) != NOTE
        !          3683:       && reg_mentioned_p (label, PATTERN (insn)))
        !          3684:     {
        !          3685:       if (delete_this)
        !          3686:        {
        !          3687:          delete_insn (insn);
        !          3688:          deleted = 1;
        !          3689:        }
        !          3690:       else
        !          3691:        return 1;
        !          3692:     }
        !          3693: 
        !          3694:   for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
        !          3695:     if (delete_labelref_insn (XEXP (link, 0), label, 1))
        !          3696:       {
        !          3697:        if (delete_this)
        !          3698:          {
        !          3699:            delete_insn (insn);
        !          3700:            deleted = 1;
        !          3701:          }
        !          3702:        else
        !          3703:          return 1;
        !          3704:       }
        !          3705: 
        !          3706:   return deleted;
        !          3707: }
        !          3708: 
        !          3709: /* Like rtx_equal_p except that it considers two REGs as equal
        !          3710:    if they renumber to the same value.  */
        !          3711: 
        !          3712: int
        !          3713: rtx_renumbered_equal_p (x, y)
        !          3714:      rtx x, y;
        !          3715: {
        !          3716:   register int i;
        !          3717:   register RTX_CODE code = GET_CODE (x);
        !          3718:   register char *fmt;
        !          3719:       
        !          3720:   if (x == y)
        !          3721:     return 1;
        !          3722:   if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
        !          3723:       && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
        !          3724:                                  && GET_CODE (SUBREG_REG (y)) == REG)))
        !          3725:     {
        !          3726:       register int j;
        !          3727: 
        !          3728:       if (GET_MODE (x) != GET_MODE (y))
        !          3729:        return 0;
        !          3730: 
        !          3731:       /* If we haven't done any renumbering, don't
        !          3732:         make any assumptions.  */
        !          3733:       if (reg_renumber == 0)
        !          3734:        return rtx_equal_p (x, y);
        !          3735: 
        !          3736:       if (code == SUBREG)
        !          3737:        {
        !          3738:          i = REGNO (SUBREG_REG (x));
        !          3739:          if (reg_renumber[i] >= 0)
        !          3740:            i = reg_renumber[i];
        !          3741:          i += SUBREG_WORD (x);
        !          3742:        }
        !          3743:       else
        !          3744:        {
        !          3745:          i = REGNO (x);
        !          3746:          if (reg_renumber[i] >= 0)
        !          3747:            i = reg_renumber[i];
        !          3748:        }
        !          3749:       if (GET_CODE (y) == SUBREG)
        !          3750:        {
        !          3751:          j = REGNO (SUBREG_REG (y));
        !          3752:          if (reg_renumber[j] >= 0)
        !          3753:            j = reg_renumber[j];
        !          3754:          j += SUBREG_WORD (y);
        !          3755:        }
        !          3756:       else
        !          3757:        {
        !          3758:          j = REGNO (y);
        !          3759:          if (reg_renumber[j] >= 0)
        !          3760:            j = reg_renumber[j];
        !          3761:        }
        !          3762:       return i == j;
        !          3763:     }
        !          3764:   /* Now we have disposed of all the cases 
        !          3765:      in which different rtx codes can match.  */
        !          3766:   if (code != GET_CODE (y))
        !          3767:     return 0;
        !          3768:   switch (code)
        !          3769:     {
        !          3770:     case PC:
        !          3771:     case CC0:
        !          3772:     case ADDR_VEC:
        !          3773:     case ADDR_DIFF_VEC:
        !          3774:       return 0;
        !          3775: 
        !          3776:     case CONST_INT:
        !          3777:       return INTVAL (x) == INTVAL (y);
        !          3778: 
        !          3779:     case LABEL_REF:
        !          3780:       /* We can't assume nonlocal labels have their following insns yet.  */
        !          3781:       if (LABEL_REF_NONLOCAL_P (x) || LABEL_REF_NONLOCAL_P (y))
        !          3782:        return XEXP (x, 0) == XEXP (y, 0);
        !          3783:       /* Two label-refs are equivalent if they point at labels
        !          3784:         in the same position in the instruction stream.  */
        !          3785:       return (next_real_insn (XEXP (x, 0))
        !          3786:              == next_real_insn (XEXP (y, 0)));
        !          3787: 
        !          3788:     case SYMBOL_REF:
        !          3789:       return XSTR (x, 0) == XSTR (y, 0);
        !          3790:     }
        !          3791: 
        !          3792:   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.  */
        !          3793: 
        !          3794:   if (GET_MODE (x) != GET_MODE (y))
        !          3795:     return 0;
        !          3796: 
        !          3797:   /* Compare the elements.  If any pair of corresponding elements
        !          3798:      fail to match, return 0 for the whole things.  */
        !          3799: 
        !          3800:   fmt = GET_RTX_FORMAT (code);
        !          3801:   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
        !          3802:     {
        !          3803:       register int j;
        !          3804:       switch (fmt[i])
        !          3805:        {
        !          3806:        case 'w':
        !          3807:          if (XWINT (x, i) != XWINT (y, i))
        !          3808:            return 0;
        !          3809:          break;
        !          3810: 
        !          3811:        case 'i':
        !          3812:          if (XINT (x, i) != XINT (y, i))
        !          3813:            return 0;
        !          3814:          break;
        !          3815: 
        !          3816:        case 's':
        !          3817:          if (strcmp (XSTR (x, i), XSTR (y, i)))
        !          3818:            return 0;
        !          3819:          break;
        !          3820: 
        !          3821:        case 'e':
        !          3822:          if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
        !          3823:            return 0;
        !          3824:          break;
        !          3825: 
        !          3826:        case 'u':
        !          3827:          if (XEXP (x, i) != XEXP (y, i))
        !          3828:            return 0;
        !          3829:          /* fall through.  */
        !          3830:        case '0':
        !          3831:          break;
        !          3832: 
        !          3833:        case 'E':
        !          3834:          if (XVECLEN (x, i) != XVECLEN (y, i))
        !          3835:            return 0;
        !          3836:          for (j = XVECLEN (x, i) - 1; j >= 0; j--)
        !          3837:            if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
        !          3838:              return 0;
        !          3839:          break;
        !          3840: 
        !          3841:        default:
        !          3842:          abort ();
        !          3843:        }
        !          3844:     }
        !          3845:   return 1;
        !          3846: }
        !          3847: 
        !          3848: /* If X is a hard register or equivalent to one or a subregister of one,
        !          3849:    return the hard register number.  If X is a pseudo register that was not
        !          3850:    assigned a hard register, return the pseudo register number.  Otherwise,
        !          3851:    return -1.  Any rtx is valid for X.  */
        !          3852: 
        !          3853: int
        !          3854: true_regnum (x)
        !          3855:      rtx x;
        !          3856: {
        !          3857:   if (GET_CODE (x) == REG)
        !          3858:     {
        !          3859:       if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
        !          3860:        return reg_renumber[REGNO (x)];
        !          3861:       return REGNO (x);
        !          3862:     }
        !          3863:   if (GET_CODE (x) == SUBREG)
        !          3864:     {
        !          3865:       int base = true_regnum (SUBREG_REG (x));
        !          3866:       if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
        !          3867:        return SUBREG_WORD (x) + base;
        !          3868:     }
        !          3869:   return -1;
        !          3870: }
        !          3871: 
        !          3872: /* Optimize code of the form:
        !          3873: 
        !          3874:        for (x = a[i]; x; ...)
        !          3875:          ...
        !          3876:        for (x = a[i]; x; ...)
        !          3877:          ...
        !          3878:       foo:
        !          3879: 
        !          3880:    Loop optimize will change the above code into
        !          3881: 
        !          3882:        if (x = a[i])
        !          3883:          for (;;)
        !          3884:             { ...; if (! (x = ...)) break; }
        !          3885:        if (x = a[i])
        !          3886:          for (;;)
        !          3887:             { ...; if (! (x = ...)) break; }
        !          3888:       foo:
        !          3889: 
        !          3890:    In general, if the first test fails, the program can branch
        !          3891:    directly to `foo' and skip the second try which is doomed to fail.
        !          3892:    We run this after loop optimization and before flow analysis.  */
        !          3893:    
        !          3894: /* When comparing the insn patterns, we track the fact that different
        !          3895:    pseudo-register numbers may have been used in each computation.
        !          3896:    The following array stores an equivalence -- same_regs[I] == J means
        !          3897:    that pseudo register I was used in the first set of tests in a context
        !          3898:    where J was used in the second set.  We also count the number of such
        !          3899:    pending equivalences.  If nonzero, the expressions really aren't the
        !          3900:    same.  */
        !          3901: 
        !          3902: static int *same_regs;
        !          3903: 
        !          3904: static int num_same_regs;
        !          3905: 
        !          3906: /* Track any registers modified between the target of the first jump and
        !          3907:    the second jump.  They never compare equal.  */
        !          3908: 
        !          3909: static char *modified_regs;
        !          3910: 
        !          3911: /* Record if memory was modified.  */
        !          3912: 
        !          3913: static int modified_mem;
        !          3914: 
        !          3915: /* Called via note_stores on each insn between the target of the first 
        !          3916:    branch and the second branch.  It marks any changed registers.  */
        !          3917: 
        !          3918: static void
        !          3919: mark_modified_reg (dest, x)
        !          3920:      rtx dest;
        !          3921:      rtx x;
        !          3922: {
        !          3923:   int regno, i;
        !          3924: 
        !          3925:   if (GET_CODE (dest) == SUBREG)
        !          3926:     dest = SUBREG_REG (dest);
        !          3927: 
        !          3928:   if (GET_CODE (dest) == MEM)
        !          3929:     modified_mem = 1;
        !          3930: 
        !          3931:   if (GET_CODE (dest) != REG)
        !          3932:     return;
        !          3933: 
        !          3934:   regno = REGNO (dest);
        !          3935:   if (regno >= FIRST_PSEUDO_REGISTER)
        !          3936:     modified_regs[regno] = 1;
        !          3937:   else
        !          3938:     for (i = 0; i < HARD_REGNO_NREGS (regno, GET_MODE (dest)); i++)
        !          3939:       modified_regs[regno + i] = 1;
        !          3940: }
        !          3941: 
        !          3942: /* F is the first insn in the chain of insns.  */
        !          3943:    
        !          3944: void
        !          3945: thread_jumps (f, max_reg, verbose)
        !          3946:      rtx f;
        !          3947:      int max_reg;
        !          3948:      int verbose;
        !          3949: {
        !          3950:   /* Basic algorithm is to find a conditional branch,
        !          3951:      the label it may branch to, and the branch after
        !          3952:      that label.  If the two branches test the same condition,
        !          3953:      walk back from both branch paths until the insn patterns
        !          3954:      differ, or code labels are hit.  If we make it back to
        !          3955:      the target of the first branch, then we know that the first branch
        !          3956:      will either always succeed or always fail depending on the relative
        !          3957:      senses of the two branches.  So adjust the first branch accordingly
        !          3958:      in this case.  */
        !          3959:      
        !          3960:   rtx label, b1, b2, t1, t2;
        !          3961:   enum rtx_code code1, code2;
        !          3962:   rtx b1op0, b1op1, b2op0, b2op1;
        !          3963:   int changed = 1;
        !          3964:   int i;
        !          3965:   int *all_reset;
        !          3966: 
        !          3967:   /* Allocate register tables and quick-reset table.  */
        !          3968:   modified_regs = (char *) alloca (max_reg * sizeof (char));
        !          3969:   same_regs = (int *) alloca (max_reg * sizeof (int));
        !          3970:   all_reset = (int *) alloca (max_reg * sizeof (int));
        !          3971:   for (i = 0; i < max_reg; i++)
        !          3972:     all_reset[i] = -1;
        !          3973:     
        !          3974:   while (changed)
        !          3975:     {
        !          3976:       changed = 0;
        !          3977: 
        !          3978:       for (b1 = f; b1; b1 = NEXT_INSN (b1))
        !          3979:        {
        !          3980:          /* Get to a candidate branch insn.  */
        !          3981:          if (GET_CODE (b1) != JUMP_INSN
        !          3982:              || ! condjump_p (b1) || simplejump_p (b1)
        !          3983:              || JUMP_LABEL (b1) == 0)
        !          3984:            continue;
        !          3985: 
        !          3986:          bzero (modified_regs, max_reg * sizeof (char));
        !          3987:          modified_mem = 0;
        !          3988: 
        !          3989:          bcopy (all_reset, same_regs, max_reg * sizeof (int));
        !          3990:          num_same_regs = 0;
        !          3991: 
        !          3992:          label = JUMP_LABEL (b1);
        !          3993: 
        !          3994:          /* Look for a branch after the target.  Record any registers and
        !          3995:             memory modified between the target and the branch.  Stop when we
        !          3996:             get to a label since we can't know what was changed there.  */
        !          3997:          for (b2 = NEXT_INSN (label); b2; b2 = NEXT_INSN (b2))
        !          3998:            {
        !          3999:              if (GET_CODE (b2) == CODE_LABEL)
        !          4000:                break;
        !          4001: 
        !          4002:              else if (GET_CODE (b2) == JUMP_INSN)
        !          4003:                {
        !          4004:                  /* If this is an unconditional jump and is the only use of
        !          4005:                     its target label, we can follow it.  */
        !          4006:                  if (simplejump_p (b2)
        !          4007:                      && JUMP_LABEL (b2) != 0
        !          4008:                      && LABEL_NUSES (JUMP_LABEL (b2)) == 1)
        !          4009:                    {
        !          4010:                      b2 = JUMP_LABEL (b2);
        !          4011:                      continue;
        !          4012:                    }
        !          4013:                  else
        !          4014:                    break;
        !          4015:                }
        !          4016: 
        !          4017:              if (GET_CODE (b2) != CALL_INSN && GET_CODE (b2) != INSN)
        !          4018:                continue;
        !          4019: 
        !          4020:              if (GET_CODE (b2) == CALL_INSN)
        !          4021:                {
        !          4022:                  modified_mem = 1;
        !          4023:                  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
        !          4024:                    if (call_used_regs[i] && ! fixed_regs[i]
        !          4025:                        && i != STACK_POINTER_REGNUM
        !          4026:                        && i != FRAME_POINTER_REGNUM
        !          4027:                        && i != HARD_FRAME_POINTER_REGNUM
        !          4028:                        && i != ARG_POINTER_REGNUM)
        !          4029:                      modified_regs[i] = 1;
        !          4030:                }
        !          4031: 
        !          4032:              note_stores (PATTERN (b2), mark_modified_reg);
        !          4033:            }
        !          4034: 
        !          4035:          /* Check the next candidate branch insn from the label
        !          4036:             of the first.  */
        !          4037:          if (b2 == 0
        !          4038:              || GET_CODE (b2) != JUMP_INSN
        !          4039:              || b2 == b1
        !          4040:              || ! condjump_p (b2)
        !          4041:              || simplejump_p (b2))
        !          4042:            continue;
        !          4043: 
        !          4044:          /* Get the comparison codes and operands, reversing the
        !          4045:             codes if appropriate.  If we don't have comparison codes,
        !          4046:             we can't do anything.  */
        !          4047:          b1op0 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 0);
        !          4048:          b1op1 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 1);
        !          4049:          code1 = GET_CODE (XEXP (SET_SRC (PATTERN (b1)), 0));
        !          4050:          if (XEXP (SET_SRC (PATTERN (b1)), 1) == pc_rtx)
        !          4051:            code1 = reverse_condition (code1);
        !          4052: 
        !          4053:          b2op0 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 0);
        !          4054:          b2op1 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 1);
        !          4055:          code2 = GET_CODE (XEXP (SET_SRC (PATTERN (b2)), 0));
        !          4056:          if (XEXP (SET_SRC (PATTERN (b2)), 1) == pc_rtx)
        !          4057:            code2 = reverse_condition (code2);
        !          4058: 
        !          4059:          /* If they test the same things and knowing that B1 branches
        !          4060:             tells us whether or not B2 branches, check if we
        !          4061:             can thread the branch.  */
        !          4062:          if (rtx_equal_for_thread_p (b1op0, b2op0, b2)
        !          4063:              && rtx_equal_for_thread_p (b1op1, b2op1, b2)
        !          4064:              && (comparison_dominates_p (code1, code2)
        !          4065:                  || comparison_dominates_p (code1, reverse_condition (code2))))
        !          4066:            {
        !          4067:              t1 = prev_nonnote_insn (b1);
        !          4068:              t2 = prev_nonnote_insn (b2);
        !          4069:              
        !          4070:              while (t1 != 0 && t2 != 0)
        !          4071:                {
        !          4072:                  if (t1 == 0 || t2 == 0)
        !          4073:                    break;
        !          4074: 
        !          4075:                  if (t2 == label)
        !          4076:                    {
        !          4077:                      /* We have reached the target of the first branch.
        !          4078:                         If there are no pending register equivalents,
        !          4079:                         we know that this branch will either always
        !          4080:                         succeed (if the senses of the two branches are
        !          4081:                         the same) or always fail (if not).  */
        !          4082:                      rtx new_label;
        !          4083: 
        !          4084:                      if (num_same_regs != 0)
        !          4085:                        break;
        !          4086: 
        !          4087:                      if (comparison_dominates_p (code1, code2))
        !          4088:                        new_label = JUMP_LABEL (b2);
        !          4089:                      else
        !          4090:                        new_label = get_label_after (b2);
        !          4091: 
        !          4092:                      if (JUMP_LABEL (b1) != new_label)
        !          4093:                        {
        !          4094:                          rtx prev = PREV_INSN (new_label);
        !          4095: 
        !          4096:                          if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_LOOP_BEG)
        !          4097:                            {
        !          4098:                              /* Don't branch into the beginning of a loop.
        !          4099:                                 Loop optmization will move loop-invariant
        !          4100:                                 insns out of the loop, and we want to execute
        !          4101:                                 them in this execution thread... */
        !          4102:                              new_label = gen_label_rtx ();
        !          4103:                              emit_label_after (new_label, PREV_INSN (prev));
        !          4104:                            }
        !          4105:                          changed = redirect_jump (b1, new_label);
        !          4106:                        }
        !          4107:                      break;
        !          4108:                    }
        !          4109:                    
        !          4110:                  /* If either of these is not a normal insn (it might be
        !          4111:                     a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail.  (NOTEs
        !          4112:                     have already been skipped above.)  Similarly, fail
        !          4113:                     if the insns are different.  */
        !          4114:                  if (GET_CODE (t1) != INSN || GET_CODE (t2) != INSN
        !          4115:                      || recog_memoized (t1) != recog_memoized (t2)
        !          4116:                      || ! rtx_equal_for_thread_p (PATTERN (t1),
        !          4117:                                                   PATTERN (t2), t2))
        !          4118:                    break;
        !          4119:                    
        !          4120:                  t1 = prev_nonnote_insn (t1);
        !          4121:                  t2 = prev_nonnote_insn (t2);
        !          4122:                }
        !          4123:            }
        !          4124:        }
        !          4125:     }
        !          4126: }
        !          4127: 
        !          4128: /* This is like RTX_EQUAL_P except that it knows about our handling of
        !          4129:    possibly equivalent registers and knows to consider volatile and
        !          4130:    modified objects as not equal.
        !          4131:    
        !          4132:    YINSN is the insn containing Y.  */
        !          4133: 
        !          4134: int
        !          4135: rtx_equal_for_thread_p (x, y, yinsn)
        !          4136:      rtx x, y;
        !          4137:      rtx yinsn;
        !          4138: {
        !          4139:   register int i;
        !          4140:   register int j;
        !          4141:   register enum rtx_code code;
        !          4142:   register char *fmt;
        !          4143: 
        !          4144:   code = GET_CODE (x);
        !          4145:   /* Rtx's of different codes cannot be equal.  */
        !          4146:   if (code != GET_CODE (y))
        !          4147:     return 0;
        !          4148: 
        !          4149:   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
        !          4150:      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
        !          4151: 
        !          4152:   if (GET_MODE (x) != GET_MODE (y))
        !          4153:     return 0;
        !          4154: 
        !          4155:   /* Handle special-cases first.  */
        !          4156:   switch (code)
        !          4157:     {
        !          4158:     case REG:
        !          4159:       if (REGNO (x) == REGNO (y) && ! modified_regs[REGNO (x)])
        !          4160:         return 1;
        !          4161: 
        !          4162:       /* If neither is user variable or hard register, check for possible
        !          4163:         equivalence.  */
        !          4164:       if (REG_USERVAR_P (x) || REG_USERVAR_P (y)
        !          4165:          || REGNO (x) < FIRST_PSEUDO_REGISTER
        !          4166:          || REGNO (y) < FIRST_PSEUDO_REGISTER)
        !          4167:        return 0;
        !          4168: 
        !          4169:       if (same_regs[REGNO (x)] == -1)
        !          4170:        {
        !          4171:          same_regs[REGNO (x)] = REGNO (y);
        !          4172:          num_same_regs++;
        !          4173: 
        !          4174:          /* If this is the first time we are seeing a register on the `Y'
        !          4175:             side, see if it is the last use.  If not, we can't thread the 
        !          4176:             jump, so mark it as not equivalent.  */
        !          4177:          if (regno_last_uid[REGNO (y)] != INSN_UID (yinsn))
        !          4178:            return 0;
        !          4179: 
        !          4180:          return 1;
        !          4181:        }
        !          4182:       else
        !          4183:        return (same_regs[REGNO (x)] == REGNO (y));
        !          4184: 
        !          4185:       break;
        !          4186: 
        !          4187:     case MEM:
        !          4188:       /* If memory modified or either volatile, not equivalent.
        !          4189:         Else, check address. */
        !          4190:       if (modified_mem || MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
        !          4191:        return 0;
        !          4192: 
        !          4193:       return rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn);
        !          4194: 
        !          4195:     case ASM_INPUT:
        !          4196:       if (MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
        !          4197:        return 0;
        !          4198: 
        !          4199:       break;
        !          4200: 
        !          4201:     case SET:
        !          4202:       /* Cancel a pending `same_regs' if setting equivalenced registers.
        !          4203:         Then process source.  */
        !          4204:       if (GET_CODE (SET_DEST (x)) == REG
        !          4205:           && GET_CODE (SET_DEST (y)) == REG)
        !          4206:        {
        !          4207:           if (same_regs[REGNO (SET_DEST (x))] == REGNO (SET_DEST (y)))
        !          4208:            {
        !          4209:              same_regs[REGNO (SET_DEST (x))] = -1;
        !          4210:              num_same_regs--;
        !          4211:            }
        !          4212:          else if (REGNO (SET_DEST (x)) != REGNO (SET_DEST (y)))
        !          4213:            return 0;
        !          4214:        }
        !          4215:       else
        !          4216:        if (rtx_equal_for_thread_p (SET_DEST (x), SET_DEST (y), yinsn) == 0)
        !          4217:          return 0;
        !          4218: 
        !          4219:       return rtx_equal_for_thread_p (SET_SRC (x), SET_SRC (y), yinsn);
        !          4220: 
        !          4221:     case LABEL_REF:
        !          4222:       return XEXP (x, 0) == XEXP (y, 0);
        !          4223: 
        !          4224:     case SYMBOL_REF:
        !          4225:       return XSTR (x, 0) == XSTR (y, 0);
        !          4226:     }
        !          4227: 
        !          4228:   if (x == y)
        !          4229:     return 1;
        !          4230: 
        !          4231:   fmt = GET_RTX_FORMAT (code);
        !          4232:   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
        !          4233:     {
        !          4234:       switch (fmt[i])
        !          4235:        {
        !          4236:        case 'w':
        !          4237:          if (XWINT (x, i) != XWINT (y, i))
        !          4238:            return 0;
        !          4239:          break;
        !          4240: 
        !          4241:        case 'n':
        !          4242:        case 'i':
        !          4243:          if (XINT (x, i) != XINT (y, i))
        !          4244:            return 0;
        !          4245:          break;
        !          4246: 
        !          4247:        case 'V':
        !          4248:        case 'E':
        !          4249:          /* Two vectors must have the same length.  */
        !          4250:          if (XVECLEN (x, i) != XVECLEN (y, i))
        !          4251:            return 0;
        !          4252: 
        !          4253:          /* And the corresponding elements must match.  */
        !          4254:          for (j = 0; j < XVECLEN (x, i); j++)
        !          4255:            if (rtx_equal_for_thread_p (XVECEXP (x, i, j),
        !          4256:                                        XVECEXP (y, i, j), yinsn) == 0)
        !          4257:              return 0;
        !          4258:          break;
        !          4259: 
        !          4260:        case 'e':
        !          4261:          if (rtx_equal_for_thread_p (XEXP (x, i), XEXP (y, i), yinsn) == 0)
        !          4262:            return 0;
        !          4263:          break;
        !          4264: 
        !          4265:        case 'S':
        !          4266:        case 's':
        !          4267:          if (strcmp (XSTR (x, i), XSTR (y, i)))
        !          4268:            return 0;
        !          4269:          break;
        !          4270: 
        !          4271:        case 'u':
        !          4272:          /* These are just backpointers, so they don't matter.  */
        !          4273:          break;
        !          4274: 
        !          4275:        case '0':
        !          4276:          break;
        !          4277: 
        !          4278:          /* It is believed that rtx's at this level will never
        !          4279:             contain anything but integers and other rtx's,
        !          4280:             except for within LABEL_REFs and SYMBOL_REFs.  */
        !          4281:        default:
        !          4282:          abort ();
        !          4283:        }
        !          4284:     }
        !          4285:   return 1;
        !          4286: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.