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