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