gcc/recog.c

   1 /* Subroutines used by or related to instruction recognition.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
   3    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "tm_p.h"
  29 #include "insn-config.h"
  30 #include "insn-attr.h"
  31 #include "hard-reg-set.h"
  32 #include "recog.h"
  33 #include "regs.h"
  34 #include "expr.h"
  35 #include "function.h"
  36 #include "flags.h"
  37 #include "real.h"
  38 #include "toplev.h"
  39 #include "basic-block.h"
  40 #include "output.h"
  41 #include "reload.h"
  42
  43 #ifndef STACK_PUSH_CODE
  44 #ifdef STACK_GROWS_DOWNWARD
  45 #define STACK_PUSH_CODE PRE_DEC
  46 #else
  47 #define STACK_PUSH_CODE PRE_INC
  48 #endif
  49 #endif
  50
  51 #ifndef STACK_POP_CODE
  52 #ifdef STACK_GROWS_DOWNWARD
  53 #define STACK_POP_CODE POST_INC
  54 #else
  55 #define STACK_POP_CODE POST_DEC
  56 #endif
  57 #endif
  58
  59 static void validate_replace_rtx_1 (rtx *, rtx, rtx, rtx);
  60 static rtx *find_single_use_1 (rtx, rtx *);
  61 static void validate_replace_src_1 (rtx *, void *);
  62 static rtx split_insn (rtx);
  63
  64 /* Nonzero means allow operands to be volatile.
  65    This should be 0 if you are generating rtl, such as if you are calling
  66    the functions in optabs.c and expmed.c (most of the time).
  67    This should be 1 if all valid insns need to be recognized,
  68    such as in regclass.c and final.c and reload.c.
  69
  70    init_recog and init_recog_no_volatile are responsible for setting this.  */
  71
  72 int volatile_ok;
  73
  74 struct recog_data recog_data;
  75
  76 /* Contains a vector of operand_alternative structures for every operand.
  77    Set up by preprocess_constraints.  */
  78 struct operand_alternative recog_op_alt[MAX_RECOG_OPERANDS][MAX_RECOG_ALTERNATIVES];
  79
  80 /* On return from `constrain_operands', indicate which alternative
  81    was satisfied.  */
  82
  83 int which_alternative;
  84
  85 /* Nonzero after end of reload pass.
  86    Set to 1 or 0 by toplev.c.
  87    Controls the significance of (SUBREG (MEM)).  */
  88
  89 int reload_completed;
  90
  91 /* Nonzero after thread_prologue_and_epilogue_insns has run.  */
  92 int epilogue_completed;
  93
  94 /* Initialize data used by the function `recog'.
  95    This must be called once in the compilation of a function
  96    before any insn recognition may be done in the function.  */
  97
  98 void
  99 init_recog_no_volatile (void)
 100 {
 101   volatile_ok = 0;
 102 }
 103
 104 void
 105 init_recog (void)
 106 {
 107   volatile_ok = 1;
 108 }
 109
 110 /* Try recognizing the instruction INSN,
 111    and return the code number that results.
 112    Remember the code so that repeated calls do not
 113    need to spend the time for actual rerecognition.
 114
 115    This function is the normal interface to instruction recognition.
 116    The automatically-generated function `recog' is normally called
 117    through this one.  (The only exception is in combine.c.)  */
 118
 119 int
 120 recog_memoized_1 (rtx insn)
 121 {
 122   if (INSN_CODE (insn) < 0)
 123     INSN_CODE (insn) = recog (PATTERN (insn), insn, 0);
 124   return INSN_CODE (insn);
 125 }
 126 \f
 127 /* Check that X is an insn-body for an `asm' with operands
 128    and that the operands mentioned in it are legitimate.  */
 129
 130 int
 131 check_asm_operands (rtx x)
 132 {
 133   int noperands;
 134   rtx *operands;
 135   const char **constraints;
 136   int i;
 137
 138   /* Post-reload, be more strict with things.  */
 139   if (reload_completed)
 140     {
 141       /* ??? Doh!  We've not got the wrapping insn.  Cook one up.  */
 142       extract_insn (make_insn_raw (x));
 143       constrain_operands (1);
 144       return which_alternative >= 0;
 145     }
 146
 147   noperands = asm_noperands (x);
 148   if (noperands < 0)
 149     return 0;
 150   if (noperands == 0)
 151     return 1;
 152
 153   operands = alloca (noperands * sizeof (rtx));
 154   constraints = alloca (noperands * sizeof (char *));
 155
 156   decode_asm_operands (x, operands, NULL, constraints, NULL);
 157
 158   for (i = 0; i < noperands; i++)
 159     {
 160       const char *c = constraints[i];
 161       if (c[0] == '%')
 162         c++;
 163       if (ISDIGIT ((unsigned char) c[0]) && c[1] == '\0')
 164         c = constraints[c[0] - '0'];
 165
 166       if (! asm_operand_ok (operands[i], c))
 167         return 0;
 168     }
 169
 170   return 1;
 171 }
 172 \f
 173 /* Static data for the next two routines.  */
 174
 175 typedef struct change_t
 176 {
 177   rtx object;
 178   int old_code;
 179   rtx *loc;
 180   rtx old;
 181 } change_t;
 182
 183 static change_t *changes;
 184 static int changes_allocated;
 185
 186 static int num_changes = 0;
 187
 188 /* Validate a proposed change to OBJECT.  LOC is the location in the rtl
 189    at which NEW will be placed.  If OBJECT is zero, no validation is done,
 190    the change is simply made.
 191
 192    Two types of objects are supported:  If OBJECT is a MEM, memory_address_p
 193    will be called with the address and mode as parameters.  If OBJECT is
 194    an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
 195    the change in place.
 196
 197    IN_GROUP is nonzero if this is part of a group of changes that must be
 198    performed as a group.  In that case, the changes will be stored.  The
 199    function `apply_change_group' will validate and apply the changes.
 200
 201    If IN_GROUP is zero, this is a single change.  Try to recognize the insn
 202    or validate the memory reference with the change applied.  If the result
 203    is not valid for the machine, suppress the change and return zero.
 204    Otherwise, perform the change and return 1.  */
 205
 206 int
 207 validate_change (rtx object, rtx *loc, rtx new, int in_group)
 208 {
 209   rtx old = *loc;
 210
 211   if (old == new || rtx_equal_p (old, new))
 212     return 1;
 213
 214   if (in_group == 0 && num_changes != 0)
 215     abort ();
 216
 217   *loc = new;
 218
 219   /* Save the information describing this change.  */
 220   if (num_changes >= changes_allocated)
 221     {
 222       if (changes_allocated == 0)
 223         /* This value allows for repeated substitutions inside complex
 224            indexed addresses, or changes in up to 5 insns.  */
 225         changes_allocated = MAX_RECOG_OPERANDS * 5;
 226       else
 227         changes_allocated *= 2;
 228
 229       changes = xrealloc (changes, sizeof (change_t) * changes_allocated);
 230     }
 231
 232   changes[num_changes].object = object;
 233   changes[num_changes].loc = loc;
 234   changes[num_changes].old = old;
 235
 236   if (object && GET_CODE (object) != MEM)
 237     {
 238       /* Set INSN_CODE to force rerecognition of insn.  Save old code in
 239          case invalid.  */
 240       changes[num_changes].old_code = INSN_CODE (object);
 241       INSN_CODE (object) = -1;
 242     }
 243
 244   num_changes++;
 245
 246   /* If we are making a group of changes, return 1.  Otherwise, validate the
 247      change group we made.  */
 248
 249   if (in_group)
 250     return 1;
 251   else
 252     return apply_change_group ();
 253 }
 254
 255 /* This subroutine of apply_change_group verifies whether the changes to INSN
 256    were valid; i.e. whether INSN can still be recognized.  */
 257
 258 int
 259 insn_invalid_p (rtx insn)
 260 {
 261   rtx pat = PATTERN (insn);
 262   int num_clobbers = 0;
 263   /* If we are before reload and the pattern is a SET, see if we can add
 264      clobbers.  */
 265   int icode = recog (pat, insn,
 266                      (GET_CODE (pat) == SET
 267                       && ! reload_completed && ! reload_in_progress)
 268                      ? &num_clobbers : 0);
 269   int is_asm = icode < 0 && asm_noperands (PATTERN (insn)) >= 0;
 270
 271
 272   /* If this is an asm and the operand aren't legal, then fail.  Likewise if
 273      this is not an asm and the insn wasn't recognized.  */
 274   if ((is_asm && ! check_asm_operands (PATTERN (insn)))
 275       || (!is_asm && icode < 0))
 276     return 1;
 277
 278   /* If we have to add CLOBBERs, fail if we have to add ones that reference
 279      hard registers since our callers can't know if they are live or not.
 280      Otherwise, add them.  */
 281   if (num_clobbers > 0)
 282     {
 283       rtx newpat;
 284
 285       if (added_clobbers_hard_reg_p (icode))
 286         return 1;
 287
 288       newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num_clobbers + 1));
 289       XVECEXP (newpat, 0, 0) = pat;
 290       add_clobbers (newpat, icode);
 291       PATTERN (insn) = pat = newpat;
 292     }
 293
 294   /* After reload, verify that all constraints are satisfied.  */
 295   if (reload_completed)
 296     {
 297       extract_insn (insn);
 298
 299       if (! constrain_operands (1))
 300         return 1;
 301     }
 302
 303   INSN_CODE (insn) = icode;
 304   return 0;
 305 }
 306
 307 /* Return number of changes made and not validated yet.  */
 308 int
 309 num_changes_pending (void)
 310 {
 311   return num_changes;
 312 }
 313
 314 /* Apply a group of changes previously issued with `validate_change'.
 315    Return 1 if all changes are valid, zero otherwise.  */
 316
 317 int
 318 apply_change_group (void)
 319 {
 320   int i;
 321   rtx last_validated = NULL_RTX;
 322
 323   /* The changes have been applied and all INSN_CODEs have been reset to force
 324      rerecognition.
 325
 326      The changes are valid if we aren't given an object, or if we are
 327      given a MEM and it still is a valid address, or if this is in insn
 328      and it is recognized.  In the latter case, if reload has completed,
 329      we also require that the operands meet the constraints for
 330      the insn.  */
 331
 332   for (i = 0; i < num_changes; i++)
 333     {
 334       rtx object = changes[i].object;
 335
 336       /* If there is no object to test or if it is the same as the one we
 337          already tested, ignore it.  */
 338       if (object == 0 || object == last_validated)
 339         continue;
 340
 341       if (GET_CODE (object) == MEM)
 342         {
 343           if (! memory_address_p (GET_MODE (object), XEXP (object, 0)))
 344             break;
 345         }
 346       else if (insn_invalid_p (object))
 347         {
 348           rtx pat = PATTERN (object);
 349
 350           /* Perhaps we couldn't recognize the insn because there were
 351              extra CLOBBERs at the end.  If so, try to re-recognize
 352              without the last CLOBBER (later iterations will cause each of
 353              them to be eliminated, in turn).  But don't do this if we
 354              have an ASM_OPERAND.  */
 355           if (GET_CODE (pat) == PARALLEL
 356               && GET_CODE (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1)) == CLOBBER
 357               && asm_noperands (PATTERN (object)) < 0)
 358             {
 359               rtx newpat;
 360
 361               if (XVECLEN (pat, 0) == 2)
 362                 newpat = XVECEXP (pat, 0, 0);
 363               else
 364                 {
 365                   int j;
 366
 367                   newpat
 368                     = gen_rtx_PARALLEL (VOIDmode,
 369                                         rtvec_alloc (XVECLEN (pat, 0) - 1));
 370                   for (j = 0; j < XVECLEN (newpat, 0); j++)
 371                     XVECEXP (newpat, 0, j) = XVECEXP (pat, 0, j);
 372                 }
 373
 374               /* Add a new change to this group to replace the pattern
 375                  with this new pattern.  Then consider this change
 376                  as having succeeded.  The change we added will
 377                  cause the entire call to fail if things remain invalid.
 378
 379                  Note that this can lose if a later change than the one
 380                  we are processing specified &XVECEXP (PATTERN (object), 0, X)
 381                  but this shouldn't occur.  */
 382
 383               validate_change (object, &PATTERN (object), newpat, 1);
 384               continue;
 385             }
 386           else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
 387             /* If this insn is a CLOBBER or USE, it is always valid, but is
 388                never recognized.  */
 389             continue;
 390           else
 391             break;
 392         }
 393       last_validated = object;
 394     }
 395
 396   if (i == num_changes)
 397     {
 398       basic_block bb;
 399
 400       for (i = 0; i < num_changes; i++)
 401         if (changes[i].object
 402             && INSN_P (changes[i].object)
 403             && (bb = BLOCK_FOR_INSN (changes[i].object)))
 404           bb->flags |= BB_DIRTY;
 405
 406       num_changes = 0;
 407       return 1;
 408     }
 409   else
 410     {
 411       cancel_changes (0);
 412       return 0;
 413     }
 414 }
 415
 416 /* Return the number of changes so far in the current group.  */
 417
 418 int
 419 num_validated_changes (void)
 420 {
 421   return num_changes;
 422 }
 423
 424 /* Retract the changes numbered NUM and up.  */
 425
 426 void
 427 cancel_changes (int num)
 428 {
 429   int i;
 430
 431   /* Back out all the changes.  Do this in the opposite order in which
 432      they were made.  */
 433   for (i = num_changes - 1; i >= num; i--)
 434     {
 435       *changes[i].loc = changes[i].old;
 436       if (changes[i].object && GET_CODE (changes[i].object) != MEM)
 437         INSN_CODE (changes[i].object) = changes[i].old_code;
 438     }
 439   num_changes = num;
 440 }
 441
 442 /* Replace every occurrence of FROM in X with TO.  Mark each change with
 443    validate_change passing OBJECT.  */
 444
 445 static void
 446 validate_replace_rtx_1 (rtx *loc, rtx from, rtx to, rtx object)
 447 {
 448   int i, j;
 449   const char *fmt;
 450   rtx x = *loc;
 451   enum rtx_code code;
 452   enum machine_mode op0_mode = VOIDmode;
 453   int prev_changes = num_changes;
 454   rtx new;
 455
 456   if (!x)
 457     return;
 458
 459   code = GET_CODE (x);
 460   fmt = GET_RTX_FORMAT (code);
 461   if (fmt[0] == 'e')
 462     op0_mode = GET_MODE (XEXP (x, 0));
 463
 464   /* X matches FROM if it is the same rtx or they are both referring to the
 465      same register in the same mode.  Avoid calling rtx_equal_p unless the
 466      operands look similar.  */
 467
 468   if (x == from
 469       || (GET_CODE (x) == REG && GET_CODE (from) == REG
 470           && GET_MODE (x) == GET_MODE (from)
 471           && REGNO (x) == REGNO (from))
 472       || (GET_CODE (x) == GET_CODE (from) && GET_MODE (x) == GET_MODE (from)
 473           && rtx_equal_p (x, from)))
 474     {
 475       validate_change (object, loc, to, 1);
 476       return;
 477     }
 478
 479   /* Call ourself recursively to perform the replacements.  */
 480
 481   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 482     {
 483       if (fmt[i] == 'e')
 484         validate_replace_rtx_1 (&XEXP (x, i), from, to, object);
 485       else if (fmt[i] == 'E')
 486         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 487           validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object);
 488     }
 489
 490   /* If we didn't substitute, there is nothing more to do.  */
 491   if (num_changes == prev_changes)
 492     return;
 493
 494   /* Allow substituted expression to have different mode.  This is used by
 495      regmove to change mode of pseudo register.  */
 496   if (fmt[0] == 'e' && GET_MODE (XEXP (x, 0)) != VOIDmode)
 497     op0_mode = GET_MODE (XEXP (x, 0));
 498
 499   /* Do changes needed to keep rtx consistent.  Don't do any other
 500      simplifications, as it is not our job.  */
 501
 502   if ((GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == 'c')
 503       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
 504     {
 505       validate_change (object, loc,
 506                        gen_rtx_fmt_ee (GET_RTX_CLASS (code) == 'c' ? code
 507                                        : swap_condition (code),
 508                                        GET_MODE (x), XEXP (x, 1),
 509                                        XEXP (x, 0)), 1);
 510       x = *loc;
 511       code = GET_CODE (x);
 512     }
 513
 514   switch (code)
 515     {
 516     case PLUS:
 517       /* If we have a PLUS whose second operand is now a CONST_INT, use
 518          simplify_gen_binary to try to simplify it.
 519          ??? We may want later to remove this, once simplification is
 520          separated from this function.  */
 521       if (GET_CODE (XEXP (x, 1)) == CONST_INT && XEXP (x, 1) == to)
 522         validate_change (object, loc,
 523                          simplify_gen_binary
 524                          (PLUS, GET_MODE (x), XEXP (x, 0), XEXP (x, 1)), 1);
 525       break;
 526     case MINUS:
 527       if (GET_CODE (XEXP (x, 1)) == CONST_INT
 528           || GET_CODE (XEXP (x, 1)) == CONST_DOUBLE)
 529         validate_change (object, loc,
 530                          simplify_gen_binary
 531                          (PLUS, GET_MODE (x), XEXP (x, 0),
 532                           simplify_gen_unary (NEG,
 533                                               GET_MODE (x), XEXP (x, 1),
 534                                               GET_MODE (x))), 1);
 535       break;
 536     case ZERO_EXTEND:
 537     case SIGN_EXTEND:
 538       if (GET_MODE (XEXP (x, 0)) == VOIDmode)
 539         {
 540           new = simplify_gen_unary (code, GET_MODE (x), XEXP (x, 0),
 541                                     op0_mode);
 542           /* If any of the above failed, substitute in something that
 543              we know won't be recognized.  */
 544           if (!new)
 545             new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
 546           validate_change (object, loc, new, 1);
 547         }
 548       break;
 549     case SUBREG:
 550       /* All subregs possible to simplify should be simplified.  */
 551       new = simplify_subreg (GET_MODE (x), SUBREG_REG (x), op0_mode,
 552                              SUBREG_BYTE (x));
 553
 554       /* Subregs of VOIDmode operands are incorrect.  */
 555       if (!new && GET_MODE (SUBREG_REG (x)) == VOIDmode)
 556         new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
 557       if (new)
 558         validate_change (object, loc, new, 1);
 559       break;
 560     case ZERO_EXTRACT:
 561     case SIGN_EXTRACT:
 562       /* If we are replacing a register with memory, try to change the memory
 563          to be the mode required for memory in extract operations (this isn't
 564          likely to be an insertion operation; if it was, nothing bad will
 565          happen, we might just fail in some cases).  */
 566
 567       if (GET_CODE (XEXP (x, 0)) == MEM
 568           && GET_CODE (XEXP (x, 1)) == CONST_INT
 569           && GET_CODE (XEXP (x, 2)) == CONST_INT
 570           && !mode_dependent_address_p (XEXP (XEXP (x, 0), 0))
 571           && !MEM_VOLATILE_P (XEXP (x, 0)))
 572         {
 573           enum machine_mode wanted_mode = VOIDmode;
 574           enum machine_mode is_mode = GET_MODE (XEXP (x, 0));
 575           int pos = INTVAL (XEXP (x, 2));
 576
 577           if (GET_CODE (x) == ZERO_EXTRACT)
 578             {
 579               enum machine_mode new_mode
 580                 = mode_for_extraction (EP_extzv, 1);
 581               if (new_mode != MAX_MACHINE_MODE)
 582                 wanted_mode = new_mode;
 583             }
 584           else if (GET_CODE (x) == SIGN_EXTRACT)
 585             {
 586               enum machine_mode new_mode
 587                 = mode_for_extraction (EP_extv, 1);
 588               if (new_mode != MAX_MACHINE_MODE)
 589                 wanted_mode = new_mode;
 590             }
 591
 592           /* If we have a narrower mode, we can do something.  */
 593           if (wanted_mode != VOIDmode
 594               && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
 595             {
 596               int offset = pos / BITS_PER_UNIT;
 597               rtx newmem;
 598
 599               /* If the bytes and bits are counted differently, we
 600                  must adjust the offset.  */
 601               if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
 602                 offset =
 603                   (GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (wanted_mode) -
 604                    offset);
 605
 606               pos %= GET_MODE_BITSIZE (wanted_mode);
 607
 608               newmem = adjust_address_nv (XEXP (x, 0), wanted_mode, offset);
 609
 610               validate_change (object, &XEXP (x, 2), GEN_INT (pos), 1);
 611               validate_change (object, &XEXP (x, 0), newmem, 1);
 612             }
 613         }
 614
 615       break;
 616
 617     default:
 618       break;
 619     }
 620 }
 621
 622 /* Try replacing every occurrence of FROM in subexpression LOC of INSN
 623    with TO.  After all changes have been made, validate by seeing
 624    if INSN is still valid.  */
 625
 626 int
 627 validate_replace_rtx_subexp (rtx from, rtx to, rtx insn, rtx *loc)
 628 {
 629   validate_replace_rtx_1 (loc, from, to, insn);
 630   return apply_change_group ();
 631 }
 632
 633 /* Try replacing every occurrence of FROM in INSN with TO.  After all
 634    changes have been made, validate by seeing if INSN is still valid.  */
 635
 636 int
 637 validate_replace_rtx (rtx from, rtx to, rtx insn)
 638 {
 639   validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
 640   return apply_change_group ();
 641 }
 642
 643 /* Try replacing every occurrence of FROM in INSN with TO.  */
 644
 645 void
 646 validate_replace_rtx_group (rtx from, rtx to, rtx insn)
 647 {
 648   validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
 649 }
 650
 651 /* Function called by note_uses to replace used subexpressions.  */
 652 struct validate_replace_src_data
 653 {
 654   rtx from;                     /* Old RTX */
 655   rtx to;                       /* New RTX */
 656   rtx insn;                     /* Insn in which substitution is occurring.  */
 657 };
 658
 659 static void
 660 validate_replace_src_1 (rtx *x, void *data)
 661 {
 662   struct validate_replace_src_data *d
 663     = (struct validate_replace_src_data *) data;
 664
 665   validate_replace_rtx_1 (x, d->from, d->to, d->insn);
 666 }
 667
 668 /* Try replacing every occurrence of FROM in INSN with TO, avoiding
 669    SET_DESTs.  */
 670
 671 void
 672 validate_replace_src_group (rtx from, rtx to, rtx insn)
 673 {
 674   struct validate_replace_src_data d;
 675
 676   d.from = from;
 677   d.to = to;
 678   d.insn = insn;
 679   note_uses (&PATTERN (insn), validate_replace_src_1, &d);
 680 }
 681
 682 /* Same as validate_replace_src_group, but validate by seeing if
 683    INSN is still valid.  */
 684 int
 685 validate_replace_src (rtx from, rtx to, rtx insn)
 686 {
 687   validate_replace_src_group (from, to, insn);
 688   return apply_change_group ();
 689 }
 690 \f
 691 #ifdef HAVE_cc0
 692 /* Return 1 if the insn using CC0 set by INSN does not contain
 693    any ordered tests applied to the condition codes.
 694    EQ and NE tests do not count.  */
 695
 696 int
 697 next_insn_tests_no_inequality (rtx insn)
 698 {
 699   rtx next = next_cc0_user (insn);
 700
 701   /* If there is no next insn, we have to take the conservative choice.  */
 702   if (next == 0)
 703     return 0;
 704
 705   return ((GET_CODE (next) == JUMP_INSN
 706            || GET_CODE (next) == INSN
 707            || GET_CODE (next) == CALL_INSN)
 708           && ! inequality_comparisons_p (PATTERN (next)));
 709 }
 710 #endif
 711 \f
 712 /* This is used by find_single_use to locate an rtx that contains exactly one
 713    use of DEST, which is typically either a REG or CC0.  It returns a
 714    pointer to the innermost rtx expression containing DEST.  Appearances of
 715    DEST that are being used to totally replace it are not counted.  */
 716
 717 static rtx *
 718 find_single_use_1 (rtx dest, rtx *loc)
 719 {
 720   rtx x = *loc;
 721   enum rtx_code code = GET_CODE (x);
 722   rtx *result = 0;
 723   rtx *this_result;
 724   int i;
 725   const char *fmt;
 726
 727   switch (code)
 728     {
 729     case CONST_INT:
 730     case CONST:
 731     case LABEL_REF:
 732     case SYMBOL_REF:
 733     case CONST_DOUBLE:
 734     case CONST_VECTOR:
 735     case CLOBBER:
 736       return 0;
 737
 738     case SET:
 739       /* If the destination is anything other than CC0, PC, a REG or a SUBREG
 740          of a REG that occupies all of the REG, the insn uses DEST if
 741          it is mentioned in the destination or the source.  Otherwise, we
 742          need just check the source.  */
 743       if (GET_CODE (SET_DEST (x)) != CC0
 744           && GET_CODE (SET_DEST (x)) != PC
 745           && GET_CODE (SET_DEST (x)) != REG
 746           && ! (GET_CODE (SET_DEST (x)) == SUBREG
 747                 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
 748                 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
 749                       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
 750                     == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
 751                          + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
 752         break;
 753
 754       return find_single_use_1 (dest, &SET_SRC (x));
 755
 756     case MEM:
 757     case SUBREG:
 758       return find_single_use_1 (dest, &XEXP (x, 0));
 759
 760     default:
 761       break;
 762     }
 763
 764   /* If it wasn't one of the common cases above, check each expression and
 765      vector of this code.  Look for a unique usage of DEST.  */
 766
 767   fmt = GET_RTX_FORMAT (code);
 768   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 769     {
 770       if (fmt[i] == 'e')
 771         {
 772           if (dest == XEXP (x, i)
 773               || (GET_CODE (dest) == REG && GET_CODE (XEXP (x, i)) == REG
 774                   && REGNO (dest) == REGNO (XEXP (x, i))))
 775             this_result = loc;
 776           else
 777             this_result = find_single_use_1 (dest, &XEXP (x, i));
 778
 779           if (result == 0)
 780             result = this_result;
 781           else if (this_result)
 782             /* Duplicate usage.  */
 783             return 0;
 784         }
 785       else if (fmt[i] == 'E')
 786         {
 787           int j;
 788
 789           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 790             {
 791               if (XVECEXP (x, i, j) == dest
 792                   || (GET_CODE (dest) == REG
 793                       && GET_CODE (XVECEXP (x, i, j)) == REG
 794                       && REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
 795                 this_result = loc;
 796               else
 797                 this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
 798
 799               if (result == 0)
 800                 result = this_result;
 801               else if (this_result)
 802                 return 0;
 803             }
 804         }
 805     }
 806
 807   return result;
 808 }
 809 \f
 810 /* See if DEST, produced in INSN, is used only a single time in the
 811    sequel.  If so, return a pointer to the innermost rtx expression in which
 812    it is used.
 813
 814    If PLOC is nonzero, *PLOC is set to the insn containing the single use.
 815
 816    This routine will return usually zero either before flow is called (because
 817    there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
 818    note can't be trusted).
 819
 820    If DEST is cc0_rtx, we look only at the next insn.  In that case, we don't
 821    care about REG_DEAD notes or LOG_LINKS.
 822
 823    Otherwise, we find the single use by finding an insn that has a
 824    LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST.  If DEST is
 825    only referenced once in that insn, we know that it must be the first
 826    and last insn referencing DEST.  */
 827
 828 rtx *
 829 find_single_use (rtx dest, rtx insn, rtx *ploc)
 830 {
 831   rtx next;
 832   rtx *result;
 833   rtx link;
 834
 835 #ifdef HAVE_cc0
 836   if (dest == cc0_rtx)
 837     {
 838       next = NEXT_INSN (insn);
 839       if (next == 0
 840           || (GET_CODE (next) != INSN && GET_CODE (next) != JUMP_INSN))
 841         return 0;
 842
 843       result = find_single_use_1 (dest, &PATTERN (next));
 844       if (result && ploc)
 845         *ploc = next;
 846       return result;
 847     }
 848 #endif
 849
 850   if (reload_completed || reload_in_progress || GET_CODE (dest) != REG)
 851     return 0;
 852
 853   for (next = next_nonnote_insn (insn);
 854        next != 0 && GET_CODE (next) != CODE_LABEL;
 855        next = next_nonnote_insn (next))
 856     if (INSN_P (next) && dead_or_set_p (next, dest))
 857       {
 858         for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
 859           if (XEXP (link, 0) == insn)
 860             break;
 861
 862         if (link)
 863           {
 864             result = find_single_use_1 (dest, &PATTERN (next));
 865             if (ploc)
 866               *ploc = next;
 867             return result;
 868           }
 869       }
 870
 871   return 0;
 872 }
 873 \f
 874 /* Return 1 if OP is a valid general operand for machine mode MODE.
 875    This is either a register reference, a memory reference,
 876    or a constant.  In the case of a memory reference, the address
 877    is checked for general validity for the target machine.
 878
 879    Register and memory references must have mode MODE in order to be valid,
 880    but some constants have no machine mode and are valid for any mode.
 881
 882    If MODE is VOIDmode, OP is checked for validity for whatever mode
 883    it has.
 884
 885    The main use of this function is as a predicate in match_operand
 886    expressions in the machine description.
 887
 888    For an explanation of this function's behavior for registers of
 889    class NO_REGS, see the comment for `register_operand'.  */
 890
 891 int
 892 general_operand (rtx op, enum machine_mode mode)
 893 {
 894   enum rtx_code code = GET_CODE (op);
 895
 896   if (mode == VOIDmode)
 897     mode = GET_MODE (op);
 898
 899   /* Don't accept CONST_INT or anything similar
 900      if the caller wants something floating.  */
 901   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 902       && GET_MODE_CLASS (mode) != MODE_INT
 903       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 904     return 0;
 905
 906   if (GET_CODE (op) == CONST_INT
 907       && mode != VOIDmode
 908       && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
 909     return 0;
 910
 911   if (CONSTANT_P (op))
 912     return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
 913              || mode == VOIDmode)
 914 #ifdef LEGITIMATE_PIC_OPERAND_P
 915             && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
 916 #endif
 917             && LEGITIMATE_CONSTANT_P (op));
 918
 919   /* Except for certain constants with VOIDmode, already checked for,
 920      OP's mode must match MODE if MODE specifies a mode.  */
 921
 922   if (GET_MODE (op) != mode)
 923     return 0;
 924
 925   if (code == SUBREG)
 926     {
 927       rtx sub = SUBREG_REG (op);
 928
 929 #ifdef INSN_SCHEDULING
 930       /* On machines that have insn scheduling, we want all memory
 931          reference to be explicit, so outlaw paradoxical SUBREGs.  */
 932       if (GET_CODE (sub) == MEM
 933           && GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (sub)))
 934         return 0;
 935 #endif
 936       /* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory
 937          may result in incorrect reference.  We should simplify all valid
 938          subregs of MEM anyway.  But allow this after reload because we
 939          might be called from cleanup_subreg_operands.
 940
 941          ??? This is a kludge.  */
 942       if (!reload_completed && SUBREG_BYTE (op) != 0
 943           && GET_CODE (sub) == MEM)
 944         return 0;
 945
 946       /* FLOAT_MODE subregs can't be paradoxical.  Combine will occasionally
 947          create such rtl, and we must reject it.  */
 948       if (GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT
 949           && GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
 950         return 0;
 951
 952       op = sub;
 953       code = GET_CODE (op);
 954     }
 955
 956   if (code == REG)
 957     /* A register whose class is NO_REGS is not a general operand.  */
 958     return (REGNO (op) >= FIRST_PSEUDO_REGISTER
 959             || REGNO_REG_CLASS (REGNO (op)) != NO_REGS);
 960
 961   if (code == MEM)
 962     {
 963       rtx y = XEXP (op, 0);
 964
 965       if (! volatile_ok && MEM_VOLATILE_P (op))
 966         return 0;
 967
 968       if (GET_CODE (y) == ADDRESSOF)
 969         return 1;
 970
 971       /* Use the mem's mode, since it will be reloaded thus.  */
 972       mode = GET_MODE (op);
 973       GO_IF_LEGITIMATE_ADDRESS (mode, y, win);
 974     }
 975
 976   /* Pretend this is an operand for now; we'll run force_operand
 977      on its replacement in fixup_var_refs_1.  */
 978   if (code == ADDRESSOF)
 979     return 1;
 980
 981   return 0;
 982
 983  win:
 984   return 1;
 985 }
 986 \f
 987 /* Return 1 if OP is a valid memory address for a memory reference
 988    of mode MODE.
 989
 990    The main use of this function is as a predicate in match_operand
 991    expressions in the machine description.  */
 992
 993 int
 994 address_operand (rtx op, enum machine_mode mode)
 995 {
 996   return memory_address_p (mode, op);
 997 }
 998
 999 /* Return 1 if OP is a register reference of mode MODE.
1000    If MODE is VOIDmode, accept a register in any mode.
1001
1002    The main use of this function is as a predicate in match_operand
1003    expressions in the machine description.
1004
1005    As a special exception, registers whose class is NO_REGS are
1006    not accepted by `register_operand'.  The reason for this change
1007    is to allow the representation of special architecture artifacts
1008    (such as a condition code register) without extending the rtl
1009    definitions.  Since registers of class NO_REGS cannot be used
1010    as registers in any case where register classes are examined,
1011    it is most consistent to keep this function from accepting them.  */
1012
1013 int
1014 register_operand (rtx op, enum machine_mode mode)
1015 {
1016   if (GET_MODE (op) != mode && mode != VOIDmode)
1017     return 0;
1018
1019   if (GET_CODE (op) == SUBREG)
1020     {
1021       rtx sub = SUBREG_REG (op);
1022
1023       /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1024          because it is guaranteed to be reloaded into one.
1025          Just make sure the MEM is valid in itself.
1026          (Ideally, (SUBREG (MEM)...) should not exist after reload,
1027          but currently it does result from (SUBREG (REG)...) where the
1028          reg went on the stack.)  */
1029       if (! reload_completed && GET_CODE (sub) == MEM)
1030         return general_operand (op, mode);
1031
1032 #ifdef CANNOT_CHANGE_MODE_CLASS
1033       if (GET_CODE (sub) == REG
1034           && REGNO (sub) < FIRST_PSEUDO_REGISTER
1035           && REG_CANNOT_CHANGE_MODE_P (REGNO (sub), GET_MODE (sub), mode)
1036           && GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_INT
1037           && GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_FLOAT)
1038         return 0;
1039 #endif
1040
1041       /* FLOAT_MODE subregs can't be paradoxical.  Combine will occasionally
1042          create such rtl, and we must reject it.  */
1043       if (GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT
1044           && GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
1045         return 0;
1046
1047       op = sub;
1048     }
1049
1050   /* If we have an ADDRESSOF, consider it valid since it will be
1051      converted into something that will not be a MEM.  */
1052   if (GET_CODE (op) == ADDRESSOF)
1053     return 1;
1054
1055   /* We don't consider registers whose class is NO_REGS
1056      to be a register operand.  */
1057   return (GET_CODE (op) == REG
1058           && (REGNO (op) >= FIRST_PSEUDO_REGISTER
1059               || REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
1060 }
1061
1062 /* Return 1 for a register in Pmode; ignore the tested mode.  */
1063
1064 int
1065 pmode_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1066 {
1067   return register_operand (op, Pmode);
1068 }
1069
1070 /* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
1071    or a hard register.  */
1072
1073 int
1074 scratch_operand (rtx op, enum machine_mode mode)
1075 {
1076   if (GET_MODE (op) != mode && mode != VOIDmode)
1077     return 0;
1078
1079   return (GET_CODE (op) == SCRATCH
1080           || (GET_CODE (op) == REG
1081               && REGNO (op) < FIRST_PSEUDO_REGISTER));
1082 }
1083
1084 /* Return 1 if OP is a valid immediate operand for mode MODE.
1085
1086    The main use of this function is as a predicate in match_operand
1087    expressions in the machine description.  */
1088
1089 int
1090 immediate_operand (rtx op, enum machine_mode mode)
1091 {
1092   /* Don't accept CONST_INT or anything similar
1093      if the caller wants something floating.  */
1094   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
1095       && GET_MODE_CLASS (mode) != MODE_INT
1096       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
1097     return 0;
1098
1099   if (GET_CODE (op) == CONST_INT
1100       && mode != VOIDmode
1101       && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
1102     return 0;
1103
1104   /* Accept CONSTANT_P_RTX, since it will be gone by CSE1 and
1105      result in 0/1.  It seems a safe assumption that this is
1106      in range for everyone.  */
1107   if (GET_CODE (op) == CONSTANT_P_RTX)
1108     return 1;
1109
1110   return (CONSTANT_P (op)
1111           && (GET_MODE (op) == mode || mode == VOIDmode
1112               || GET_MODE (op) == VOIDmode)
1113 #ifdef LEGITIMATE_PIC_OPERAND_P
1114           && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1115 #endif
1116           && LEGITIMATE_CONSTANT_P (op));
1117 }
1118
1119 /* Returns 1 if OP is an operand that is a CONST_INT.  */
1120
1121 int
1122 const_int_operand (rtx op, enum machine_mode mode)
1123 {
1124   if (GET_CODE (op) != CONST_INT)
1125     return 0;
1126
1127   if (mode != VOIDmode
1128       && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
1129     return 0;
1130
1131   return 1;
1132 }
1133
1134 /* Returns 1 if OP is an operand that is a constant integer or constant
1135    floating-point number.  */
1136
1137 int
1138 const_double_operand (rtx op, enum machine_mode mode)
1139 {
1140   /* Don't accept CONST_INT or anything similar
1141      if the caller wants something floating.  */
1142   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
1143       && GET_MODE_CLASS (mode) != MODE_INT
1144       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
1145     return 0;
1146
1147   return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
1148           && (mode == VOIDmode || GET_MODE (op) == mode
1149               || GET_MODE (op) == VOIDmode));
1150 }
1151
1152 /* Return 1 if OP is a general operand that is not an immediate operand.  */
1153
1154 int
1155 nonimmediate_operand (rtx op, enum machine_mode mode)
1156 {
1157   return (general_operand (op, mode) && ! CONSTANT_P (op));
1158 }
1159
1160 /* Return 1 if OP is a register reference or immediate value of mode MODE.  */
1161
1162 int
1163 nonmemory_operand (rtx op, enum machine_mode mode)
1164 {
1165   if (CONSTANT_P (op))
1166     {
1167       /* Don't accept CONST_INT or anything similar
1168          if the caller wants something floating.  */
1169       if (GET_MODE (op) == VOIDmode && mode != VOIDmode
1170           && GET_MODE_CLASS (mode) != MODE_INT
1171           && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
1172         return 0;
1173
1174       if (GET_CODE (op) == CONST_INT
1175           && mode != VOIDmode
1176           && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
1177         return 0;
1178
1179       return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
1180                || mode == VOIDmode)
1181 #ifdef LEGITIMATE_PIC_OPERAND_P
1182               && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1183 #endif
1184               && LEGITIMATE_CONSTANT_P (op));
1185     }
1186
1187   if (GET_MODE (op) != mode && mode != VOIDmode)
1188     return 0;
1189
1190   if (GET_CODE (op) == SUBREG)
1191     {
1192       /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1193          because it is guaranteed to be reloaded into one.
1194          Just make sure the MEM is valid in itself.
1195          (Ideally, (SUBREG (MEM)...) should not exist after reload,
1196          but currently it does result from (SUBREG (REG)...) where the
1197          reg went on the stack.)  */
1198       if (! reload_completed && GET_CODE (SUBREG_REG (op)) == MEM)
1199         return general_operand (op, mode);
1200       op = SUBREG_REG (op);
1201     }
1202
1203   /* We don't consider registers whose class is NO_REGS
1204      to be a register operand.  */
1205   return (GET_CODE (op) == REG
1206           && (REGNO (op) >= FIRST_PSEUDO_REGISTER
1207               || REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
1208 }
1209
1210 /* Return 1 if OP is a valid operand that stands for pushing a
1211    value of mode MODE onto the stack.
1212
1213    The main use of this function is as a predicate in match_operand
1214    expressions in the machine description.  */
1215
1216 int
1217 push_operand (rtx op, enum machine_mode mode)
1218 {
1219   unsigned int rounded_size = GET_MODE_SIZE (mode);
1220
1221 #ifdef PUSH_ROUNDING
1222   rounded_size = PUSH_ROUNDING (rounded_size);
1223 #endif
1224
1225   if (GET_CODE (op) != MEM)
1226     return 0;
1227
1228   if (mode != VOIDmode && GET_MODE (op) != mode)
1229     return 0;
1230
1231   op = XEXP (op, 0);
1232
1233   if (rounded_size == GET_MODE_SIZE (mode))
1234     {
1235       if (GET_CODE (op) != STACK_PUSH_CODE)
1236         return 0;
1237     }
1238   else
1239     {
1240       if (GET_CODE (op) != PRE_MODIFY
1241           || GET_CODE (XEXP (op, 1)) != PLUS
1242           || XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
1243           || GET_CODE (XEXP (XEXP (op, 1), 1)) != CONST_INT
1244 #ifdef STACK_GROWS_DOWNWARD
1245           || INTVAL (XEXP (XEXP (op, 1), 1)) != - (int) rounded_size
1246 #else
1247           || INTVAL (XEXP (XEXP (op, 1), 1)) != (int) rounded_size
1248 #endif
1249           )
1250         return 0;
1251     }
1252
1253   return XEXP (op, 0) == stack_pointer_rtx;
1254 }
1255
1256 /* Return 1 if OP is a valid operand that stands for popping a
1257    value of mode MODE off the stack.
1258
1259    The main use of this function is as a predicate in match_operand
1260    expressions in the machine description.  */
1261
1262 int
1263 pop_operand (rtx op, enum machine_mode mode)
1264 {
1265   if (GET_CODE (op) != MEM)
1266     return 0;
1267
1268   if (mode != VOIDmode && GET_MODE (op) != mode)
1269     return 0;
1270
1271   op = XEXP (op, 0);
1272
1273   if (GET_CODE (op) != STACK_POP_CODE)
1274     return 0;
1275
1276   return XEXP (op, 0) == stack_pointer_rtx;
1277 }
1278
1279 /* Return 1 if ADDR is a valid memory address for mode MODE.  */
1280
1281 int
1282 memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
1283 {
1284   if (GET_CODE (addr) == ADDRESSOF)
1285     return 1;
1286
1287   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
1288   return 0;
1289
1290  win:
1291   return 1;
1292 }
1293
1294 /* Return 1 if OP is a valid memory reference with mode MODE,
1295    including a valid address.
1296
1297    The main use of this function is as a predicate in match_operand
1298    expressions in the machine description.  */
1299
1300 int
1301 memory_operand (rtx op, enum machine_mode mode)
1302 {
1303   rtx inner;
1304
1305   if (! reload_completed)
1306     /* Note that no SUBREG is a memory operand before end of reload pass,
1307        because (SUBREG (MEM...)) forces reloading into a register.  */
1308     return GET_CODE (op) == MEM && general_operand (op, mode);
1309
1310   if (mode != VOIDmode && GET_MODE (op) != mode)
1311     return 0;
1312
1313   inner = op;
1314   if (GET_CODE (inner) == SUBREG)
1315     inner = SUBREG_REG (inner);
1316
1317   return (GET_CODE (inner) == MEM && general_operand (op, mode));
1318 }
1319
1320 /* Return 1 if OP is a valid indirect memory reference with mode MODE;
1321    that is, a memory reference whose address is a general_operand.  */
1322
1323 int
1324 indirect_operand (rtx op, enum machine_mode mode)
1325 {
1326   /* Before reload, a SUBREG isn't in memory (see memory_operand, above).  */
1327   if (! reload_completed
1328       && GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == MEM)
1329     {
1330       int offset = SUBREG_BYTE (op);
1331       rtx inner = SUBREG_REG (op);
1332
1333       if (mode != VOIDmode && GET_MODE (op) != mode)
1334         return 0;
1335
1336       /* The only way that we can have a general_operand as the resulting
1337          address is if OFFSET is zero and the address already is an operand
1338          or if the address is (plus Y (const_int -OFFSET)) and Y is an
1339          operand.  */
1340
1341       return ((offset == 0 && general_operand (XEXP (inner, 0), Pmode))
1342               || (GET_CODE (XEXP (inner, 0)) == PLUS
1343                   && GET_CODE (XEXP (XEXP (inner, 0), 1)) == CONST_INT
1344                   && INTVAL (XEXP (XEXP (inner, 0), 1)) == -offset
1345                   && general_operand (XEXP (XEXP (inner, 0), 0), Pmode)));
1346     }
1347
1348   return (GET_CODE (op) == MEM
1349           && memory_operand (op, mode)
1350           && general_operand (XEXP (op, 0), Pmode));
1351 }
1352
1353 /* Return 1 if this is a comparison operator.  This allows the use of
1354    MATCH_OPERATOR to recognize all the branch insns.  */
1355
1356 int
1357 comparison_operator (rtx op, enum machine_mode mode)
1358 {
1359   return ((mode == VOIDmode || GET_MODE (op) == mode)
1360           && GET_RTX_CLASS (GET_CODE (op)) == '<');
1361 }
1362 \f
1363 /* If BODY is an insn body that uses ASM_OPERANDS,
1364    return the number of operands (both input and output) in the insn.
1365    Otherwise return -1.  */
1366
1367 int
1368 asm_noperands (rtx body)
1369 {
1370   switch (GET_CODE (body))
1371     {
1372     case ASM_OPERANDS:
1373       /* No output operands: return number of input operands.  */
1374       return ASM_OPERANDS_INPUT_LENGTH (body);
1375     case SET:
1376       if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1377         /* Single output operand: BODY is (set OUTPUT (asm_operands ...)).  */
1378         return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body)) + 1;
1379       else
1380         return -1;
1381     case PARALLEL:
1382       if (GET_CODE (XVECEXP (body, 0, 0)) == SET
1383           && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
1384         {
1385           /* Multiple output operands, or 1 output plus some clobbers:
1386              body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...].  */
1387           int i;
1388           int n_sets;
1389
1390           /* Count backwards through CLOBBERs to determine number of SETs.  */
1391           for (i = XVECLEN (body, 0); i > 0; i--)
1392             {
1393               if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
1394                 break;
1395               if (GET_CODE (XVECEXP (body, 0, i - 1)) != CLOBBER)
1396                 return -1;
1397             }
1398
1399           /* N_SETS is now number of output operands.  */
1400           n_sets = i;
1401
1402           /* Verify that all the SETs we have
1403              came from a single original asm_operands insn
1404              (so that invalid combinations are blocked).  */
1405           for (i = 0; i < n_sets; i++)
1406             {
1407               rtx elt = XVECEXP (body, 0, i);
1408               if (GET_CODE (elt) != SET)
1409                 return -1;
1410               if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
1411                 return -1;
1412               /* If these ASM_OPERANDS rtx's came from different original insns
1413                  then they aren't allowed together.  */
1414               if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
1415                   != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body, 0, 0))))
1416                 return -1;
1417             }
1418           return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)))
1419                   + n_sets);
1420         }
1421       else if (GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1422         {
1423           /* 0 outputs, but some clobbers:
1424              body is [(asm_operands ...) (clobber (reg ...))...].  */
1425           int i;
1426
1427           /* Make sure all the other parallel things really are clobbers.  */
1428           for (i = XVECLEN (body, 0) - 1; i > 0; i--)
1429             if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
1430               return -1;
1431
1432           return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
1433         }
1434       else
1435         return -1;
1436     default:
1437       return -1;
1438     }
1439 }
1440
1441 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
1442    copy its operands (both input and output) into the vector OPERANDS,
1443    the locations of the operands within the insn into the vector OPERAND_LOCS,
1444    and the constraints for the operands into CONSTRAINTS.
1445    Write the modes of the operands into MODES.
1446    Return the assembler-template.
1447
1448    If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
1449    we don't store that info.  */
1450
1451 const char *
1452 decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
1453                      const char **constraints, enum machine_mode *modes)
1454 {
1455   int i;
1456   int noperands;
1457   const char *template = 0;
1458
1459   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1460     {
1461       rtx asmop = SET_SRC (body);
1462       /* Single output operand: BODY is (set OUTPUT (asm_operands ....)).  */
1463
1464       noperands = ASM_OPERANDS_INPUT_LENGTH (asmop) + 1;
1465
1466       for (i = 1; i < noperands; i++)
1467         {
1468           if (operand_locs)
1469             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i - 1);
1470           if (operands)
1471             operands[i] = ASM_OPERANDS_INPUT (asmop, i - 1);
1472           if (constraints)
1473             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i - 1);
1474           if (modes)
1475             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i - 1);
1476         }
1477
1478       /* The output is in the SET.
1479          Its constraint is in the ASM_OPERANDS itself.  */
1480       if (operands)
1481         operands[0] = SET_DEST (body);
1482       if (operand_locs)
1483         operand_locs[0] = &SET_DEST (body);
1484       if (constraints)
1485         constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
1486       if (modes)
1487         modes[0] = GET_MODE (SET_DEST (body));
1488       template = ASM_OPERANDS_TEMPLATE (asmop);
1489     }
1490   else if (GET_CODE (body) == ASM_OPERANDS)
1491     {
1492       rtx asmop = body;
1493       /* No output operands: BODY is (asm_operands ....).  */
1494
1495       noperands = ASM_OPERANDS_INPUT_LENGTH (asmop);
1496
1497       /* The input operands are found in the 1st element vector.  */
1498       /* Constraints for inputs are in the 2nd element vector.  */
1499       for (i = 0; i < noperands; i++)
1500         {
1501           if (operand_locs)
1502             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
1503           if (operands)
1504             operands[i] = ASM_OPERANDS_INPUT (asmop, i);
1505           if (constraints)
1506             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1507           if (modes)
1508             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1509         }
1510       template = ASM_OPERANDS_TEMPLATE (asmop);
1511     }
1512   else if (GET_CODE (body) == PARALLEL
1513            && GET_CODE (XVECEXP (body, 0, 0)) == SET
1514            && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
1515     {
1516       rtx asmop = SET_SRC (XVECEXP (body, 0, 0));
1517       int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs.  */
1518       int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
1519       int nout = 0;             /* Does not include CLOBBERs.  */
1520
1521       /* At least one output, plus some CLOBBERs.  */
1522
1523       /* The outputs are in the SETs.
1524          Their constraints are in the ASM_OPERANDS itself.  */
1525       for (i = 0; i < nparallel; i++)
1526         {
1527           if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
1528             break;              /* Past last SET */
1529
1530           if (operands)
1531             operands[i] = SET_DEST (XVECEXP (body, 0, i));
1532           if (operand_locs)
1533             operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
1534           if (constraints)
1535             constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
1536           if (modes)
1537             modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
1538           nout++;
1539         }
1540
1541       for (i = 0; i < nin; i++)
1542         {
1543           if (operand_locs)
1544             operand_locs[i + nout] = &ASM_OPERANDS_INPUT (asmop, i);
1545           if (operands)
1546             operands[i + nout] = ASM_OPERANDS_INPUT (asmop, i);
1547           if (constraints)
1548             constraints[i + nout] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1549           if (modes)
1550             modes[i + nout] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1551         }
1552
1553       template = ASM_OPERANDS_TEMPLATE (asmop);
1554     }
1555   else if (GET_CODE (body) == PARALLEL
1556            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1557     {
1558       /* No outputs, but some CLOBBERs.  */
1559
1560       rtx asmop = XVECEXP (body, 0, 0);
1561       int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
1562
1563       for (i = 0; i < nin; i++)
1564         {
1565           if (operand_locs)
1566             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
1567           if (operands)
1568             operands[i] = ASM_OPERANDS_INPUT (asmop, i);
1569           if (constraints)
1570             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1571           if (modes)
1572             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1573         }
1574
1575       template = ASM_OPERANDS_TEMPLATE (asmop);
1576     }
1577
1578   return template;
1579 }
1580
1581 /* Check if an asm_operand matches it's constraints.
1582    Return > 0 if ok, = 0 if bad, < 0 if inconclusive.  */
1583
1584 int
1585 asm_operand_ok (rtx op, const char *constraint)
1586 {
1587   int result = 0;
1588
1589   /* Use constrain_operands after reload.  */
1590   if (reload_completed)
1591     abort ();
1592
1593   while (*constraint)
1594     {
1595       char c = *constraint;
1596       int len;
1597       switch (c)
1598         {
1599         case ',':
1600           constraint++;
1601           continue;
1602         case '=':
1603         case '+':
1604         case '*':
1605         case '%':
1606         case '!':
1607         case '#':
1608         case '&':
1609         case '?':
1610           break;
1611
1612         case '0': case '1': case '2': case '3': case '4':
1613         case '5': case '6': case '7': case '8': case '9':
1614           /* For best results, our caller should have given us the
1615              proper matching constraint, but we can't actually fail
1616              the check if they didn't.  Indicate that results are
1617              inconclusive.  */
1618           do
1619             constraint++;
1620           while (ISDIGIT (*constraint));
1621           if (! result)
1622             result = -1;
1623           continue;
1624
1625         case 'p':
1626           if (address_operand (op, VOIDmode))
1627             result = 1;
1628           break;
1629
1630         case 'm':
1631         case 'V': /* non-offsettable */
1632           if (memory_operand (op, VOIDmode))
1633             result = 1;
1634           break;
1635
1636         case 'o': /* offsettable */
1637           if (offsettable_nonstrict_memref_p (op))
1638             result = 1;
1639           break;
1640
1641         case '<':
1642           /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1643              excepting those that expand_call created.  Further, on some
1644              machines which do not have generalized auto inc/dec, an inc/dec
1645              is not a memory_operand.
1646
1647              Match any memory and hope things are resolved after reload.  */
1648
1649           if (GET_CODE (op) == MEM
1650               && (1
1651                   || GET_CODE (XEXP (op, 0)) == PRE_DEC
1652                   || GET_CODE (XEXP (op, 0)) == POST_DEC))
1653             result = 1;
1654           break;
1655
1656         case '>':
1657           if (GET_CODE (op) == MEM
1658               && (1
1659                   || GET_CODE (XEXP (op, 0)) == PRE_INC
1660                   || GET_CODE (XEXP (op, 0)) == POST_INC))
1661             result = 1;
1662           break;
1663
1664         case 'E':
1665         case 'F':
1666           if (GET_CODE (op) == CONST_DOUBLE
1667               || (GET_CODE (op) == CONST_VECTOR
1668                   && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
1669             result = 1;
1670           break;
1671
1672         case 'G':
1673           if (GET_CODE (op) == CONST_DOUBLE
1674               && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', constraint))
1675             result = 1;
1676           break;
1677         case 'H':
1678           if (GET_CODE (op) == CONST_DOUBLE
1679               && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint))
1680             result = 1;
1681           break;
1682
1683         case 's':
1684           if (GET_CODE (op) == CONST_INT
1685               || (GET_CODE (op) == CONST_DOUBLE
1686                   && GET_MODE (op) == VOIDmode))
1687             break;
1688           /* FALLTHRU */
1689
1690         case 'i':
1691           if (CONSTANT_P (op)
1692 #ifdef LEGITIMATE_PIC_OPERAND_P
1693               && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1694 #endif
1695               )
1696             result = 1;
1697           break;
1698
1699         case 'n':
1700           if (GET_CODE (op) == CONST_INT
1701               || (GET_CODE (op) == CONST_DOUBLE
1702                   && GET_MODE (op) == VOIDmode))
1703             result = 1;
1704           break;
1705
1706         case 'I':
1707           if (GET_CODE (op) == CONST_INT
1708               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'I', constraint))
1709             result = 1;
1710           break;
1711         case 'J':
1712           if (GET_CODE (op) == CONST_INT
1713               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'J', constraint))
1714             result = 1;
1715           break;
1716         case 'K':
1717           if (GET_CODE (op) == CONST_INT
1718               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'K', constraint))
1719             result = 1;
1720           break;
1721         case 'L':
1722           if (GET_CODE (op) == CONST_INT
1723               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'L', constraint))
1724             result = 1;
1725           break;
1726         case 'M':
1727           if (GET_CODE (op) == CONST_INT
1728               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'M', constraint))
1729             result = 1;
1730           break;
1731         case 'N':
1732           if (GET_CODE (op) == CONST_INT
1733               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'N', constraint))
1734             result = 1;
1735           break;
1736         case 'O':
1737           if (GET_CODE (op) == CONST_INT
1738               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'O', constraint))
1739             result = 1;
1740           break;
1741         case 'P':
1742           if (GET_CODE (op) == CONST_INT
1743               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'P', constraint))
1744             result = 1;
1745           break;
1746
1747         case 'X':
1748           result = 1;
1749           break;
1750
1751         case 'g':
1752           if (general_operand (op, VOIDmode))
1753             result = 1;
1754           break;
1755
1756         default:
1757           /* For all other letters, we first check for a register class,
1758              otherwise it is an EXTRA_CONSTRAINT.  */
1759           if (REG_CLASS_FROM_CONSTRAINT (c, constraint) != NO_REGS)
1760             {
1761             case 'r':
1762               if (GET_MODE (op) == BLKmode)
1763                 break;
1764               if (register_operand (op, VOIDmode))
1765                 result = 1;
1766             }
1767 #ifdef EXTRA_CONSTRAINT_STR
1768           else if (EXTRA_CONSTRAINT_STR (op, c, constraint))
1769             result = 1;
1770           else if (EXTRA_MEMORY_CONSTRAINT (c, constraint)
1771                    /* Every memory operand can be reloaded to fit.  */
1772                    && memory_operand (op, VOIDmode))
1773             result = 1;
1774           else if (EXTRA_ADDRESS_CONSTRAINT (c, constraint)
1775                    /* Every address operand can be reloaded to fit.  */
1776                    && address_operand (op, VOIDmode))
1777             result = 1;
1778 #endif
1779           break;
1780         }
1781       len = CONSTRAINT_LEN (c, constraint);
1782       do
1783         constraint++;
1784       while (--len && *constraint);
1785       if (len)
1786         return 0;
1787     }
1788
1789   return result;
1790 }
1791 \f
1792 /* Given an rtx *P, if it is a sum containing an integer constant term,
1793    return the location (type rtx *) of the pointer to that constant term.
1794    Otherwise, return a null pointer.  */
1795
1796 rtx *
1797 find_constant_term_loc (rtx *p)
1798 {
1799   rtx *tem;
1800   enum rtx_code code = GET_CODE (*p);
1801
1802   /* If *P IS such a constant term, P is its location.  */
1803
1804   if (code == CONST_INT || code == SYMBOL_REF || code == LABEL_REF
1805       || code == CONST)
1806     return p;
1807
1808   /* Otherwise, if not a sum, it has no constant term.  */
1809
1810   if (GET_CODE (*p) != PLUS)
1811     return 0;
1812
1813   /* If one of the summands is constant, return its location.  */
1814
1815   if (XEXP (*p, 0) && CONSTANT_P (XEXP (*p, 0))
1816       && XEXP (*p, 1) && CONSTANT_P (XEXP (*p, 1)))
1817     return p;
1818
1819   /* Otherwise, check each summand for containing a constant term.  */
1820
1821   if (XEXP (*p, 0) != 0)
1822     {
1823       tem = find_constant_term_loc (&XEXP (*p, 0));
1824       if (tem != 0)
1825         return tem;
1826     }
1827
1828   if (XEXP (*p, 1) != 0)
1829     {
1830       tem = find_constant_term_loc (&XEXP (*p, 1));
1831       if (tem != 0)
1832         return tem;
1833     }
1834
1835   return 0;
1836 }
1837 \f
1838 /* Return 1 if OP is a memory reference
1839    whose address contains no side effects
1840    and remains valid after the addition
1841    of a positive integer less than the
1842    size of the object being referenced.
1843
1844    We assume that the original address is valid and do not check it.
1845
1846    This uses strict_memory_address_p as a subroutine, so
1847    don't use it before reload.  */
1848
1849 int
1850 offsettable_memref_p (rtx op)
1851 {
1852   return ((GET_CODE (op) == MEM)
1853           && offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)));
1854 }
1855
1856 /* Similar, but don't require a strictly valid mem ref:
1857    consider pseudo-regs valid as index or base regs.  */
1858
1859 int
1860 offsettable_nonstrict_memref_p (rtx op)
1861 {
1862   return ((GET_CODE (op) == MEM)
1863           && offsettable_address_p (0, GET_MODE (op), XEXP (op, 0)));
1864 }
1865
1866 /* Return 1 if Y is a memory address which contains no side effects
1867    and would remain valid after the addition of a positive integer
1868    less than the size of that mode.
1869
1870    We assume that the original address is valid and do not check it.
1871    We do check that it is valid for narrower modes.
1872
1873    If STRICTP is nonzero, we require a strictly valid address,
1874    for the sake of use in reload.c.  */
1875
1876 int
1877 offsettable_address_p (int strictp, enum machine_mode mode, rtx y)
1878 {
1879   enum rtx_code ycode = GET_CODE (y);
1880   rtx z;
1881   rtx y1 = y;
1882   rtx *y2;
1883   int (*addressp) (enum machine_mode, rtx) =
1884     (strictp ? strict_memory_address_p : memory_address_p);
1885   unsigned int mode_sz = GET_MODE_SIZE (mode);
1886
1887   if (CONSTANT_ADDRESS_P (y))
1888     return 1;
1889
1890   /* Adjusting an offsettable address involves changing to a narrower mode.
1891      Make sure that's OK.  */
1892
1893   if (mode_dependent_address_p (y))
1894     return 0;
1895
1896   /* ??? How much offset does an offsettable BLKmode reference need?
1897      Clearly that depends on the situation in which it's being used.
1898      However, the current situation in which we test 0xffffffff is
1899      less than ideal.  Caveat user.  */
1900   if (mode_sz == 0)
1901     mode_sz = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
1902
1903   /* If the expression contains a constant term,
1904      see if it remains valid when max possible offset is added.  */
1905
1906   if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1)))
1907     {
1908       int good;
1909
1910       y1 = *y2;
1911       *y2 = plus_constant (*y2, mode_sz - 1);
1912       /* Use QImode because an odd displacement may be automatically invalid
1913          for any wider mode.  But it should be valid for a single byte.  */
1914       good = (*addressp) (QImode, y);
1915
1916       /* In any case, restore old contents of memory.  */
1917       *y2 = y1;
1918       return good;
1919     }
1920
1921   if (GET_RTX_CLASS (ycode) == 'a')
1922     return 0;
1923
1924   /* The offset added here is chosen as the maximum offset that
1925      any instruction could need to add when operating on something
1926      of the specified mode.  We assume that if Y and Y+c are
1927      valid addresses then so is Y+d for all 0<d<c.  adjust_address will
1928      go inside a LO_SUM here, so we do so as well.  */
1929   if (GET_CODE (y) == LO_SUM
1930       && mode != BLKmode
1931       && mode_sz <= GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT)
1932     z = gen_rtx_LO_SUM (GET_MODE (y), XEXP (y, 0),
1933                         plus_constant (XEXP (y, 1), mode_sz - 1));
1934   else
1935     z = plus_constant (y, mode_sz - 1);
1936
1937   /* Use QImode because an odd displacement may be automatically invalid
1938      for any wider mode.  But it should be valid for a single byte.  */
1939   return (*addressp) (QImode, z);
1940 }
1941
1942 /* Return 1 if ADDR is an address-expression whose effect depends
1943    on the mode of the memory reference it is used in.
1944
1945    Autoincrement addressing is a typical example of mode-dependence
1946    because the amount of the increment depends on the mode.  */
1947
1948 int
1949 mode_dependent_address_p (rtx addr ATTRIBUTE_UNUSED /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS.  */)
1950 {
1951   GO_IF_MODE_DEPENDENT_ADDRESS (addr, win);
1952   return 0;
1953   /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS.  */
1954  win: ATTRIBUTE_UNUSED_LABEL
1955   return 1;
1956 }
1957 \f
1958 /* Like extract_insn, but save insn extracted and don't extract again, when
1959    called again for the same insn expecting that recog_data still contain the
1960    valid information.  This is used primary by gen_attr infrastructure that
1961    often does extract insn again and again.  */
1962 void
1963 extract_insn_cached (rtx insn)
1964 {
1965   if (recog_data.insn == insn && INSN_CODE (insn) >= 0)
1966     return;
1967   extract_insn (insn);
1968   recog_data.insn = insn;
1969 }
1970 /* Do cached extract_insn, constrain_operands and complain about failures.
1971    Used by insn_attrtab.  */
1972 void
1973 extract_constrain_insn_cached (rtx insn)
1974 {
1975   extract_insn_cached (insn);
1976   if (which_alternative == -1
1977       && !constrain_operands (reload_completed))
1978     fatal_insn_not_found (insn);
1979 }
1980 /* Do cached constrain_operands and complain about failures.  */
1981 int
1982 constrain_operands_cached (int strict)
1983 {
1984   if (which_alternative == -1)
1985     return constrain_operands (strict);
1986   else
1987     return 1;
1988 }
1989 \f
1990 /* Analyze INSN and fill in recog_data.  */
1991
1992 void
1993 extract_insn (rtx insn)
1994 {
1995   int i;
1996   int icode;
1997   int noperands;
1998   rtx body = PATTERN (insn);
1999
2000   recog_data.insn = NULL;
2001   recog_data.n_operands = 0;
2002   recog_data.n_alternatives = 0;
2003   recog_data.n_dups = 0;
2004   which_alternative = -1;
2005
2006   switch (GET_CODE (body))
2007     {
2008     case USE:
2009     case CLOBBER:
2010     case ASM_INPUT:
2011     case ADDR_VEC:
2012     case ADDR_DIFF_VEC:
2013       return;
2014
2015     case SET:
2016       if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
2017         goto asm_insn;
2018       else
2019         goto normal_insn;
2020     case PARALLEL:
2021       if ((GET_CODE (XVECEXP (body, 0, 0)) == SET
2022            && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
2023           || GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
2024         goto asm_insn;
2025       else
2026         goto normal_insn;
2027     case ASM_OPERANDS:
2028     asm_insn:
2029       recog_data.n_operands = noperands = asm_noperands (body);
2030       if (noperands >= 0)
2031         {
2032           /* This insn is an `asm' with operands.  */
2033
2034           /* expand_asm_operands makes sure there aren't too many operands.  */
2035           if (noperands > MAX_RECOG_OPERANDS)
2036             abort ();
2037
2038           /* Now get the operand values and constraints out of the insn.  */
2039           decode_asm_operands (body, recog_data.operand,
2040                                recog_data.operand_loc,
2041                                recog_data.constraints,
2042                                recog_data.operand_mode);
2043           if (noperands > 0)
2044             {
2045               const char *p =  recog_data.constraints[0];
2046               recog_data.n_alternatives = 1;
2047               while (*p)
2048                 recog_data.n_alternatives += (*p++ == ',');
2049             }
2050           break;
2051         }
2052       fatal_insn_not_found (insn);
2053
2054     default:
2055     normal_insn:
2056       /* Ordinary insn: recognize it, get the operands via insn_extract
2057          and get the constraints.  */
2058
2059       icode = recog_memoized (insn);
2060       if (icode < 0)
2061         fatal_insn_not_found (insn);
2062
2063       recog_data.n_operands = noperands = insn_data[icode].n_operands;
2064       recog_data.n_alternatives = insn_data[icode].n_alternatives;
2065       recog_data.n_dups = insn_data[icode].n_dups;
2066
2067       insn_extract (insn);
2068
2069       for (i = 0; i < noperands; i++)
2070         {
2071           recog_data.constraints[i] = insn_data[icode].operand[i].constraint;
2072           recog_data.operand_mode[i] = insn_data[icode].operand[i].mode;
2073           /* VOIDmode match_operands gets mode from their real operand.  */
2074           if (recog_data.operand_mode[i] == VOIDmode)
2075             recog_data.operand_mode[i] = GET_MODE (recog_data.operand[i]);
2076         }
2077     }
2078   for (i = 0; i < noperands; i++)
2079     recog_data.operand_type[i]
2080       = (recog_data.constraints[i][0] == '=' ? OP_OUT
2081          : recog_data.constraints[i][0] == '+' ? OP_INOUT
2082          : OP_IN);
2083
2084   if (recog_data.n_alternatives > MAX_RECOG_ALTERNATIVES)
2085     abort ();
2086 }
2087
2088 /* After calling extract_insn, you can use this function to extract some
2089    information from the constraint strings into a more usable form.
2090    The collected data is stored in recog_op_alt.  */
2091 void
2092 preprocess_constraints (void)
2093 {
2094   int i;
2095
2096   for (i = 0; i < recog_data.n_operands; i++)
2097     memset (recog_op_alt[i], 0, (recog_data.n_alternatives
2098                                  * sizeof (struct operand_alternative)));
2099
2100   for (i = 0; i < recog_data.n_operands; i++)
2101     {
2102       int j;
2103       struct operand_alternative *op_alt;
2104       const char *p = recog_data.constraints[i];
2105
2106       op_alt = recog_op_alt[i];
2107
2108       for (j = 0; j < recog_data.n_alternatives; j++)
2109         {
2110           op_alt[j].class = NO_REGS;
2111           op_alt[j].constraint = p;
2112           op_alt[j].matches = -1;
2113           op_alt[j].matched = -1;
2114
2115           if (*p == '\0' || *p == ',')
2116             {
2117               op_alt[j].anything_ok = 1;
2118               continue;
2119             }
2120
2121           for (;;)
2122             {
2123               char c = *p;
2124               if (c == '#')
2125                 do
2126                   c = *++p;
2127                 while (c != ',' && c != '\0');
2128               if (c == ',' || c == '\0')
2129                 {
2130                   p++;
2131                   break;
2132                 }
2133
2134               switch (c)
2135                 {
2136                 case '=': case '+': case '*': case '%':
2137                 case 'E': case 'F': case 'G': case 'H':
2138                 case 's': case 'i': case 'n':
2139                 case 'I': case 'J': case 'K': case 'L':
2140                 case 'M': case 'N': case 'O': case 'P':
2141                   /* These don't say anything we care about.  */
2142                   break;
2143
2144                 case '?':
2145                   op_alt[j].reject += 6;
2146                   break;
2147                 case '!':
2148                   op_alt[j].reject += 600;
2149                   break;
2150                 case '&':
2151                   op_alt[j].earlyclobber = 1;
2152                   break;
2153
2154                 case '0': case '1': case '2': case '3': case '4':
2155                 case '5': case '6': case '7': case '8': case '9':
2156                   {
2157                     char *end;
2158                     op_alt[j].matches = strtoul (p, &end, 10);
2159                     recog_op_alt[op_alt[j].matches][j].matched = i;
2160                     p = end;
2161                   }
2162                   continue;
2163
2164                 case 'm':
2165                   op_alt[j].memory_ok = 1;
2166                   break;
2167                 case '<':
2168                   op_alt[j].decmem_ok = 1;
2169                   break;
2170                 case '>':
2171                   op_alt[j].incmem_ok = 1;
2172                   break;
2173                 case 'V':
2174                   op_alt[j].nonoffmem_ok = 1;
2175                   break;
2176                 case 'o':
2177                   op_alt[j].offmem_ok = 1;
2178                   break;
2179                 case 'X':
2180                   op_alt[j].anything_ok = 1;
2181                   break;
2182
2183                 case 'p':
2184                   op_alt[j].is_address = 1;
2185                   op_alt[j].class = reg_class_subunion[(int) op_alt[j].class]
2186                     [(int) MODE_BASE_REG_CLASS (VOIDmode)];
2187                   break;
2188
2189                 case 'g': case 'r':
2190                   op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) GENERAL_REGS];
2191                   break;
2192
2193                 default:
2194                   if (EXTRA_MEMORY_CONSTRAINT (c, p))
2195                     {
2196                       op_alt[j].memory_ok = 1;
2197                       break;
2198                     }
2199                   if (EXTRA_ADDRESS_CONSTRAINT (c, p))
2200                     {
2201                       op_alt[j].is_address = 1;
2202                       op_alt[j].class
2203                         = (reg_class_subunion
2204                            [(int) op_alt[j].class]
2205                            [(int) MODE_BASE_REG_CLASS (VOIDmode)]);
2206                       break;
2207                     }
2208
2209                   op_alt[j].class
2210                     = (reg_class_subunion
2211                        [(int) op_alt[j].class]
2212                        [(int) REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)]);
2213                   break;
2214                 }
2215               p += CONSTRAINT_LEN (c, p);
2216             }
2217         }
2218     }
2219 }
2220
2221 /* Check the operands of an insn against the insn's operand constraints
2222    and return 1 if they are valid.
2223    The information about the insn's operands, constraints, operand modes
2224    etc. is obtained from the global variables set up by extract_insn.
2225
2226    WHICH_ALTERNATIVE is set to a number which indicates which
2227    alternative of constraints was matched: 0 for the first alternative,
2228    1 for the next, etc.
2229
2230    In addition, when two operands are required to match
2231    and it happens that the output operand is (reg) while the
2232    input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
2233    make the output operand look like the input.
2234    This is because the output operand is the one the template will print.
2235
2236    This is used in final, just before printing the assembler code and by
2237    the routines that determine an insn's attribute.
2238
2239    If STRICT is a positive nonzero value, it means that we have been
2240    called after reload has been completed.  In that case, we must
2241    do all checks strictly.  If it is zero, it means that we have been called
2242    before reload has completed.  In that case, we first try to see if we can
2243    find an alternative that matches strictly.  If not, we try again, this
2244    time assuming that reload will fix up the insn.  This provides a "best
2245    guess" for the alternative and is used to compute attributes of insns prior
2246    to reload.  A negative value of STRICT is used for this internal call.  */
2247
2248 struct funny_match
2249 {
2250   int this, other;
2251 };
2252
2253 int
2254 constrain_operands (int strict)
2255 {
2256   const char *constraints[MAX_RECOG_OPERANDS];
2257   int matching_operands[MAX_RECOG_OPERANDS];
2258   int earlyclobber[MAX_RECOG_OPERANDS];
2259   int c;
2260
2261   struct funny_match funny_match[MAX_RECOG_OPERANDS];
2262   int funny_match_index;
2263
2264   which_alternative = 0;
2265   if (recog_data.n_operands == 0 || recog_data.n_alternatives == 0)
2266     return 1;
2267
2268   for (c = 0; c < recog_data.n_operands; c++)
2269     {
2270       constraints[c] = recog_data.constraints[c];
2271       matching_operands[c] = -1;
2272     }
2273
2274   do
2275     {
2276       int opno;
2277       int lose = 0;
2278       funny_match_index = 0;
2279
2280       for (opno = 0; opno < recog_data.n_operands; opno++)
2281         {
2282           rtx op = recog_data.operand[opno];
2283           enum machine_mode mode = GET_MODE (op);
2284           const char *p = constraints[opno];
2285           int offset = 0;
2286           int win = 0;
2287           int val;
2288           int len;
2289
2290           earlyclobber[opno] = 0;
2291
2292           /* A unary operator may be accepted by the predicate, but it
2293              is irrelevant for matching constraints.  */
2294           if (GET_RTX_CLASS (GET_CODE (op)) == '1')
2295             op = XEXP (op, 0);
2296
2297           if (GET_CODE (op) == SUBREG)
2298             {
2299               if (GET_CODE (SUBREG_REG (op)) == REG
2300                   && REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER)
2301                 offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
2302                                               GET_MODE (SUBREG_REG (op)),
2303                                               SUBREG_BYTE (op),
2304                                               GET_MODE (op));
2305               op = SUBREG_REG (op);
2306             }
2307
2308           /* An empty constraint or empty alternative
2309              allows anything which matched the pattern.  */
2310           if (*p == 0 || *p == ',')
2311             win = 1;
2312
2313           do
2314             switch (c = *p, len = CONSTRAINT_LEN (c, p), c)
2315               {
2316               case '\0':
2317                 len = 0;
2318                 break;
2319               case ',':
2320                 c = '\0';
2321                 break;
2322
2323               case '?':  case '!': case '*':  case '%':
2324               case '=':  case '+':
2325                 break;
2326
2327               case '#':
2328                 /* Ignore rest of this alternative as far as
2329                    constraint checking is concerned.  */
2330                 do
2331                   p++;
2332                 while (*p && *p != ',');
2333                 len = 0;
2334                 break;
2335
2336               case '&':
2337                 earlyclobber[opno] = 1;
2338                 break;
2339
2340               case '0':  case '1':  case '2':  case '3':  case '4':
2341               case '5':  case '6':  case '7':  case '8':  case '9':
2342                 {
2343                   /* This operand must be the same as a previous one.
2344                      This kind of constraint is used for instructions such
2345                      as add when they take only two operands.
2346
2347                      Note that the lower-numbered operand is passed first.
2348
2349                      If we are not testing strictly, assume that this
2350                      constraint will be satisfied.  */
2351
2352                   char *end;
2353                   int match;
2354
2355                   match = strtoul (p, &end, 10);
2356                   p = end;
2357
2358                   if (strict < 0)
2359                     val = 1;
2360                   else
2361                     {
2362                       rtx op1 = recog_data.operand[match];
2363                       rtx op2 = recog_data.operand[opno];
2364
2365                       /* A unary operator may be accepted by the predicate,
2366                          but it is irrelevant for matching constraints.  */
2367                       if (GET_RTX_CLASS (GET_CODE (op1)) == '1')
2368                         op1 = XEXP (op1, 0);
2369                       if (GET_RTX_CLASS (GET_CODE (op2)) == '1')
2370                         op2 = XEXP (op2, 0);
2371
2372                       val = operands_match_p (op1, op2);
2373                     }
2374
2375                   matching_operands[opno] = match;
2376                   matching_operands[match] = opno;
2377
2378                   if (val != 0)
2379                     win = 1;
2380
2381                   /* If output is *x and input is *--x, arrange later
2382                      to change the output to *--x as well, since the
2383                      output op is the one that will be printed.  */
2384                   if (val == 2 && strict > 0)
2385                     {
2386                       funny_match[funny_match_index].this = opno;
2387                       funny_match[funny_match_index++].other = match;
2388                     }
2389                 }
2390                 len = 0;
2391                 break;
2392
2393               case 'p':
2394                 /* p is used for address_operands.  When we are called by
2395                    gen_reload, no one will have checked that the address is
2396                    strictly valid, i.e., that all pseudos requiring hard regs
2397                    have gotten them.  */
2398                 if (strict <= 0
2399                     || (strict_memory_address_p (recog_data.operand_mode[opno],
2400                                                  op)))
2401                   win = 1;
2402                 break;
2403
2404                 /* No need to check general_operand again;
2405                    it was done in insn-recog.c.  */
2406               case 'g':
2407                 /* Anything goes unless it is a REG and really has a hard reg
2408                    but the hard reg is not in the class GENERAL_REGS.  */
2409                 if (strict < 0
2410                     || GENERAL_REGS == ALL_REGS
2411                     || GET_CODE (op) != REG
2412                     || (reload_in_progress
2413                         && REGNO (op) >= FIRST_PSEUDO_REGISTER)
2414                     || reg_fits_class_p (op, GENERAL_REGS, offset, mode))
2415                   win = 1;
2416                 break;
2417
2418               case 'X':
2419                 /* This is used for a MATCH_SCRATCH in the cases when
2420                    we don't actually need anything.  So anything goes
2421                    any time.  */
2422                 win = 1;
2423                 break;
2424
2425               case 'm':
2426                 if (GET_CODE (op) == MEM
2427                     /* Before reload, accept what reload can turn into mem.  */
2428                     || (strict < 0 && CONSTANT_P (op))
2429                     /* During reload, accept a pseudo  */
2430                     || (reload_in_progress && GET_CODE (op) == REG
2431                         && REGNO (op) >= FIRST_PSEUDO_REGISTER))
2432                   win = 1;
2433                 break;
2434
2435               case '<':
2436                 if (GET_CODE (op) == MEM
2437                     && (GET_CODE (XEXP (op, 0)) == PRE_DEC
2438                         || GET_CODE (XEXP (op, 0)) == POST_DEC))
2439                   win = 1;
2440                 break;
2441
2442               case '>':
2443                 if (GET_CODE (op) == MEM
2444                     && (GET_CODE (XEXP (op, 0)) == PRE_INC
2445                         || GET_CODE (XEXP (op, 0)) == POST_INC))
2446                   win = 1;
2447                 break;
2448
2449               case 'E':
2450               case 'F':
2451                 if (GET_CODE (op) == CONST_DOUBLE
2452                     || (GET_CODE (op) == CONST_VECTOR
2453                         && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
2454                   win = 1;
2455                 break;
2456
2457               case 'G':
2458               case 'H':
2459                 if (GET_CODE (op) == CONST_DOUBLE
2460                     && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
2461                   win = 1;
2462                 break;
2463
2464               case 's':
2465                 if (GET_CODE (op) == CONST_INT
2466                     || (GET_CODE (op) == CONST_DOUBLE
2467                         && GET_MODE (op) == VOIDmode))
2468                   break;
2469               case 'i':
2470                 if (CONSTANT_P (op))
2471                   win = 1;
2472                 break;
2473
2474               case 'n':
2475                 if (GET_CODE (op) == CONST_INT
2476                     || (GET_CODE (op) == CONST_DOUBLE
2477                         && GET_MODE (op) == VOIDmode))
2478                   win = 1;
2479                 break;
2480
2481               case 'I':
2482               case 'J':
2483               case 'K':
2484               case 'L':
2485               case 'M':
2486               case 'N':
2487               case 'O':
2488               case 'P':
2489                 if (GET_CODE (op) == CONST_INT
2490                     && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), c, p))
2491                   win = 1;
2492                 break;
2493
2494               case 'V':
2495                 if (GET_CODE (op) == MEM
2496                     && ((strict > 0 && ! offsettable_memref_p (op))
2497                         || (strict < 0
2498                             && !(CONSTANT_P (op) || GET_CODE (op) == MEM))
2499                         || (reload_in_progress
2500                             && !(GET_CODE (op) == REG
2501                                  && REGNO (op) >= FIRST_PSEUDO_REGISTER))))
2502                   win = 1;
2503                 break;
2504
2505               case 'o':
2506                 if ((strict > 0 && offsettable_memref_p (op))
2507                     || (strict == 0 && offsettable_nonstrict_memref_p (op))
2508                     /* Before reload, accept what reload can handle.  */
2509                     || (strict < 0
2510                         && (CONSTANT_P (op) || GET_CODE (op) == MEM))
2511                     /* During reload, accept a pseudo  */
2512                     || (reload_in_progress && GET_CODE (op) == REG
2513                         && REGNO (op) >= FIRST_PSEUDO_REGISTER))
2514                   win = 1;
2515                 break;
2516
2517               default:
2518                 {
2519                   enum reg_class class;
2520
2521                   class = (c == 'r'
2522                            ? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p));
2523                   if (class != NO_REGS)
2524                     {
2525                       if (strict < 0
2526                           || (strict == 0
2527                               && GET_CODE (op) == REG
2528                               && REGNO (op) >= FIRST_PSEUDO_REGISTER)
2529                           || (strict == 0 && GET_CODE (op) == SCRATCH)
2530                           || (GET_CODE (op) == REG
2531                               && reg_fits_class_p (op, class, offset, mode)))
2532                         win = 1;
2533                     }
2534 #ifdef EXTRA_CONSTRAINT_STR
2535                   else if (EXTRA_CONSTRAINT_STR (op, c, p))
2536                     win = 1;
2537
2538                   else if (EXTRA_MEMORY_CONSTRAINT (c, p)
2539                            /* Every memory operand can be reloaded to fit.  */
2540                            && ((strict < 0 && GET_CODE (op) == MEM)
2541                                /* Before reload, accept what reload can turn
2542                                   into mem.  */
2543                                || (strict < 0 && CONSTANT_P (op))
2544                                /* During reload, accept a pseudo  */
2545                                || (reload_in_progress && GET_CODE (op) == REG
2546                                    && REGNO (op) >= FIRST_PSEUDO_REGISTER)))
2547                     win = 1;
2548                   else if (EXTRA_ADDRESS_CONSTRAINT (c, p)
2549                            /* Every address operand can be reloaded to fit.  */
2550                            && strict < 0)
2551                     win = 1;
2552 #endif
2553                   break;
2554                 }
2555               }
2556           while (p += len, c);
2557
2558           constraints[opno] = p;
2559           /* If this operand did not win somehow,
2560              this alternative loses.  */
2561           if (! win)
2562             lose = 1;
2563         }
2564       /* This alternative won; the operands are ok.
2565          Change whichever operands this alternative says to change.  */
2566       if (! lose)
2567         {
2568           int opno, eopno;
2569
2570           /* See if any earlyclobber operand conflicts with some other
2571              operand.  */
2572
2573           if (strict > 0)
2574             for (eopno = 0; eopno < recog_data.n_operands; eopno++)
2575               /* Ignore earlyclobber operands now in memory,
2576                  because we would often report failure when we have
2577                  two memory operands, one of which was formerly a REG.  */
2578               if (earlyclobber[eopno]
2579                   && GET_CODE (recog_data.operand[eopno]) == REG)
2580                 for (opno = 0; opno < recog_data.n_operands; opno++)
2581                   if ((GET_CODE (recog_data.operand[opno]) == MEM
2582                        || recog_data.operand_type[opno] != OP_OUT)
2583                       && opno != eopno
2584                       /* Ignore things like match_operator operands.  */
2585                       && *recog_data.constraints[opno] != 0
2586                       && ! (matching_operands[opno] == eopno
2587                             && operands_match_p (recog_data.operand[opno],
2588                                                  recog_data.operand[eopno]))
2589                       && ! safe_from_earlyclobber (recog_data.operand[opno],
2590                                                    recog_data.operand[eopno]))
2591                     lose = 1;
2592
2593           if (! lose)
2594             {
2595               while (--funny_match_index >= 0)
2596                 {
2597                   recog_data.operand[funny_match[funny_match_index].other]
2598                     = recog_data.operand[funny_match[funny_match_index].this];
2599                 }
2600
2601               return 1;
2602             }
2603         }
2604
2605       which_alternative++;
2606     }
2607   while (which_alternative < recog_data.n_alternatives);
2608
2609   which_alternative = -1;
2610   /* If we are about to reject this, but we are not to test strictly,
2611      try a very loose test.  Only return failure if it fails also.  */
2612   if (strict == 0)
2613     return constrain_operands (-1);
2614   else
2615     return 0;
2616 }
2617
2618 /* Return 1 iff OPERAND (assumed to be a REG rtx)
2619    is a hard reg in class CLASS when its regno is offset by OFFSET
2620    and changed to mode MODE.
2621    If REG occupies multiple hard regs, all of them must be in CLASS.  */
2622
2623 int
2624 reg_fits_class_p (rtx operand, enum reg_class class, int offset,
2625                   enum machine_mode mode)
2626 {
2627   int regno = REGNO (operand);
2628   if (regno < FIRST_PSEUDO_REGISTER
2629       && TEST_HARD_REG_BIT (reg_class_contents[(int) class],
2630                             regno + offset))
2631     {
2632       int sr;
2633       regno += offset;
2634       for (sr = HARD_REGNO_NREGS (regno, mode) - 1;
2635            sr > 0; sr--)
2636         if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
2637                                  regno + sr))
2638           break;
2639       return sr == 0;
2640     }
2641
2642   return 0;
2643 }
2644 \f
2645 /* Split single instruction.  Helper function for split_all_insns and
2646    split_all_insns_noflow.  Return last insn in the sequence if successful,
2647    or NULL if unsuccessful.  */
2648
2649 static rtx
2650 split_insn (rtx insn)
2651 {
2652   /* Split insns here to get max fine-grain parallelism.  */
2653   rtx first = PREV_INSN (insn);
2654   rtx last = try_split (PATTERN (insn), insn, 1);
2655
2656   if (last == insn)
2657     return NULL_RTX;
2658
2659   /* try_split returns the NOTE that INSN became.  */
2660   PUT_CODE (insn, NOTE);
2661   NOTE_SOURCE_FILE (insn) = 0;
2662   NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2663
2664   /* ??? Coddle to md files that generate subregs in post-reload
2665      splitters instead of computing the proper hard register.  */
2666   if (reload_completed && first != last)
2667     {
2668       first = NEXT_INSN (first);
2669       for (;;)
2670         {
2671           if (INSN_P (first))
2672             cleanup_subreg_operands (first);
2673           if (first == last)
2674             break;
2675           first = NEXT_INSN (first);
2676         }
2677     }
2678   return last;
2679 }
2680
2681 /* Split all insns in the function.  If UPD_LIFE, update life info after.  */
2682
2683 void
2684 split_all_insns (int upd_life)
2685 {
2686   sbitmap blocks;
2687   bool changed;
2688   basic_block bb;
2689
2690   blocks = sbitmap_alloc (last_basic_block);
2691   sbitmap_zero (blocks);
2692   changed = false;
2693
2694   FOR_EACH_BB_REVERSE (bb)
2695     {
2696       rtx insn, next;
2697       bool finish = false;
2698
2699       for (insn = BB_HEAD (bb); !finish ; insn = next)
2700         {
2701           /* Can't use `next_real_insn' because that might go across
2702              CODE_LABELS and short-out basic blocks.  */
2703           next = NEXT_INSN (insn);
2704           finish = (insn == BB_END (bb));
2705           if (INSN_P (insn))
2706             {
2707               rtx set = single_set (insn);
2708
2709               /* Don't split no-op move insns.  These should silently
2710                  disappear later in final.  Splitting such insns would
2711                  break the code that handles REG_NO_CONFLICT blocks.  */
2712               if (set && set_noop_p (set))
2713                 {
2714                   /* Nops get in the way while scheduling, so delete them
2715                      now if register allocation has already been done.  It
2716                      is too risky to try to do this before register
2717                      allocation, and there are unlikely to be very many
2718                      nops then anyways.  */
2719                   if (reload_completed)
2720                     {
2721                       /* If the no-op set has a REG_UNUSED note, we need
2722                          to update liveness information.  */
2723                       if (find_reg_note (insn, REG_UNUSED, NULL_RTX))
2724                         {
2725                           SET_BIT (blocks, bb->index);
2726                           changed = true;
2727                         }
2728                       /* ??? Is life info affected by deleting edges?  */
2729                       delete_insn_and_edges (insn);
2730                     }
2731                 }
2732               else
2733                 {
2734                   rtx last = split_insn (insn);
2735                   if (last)
2736                     {
2737                       /* The split sequence may include barrier, but the
2738                          BB boundary we are interested in will be set to
2739                          previous one.  */
2740
2741                       while (GET_CODE (last) == BARRIER)
2742                         last = PREV_INSN (last);
2743                       SET_BIT (blocks, bb->index);
2744                       changed = true;
2745                     }
2746                 }
2747             }
2748         }
2749     }
2750
2751   if (changed)
2752     {
2753       int old_last_basic_block = last_basic_block;
2754
2755       find_many_sub_basic_blocks (blocks);
2756
2757       if (old_last_basic_block != last_basic_block && upd_life)
2758         blocks = sbitmap_resize (blocks, last_basic_block, 1);
2759     }
2760
2761   if (changed && upd_life)
2762     update_life_info (blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
2763                       PROP_DEATH_NOTES | PROP_REG_INFO);
2764
2765 #ifdef ENABLE_CHECKING
2766   verify_flow_info ();
2767 #endif
2768
2769   sbitmap_free (blocks);
2770 }
2771
2772 /* Same as split_all_insns, but do not expect CFG to be available.
2773    Used by machine dependent reorg passes.  */
2774
2775 void
2776 split_all_insns_noflow (void)
2777 {
2778   rtx next, insn;
2779
2780   for (insn = get_insns (); insn; insn = next)
2781     {
2782       next = NEXT_INSN (insn);
2783       if (INSN_P (insn))
2784         {
2785           /* Don't split no-op move insns.  These should silently
2786              disappear later in final.  Splitting such insns would
2787              break the code that handles REG_NO_CONFLICT blocks.  */
2788           rtx set = single_set (insn);
2789           if (set && set_noop_p (set))
2790             {
2791               /* Nops get in the way while scheduling, so delete them
2792                  now if register allocation has already been done.  It
2793                  is too risky to try to do this before register
2794                  allocation, and there are unlikely to be very many
2795                  nops then anyways.
2796
2797                  ??? Should we use delete_insn when the CFG isn't valid?  */
2798               if (reload_completed)
2799                 delete_insn_and_edges (insn);
2800             }
2801           else
2802             split_insn (insn);
2803         }
2804     }
2805 }
2806 \f
2807 #ifdef HAVE_peephole2
2808 struct peep2_insn_data
2809 {
2810   rtx insn;
2811   regset live_before;
2812 };
2813
2814 static struct peep2_insn_data peep2_insn_data[MAX_INSNS_PER_PEEP2 + 1];
2815 static int peep2_current;
2816
2817 /* A non-insn marker indicating the last insn of the block.
2818    The live_before regset for this element is correct, indicating
2819    global_live_at_end for the block.  */
2820 #define PEEP2_EOB       pc_rtx
2821
2822 /* Return the Nth non-note insn after `current', or return NULL_RTX if it
2823    does not exist.  Used by the recognizer to find the next insn to match
2824    in a multi-insn pattern.  */
2825
2826 rtx
2827 peep2_next_insn (int n)
2828 {
2829   if (n >= MAX_INSNS_PER_PEEP2 + 1)
2830     abort ();
2831
2832   n += peep2_current;
2833   if (n >= MAX_INSNS_PER_PEEP2 + 1)
2834     n -= MAX_INSNS_PER_PEEP2 + 1;
2835
2836   if (peep2_insn_data[n].insn == PEEP2_EOB)
2837     return NULL_RTX;
2838   return peep2_insn_data[n].insn;
2839 }
2840
2841 /* Return true if REGNO is dead before the Nth non-note insn
2842    after `current'.  */
2843
2844 int
2845 peep2_regno_dead_p (int ofs, int regno)
2846 {
2847   if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
2848     abort ();
2849
2850   ofs += peep2_current;
2851   if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
2852     ofs -= MAX_INSNS_PER_PEEP2 + 1;
2853
2854   if (peep2_insn_data[ofs].insn == NULL_RTX)
2855     abort ();
2856
2857   return ! REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno);
2858 }
2859
2860 /* Similarly for a REG.  */
2861
2862 int
2863 peep2_reg_dead_p (int ofs, rtx reg)
2864 {
2865   int regno, n;
2866
2867   if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
2868     abort ();
2869
2870   ofs += peep2_current;
2871   if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
2872     ofs -= MAX_INSNS_PER_PEEP2 + 1;
2873
2874   if (peep2_insn_data[ofs].insn == NULL_RTX)
2875     abort ();
2876
2877   regno = REGNO (reg);
2878   n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
2879   while (--n >= 0)
2880     if (REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno + n))
2881       return 0;
2882   return 1;
2883 }
2884
2885 /* Try to find a hard register of mode MODE, matching the register class in
2886    CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
2887    remains available until the end of LAST_INSN.  LAST_INSN may be NULL_RTX,
2888    in which case the only condition is that the register must be available
2889    before CURRENT_INSN.
2890    Registers that already have bits set in REG_SET will not be considered.
2891
2892    If an appropriate register is available, it will be returned and the
2893    corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
2894    returned.  */
2895
2896 rtx
2897 peep2_find_free_register (int from, int to, const char *class_str,
2898                           enum machine_mode mode, HARD_REG_SET *reg_set)
2899 {
2900   static int search_ofs;
2901   enum reg_class class;
2902   HARD_REG_SET live;
2903   int i;
2904
2905   if (from >= MAX_INSNS_PER_PEEP2 + 1 || to >= MAX_INSNS_PER_PEEP2 + 1)
2906     abort ();
2907
2908   from += peep2_current;
2909   if (from >= MAX_INSNS_PER_PEEP2 + 1)
2910     from -= MAX_INSNS_PER_PEEP2 + 1;
2911   to += peep2_current;
2912   if (to >= MAX_INSNS_PER_PEEP2 + 1)
2913     to -= MAX_INSNS_PER_PEEP2 + 1;
2914
2915   if (peep2_insn_data[from].insn == NULL_RTX)
2916     abort ();
2917   REG_SET_TO_HARD_REG_SET (live, peep2_insn_data[from].live_before);
2918
2919   while (from != to)
2920     {
2921       HARD_REG_SET this_live;
2922
2923       if (++from >= MAX_INSNS_PER_PEEP2 + 1)
2924         from = 0;
2925       if (peep2_insn_data[from].insn == NULL_RTX)
2926         abort ();
2927       REG_SET_TO_HARD_REG_SET (this_live, peep2_insn_data[from].live_before);
2928       IOR_HARD_REG_SET (live, this_live);
2929     }
2930
2931   class = (class_str[0] == 'r' ? GENERAL_REGS
2932            : REG_CLASS_FROM_CONSTRAINT (class_str[0], class_str));
2933
2934   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2935     {
2936       int raw_regno, regno, success, j;
2937
2938       /* Distribute the free registers as much as possible.  */
2939       raw_regno = search_ofs + i;
2940       if (raw_regno >= FIRST_PSEUDO_REGISTER)
2941         raw_regno -= FIRST_PSEUDO_REGISTER;
2942 #ifdef REG_ALLOC_ORDER
2943       regno = reg_alloc_order[raw_regno];
2944 #else
2945       regno = raw_regno;
2946 #endif
2947
2948       /* Don't allocate fixed registers.  */
2949       if (fixed_regs[regno])
2950         continue;
2951       /* Make sure the register is of the right class.  */
2952       if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno))
2953         continue;
2954       /* And can support the mode we need.  */
2955       if (! HARD_REGNO_MODE_OK (regno, mode))
2956         continue;
2957       /* And that we don't create an extra save/restore.  */
2958       if (! call_used_regs[regno] && ! regs_ever_live[regno])
2959         continue;
2960       /* And we don't clobber traceback for noreturn functions.  */
2961       if ((regno == FRAME_POINTER_REGNUM || regno == HARD_FRAME_POINTER_REGNUM)
2962           && (! reload_completed || frame_pointer_needed))
2963         continue;
2964
2965       success = 1;
2966       for (j = HARD_REGNO_NREGS (regno, mode) - 1; j >= 0; j--)
2967         {
2968           if (TEST_HARD_REG_BIT (*reg_set, regno + j)
2969               || TEST_HARD_REG_BIT (live, regno + j))
2970             {
2971               success = 0;
2972               break;
2973             }
2974         }
2975       if (success)
2976         {
2977           for (j = HARD_REGNO_NREGS (regno, mode) - 1; j >= 0; j--)
2978             SET_HARD_REG_BIT (*reg_set, regno + j);
2979
2980           /* Start the next search with the next register.  */
2981           if (++raw_regno >= FIRST_PSEUDO_REGISTER)
2982             raw_regno = 0;
2983           search_ofs = raw_regno;
2984
2985           return gen_rtx_REG (mode, regno);
2986         }
2987     }
2988
2989   search_ofs = 0;
2990   return NULL_RTX;
2991 }
2992
2993 /* Perform the peephole2 optimization pass.  */
2994
2995 void
2996 peephole2_optimize (FILE *dump_file ATTRIBUTE_UNUSED)
2997 {
2998   regset_head rs_heads[MAX_INSNS_PER_PEEP2 + 2];
2999   rtx insn, prev;
3000   regset live;
3001   int i;
3002   basic_block bb;
3003 #ifdef HAVE_conditional_execution
3004   sbitmap blocks;
3005   bool changed;
3006 #endif
3007   bool do_cleanup_cfg = false;
3008   bool do_rebuild_jump_labels = false;
3009
3010   /* Initialize the regsets we're going to use.  */
3011   for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
3012     peep2_insn_data[i].live_before = INITIALIZE_REG_SET (rs_heads[i]);
3013   live = INITIALIZE_REG_SET (rs_heads[i]);
3014
3015 #ifdef HAVE_conditional_execution
3016   blocks = sbitmap_alloc (last_basic_block);
3017   sbitmap_zero (blocks);
3018   changed = false;
3019 #else
3020   count_or_remove_death_notes (NULL, 1);
3021 #endif
3022
3023   FOR_EACH_BB_REVERSE (bb)
3024     {
3025       struct propagate_block_info *pbi;
3026
3027       /* Indicate that all slots except the last holds invalid data.  */
3028       for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
3029         peep2_insn_data[i].insn = NULL_RTX;
3030
3031       /* Indicate that the last slot contains live_after data.  */
3032       peep2_insn_data[MAX_INSNS_PER_PEEP2].insn = PEEP2_EOB;
3033       peep2_current = MAX_INSNS_PER_PEEP2;
3034
3035       /* Start up propagation.  */
3036       COPY_REG_SET (live, bb->global_live_at_end);
3037       COPY_REG_SET (peep2_insn_data[MAX_INSNS_PER_PEEP2].live_before, live);
3038
3039 #ifdef HAVE_conditional_execution
3040       pbi = init_propagate_block_info (bb, live, NULL, NULL, 0);
3041 #else
3042       pbi = init_propagate_block_info (bb, live, NULL, NULL, PROP_DEATH_NOTES);
3043 #endif
3044
3045       for (insn = BB_END (bb); ; insn = prev)
3046         {
3047           prev = PREV_INSN (insn);
3048           if (INSN_P (insn))
3049             {
3050               rtx try, before_try, x;
3051               int match_len;
3052               rtx note;
3053               bool was_call = false;
3054
3055               /* Record this insn.  */
3056               if (--peep2_current < 0)
3057                 peep2_current = MAX_INSNS_PER_PEEP2;
3058               peep2_insn_data[peep2_current].insn = insn;
3059               propagate_one_insn (pbi, insn);
3060               COPY_REG_SET (peep2_insn_data[peep2_current].live_before, live);
3061
3062               /* Match the peephole.  */
3063               try = peephole2_insns (PATTERN (insn), insn, &match_len);
3064               if (try != NULL)
3065                 {
3066                   /* If we are splitting a CALL_INSN, look for the CALL_INSN
3067                      in SEQ and copy our CALL_INSN_FUNCTION_USAGE and other
3068                      cfg-related call notes.  */
3069                   for (i = 0; i <= match_len; ++i)
3070                     {
3071                       int j;
3072                       rtx old_insn, new_insn, note;
3073
3074                       j = i + peep2_current;
3075                       if (j >= MAX_INSNS_PER_PEEP2 + 1)
3076                         j -= MAX_INSNS_PER_PEEP2 + 1;
3077                       old_insn = peep2_insn_data[j].insn;
3078                       if (GET_CODE (old_insn) != CALL_INSN)
3079                         continue;
3080                       was_call = true;
3081
3082                       new_insn = try;
3083                       while (new_insn != NULL_RTX)
3084                         {
3085                           if (GET_CODE (new_insn) == CALL_INSN)
3086                             break;
3087                           new_insn = NEXT_INSN (new_insn);
3088                         }
3089
3090                       if (new_insn == NULL_RTX)
3091                         abort ();
3092
3093                       CALL_INSN_FUNCTION_USAGE (new_insn)
3094                         = CALL_INSN_FUNCTION_USAGE (old_insn);
3095
3096                       for (note = REG_NOTES (old_insn);
3097                            note;
3098                            note = XEXP (note, 1))
3099                         switch (REG_NOTE_KIND (note))
3100                           {
3101                           case REG_NORETURN:
3102                           case REG_SETJMP:
3103                           case REG_ALWAYS_RETURN:
3104                             REG_NOTES (new_insn)
3105                               = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3106                                                    XEXP (note, 0),
3107                                                    REG_NOTES (new_insn));
3108                           default:
3109                             /* Discard all other reg notes.  */
3110                             break;
3111                           }
3112
3113                       /* Croak if there is another call in the sequence.  */
3114                       while (++i <= match_len)
3115                         {
3116                           j = i + peep2_current;
3117                           if (j >= MAX_INSNS_PER_PEEP2 + 1)
3118                             j -= MAX_INSNS_PER_PEEP2 + 1;
3119                           old_insn = peep2_insn_data[j].insn;
3120                           if (GET_CODE (old_insn) == CALL_INSN)
3121                             abort ();
3122                         }
3123                       break;
3124                     }
3125
3126                   i = match_len + peep2_current;
3127                   if (i >= MAX_INSNS_PER_PEEP2 + 1)
3128                     i -= MAX_INSNS_PER_PEEP2 + 1;
3129
3130                   note = find_reg_note (peep2_insn_data[i].insn,
3131                                         REG_EH_REGION, NULL_RTX);
3132
3133                   /* Replace the old sequence with the new.  */
3134                   try = emit_insn_after_setloc (try, peep2_insn_data[i].insn,
3135                                                 INSN_LOCATOR (peep2_insn_data[i].insn));
3136                   before_try = PREV_INSN (insn);
3137                   delete_insn_chain (insn, peep2_insn_data[i].insn);
3138
3139                   /* Re-insert the EH_REGION notes.  */
3140                   if (note || (was_call && nonlocal_goto_handler_labels))
3141                     {
3142                       edge eh_edge;
3143
3144                       for (eh_edge = bb->succ; eh_edge
3145                            ; eh_edge = eh_edge->succ_next)
3146                         if (eh_edge->flags & (EDGE_EH | EDGE_ABNORMAL_CALL))
3147                           break;
3148
3149                       for (x = try ; x != before_try ; x = PREV_INSN (x))
3150                         if (GET_CODE (x) == CALL_INSN
3151                             || (flag_non_call_exceptions
3152                                 && may_trap_p (PATTERN (x))
3153                                 && !find_reg_note (x, REG_EH_REGION, NULL)))
3154                           {
3155                             if (note)
3156                               REG_NOTES (x)
3157                                 = gen_rtx_EXPR_LIST (REG_EH_REGION,
3158                                                      XEXP (note, 0),
3159                                                      REG_NOTES (x));
3160
3161                             if (x != BB_END (bb) && eh_edge)
3162                               {
3163                                 edge nfte, nehe;
3164                                 int flags;
3165
3166                                 nfte = split_block (bb, x);
3167                                 flags = (eh_edge->flags
3168                                          & (EDGE_EH | EDGE_ABNORMAL));
3169                                 if (GET_CODE (x) == CALL_INSN)
3170                                   flags |= EDGE_ABNORMAL_CALL;
3171                                 nehe = make_edge (nfte->src, eh_edge->dest,
3172                                                   flags);
3173
3174                                 nehe->probability = eh_edge->probability;
3175                                 nfte->probability
3176                                   = REG_BR_PROB_BASE - nehe->probability;
3177
3178                                 do_cleanup_cfg |= purge_dead_edges (nfte->dest);
3179 #ifdef HAVE_conditional_execution
3180                                 SET_BIT (blocks, nfte->dest->index);
3181                                 changed = true;
3182 #endif
3183                                 bb = nfte->src;
3184                                 eh_edge = nehe;
3185                               }
3186                           }
3187
3188                       /* Converting possibly trapping insn to non-trapping is
3189                          possible.  Zap dummy outgoing edges.  */
3190                       do_cleanup_cfg |= purge_dead_edges (bb);
3191                     }
3192
3193 #ifdef HAVE_conditional_execution
3194                   /* With conditional execution, we cannot back up the
3195                      live information so easily, since the conditional
3196                      death data structures are not so self-contained.
3197                      So record that we've made a modification to this
3198                      block and update life information at the end.  */
3199                   SET_BIT (blocks, bb->index);
3200                   changed = true;
3201
3202                   for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
3203                     peep2_insn_data[i].insn = NULL_RTX;
3204                   peep2_insn_data[peep2_current].insn = PEEP2_EOB;
3205 #else
3206                   /* Back up lifetime information past the end of the
3207                      newly created sequence.  */
3208                   if (++i >= MAX_INSNS_PER_PEEP2 + 1)
3209                     i = 0;
3210                   COPY_REG_SET (live, peep2_insn_data[i].live_before);
3211
3212                   /* Update life information for the new sequence.  */
3213                   x = try;
3214                   do
3215                     {
3216                       if (INSN_P (x))
3217                         {
3218                           if (--i < 0)
3219                             i = MAX_INSNS_PER_PEEP2;
3220                           peep2_insn_data[i].insn = x;
3221                           propagate_one_insn (pbi, x);
3222                           COPY_REG_SET (peep2_insn_data[i].live_before, live);
3223                         }
3224                       x = PREV_INSN (x);
3225                     }
3226                   while (x != prev);
3227
3228                   /* ??? Should verify that LIVE now matches what we
3229                      had before the new sequence.  */
3230
3231                   peep2_current = i;
3232 #endif
3233
3234                   /* If we generated a jump instruction, it won't have
3235                      JUMP_LABEL set.  Recompute after we're done.  */
3236                   for (x = try; x != before_try; x = PREV_INSN (x))
3237                     if (GET_CODE (x) == JUMP_INSN)
3238                       {
3239                         do_rebuild_jump_labels = true;
3240                         break;
3241                       }
3242                 }
3243             }
3244
3245           if (insn == BB_HEAD (bb))
3246             break;
3247         }
3248
3249       free_propagate_block_info (pbi);
3250     }
3251
3252   for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
3253     FREE_REG_SET (peep2_insn_data[i].live_before);
3254   FREE_REG_SET (live);
3255
3256   if (do_rebuild_jump_labels)
3257     rebuild_jump_labels (get_insns ());
3258
3259   /* If we eliminated EH edges, we may be able to merge blocks.  Further,
3260      we've changed global life since exception handlers are no longer
3261      reachable.  */
3262   if (do_cleanup_cfg)
3263     {
3264       cleanup_cfg (0);
3265       update_life_info (0, UPDATE_LIFE_GLOBAL_RM_NOTES, PROP_DEATH_NOTES);
3266     }
3267 #ifdef HAVE_conditional_execution
3268   else
3269     {
3270       count_or_remove_death_notes (blocks, 1);
3271       update_life_info (blocks, UPDATE_LIFE_LOCAL, PROP_DEATH_NOTES);
3272     }
3273   sbitmap_free (blocks);
3274 #endif
3275 }
3276 #endif /* HAVE_peephole2 */
3277
3278 /* Common predicates for use with define_bypass.  */
3279
3280 /* True if the dependency between OUT_INSN and IN_INSN is on the store
3281    data not the address operand(s) of the store.  IN_INSN must be
3282    single_set.  OUT_INSN must be either a single_set or a PARALLEL with
3283    SETs inside.  */
3284
3285 int
3286 store_data_bypass_p (rtx out_insn, rtx in_insn)
3287 {
3288   rtx out_set, in_set;
3289
3290   in_set = single_set (in_insn);
3291   if (! in_set)
3292     abort ();
3293
3294   if (GET_CODE (SET_DEST (in_set)) != MEM)
3295     return false;
3296
3297   out_set = single_set (out_insn);
3298   if (out_set)
3299     {
3300       if (reg_mentioned_p (SET_DEST (out_set), SET_DEST (in_set)))
3301         return false;
3302     }
3303   else
3304     {
3305       rtx out_pat;
3306       int i;
3307
3308       out_pat = PATTERN (out_insn);
3309       if (GET_CODE (out_pat) != PARALLEL)
3310         abort ();
3311
3312       for (i = 0; i < XVECLEN (out_pat, 0); i++)
3313         {
3314           rtx exp = XVECEXP (out_pat, 0, i);
3315
3316           if (GET_CODE (exp) == CLOBBER)
3317             continue;
3318
3319           if (GET_CODE (exp) != SET)
3320             abort ();
3321
3322           if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
3323             return false;
3324         }
3325     }
3326
3327   return true;
3328 }
3329
3330 /* True if the dependency between OUT_INSN and IN_INSN is in the IF_THEN_ELSE
3331    condition, and not the THEN or ELSE branch.  OUT_INSN may be either a single
3332    or multiple set; IN_INSN should be single_set for truth, but for convenience
3333    of insn categorization may be any JUMP or CALL insn.  */
3334
3335 int
3336 if_test_bypass_p (rtx out_insn, rtx in_insn)
3337 {
3338   rtx out_set, in_set;
3339
3340   in_set = single_set (in_insn);
3341   if (! in_set)
3342     {
3343       if (GET_CODE (in_insn) == JUMP_INSN || GET_CODE (in_insn) == CALL_INSN)
3344         return false;
3345       abort ();
3346     }
3347
3348   if (GET_CODE (SET_SRC (in_set)) != IF_THEN_ELSE)
3349     return false;
3350   in_set = SET_SRC (in_set);
3351
3352   out_set = single_set (out_insn);
3353   if (out_set)
3354     {
3355       if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
3356           || reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
3357         return false;
3358     }
3359   else
3360     {
3361       rtx out_pat;
3362       int i;
3363
3364       out_pat = PATTERN (out_insn);
3365       if (GET_CODE (out_pat) != PARALLEL)
3366         abort ();
3367
3368       for (i = 0; i < XVECLEN (out_pat, 0); i++)
3369         {
3370           rtx exp = XVECEXP (out_pat, 0, i);
3371
3372           if (GET_CODE (exp) == CLOBBER)
3373             continue;
3374
3375           if (GET_CODE (exp) != SET)
3376             abort ();
3377
3378           if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
3379               || reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
3380             return false;
3381         }
3382     }
3383
3384   return true;
3385 }