gcc/recog.c

   1 /* Subroutines used by or related to instruction recognition.
   2    Copyright (C) 1987, 1988, 91-98, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "tm_p.h"
  26 #include "insn-config.h"
  27 #include "insn-attr.h"
  28 #include "insn-flags.h"
  29 #include "insn-codes.h"
  30 #include "recog.h"
  31 #include "regs.h"
  32 #include "hard-reg-set.h"
  33 #include "function.h"
  34 #include "flags.h"
  35 #include "real.h"
  36 #include "toplev.h"
  37 #include "basic-block.h"
  38 #include "output.h"
  39 #include "resource.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      PROTO((rtx *, rtx, rtx, rtx));
  58 static rtx *find_single_use_1           PROTO((rtx, rtx *));
  59 static rtx *find_constant_term_loc      PROTO((rtx *));
  60 static int insn_invalid_p               PROTO((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           RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (to);
 521           MEM_COPY_ATTRIBUTES (new, to);
 522           validate_change (object, loc, new, 1);
 523           return;
 524         }
 525       break;
 526
 527     case ZERO_EXTRACT:
 528     case SIGN_EXTRACT:
 529       /* If we are replacing a register with memory, try to change the memory
 530          to be the mode required for memory in extract operations (this isn't
 531          likely to be an insertion operation; if it was, nothing bad will
 532          happen, we might just fail in some cases).  */
 533
 534       if (XEXP (x, 0) == from && GET_CODE (from) == REG && GET_CODE (to) == MEM
 535           && GET_CODE (XEXP (x, 1)) == CONST_INT
 536           && GET_CODE (XEXP (x, 2)) == CONST_INT
 537           && ! mode_dependent_address_p (XEXP (to, 0))
 538           && ! MEM_VOLATILE_P (to))
 539         {
 540           enum machine_mode wanted_mode = VOIDmode;
 541           enum machine_mode is_mode = GET_MODE (to);
 542           int pos = INTVAL (XEXP (x, 2));
 543
 544 #ifdef HAVE_extzv
 545           if (code == ZERO_EXTRACT)
 546             {
 547               wanted_mode = insn_data[(int) CODE_FOR_extzv].operand[1].mode;
 548               if (wanted_mode == VOIDmode)
 549                 wanted_mode = word_mode;
 550             }
 551 #endif
 552 #ifdef HAVE_extv
 553           if (code == SIGN_EXTRACT)
 554             {
 555               wanted_mode = insn_data[(int) CODE_FOR_extv].operand[1].mode;
 556               if (wanted_mode == VOIDmode)
 557                 wanted_mode = word_mode;
 558             }
 559 #endif
 560
 561           /* If we have a narrower mode, we can do something.  */
 562           if (wanted_mode != VOIDmode
 563               && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
 564             {
 565               int offset = pos / BITS_PER_UNIT;
 566               rtx newmem;
 567
 568                   /* If the bytes and bits are counted differently, we
 569                      must adjust the offset.  */
 570               if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
 571                 offset = (GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (wanted_mode)
 572                           - offset);
 573
 574               pos %= GET_MODE_BITSIZE (wanted_mode);
 575
 576               newmem = gen_rtx_MEM (wanted_mode,
 577                                     plus_constant (XEXP (to, 0), offset));
 578               RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (to);
 579               MEM_COPY_ATTRIBUTES (newmem, to);
 580
 581               validate_change (object, &XEXP (x, 2), GEN_INT (pos), 1);
 582               validate_change (object, &XEXP (x, 0), newmem, 1);
 583             }
 584         }
 585
 586       break;
 587
 588     default:
 589       break;
 590     }
 591
 592   /* For commutative or comparison operations we've already performed
 593      replacements.  Don't try to perform them again.  */
 594   if (GET_RTX_CLASS (code) != '<' && GET_RTX_CLASS (code) != 'c')
 595     {
 596       fmt = GET_RTX_FORMAT (code);
 597       for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 598         {
 599           if (fmt[i] == 'e')
 600             validate_replace_rtx_1 (&XEXP (x, i), from, to, object);
 601           else if (fmt[i] == 'E')
 602             for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 603               validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object);
 604         }
 605     }
 606 }
 607
 608 /* Try replacing every occurrence of FROM in INSN with TO.  After all
 609    changes have been made, validate by seeing if INSN is still valid.  */
 610
 611 int
 612 validate_replace_rtx (from, to, insn)
 613      rtx from, to, insn;
 614 {
 615   validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
 616   return apply_change_group ();
 617 }
 618
 619 /* Try replacing every occurrence of FROM in INSN with TO.  After all
 620    changes have been made, validate by seeing if INSN is still valid.  */
 621
 622 void
 623 validate_replace_rtx_group (from, to, insn)
 624      rtx from, to, insn;
 625 {
 626   validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
 627 }
 628
 629 /* Try replacing every occurrence of FROM in INSN with TO, avoiding
 630    SET_DESTs.  After all changes have been made, validate by seeing if
 631    INSN is still valid.  */
 632
 633 int
 634 validate_replace_src (from, to, insn)
 635      rtx from, to, insn;
 636 {
 637   if ((GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
 638       || GET_CODE (PATTERN (insn)) != SET)
 639     abort ();
 640
 641   validate_replace_rtx_1 (&SET_SRC (PATTERN (insn)), from, to, insn);
 642   if (GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
 643     validate_replace_rtx_1 (&XEXP (SET_DEST (PATTERN (insn)), 0),
 644                             from, to, insn);
 645   return apply_change_group ();
 646 }
 647 \f
 648 #ifdef HAVE_cc0
 649 /* Return 1 if the insn using CC0 set by INSN does not contain
 650    any ordered tests applied to the condition codes.
 651    EQ and NE tests do not count.  */
 652
 653 int
 654 next_insn_tests_no_inequality (insn)
 655      rtx insn;
 656 {
 657   register rtx next = next_cc0_user (insn);
 658
 659   /* If there is no next insn, we have to take the conservative choice.  */
 660   if (next == 0)
 661     return 0;
 662
 663   return ((GET_CODE (next) == JUMP_INSN
 664            || GET_CODE (next) == INSN
 665            || GET_CODE (next) == CALL_INSN)
 666           && ! inequality_comparisons_p (PATTERN (next)));
 667 }
 668
 669 #if 0  /* This is useless since the insn that sets the cc's
 670           must be followed immediately by the use of them.  */
 671 /* Return 1 if the CC value set up by INSN is not used.  */
 672
 673 int
 674 next_insns_test_no_inequality (insn)
 675      rtx insn;
 676 {
 677   register rtx next = NEXT_INSN (insn);
 678
 679   for (; next != 0; next = NEXT_INSN (next))
 680     {
 681       if (GET_CODE (next) == CODE_LABEL
 682           || GET_CODE (next) == BARRIER)
 683         return 1;
 684       if (GET_CODE (next) == NOTE)
 685         continue;
 686       if (inequality_comparisons_p (PATTERN (next)))
 687         return 0;
 688       if (sets_cc0_p (PATTERN (next)) == 1)
 689         return 1;
 690       if (! reg_mentioned_p (cc0_rtx, PATTERN (next)))
 691         return 1;
 692     }
 693   return 1;
 694 }
 695 #endif
 696 #endif
 697 \f
 698 /* This is used by find_single_use to locate an rtx that contains exactly one
 699    use of DEST, which is typically either a REG or CC0.  It returns a
 700    pointer to the innermost rtx expression containing DEST.  Appearances of
 701    DEST that are being used to totally replace it are not counted.  */
 702
 703 static rtx *
 704 find_single_use_1 (dest, loc)
 705      rtx dest;
 706      rtx *loc;
 707 {
 708   rtx x = *loc;
 709   enum rtx_code code = GET_CODE (x);
 710   rtx *result = 0;
 711   rtx *this_result;
 712   int i;
 713   const char *fmt;
 714
 715   switch (code)
 716     {
 717     case CONST_INT:
 718     case CONST:
 719     case LABEL_REF:
 720     case SYMBOL_REF:
 721     case CONST_DOUBLE:
 722     case CLOBBER:
 723       return 0;
 724
 725     case SET:
 726       /* If the destination is anything other than CC0, PC, a REG or a SUBREG
 727          of a REG that occupies all of the REG, the insn uses DEST if
 728          it is mentioned in the destination or the source.  Otherwise, we
 729          need just check the source.  */
 730       if (GET_CODE (SET_DEST (x)) != CC0
 731           && GET_CODE (SET_DEST (x)) != PC
 732           && GET_CODE (SET_DEST (x)) != REG
 733           && ! (GET_CODE (SET_DEST (x)) == SUBREG
 734                 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
 735                 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
 736                       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
 737                     == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
 738                          + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
 739         break;
 740
 741       return find_single_use_1 (dest, &SET_SRC (x));
 742
 743     case MEM:
 744     case SUBREG:
 745       return find_single_use_1 (dest, &XEXP (x, 0));
 746
 747     default:
 748       break;
 749     }
 750
 751   /* If it wasn't one of the common cases above, check each expression and
 752      vector of this code.  Look for a unique usage of DEST.  */
 753
 754   fmt = GET_RTX_FORMAT (code);
 755   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 756     {
 757       if (fmt[i] == 'e')
 758         {
 759           if (dest == XEXP (x, i)
 760               || (GET_CODE (dest) == REG && GET_CODE (XEXP (x, i)) == REG
 761                   && REGNO (dest) == REGNO (XEXP (x, i))))
 762             this_result = loc;
 763           else
 764             this_result = find_single_use_1 (dest, &XEXP (x, i));
 765
 766           if (result == 0)
 767             result = this_result;
 768           else if (this_result)
 769             /* Duplicate usage.  */
 770             return 0;
 771         }
 772       else if (fmt[i] == 'E')
 773         {
 774           int j;
 775
 776           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 777             {
 778               if (XVECEXP (x, i, j) == dest
 779                   || (GET_CODE (dest) == REG
 780                       && GET_CODE (XVECEXP (x, i, j)) == REG
 781                       && REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
 782                 this_result = loc;
 783               else
 784                 this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
 785
 786               if (result == 0)
 787                 result = this_result;
 788               else if (this_result)
 789                 return 0;
 790             }
 791         }
 792     }
 793
 794   return result;
 795 }
 796 \f
 797 /* See if DEST, produced in INSN, is used only a single time in the
 798    sequel.  If so, return a pointer to the innermost rtx expression in which
 799    it is used.
 800
 801    If PLOC is non-zero, *PLOC is set to the insn containing the single use.
 802
 803    This routine will return usually zero either before flow is called (because
 804    there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
 805    note can't be trusted).
 806
 807    If DEST is cc0_rtx, we look only at the next insn.  In that case, we don't
 808    care about REG_DEAD notes or LOG_LINKS.
 809
 810    Otherwise, we find the single use by finding an insn that has a
 811    LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST.  If DEST is
 812    only referenced once in that insn, we know that it must be the first
 813    and last insn referencing DEST.  */
 814
 815 rtx *
 816 find_single_use (dest, insn, ploc)
 817      rtx dest;
 818      rtx insn;
 819      rtx *ploc;
 820 {
 821   rtx next;
 822   rtx *result;
 823   rtx link;
 824
 825 #ifdef HAVE_cc0
 826   if (dest == cc0_rtx)
 827     {
 828       next = NEXT_INSN (insn);
 829       if (next == 0
 830           || (GET_CODE (next) != INSN && GET_CODE (next) != JUMP_INSN))
 831         return 0;
 832
 833       result = find_single_use_1 (dest, &PATTERN (next));
 834       if (result && ploc)
 835         *ploc = next;
 836       return result;
 837     }
 838 #endif
 839
 840   if (reload_completed || reload_in_progress || GET_CODE (dest) != REG)
 841     return 0;
 842
 843   for (next = next_nonnote_insn (insn);
 844        next != 0 && GET_CODE (next) != CODE_LABEL;
 845        next = next_nonnote_insn (next))
 846     if (GET_RTX_CLASS (GET_CODE (next)) == 'i' && dead_or_set_p (next, dest))
 847       {
 848         for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
 849           if (XEXP (link, 0) == insn)
 850             break;
 851
 852         if (link)
 853           {
 854             result = find_single_use_1 (dest, &PATTERN (next));
 855             if (ploc)
 856               *ploc = next;
 857             return result;
 858           }
 859       }
 860
 861   return 0;
 862 }
 863 \f
 864 /* Return 1 if OP is a valid general operand for machine mode MODE.
 865    This is either a register reference, a memory reference,
 866    or a constant.  In the case of a memory reference, the address
 867    is checked for general validity for the target machine.
 868
 869    Register and memory references must have mode MODE in order to be valid,
 870    but some constants have no machine mode and are valid for any mode.
 871
 872    If MODE is VOIDmode, OP is checked for validity for whatever mode
 873    it has.
 874
 875    The main use of this function is as a predicate in match_operand
 876    expressions in the machine description.
 877
 878    For an explanation of this function's behavior for registers of
 879    class NO_REGS, see the comment for `register_operand'.  */
 880
 881 int
 882 general_operand (op, mode)
 883      register rtx op;
 884      enum machine_mode mode;
 885 {
 886   register enum rtx_code code = GET_CODE (op);
 887   int mode_altering_drug = 0;
 888
 889   if (mode == VOIDmode)
 890     mode = GET_MODE (op);
 891
 892   /* Don't accept CONST_INT or anything similar
 893      if the caller wants something floating.  */
 894   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 895       && GET_MODE_CLASS (mode) != MODE_INT
 896       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 897     return 0;
 898
 899   if (CONSTANT_P (op))
 900     return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode)
 901 #ifdef LEGITIMATE_PIC_OPERAND_P
 902             && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
 903 #endif
 904             && LEGITIMATE_CONSTANT_P (op));
 905
 906   /* Except for certain constants with VOIDmode, already checked for,
 907      OP's mode must match MODE if MODE specifies a mode.  */
 908
 909   if (GET_MODE (op) != mode)
 910     return 0;
 911
 912   if (code == SUBREG)
 913     {
 914 #ifdef INSN_SCHEDULING
 915       /* On machines that have insn scheduling, we want all memory
 916          reference to be explicit, so outlaw paradoxical SUBREGs.  */
 917       if (GET_CODE (SUBREG_REG (op)) == MEM
 918           && GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
 919         return 0;
 920 #endif
 921
 922       op = SUBREG_REG (op);
 923       code = GET_CODE (op);
 924 #if 0
 925       /* No longer needed, since (SUBREG (MEM...))
 926          will load the MEM into a reload reg in the MEM's own mode.  */
 927       mode_altering_drug = 1;
 928 #endif
 929     }
 930
 931   if (code == REG)
 932     /* A register whose class is NO_REGS is not a general operand.  */
 933     return (REGNO (op) >= FIRST_PSEUDO_REGISTER
 934             || REGNO_REG_CLASS (REGNO (op)) != NO_REGS);
 935
 936   if (code == MEM)
 937     {
 938       register rtx y = XEXP (op, 0);
 939       if (! volatile_ok && MEM_VOLATILE_P (op))
 940         return 0;
 941       if (GET_CODE (y) == ADDRESSOF)
 942         return 1;
 943       /* Use the mem's mode, since it will be reloaded thus.  */
 944       mode = GET_MODE (op);
 945       GO_IF_LEGITIMATE_ADDRESS (mode, y, win);
 946     }
 947
 948   /* Pretend this is an operand for now; we'll run force_operand
 949      on its replacement in fixup_var_refs_1.  */
 950   if (code == ADDRESSOF)
 951     return 1;
 952
 953   return 0;
 954
 955  win:
 956   if (mode_altering_drug)
 957     return ! mode_dependent_address_p (XEXP (op, 0));
 958   return 1;
 959 }
 960 \f
 961 /* Return 1 if OP is a valid memory address for a memory reference
 962    of mode MODE.
 963
 964    The main use of this function is as a predicate in match_operand
 965    expressions in the machine description.  */
 966
 967 int
 968 address_operand (op, mode)
 969      register rtx op;
 970      enum machine_mode mode;
 971 {
 972   return memory_address_p (mode, op);
 973 }
 974
 975 /* Return 1 if OP is a register reference of mode MODE.
 976    If MODE is VOIDmode, accept a register in any mode.
 977
 978    The main use of this function is as a predicate in match_operand
 979    expressions in the machine description.
 980
 981    As a special exception, registers whose class is NO_REGS are
 982    not accepted by `register_operand'.  The reason for this change
 983    is to allow the representation of special architecture artifacts
 984    (such as a condition code register) without extending the rtl
 985    definitions.  Since registers of class NO_REGS cannot be used
 986    as registers in any case where register classes are examined,
 987    it is most consistent to keep this function from accepting them.  */
 988
 989 int
 990 register_operand (op, mode)
 991      register rtx op;
 992      enum machine_mode mode;
 993 {
 994   if (GET_MODE (op) != mode && mode != VOIDmode)
 995     return 0;
 996
 997   if (GET_CODE (op) == SUBREG)
 998     {
 999       /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1000          because it is guaranteed to be reloaded into one.
1001          Just make sure the MEM is valid in itself.
1002          (Ideally, (SUBREG (MEM)...) should not exist after reload,
1003          but currently it does result from (SUBREG (REG)...) where the
1004          reg went on the stack.)  */
1005       if (! reload_completed && GET_CODE (SUBREG_REG (op)) == MEM)
1006         return general_operand (op, mode);
1007
1008 #ifdef CLASS_CANNOT_CHANGE_SIZE
1009       if (GET_CODE (SUBREG_REG (op)) == REG
1010           && REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER
1011           && TEST_HARD_REG_BIT (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE],
1012                                 REGNO (SUBREG_REG (op)))
1013           && (GET_MODE_SIZE (mode)
1014               != GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
1015           && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_INT
1016           && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_FLOAT)
1017         return 0;
1018 #endif
1019
1020       op = SUBREG_REG (op);
1021     }
1022
1023   /* We don't consider registers whose class is NO_REGS
1024      to be a register operand.  */
1025   return (GET_CODE (op) == REG
1026           && (REGNO (op) >= FIRST_PSEUDO_REGISTER
1027               || REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
1028 }
1029
1030 /* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
1031    or a hard register.  */
1032
1033 int
1034 scratch_operand (op, mode)
1035      register rtx op;
1036      enum machine_mode mode;
1037 {
1038   return (GET_MODE (op) == mode
1039           && (GET_CODE (op) == SCRATCH
1040               || (GET_CODE (op) == REG
1041                   && REGNO (op) < FIRST_PSEUDO_REGISTER)));
1042 }
1043
1044 /* Return 1 if OP is a valid immediate operand for mode MODE.
1045
1046    The main use of this function is as a predicate in match_operand
1047    expressions in the machine description.  */
1048
1049 int
1050 immediate_operand (op, mode)
1051      register rtx op;
1052      enum machine_mode mode;
1053 {
1054   /* Don't accept CONST_INT or anything similar
1055      if the caller wants something floating.  */
1056   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
1057       && GET_MODE_CLASS (mode) != MODE_INT
1058       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
1059     return 0;
1060
1061   /* Accept CONSTANT_P_RTX, since it will be gone by CSE1 and
1062      result in 0/1.  It seems a safe assumption that this is
1063      in range for everyone.  */
1064   if (GET_CODE (op) == CONSTANT_P_RTX)
1065     return 1;
1066
1067   return (CONSTANT_P (op)
1068           && (GET_MODE (op) == mode || mode == VOIDmode
1069               || GET_MODE (op) == VOIDmode)
1070 #ifdef LEGITIMATE_PIC_OPERAND_P
1071           && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1072 #endif
1073           && LEGITIMATE_CONSTANT_P (op));
1074 }
1075
1076 /* Returns 1 if OP is an operand that is a CONST_INT.  */
1077
1078 int
1079 const_int_operand (op, mode)
1080      register rtx op;
1081      enum machine_mode mode ATTRIBUTE_UNUSED;
1082 {
1083   return GET_CODE (op) == CONST_INT;
1084 }
1085
1086 /* Returns 1 if OP is an operand that is a constant integer or constant
1087    floating-point number.  */
1088
1089 int
1090 const_double_operand (op, mode)
1091      register rtx op;
1092      enum machine_mode mode;
1093 {
1094   /* Don't accept CONST_INT or anything similar
1095      if the caller wants something floating.  */
1096   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
1097       && GET_MODE_CLASS (mode) != MODE_INT
1098       && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
1099     return 0;
1100
1101   return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
1102           && (mode == VOIDmode || GET_MODE (op) == mode
1103               || GET_MODE (op) == VOIDmode));
1104 }
1105
1106 /* Return 1 if OP is a general operand that is not an immediate operand.  */
1107
1108 int
1109 nonimmediate_operand (op, mode)
1110      register rtx op;
1111      enum machine_mode mode;
1112 {
1113   return (general_operand (op, mode) && ! CONSTANT_P (op));
1114 }
1115
1116 /* Return 1 if OP is a register reference or immediate value of mode MODE.  */
1117
1118 int
1119 nonmemory_operand (op, mode)
1120      register rtx op;
1121      enum machine_mode mode;
1122 {
1123   if (CONSTANT_P (op))
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_MODE (op) == VOIDmode || GET_MODE (op) == mode)
1133 #ifdef LEGITIMATE_PIC_OPERAND_P
1134               && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1135 #endif
1136               && LEGITIMATE_CONSTANT_P (op));
1137     }
1138
1139   if (GET_MODE (op) != mode && mode != VOIDmode)
1140     return 0;
1141
1142   if (GET_CODE (op) == SUBREG)
1143     {
1144       /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1145          because it is guaranteed to be reloaded into one.
1146          Just make sure the MEM is valid in itself.
1147          (Ideally, (SUBREG (MEM)...) should not exist after reload,
1148          but currently it does result from (SUBREG (REG)...) where the
1149          reg went on the stack.)  */
1150       if (! reload_completed && GET_CODE (SUBREG_REG (op)) == MEM)
1151         return general_operand (op, mode);
1152       op = SUBREG_REG (op);
1153     }
1154
1155   /* We don't consider registers whose class is NO_REGS
1156      to be a register operand.  */
1157   return (GET_CODE (op) == REG
1158           && (REGNO (op) >= FIRST_PSEUDO_REGISTER
1159               || REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
1160 }
1161
1162 /* Return 1 if OP is a valid operand that stands for pushing a
1163    value of mode MODE onto the stack.
1164
1165    The main use of this function is as a predicate in match_operand
1166    expressions in the machine description.  */
1167
1168 int
1169 push_operand (op, mode)
1170      rtx op;
1171      enum machine_mode mode;
1172 {
1173   if (GET_CODE (op) != MEM)
1174     return 0;
1175
1176   if (mode != VOIDmode && GET_MODE (op) != mode)
1177     return 0;
1178
1179   op = XEXP (op, 0);
1180
1181   if (GET_CODE (op) != STACK_PUSH_CODE)
1182     return 0;
1183
1184   return XEXP (op, 0) == stack_pointer_rtx;
1185 }
1186
1187 /* Return 1 if OP is a valid operand that stands for popping a
1188    value of mode MODE off the stack.
1189
1190    The main use of this function is as a predicate in match_operand
1191    expressions in the machine description.  */
1192
1193 int
1194 pop_operand (op, mode)
1195      rtx op;
1196      enum machine_mode mode;
1197 {
1198   if (GET_CODE (op) != MEM)
1199     return 0;
1200
1201   if (mode != VOIDmode && GET_MODE (op) != mode)
1202     return 0;
1203
1204   op = XEXP (op, 0);
1205
1206   if (GET_CODE (op) != STACK_POP_CODE)
1207     return 0;
1208
1209   return XEXP (op, 0) == stack_pointer_rtx;
1210 }
1211
1212 /* Return 1 if ADDR is a valid memory address for mode MODE.  */
1213
1214 int
1215 memory_address_p (mode, addr)
1216      enum machine_mode mode;
1217      register rtx addr;
1218 {
1219   if (GET_CODE (addr) == ADDRESSOF)
1220     return 1;
1221
1222   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
1223   return 0;
1224
1225  win:
1226   return 1;
1227 }
1228
1229 /* Return 1 if OP is a valid memory reference with mode MODE,
1230    including a valid address.
1231
1232    The main use of this function is as a predicate in match_operand
1233    expressions in the machine description.  */
1234
1235 int
1236 memory_operand (op, mode)
1237      register rtx op;
1238      enum machine_mode mode;
1239 {
1240   rtx inner;
1241
1242   if (! reload_completed)
1243     /* Note that no SUBREG is a memory operand before end of reload pass,
1244        because (SUBREG (MEM...)) forces reloading into a register.  */
1245     return GET_CODE (op) == MEM && general_operand (op, mode);
1246
1247   if (mode != VOIDmode && GET_MODE (op) != mode)
1248     return 0;
1249
1250   inner = op;
1251   if (GET_CODE (inner) == SUBREG)
1252     inner = SUBREG_REG (inner);
1253
1254   return (GET_CODE (inner) == MEM && general_operand (op, mode));
1255 }
1256
1257 /* Return 1 if OP is a valid indirect memory reference with mode MODE;
1258    that is, a memory reference whose address is a general_operand.  */
1259
1260 int
1261 indirect_operand (op, mode)
1262      register rtx op;
1263      enum machine_mode mode;
1264 {
1265   /* Before reload, a SUBREG isn't in memory (see memory_operand, above).  */
1266   if (! reload_completed
1267       && GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == MEM)
1268     {
1269       register int offset = SUBREG_WORD (op) * UNITS_PER_WORD;
1270       rtx inner = SUBREG_REG (op);
1271
1272       if (BYTES_BIG_ENDIAN)
1273         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (op)))
1274                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (inner))));
1275
1276       if (mode != VOIDmode && GET_MODE (op) != mode)
1277         return 0;
1278
1279       /* The only way that we can have a general_operand as the resulting
1280          address is if OFFSET is zero and the address already is an operand
1281          or if the address is (plus Y (const_int -OFFSET)) and Y is an
1282          operand.  */
1283
1284       return ((offset == 0 && general_operand (XEXP (inner, 0), Pmode))
1285               || (GET_CODE (XEXP (inner, 0)) == PLUS
1286                   && GET_CODE (XEXP (XEXP (inner, 0), 1)) == CONST_INT
1287                   && INTVAL (XEXP (XEXP (inner, 0), 1)) == -offset
1288                   && general_operand (XEXP (XEXP (inner, 0), 0), Pmode)));
1289     }
1290
1291   return (GET_CODE (op) == MEM
1292           && memory_operand (op, mode)
1293           && general_operand (XEXP (op, 0), Pmode));
1294 }
1295
1296 /* Return 1 if this is a comparison operator.  This allows the use of
1297    MATCH_OPERATOR to recognize all the branch insns.  */
1298
1299 int
1300 comparison_operator (op, mode)
1301     register rtx op;
1302     enum machine_mode mode;
1303 {
1304   return ((mode == VOIDmode || GET_MODE (op) == mode)
1305           && GET_RTX_CLASS (GET_CODE (op)) == '<');
1306 }
1307 \f
1308 /* If BODY is an insn body that uses ASM_OPERANDS,
1309    return the number of operands (both input and output) in the insn.
1310    Otherwise return -1.  */
1311
1312 int
1313 asm_noperands (body)
1314      rtx body;
1315 {
1316   if (GET_CODE (body) == ASM_OPERANDS)
1317     /* No output operands: return number of input operands.  */
1318     return ASM_OPERANDS_INPUT_LENGTH (body);
1319   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1320     /* Single output operand: BODY is (set OUTPUT (asm_operands ...)).  */
1321     return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body)) + 1;
1322   else if (GET_CODE (body) == PARALLEL
1323            && GET_CODE (XVECEXP (body, 0, 0)) == SET
1324            && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
1325     {
1326       /* Multiple output operands, or 1 output plus some clobbers:
1327          body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...].  */
1328       int i;
1329       int n_sets;
1330
1331       /* Count backwards through CLOBBERs to determine number of SETs.  */
1332       for (i = XVECLEN (body, 0); i > 0; i--)
1333         {
1334           if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
1335             break;
1336           if (GET_CODE (XVECEXP (body, 0, i - 1)) != CLOBBER)
1337             return -1;
1338         }
1339
1340       /* N_SETS is now number of output operands.  */
1341       n_sets = i;
1342
1343       /* Verify that all the SETs we have
1344          came from a single original asm_operands insn
1345          (so that invalid combinations are blocked).  */
1346       for (i = 0; i < n_sets; i++)
1347         {
1348           rtx elt = XVECEXP (body, 0, i);
1349           if (GET_CODE (elt) != SET)
1350             return -1;
1351           if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
1352             return -1;
1353           /* If these ASM_OPERANDS rtx's came from different original insns
1354              then they aren't allowed together.  */
1355           if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
1356               != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body, 0, 0))))
1357             return -1;
1358         }
1359       return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)))
1360               + n_sets);
1361     }
1362   else if (GET_CODE (body) == PARALLEL
1363            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1364     {
1365       /* 0 outputs, but some clobbers:
1366          body is [(asm_operands ...) (clobber (reg ...))...].  */
1367       int i;
1368
1369       /* Make sure all the other parallel things really are clobbers.  */
1370       for (i = XVECLEN (body, 0) - 1; i > 0; i--)
1371         if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
1372           return -1;
1373
1374       return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
1375     }
1376   else
1377     return -1;
1378 }
1379
1380 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
1381    copy its operands (both input and output) into the vector OPERANDS,
1382    the locations of the operands within the insn into the vector OPERAND_LOCS,
1383    and the constraints for the operands into CONSTRAINTS.
1384    Write the modes of the operands into MODES.
1385    Return the assembler-template.
1386
1387    If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
1388    we don't store that info.  */
1389
1390 char *
1391 decode_asm_operands (body, operands, operand_locs, constraints, modes)
1392      rtx body;
1393      rtx *operands;
1394      rtx **operand_locs;
1395      const char **constraints;
1396      enum machine_mode *modes;
1397 {
1398   register int i;
1399   int noperands;
1400   char *template = 0;
1401
1402   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1403     {
1404       rtx asmop = SET_SRC (body);
1405       /* Single output operand: BODY is (set OUTPUT (asm_operands ....)).  */
1406
1407       noperands = ASM_OPERANDS_INPUT_LENGTH (asmop) + 1;
1408
1409       for (i = 1; i < noperands; i++)
1410         {
1411           if (operand_locs)
1412             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i - 1);
1413           if (operands)
1414             operands[i] = ASM_OPERANDS_INPUT (asmop, i - 1);
1415           if (constraints)
1416             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i - 1);
1417           if (modes)
1418             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i - 1);
1419         }
1420
1421       /* The output is in the SET.
1422          Its constraint is in the ASM_OPERANDS itself.  */
1423       if (operands)
1424         operands[0] = SET_DEST (body);
1425       if (operand_locs)
1426         operand_locs[0] = &SET_DEST (body);
1427       if (constraints)
1428         constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
1429       if (modes)
1430         modes[0] = GET_MODE (SET_DEST (body));
1431       template = ASM_OPERANDS_TEMPLATE (asmop);
1432     }
1433   else if (GET_CODE (body) == ASM_OPERANDS)
1434     {
1435       rtx asmop = body;
1436       /* No output operands: BODY is (asm_operands ....).  */
1437
1438       noperands = ASM_OPERANDS_INPUT_LENGTH (asmop);
1439
1440       /* The input operands are found in the 1st element vector.  */
1441       /* Constraints for inputs are in the 2nd element vector.  */
1442       for (i = 0; i < noperands; i++)
1443         {
1444           if (operand_locs)
1445             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
1446           if (operands)
1447             operands[i] = ASM_OPERANDS_INPUT (asmop, i);
1448           if (constraints)
1449             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1450           if (modes)
1451             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1452         }
1453       template = ASM_OPERANDS_TEMPLATE (asmop);
1454     }
1455   else if (GET_CODE (body) == PARALLEL
1456            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1457     {
1458       rtx asmop = SET_SRC (XVECEXP (body, 0, 0));
1459       int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs.  */
1460       int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
1461       int nout = 0;             /* Does not include CLOBBERs.  */
1462
1463       /* At least one output, plus some CLOBBERs.  */
1464
1465       /* The outputs are in the SETs.
1466          Their constraints are in the ASM_OPERANDS itself.  */
1467       for (i = 0; i < nparallel; i++)
1468         {
1469           if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
1470             break;              /* Past last SET */
1471
1472           if (operands)
1473             operands[i] = SET_DEST (XVECEXP (body, 0, i));
1474           if (operand_locs)
1475             operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
1476           if (constraints)
1477             constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
1478           if (modes)
1479             modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
1480           nout++;
1481         }
1482
1483       for (i = 0; i < nin; i++)
1484         {
1485           if (operand_locs)
1486             operand_locs[i + nout] = &ASM_OPERANDS_INPUT (asmop, i);
1487           if (operands)
1488             operands[i + nout] = ASM_OPERANDS_INPUT (asmop, i);
1489           if (constraints)
1490             constraints[i + nout] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1491           if (modes)
1492             modes[i + nout] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1493         }
1494
1495       template = ASM_OPERANDS_TEMPLATE (asmop);
1496     }
1497   else if (GET_CODE (body) == PARALLEL
1498            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1499     {
1500       /* No outputs, but some CLOBBERs.  */
1501
1502       rtx asmop = XVECEXP (body, 0, 0);
1503       int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
1504
1505       for (i = 0; i < nin; i++)
1506         {
1507           if (operand_locs)
1508             operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
1509           if (operands)
1510             operands[i] = ASM_OPERANDS_INPUT (asmop, i);
1511           if (constraints)
1512             constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
1513           if (modes)
1514             modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
1515         }
1516
1517       template = ASM_OPERANDS_TEMPLATE (asmop);
1518     }
1519
1520   return template;
1521 }
1522
1523 /* Check if an asm_operand matches it's constraints.
1524    Return > 0 if ok, = 0 if bad, < 0 if inconclusive.  */
1525
1526 int
1527 asm_operand_ok (op, constraint)
1528      rtx op;
1529      const char *constraint;
1530 {
1531   int result = 0;
1532
1533   /* Use constrain_operands after reload.  */
1534   if (reload_completed)
1535     abort ();
1536
1537   while (*constraint)
1538     {
1539       switch (*constraint++)
1540         {
1541         case '=':
1542         case '+':
1543         case '*':
1544         case '%':
1545         case '?':
1546         case '!':
1547         case '#':
1548         case '&':
1549         case ',':
1550           break;
1551
1552         case '0': case '1': case '2': case '3': case '4':
1553         case '5': case '6': case '7': case '8': case '9':
1554           /* For best results, our caller should have given us the
1555              proper matching constraint, but we can't actually fail
1556              the check if they didn't.  Indicate that results are
1557              inconclusive.  */
1558           result = -1;
1559           break;
1560
1561         case 'p':
1562           if (address_operand (op, VOIDmode))
1563             return 1;
1564           break;
1565
1566         case 'm':
1567         case 'V': /* non-offsettable */
1568           if (memory_operand (op, VOIDmode))
1569             return 1;
1570           break;
1571
1572         case 'o': /* offsettable */
1573           if (offsettable_nonstrict_memref_p (op))
1574             return 1;
1575           break;
1576
1577         case '<':
1578           /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1579              excepting those that expand_call created.  Further, on some
1580              machines which do not have generalized auto inc/dec, an inc/dec
1581              is not a memory_operand.
1582
1583              Match any memory and hope things are resolved after reload.  */
1584
1585           if (GET_CODE (op) == MEM
1586               && (1
1587                   || GET_CODE (XEXP (op, 0)) == PRE_DEC
1588                   || GET_CODE (XEXP (op, 0)) == POST_DEC))
1589             return 1;
1590           break;
1591
1592         case '>':
1593           if (GET_CODE (op) == MEM
1594               && (1
1595                   || GET_CODE (XEXP (op, 0)) == PRE_INC
1596                   || GET_CODE (XEXP (op, 0)) == POST_INC))
1597             return 1;
1598           break;
1599
1600         case 'E':
1601 #ifndef REAL_ARITHMETIC
1602           /* Match any floating double constant, but only if
1603              we can examine the bits of it reliably.  */
1604           if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
1605                || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
1606               && GET_MODE (op) != VOIDmode && ! flag_pretend_float)
1607             break;
1608 #endif
1609           /* FALLTHRU */
1610
1611         case 'F':
1612           if (GET_CODE (op) == CONST_DOUBLE)
1613             return 1;
1614           break;
1615
1616         case 'G':
1617           if (GET_CODE (op) == CONST_DOUBLE
1618               && CONST_DOUBLE_OK_FOR_LETTER_P (op, 'G'))
1619             return 1;
1620           break;
1621         case 'H':
1622           if (GET_CODE (op) == CONST_DOUBLE
1623               && CONST_DOUBLE_OK_FOR_LETTER_P (op, 'H'))
1624             return 1;
1625           break;
1626
1627         case 's':
1628           if (GET_CODE (op) == CONST_INT
1629               || (GET_CODE (op) == CONST_DOUBLE
1630                   && GET_MODE (op) == VOIDmode))
1631             break;
1632           /* FALLTHRU */
1633
1634         case 'i':
1635           if (CONSTANT_P (op)
1636 #ifdef LEGITIMATE_PIC_OPERAND_P
1637               && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
1638 #endif
1639               )
1640             return 1;
1641           break;
1642
1643         case 'n':
1644           if (GET_CODE (op) == CONST_INT
1645               || (GET_CODE (op) == CONST_DOUBLE
1646                   && GET_MODE (op) == VOIDmode))
1647             return 1;
1648           break;
1649
1650         case 'I':
1651           if (GET_CODE (op) == CONST_INT
1652               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'))
1653             return 1;
1654           break;
1655         case 'J':
1656           if (GET_CODE (op) == CONST_INT
1657               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'J'))
1658             return 1;
1659           break;
1660         case 'K':
1661           if (GET_CODE (op) == CONST_INT
1662               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'K'))
1663             return 1;
1664           break;
1665         case 'L':
1666           if (GET_CODE (op) == CONST_INT
1667               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'))
1668             return 1;
1669           break;
1670         case 'M':
1671           if (GET_CODE (op) == CONST_INT
1672               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'M'))
1673             return 1;
1674           break;
1675         case 'N':
1676           if (GET_CODE (op) == CONST_INT
1677               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'N'))
1678             return 1;
1679           break;
1680         case 'O':
1681           if (GET_CODE (op) == CONST_INT
1682               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'O'))
1683             return 1;
1684           break;
1685         case 'P':
1686           if (GET_CODE (op) == CONST_INT
1687               && CONST_OK_FOR_LETTER_P (INTVAL (op), 'P'))
1688             return 1;
1689           break;
1690
1691         case 'X':
1692           return 1;
1693
1694         case 'g':
1695           if (general_operand (op, VOIDmode))
1696             return 1;
1697           break;
1698
1699 #ifdef EXTRA_CONSTRAINT
1700         case 'Q':
1701           if (EXTRA_CONSTRAINT (op, 'Q'))
1702             return 1;
1703           break;
1704         case 'R':
1705           if (EXTRA_CONSTRAINT (op, 'R'))
1706             return 1;
1707           break;
1708         case 'S':
1709           if (EXTRA_CONSTRAINT (op, 'S'))
1710             return 1;
1711           break;
1712         case 'T':
1713           if (EXTRA_CONSTRAINT (op, 'T'))
1714             return 1;
1715           break;
1716         case 'U':
1717           if (EXTRA_CONSTRAINT (op, 'U'))
1718             return 1;
1719           break;
1720 #endif
1721
1722         case 'r':
1723         default:
1724           if (GET_MODE (op) == BLKmode)
1725             break;
1726           if (register_operand (op, VOIDmode))
1727             return 1;
1728           break;
1729         }
1730     }
1731
1732   return result;
1733 }
1734 \f
1735 /* Given an rtx *P, if it is a sum containing an integer constant term,
1736    return the location (type rtx *) of the pointer to that constant term.
1737    Otherwise, return a null pointer.  */
1738
1739 static rtx *
1740 find_constant_term_loc (p)
1741      rtx *p;
1742 {
1743   register rtx *tem;
1744   register enum rtx_code code = GET_CODE (*p);
1745
1746   /* If *P IS such a constant term, P is its location.  */
1747
1748   if (code == CONST_INT || code == SYMBOL_REF || code == LABEL_REF
1749       || code == CONST)
1750     return p;
1751
1752   /* Otherwise, if not a sum, it has no constant term.  */
1753
1754   if (GET_CODE (*p) != PLUS)
1755     return 0;
1756
1757   /* If one of the summands is constant, return its location.  */
1758
1759   if (XEXP (*p, 0) && CONSTANT_P (XEXP (*p, 0))
1760       && XEXP (*p, 1) && CONSTANT_P (XEXP (*p, 1)))
1761     return p;
1762
1763   /* Otherwise, check each summand for containing a constant term.  */
1764
1765   if (XEXP (*p, 0) != 0)
1766     {
1767       tem = find_constant_term_loc (&XEXP (*p, 0));
1768       if (tem != 0)
1769         return tem;
1770     }
1771
1772   if (XEXP (*p, 1) != 0)
1773     {
1774       tem = find_constant_term_loc (&XEXP (*p, 1));
1775       if (tem != 0)
1776         return tem;
1777     }
1778
1779   return 0;
1780 }
1781 \f
1782 /* Return 1 if OP is a memory reference
1783    whose address contains no side effects
1784    and remains valid after the addition
1785    of a positive integer less than the
1786    size of the object being referenced.
1787
1788    We assume that the original address is valid and do not check it.
1789
1790    This uses strict_memory_address_p as a subroutine, so
1791    don't use it before reload.  */
1792
1793 int
1794 offsettable_memref_p (op)
1795      rtx op;
1796 {
1797   return ((GET_CODE (op) == MEM)
1798           && offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)));
1799 }
1800
1801 /* Similar, but don't require a strictly valid mem ref:
1802    consider pseudo-regs valid as index or base regs.  */
1803
1804 int
1805 offsettable_nonstrict_memref_p (op)
1806      rtx op;
1807 {
1808   return ((GET_CODE (op) == MEM)
1809           && offsettable_address_p (0, GET_MODE (op), XEXP (op, 0)));
1810 }
1811
1812 /* Return 1 if Y is a memory address which contains no side effects
1813    and would remain valid after the addition of a positive integer
1814    less than the size of that mode.
1815
1816    We assume that the original address is valid and do not check it.
1817    We do check that it is valid for narrower modes.
1818
1819    If STRICTP is nonzero, we require a strictly valid address,
1820    for the sake of use in reload.c.  */
1821
1822 int
1823 offsettable_address_p (strictp, mode, y)
1824      int strictp;
1825      enum machine_mode mode;
1826      register rtx y;
1827 {
1828   register enum rtx_code ycode = GET_CODE (y);
1829   register rtx z;
1830   rtx y1 = y;
1831   rtx *y2;
1832   int (*addressp) PROTO ((enum machine_mode, rtx)) =
1833     (strictp ? strict_memory_address_p : memory_address_p);
1834
1835   if (CONSTANT_ADDRESS_P (y))
1836     return 1;
1837
1838   /* Adjusting an offsettable address involves changing to a narrower mode.
1839      Make sure that's OK.  */
1840
1841   if (mode_dependent_address_p (y))
1842     return 0;
1843
1844   /* If the expression contains a constant term,
1845      see if it remains valid when max possible offset is added.  */
1846
1847   if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1)))
1848     {
1849       int good;
1850
1851       y1 = *y2;
1852       *y2 = plus_constant (*y2, GET_MODE_SIZE (mode) - 1);
1853       /* Use QImode because an odd displacement may be automatically invalid
1854          for any wider mode.  But it should be valid for a single byte.  */
1855       good = (*addressp) (QImode, y);
1856
1857       /* In any case, restore old contents of memory.  */
1858       *y2 = y1;
1859       return good;
1860     }
1861
1862   if (ycode == PRE_DEC || ycode == PRE_INC
1863       || ycode == POST_DEC || ycode == POST_INC)
1864     return 0;
1865
1866   /* The offset added here is chosen as the maximum offset that
1867      any instruction could need to add when operating on something
1868      of the specified mode.  We assume that if Y and Y+c are
1869      valid addresses then so is Y+d for all 0<d<c.  */
1870
1871   z = plus_constant_for_output (y, GET_MODE_SIZE (mode) - 1);
1872
1873   /* Use QImode because an odd displacement may be automatically invalid
1874      for any wider mode.  But it should be valid for a single byte.  */
1875   return (*addressp) (QImode, z);
1876 }
1877
1878 /* Return 1 if ADDR is an address-expression whose effect depends
1879    on the mode of the memory reference it is used in.
1880
1881    Autoincrement addressing is a typical example of mode-dependence
1882    because the amount of the increment depends on the mode.  */
1883
1884 int
1885 mode_dependent_address_p (addr)
1886   rtx addr ATTRIBUTE_UNUSED; /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS. */
1887 {
1888   GO_IF_MODE_DEPENDENT_ADDRESS (addr, win);
1889   return 0;
1890   /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1891  win: ATTRIBUTE_UNUSED_LABEL
1892   return 1;
1893 }
1894
1895 /* Return 1 if OP is a general operand
1896    other than a memory ref with a mode dependent address.  */
1897
1898 int
1899 mode_independent_operand (op, mode)
1900      enum machine_mode mode;
1901      rtx op;
1902 {
1903   rtx addr;
1904
1905   if (! general_operand (op, mode))
1906     return 0;
1907
1908   if (GET_CODE (op) != MEM)
1909     return 1;
1910
1911   addr = XEXP (op, 0);
1912   GO_IF_MODE_DEPENDENT_ADDRESS (addr, lose);
1913   return 1;
1914   /* Label `lose' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1915  lose: ATTRIBUTE_UNUSED_LABEL
1916   return 0;
1917 }
1918
1919 /* Given an operand OP that is a valid memory reference
1920    which satisfies offsettable_memref_p,
1921    return a new memory reference whose address has been adjusted by OFFSET.
1922    OFFSET should be positive and less than the size of the object referenced.
1923 */
1924
1925 rtx
1926 adj_offsettable_operand (op, offset)
1927      rtx op;
1928      int offset;
1929 {
1930   register enum rtx_code code = GET_CODE (op);
1931
1932   if (code == MEM)
1933     {
1934       register rtx y = XEXP (op, 0);
1935       register rtx new;
1936
1937       if (CONSTANT_ADDRESS_P (y))
1938         {
1939           new = gen_rtx_MEM (GET_MODE (op),
1940                              plus_constant_for_output (y, offset));
1941           RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op);
1942           return new;
1943         }
1944
1945       if (GET_CODE (y) == PLUS)
1946         {
1947           rtx z = y;
1948           register rtx *const_loc;
1949
1950           op = copy_rtx (op);
1951           z = XEXP (op, 0);
1952           const_loc = find_constant_term_loc (&z);
1953           if (const_loc)
1954             {
1955               *const_loc = plus_constant_for_output (*const_loc, offset);
1956               return op;
1957             }
1958         }
1959
1960       new = gen_rtx_MEM (GET_MODE (op), plus_constant_for_output (y, offset));
1961       RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op);
1962       return new;
1963     }
1964   abort ();
1965 }
1966 \f
1967 /* Analyze INSN and fill in recog_data.  */
1968
1969 void
1970 extract_insn (insn)
1971      rtx insn;
1972 {
1973   int i;
1974   int icode;
1975   int noperands;
1976   rtx body = PATTERN (insn);
1977
1978   recog_data.n_operands = 0;
1979   recog_data.n_alternatives = 0;
1980   recog_data.n_dups = 0;
1981
1982   switch (GET_CODE (body))
1983     {
1984     case USE:
1985     case CLOBBER:
1986     case ASM_INPUT:
1987     case ADDR_VEC:
1988     case ADDR_DIFF_VEC:
1989       return;
1990
1991     case SET:
1992     case PARALLEL:
1993     case ASM_OPERANDS:
1994       recog_data.n_operands = noperands = asm_noperands (body);
1995       if (noperands >= 0)
1996         {
1997           /* This insn is an `asm' with operands.  */
1998
1999           /* expand_asm_operands makes sure there aren't too many operands.  */
2000           if (noperands > MAX_RECOG_OPERANDS)
2001             abort ();
2002
2003           /* Now get the operand values and constraints out of the insn.  */
2004           decode_asm_operands (body, recog_data.operand,
2005                                recog_data.operand_loc,
2006                                recog_data.constraints,
2007                                recog_data.operand_mode);
2008           if (noperands > 0)
2009             {
2010               const char *p =  recog_data.constraints[0];
2011               recog_data.n_alternatives = 1;
2012               while (*p)
2013                 recog_data.n_alternatives += (*p++ == ',');
2014             }
2015           break;
2016         }
2017
2018       /* FALLTHROUGH */
2019
2020     default:
2021       /* Ordinary insn: recognize it, get the operands via insn_extract
2022          and get the constraints.  */
2023
2024       icode = recog_memoized (insn);
2025       if (icode < 0)
2026         fatal_insn_not_found (insn);
2027
2028       recog_data.n_operands = noperands = insn_data[icode].n_operands;
2029       recog_data.n_alternatives = insn_data[icode].n_alternatives;
2030       recog_data.n_dups = insn_data[icode].n_dups;
2031
2032       insn_extract (insn);
2033
2034       for (i = 0; i < noperands; i++)
2035         {
2036           recog_data.constraints[i] = insn_data[icode].operand[i].constraint;
2037           recog_data.operand_mode[i] = insn_data[icode].operand[i].mode;
2038         }
2039     }
2040   for (i = 0; i < noperands; i++)
2041     recog_data.operand_type[i]
2042       = (recog_data.constraints[i][0] == '=' ? OP_OUT
2043          : recog_data.constraints[i][0] == '+' ? OP_INOUT
2044          : OP_IN);
2045
2046   if (recog_data.n_alternatives > MAX_RECOG_ALTERNATIVES)
2047     abort ();
2048 }
2049
2050 /* After calling extract_insn, you can use this function to extract some
2051    information from the constraint strings into a more usable form.
2052    The collected data is stored in recog_op_alt.  */
2053 void
2054 preprocess_constraints ()
2055 {
2056   int i;
2057
2058   memset (recog_op_alt, 0, sizeof recog_op_alt);
2059   for (i = 0; i < recog_data.n_operands; i++)
2060     {
2061       int j;
2062       struct operand_alternative *op_alt;
2063       const char *p = recog_data.constraints[i];
2064
2065       op_alt = recog_op_alt[i];
2066
2067       for (j = 0; j < recog_data.n_alternatives; j++)
2068         {
2069           op_alt[j].class = NO_REGS;
2070           op_alt[j].constraint = p;
2071           op_alt[j].matches = -1;
2072           op_alt[j].matched = -1;
2073
2074           if (*p == '\0' || *p == ',')
2075             {
2076               op_alt[j].anything_ok = 1;
2077               continue;
2078             }
2079
2080           for (;;)
2081             {
2082               char c = *p++;
2083               if (c == '#')
2084                 do
2085                   c = *p++;
2086                 while (c != ',' && c != '\0');
2087               if (c == ',' || c == '\0')
2088                 break;
2089
2090               switch (c)
2091                 {
2092                 case '=': case '+': case '*': case '%':
2093                 case 'E': case 'F': case 'G': case 'H':
2094                 case 's': case 'i': case 'n':
2095                 case 'I': case 'J': case 'K': case 'L':
2096                 case 'M': case 'N': case 'O': case 'P':
2097 #ifdef EXTRA_CONSTRAINT
2098                 case 'Q': case 'R': case 'S': case 'T': case 'U':
2099 #endif
2100                   /* These don't say anything we care about.  */
2101                   break;
2102
2103                 case '?':
2104                   op_alt[j].reject += 6;
2105                   break;
2106                 case '!':
2107                   op_alt[j].reject += 600;
2108                   break;
2109                 case '&':
2110                   op_alt[j].earlyclobber = 1;
2111                   break;
2112
2113                 case '0': case '1': case '2': case '3': case '4':
2114                 case '5': case '6': case '7': case '8': case '9':
2115                   op_alt[j].matches = c - '0';
2116                   op_alt[op_alt[j].matches].matched = i;
2117                   break;
2118
2119                 case 'm':
2120                   op_alt[j].memory_ok = 1;
2121                   break;
2122                 case '<':
2123                   op_alt[j].decmem_ok = 1;
2124                   break;
2125                 case '>':
2126                   op_alt[j].incmem_ok = 1;
2127                   break;
2128                 case 'V':
2129                   op_alt[j].nonoffmem_ok = 1;
2130                   break;
2131                 case 'o':
2132                   op_alt[j].offmem_ok = 1;
2133                   break;
2134                 case 'X':
2135                   op_alt[j].anything_ok = 1;
2136                   break;
2137
2138                 case 'p':
2139                   op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) BASE_REG_CLASS];
2140                   break;
2141
2142                 case 'g': case 'r':
2143                   op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) GENERAL_REGS];
2144                   break;
2145
2146                 default:
2147                   op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) REG_CLASS_FROM_LETTER ((unsigned char)c)];
2148                   break;
2149                 }
2150             }
2151         }
2152     }
2153 }
2154
2155 /* Check the operands of an insn against the insn's operand constraints
2156    and return 1 if they are valid.
2157    The information about the insn's operands, constraints, operand modes
2158    etc. is obtained from the global variables set up by extract_insn.
2159
2160    WHICH_ALTERNATIVE is set to a number which indicates which
2161    alternative of constraints was matched: 0 for the first alternative,
2162    1 for the next, etc.
2163
2164    In addition, when two operands are match
2165    and it happens that the output operand is (reg) while the
2166    input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
2167    make the output operand look like the input.
2168    This is because the output operand is the one the template will print.
2169
2170    This is used in final, just before printing the assembler code and by
2171    the routines that determine an insn's attribute.
2172
2173    If STRICT is a positive non-zero value, it means that we have been
2174    called after reload has been completed.  In that case, we must
2175    do all checks strictly.  If it is zero, it means that we have been called
2176    before reload has completed.  In that case, we first try to see if we can
2177    find an alternative that matches strictly.  If not, we try again, this
2178    time assuming that reload will fix up the insn.  This provides a "best
2179    guess" for the alternative and is used to compute attributes of insns prior
2180    to reload.  A negative value of STRICT is used for this internal call.  */
2181
2182 struct funny_match
2183 {
2184   int this, other;
2185 };
2186
2187 int
2188 constrain_operands (strict)
2189      int strict;
2190 {
2191   const char *constraints[MAX_RECOG_OPERANDS];
2192   int matching_operands[MAX_RECOG_OPERANDS];
2193   int earlyclobber[MAX_RECOG_OPERANDS];
2194   register int c;
2195
2196   struct funny_match funny_match[MAX_RECOG_OPERANDS];
2197   int funny_match_index;
2198
2199   if (recog_data.n_operands == 0 || recog_data.n_alternatives == 0)
2200     return 1;
2201
2202   for (c = 0; c < recog_data.n_operands; c++)
2203     {
2204       constraints[c] = recog_data.constraints[c];
2205       matching_operands[c] = -1;
2206     }
2207
2208   which_alternative = 0;
2209
2210   while (which_alternative < recog_data.n_alternatives)
2211     {
2212       register int opno;
2213       int lose = 0;
2214       funny_match_index = 0;
2215
2216       for (opno = 0; opno < recog_data.n_operands; opno++)
2217         {
2218           register rtx op = recog_data.operand[opno];
2219           enum machine_mode mode = GET_MODE (op);
2220           register const char *p = constraints[opno];
2221           int offset = 0;
2222           int win = 0;
2223           int val;
2224
2225           earlyclobber[opno] = 0;
2226
2227           /* A unary operator may be accepted by the predicate, but it
2228              is irrelevant for matching constraints.  */
2229           if (GET_RTX_CLASS (GET_CODE (op)) == '1')
2230             op = XEXP (op, 0);
2231
2232           if (GET_CODE (op) == SUBREG)
2233             {
2234               if (GET_CODE (SUBREG_REG (op)) == REG
2235                   && REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER)
2236                 offset = SUBREG_WORD (op);
2237               op = SUBREG_REG (op);
2238             }
2239
2240           /* An empty constraint or empty alternative
2241              allows anything which matched the pattern.  */
2242           if (*p == 0 || *p == ',')
2243             win = 1;
2244
2245           while (*p && (c = *p++) != ',')
2246             switch (c)
2247               {
2248               case '?':  case '!': case '*':  case '%':
2249               case '=':  case '+':
2250                 break;
2251
2252               case '#':
2253                 /* Ignore rest of this alternative as far as
2254                    constraint checking is concerned.  */
2255                 while (*p && *p != ',')
2256                   p++;
2257                 break;
2258
2259               case '&':
2260                 earlyclobber[opno] = 1;
2261                 break;
2262
2263               case '0':  case '1':  case '2':  case '3':  case '4':
2264               case '5':  case '6':  case '7':  case '8':  case '9':
2265
2266                 /* This operand must be the same as a previous one.
2267                    This kind of constraint is used for instructions such
2268                    as add when they take only two operands.
2269
2270                    Note that the lower-numbered operand is passed first.
2271
2272                    If we are not testing strictly, assume that this constraint
2273                    will be satisfied.  */
2274                 if (strict < 0)
2275                   val = 1;
2276                 else
2277                   {
2278                     rtx op1 = recog_data.operand[c - '0'];
2279                     rtx op2 = recog_data.operand[opno];
2280
2281                     /* A unary operator may be accepted by the predicate,
2282                        but it is irrelevant for matching constraints.  */
2283                     if (GET_RTX_CLASS (GET_CODE (op1)) == '1')
2284                       op1 = XEXP (op1, 0);
2285                     if (GET_RTX_CLASS (GET_CODE (op2)) == '1')
2286                       op2 = XEXP (op2, 0);
2287
2288                     val = operands_match_p (op1, op2);
2289                   }
2290
2291                 matching_operands[opno] = c - '0';
2292                 matching_operands[c - '0'] = opno;
2293
2294                 if (val != 0)
2295                   win = 1;
2296                 /* If output is *x and input is *--x,
2297                    arrange later to change the output to *--x as well,
2298                    since the output op is the one that will be printed.  */
2299                 if (val == 2 && strict > 0)
2300                   {
2301                     funny_match[funny_match_index].this = opno;
2302                     funny_match[funny_match_index++].other = c - '0';
2303                   }
2304                 break;
2305
2306               case 'p':
2307                 /* p is used for address_operands.  When we are called by
2308                    gen_reload, no one will have checked that the address is
2309                    strictly valid, i.e., that all pseudos requiring hard regs
2310                    have gotten them.  */
2311                 if (strict <= 0
2312                     || (strict_memory_address_p (recog_data.operand_mode[opno],
2313                                                  op)))
2314                   win = 1;
2315                 break;
2316
2317                 /* No need to check general_operand again;
2318                    it was done in insn-recog.c.  */
2319               case 'g':
2320                 /* Anything goes unless it is a REG and really has a hard reg
2321                    but the hard reg is not in the class GENERAL_REGS.  */
2322                 if (strict < 0
2323                     || GENERAL_REGS == ALL_REGS
2324                     || GET_CODE (op) != REG
2325                     || (reload_in_progress
2326                         && REGNO (op) >= FIRST_PSEUDO_REGISTER)
2327                     || reg_fits_class_p (op, GENERAL_REGS, offset, mode))
2328                   win = 1;
2329                 break;
2330
2331               case 'r':
2332                 if (strict < 0
2333                     || (strict == 0
2334                         && GET_CODE (op) == REG
2335                         && REGNO (op) >= FIRST_PSEUDO_REGISTER)
2336                     || (strict == 0 && GET_CODE (op) == SCRATCH)
2337                     || (GET_CODE (op) == REG
2338                         && ((GENERAL_REGS == ALL_REGS
2339                              && REGNO (op) < FIRST_PSEUDO_REGISTER)
2340                             || reg_fits_class_p (op, GENERAL_REGS,
2341                                                  offset, mode))))
2342                   win = 1;
2343                 break;
2344
2345               case 'X':
2346                 /* This is used for a MATCH_SCRATCH in the cases when
2347                    we don't actually need anything.  So anything goes
2348                    any time.  */
2349                 win = 1;
2350                 break;
2351
2352               case 'm':
2353                 if (GET_CODE (op) == MEM
2354                     /* Before reload, accept what reload can turn into mem.  */
2355                     || (strict < 0 && CONSTANT_P (op))
2356                     /* During reload, accept a pseudo  */
2357                     || (reload_in_progress && GET_CODE (op) == REG
2358                         && REGNO (op) >= FIRST_PSEUDO_REGISTER))
2359                   win = 1;
2360                 break;
2361
2362               case '<':
2363                 if (GET_CODE (op) == MEM
2364                     && (GET_CODE (XEXP (op, 0)) == PRE_DEC
2365                         || GET_CODE (XEXP (op, 0)) == POST_DEC))
2366                   win = 1;
2367                 break;
2368
2369               case '>':
2370                 if (GET_CODE (op) == MEM
2371                     && (GET_CODE (XEXP (op, 0)) == PRE_INC
2372                         || GET_CODE (XEXP (op, 0)) == POST_INC))
2373                   win = 1;
2374                 break;
2375
2376               case 'E':
2377 #ifndef REAL_ARITHMETIC
2378                 /* Match any CONST_DOUBLE, but only if
2379                    we can examine the bits of it reliably.  */
2380                 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
2381                      || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
2382                     && GET_MODE (op) != VOIDmode && ! flag_pretend_float)
2383                   break;
2384 #endif
2385                 if (GET_CODE (op) == CONST_DOUBLE)
2386                   win = 1;
2387                 break;
2388
2389               case 'F':
2390                 if (GET_CODE (op) == CONST_DOUBLE)
2391                   win = 1;
2392                 break;
2393
2394               case 'G':
2395               case 'H':
2396                 if (GET_CODE (op) == CONST_DOUBLE
2397                     && CONST_DOUBLE_OK_FOR_LETTER_P (op, c))
2398                   win = 1;
2399                 break;
2400
2401               case 's':
2402                 if (GET_CODE (op) == CONST_INT
2403                     || (GET_CODE (op) == CONST_DOUBLE
2404                         && GET_MODE (op) == VOIDmode))
2405                   break;
2406               case 'i':
2407                 if (CONSTANT_P (op))
2408                   win = 1;
2409                 break;
2410
2411               case 'n':
2412                 if (GET_CODE (op) == CONST_INT
2413                     || (GET_CODE (op) == CONST_DOUBLE
2414                         && GET_MODE (op) == VOIDmode))
2415                   win = 1;
2416                 break;
2417
2418               case 'I':
2419               case 'J':
2420               case 'K':
2421               case 'L':
2422               case 'M':
2423               case 'N':
2424               case 'O':
2425               case 'P':
2426                 if (GET_CODE (op) == CONST_INT
2427                     && CONST_OK_FOR_LETTER_P (INTVAL (op), c))
2428                   win = 1;
2429                 break;
2430
2431 #ifdef EXTRA_CONSTRAINT
2432               case 'Q':
2433               case 'R':
2434               case 'S':
2435               case 'T':
2436               case 'U':
2437                 if (EXTRA_CONSTRAINT (op, c))
2438                   win = 1;
2439                 break;
2440 #endif
2441
2442               case 'V':
2443                 if (GET_CODE (op) == MEM
2444                     && ((strict > 0 && ! offsettable_memref_p (op))
2445                         || (strict < 0
2446                             && !(CONSTANT_P (op) || GET_CODE (op) == MEM))
2447                         || (reload_in_progress
2448                             && !(GET_CODE (op) == REG
2449                                  && REGNO (op) >= FIRST_PSEUDO_REGISTER))))
2450                   win = 1;
2451                 break;
2452
2453               case 'o':
2454                 if ((strict > 0 && offsettable_memref_p (op))
2455                     || (strict == 0 && offsettable_nonstrict_memref_p (op))
2456                     /* Before reload, accept what reload can handle.  */
2457                     || (strict < 0
2458                         && (CONSTANT_P (op) || GET_CODE (op) == MEM))
2459                     /* During reload, accept a pseudo  */
2460                     || (reload_in_progress && GET_CODE (op) == REG
2461                         && REGNO (op) >= FIRST_PSEUDO_REGISTER))
2462                   win = 1;
2463                 break;
2464
2465               default:
2466                 if (strict < 0
2467                     || (strict == 0
2468                         && GET_CODE (op) == REG
2469                         && REGNO (op) >= FIRST_PSEUDO_REGISTER)
2470                     || (strict == 0 && GET_CODE (op) == SCRATCH)
2471                     || (GET_CODE (op) == REG
2472                         && reg_fits_class_p (op, REG_CLASS_FROM_LETTER (c),
2473                                              offset, mode)))
2474                   win = 1;
2475               }
2476
2477           constraints[opno] = p;
2478           /* If this operand did not win somehow,
2479              this alternative loses.  */
2480           if (! win)
2481             lose = 1;
2482         }
2483       /* This alternative won; the operands are ok.
2484          Change whichever operands this alternative says to change.  */
2485       if (! lose)
2486         {
2487           int opno, eopno;
2488
2489           /* See if any earlyclobber operand conflicts with some other
2490              operand.  */
2491
2492           if (strict > 0)
2493             for (eopno = 0; eopno < recog_data.n_operands; eopno++)
2494               /* Ignore earlyclobber operands now in memory,
2495                  because we would often report failure when we have
2496                  two memory operands, one of which was formerly a REG.  */
2497               if (earlyclobber[eopno]
2498                   && GET_CODE (recog_data.operand[eopno]) == REG)
2499                 for (opno = 0; opno < recog_data.n_operands; opno++)
2500                   if ((GET_CODE (recog_data.operand[opno]) == MEM
2501                        || recog_data.operand_type[opno] != OP_OUT)
2502                       && opno != eopno
2503                       /* Ignore things like match_operator operands.  */
2504                       && *recog_data.constraints[opno] != 0
2505                       && ! (matching_operands[opno] == eopno
2506                             && operands_match_p (recog_data.operand[opno],
2507                                                  recog_data.operand[eopno]))
2508                       && ! safe_from_earlyclobber (recog_data.operand[opno],
2509                                                    recog_data.operand[eopno]))
2510                     lose = 1;
2511
2512           if (! lose)
2513             {
2514               while (--funny_match_index >= 0)
2515                 {
2516                   recog_data.operand[funny_match[funny_match_index].other]
2517                     = recog_data.operand[funny_match[funny_match_index].this];
2518                 }
2519
2520               return 1;
2521             }
2522         }
2523
2524       which_alternative++;
2525     }
2526
2527   /* If we are about to reject this, but we are not to test strictly,
2528      try a very loose test.  Only return failure if it fails also.  */
2529   if (strict == 0)
2530     return constrain_operands (-1);
2531   else
2532     return 0;
2533 }
2534
2535 /* Return 1 iff OPERAND (assumed to be a REG rtx)
2536    is a hard reg in class CLASS when its regno is offset by OFFSET
2537    and changed to mode MODE.
2538    If REG occupies multiple hard regs, all of them must be in CLASS.  */
2539
2540 int
2541 reg_fits_class_p (operand, class, offset, mode)
2542      rtx operand;
2543      register enum reg_class class;
2544      int offset;
2545      enum machine_mode mode;
2546 {
2547   register int regno = REGNO (operand);
2548   if (regno < FIRST_PSEUDO_REGISTER
2549       && TEST_HARD_REG_BIT (reg_class_contents[(int) class],
2550                             regno + offset))
2551     {
2552       register int sr;
2553       regno += offset;
2554       for (sr = HARD_REGNO_NREGS (regno, mode) - 1;
2555            sr > 0; sr--)
2556         if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
2557                                  regno + sr))
2558           break;
2559       return sr == 0;
2560     }
2561
2562   return 0;
2563 }
2564 \f
2565 /* Do the splitting of insns in the block B. Only try to actually split if
2566    DO_SPLIT is true; otherwise, just remove nops. */
2567
2568 void
2569 split_block_insns (b, do_split)
2570      int b;
2571      int do_split;
2572 {
2573   rtx insn, next;
2574
2575   for (insn = BLOCK_HEAD (b);; insn = next)
2576     {
2577       rtx set;
2578
2579       /* Can't use `next_real_insn' because that
2580          might go across CODE_LABELS and short-out basic blocks.  */
2581       next = NEXT_INSN (insn);
2582       if (GET_CODE (insn) != INSN)
2583         {
2584           if (insn == BLOCK_END (b))
2585             break;
2586
2587           continue;
2588         }
2589
2590       /* Don't split no-op move insns.  These should silently disappear
2591          later in final.  Splitting such insns would break the code
2592          that handles REG_NO_CONFLICT blocks.  */
2593       set = single_set (insn);
2594       if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
2595         {
2596           if (insn == BLOCK_END (b))
2597             break;
2598
2599           /* Nops get in the way while scheduling, so delete them now if
2600              register allocation has already been done.  It is too risky
2601              to try to do this before register allocation, and there are
2602              unlikely to be very many nops then anyways.  */
2603           if (reload_completed)
2604             {
2605
2606               PUT_CODE (insn, NOTE);
2607               NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2608               NOTE_SOURCE_FILE (insn) = 0;
2609             }
2610
2611           continue;
2612         }
2613
2614       if (do_split)
2615         {
2616           /* Split insns here to get max fine-grain parallelism.  */
2617           rtx first = PREV_INSN (insn);
2618           rtx notes = REG_NOTES (insn);
2619           rtx last = try_split (PATTERN (insn), insn, 1);
2620
2621           if (last != insn)
2622             {
2623               /* try_split returns the NOTE that INSN became.  */
2624               first = NEXT_INSN (first);
2625 #ifdef INSN_SCHEDULING
2626               update_life_info (notes, first, last, insn, insn);
2627 #endif
2628               PUT_CODE (insn, NOTE);
2629               NOTE_SOURCE_FILE (insn) = 0;
2630               NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2631               if (insn == BLOCK_HEAD (b))
2632                 BLOCK_HEAD (b) = first;
2633               if (insn == BLOCK_END (b))
2634                 {
2635                   BLOCK_END (b) = last;
2636                   break;
2637                 }
2638             }
2639         }
2640
2641       if (insn == BLOCK_END (b))
2642         break;
2643     }
2644 }
2645 \f
2646 #ifdef HAVE_peephole2
2647 /* Return the Nth non-note insn after INSN, or return NULL_RTX if it does
2648    not exist.  Used by the recognizer to find the next insn to match in a
2649    multi-insn pattern.  */
2650 rtx
2651 recog_next_insn (insn, n)
2652      rtx insn;
2653      int n;
2654 {
2655   while (insn != NULL_RTX && n > 0)
2656     {
2657       insn = next_nonnote_insn (insn);
2658
2659       if (insn == NULL_RTX)
2660         return insn;
2661
2662       if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
2663         return NULL_RTX;
2664
2665       n--;
2666     }
2667
2668   return insn;
2669 }
2670
2671 /* Perform the peephole2 optimization pass. */
2672 void
2673 peephole2_optimize (dump_file)
2674      FILE *dump_file ATTRIBUTE_UNUSED;
2675 {
2676   rtx insn;
2677   rtx epilogue_insn = 0;
2678
2679   for (insn = get_last_insn (); insn != NULL_RTX; insn = PREV_INSN (insn))
2680     {
2681       if (GET_CODE (insn) == NOTE
2682           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
2683         {
2684           epilogue_insn = insn;
2685           break;
2686         }
2687     }
2688
2689   init_resource_info (epilogue_insn);
2690
2691   for (insn = get_insns (); insn != NULL;
2692        insn = next_nonnote_insn (insn))
2693     {
2694       if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
2695         {
2696           rtx last_insn;
2697           rtx before = PREV_INSN (insn);
2698
2699           rtx try = peephole2_insns (PATTERN (insn), insn, &last_insn);
2700           if (try != NULL)
2701             {
2702               replace_insns (insn, last_insn, try, NULL_RTX);
2703               insn = NEXT_INSN (before);
2704             }
2705         }
2706     }
2707
2708   free_resource_info ();
2709 }
2710 #endif