gcc/recog.c

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