gcc/rtl.c

   1 /* Allocate and read RTL for GNU C Compiler.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000
   3    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 "real.h"
  27 #include "bitmap.h"
  28 #include "ggc.h"
  29 #include "obstack.h"
  30 #include "toplev.h"
  31
  32 #define obstack_chunk_alloc     xmalloc
  33 #define obstack_chunk_free      free
  34
  35 /* Obstack used for allocating RTL objects.
  36    Between functions, this is the permanent_obstack.
  37    While parsing and expanding a function, this is maybepermanent_obstack
  38    so we can save it if it is an inline function.
  39    During optimization and output, this is function_obstack.  */
  40
  41 extern struct obstack *rtl_obstack;
  42 \f
  43 /* Calculate the format for CONST_DOUBLE.  This depends on the relative
  44    widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
  45
  46    We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
  47    per element in REAL_VALUE_TYPE.
  48
  49    This is duplicated in gengenrtl.c.
  50
  51    A number of places assume that there are always at least two 'w'
  52    slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
  53
  54 #ifdef REAL_ARITHMETIC
  55 #if MAX_LONG_DOUBLE_TYPE_SIZE == 96
  56 #define REAL_WIDTH      (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  57 #elif MAX_LONG_DOUBLE_TYPE_SIZE == 128
  58 #define REAL_WIDTH      (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  59 #elif HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
  60 #define REAL_WIDTH      (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  61 #endif
  62 #endif /* REAL_ARITHMETIC */
  63
  64 #ifndef REAL_WIDTH
  65 #if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
  66 #define REAL_WIDTH      2
  67 #elif HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
  68 #define REAL_WIDTH      3
  69 #elif HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
  70 #define REAL_WIDTH      4
  71 #endif
  72 #endif /* REAL_WIDTH */
  73
  74 #if REAL_WIDTH == 1
  75 #define CONST_DOUBLE_FORMAT     "e0ww"
  76 #elif REAL_WIDTH == 2
  77 #define CONST_DOUBLE_FORMAT     "e0ww"
  78 #elif REAL_WIDTH == 3
  79 #define CONST_DOUBLE_FORMAT     "e0www"
  80 #elif REAL_WIDTH == 4
  81 #define CONST_DOUBLE_FORMAT     "e0wwww"
  82 #elif REAL_WIDTH == 5
  83 #define CONST_DOUBLE_FORMAT     "e0wwwww"
  84 #else
  85 #define CONST_DOUBLE_FORMAT     /* nothing - will cause syntax error */
  86 #endif
  87
  88 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  89    Does NOT include rtx header data (code and links).  */
  90
  91 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  92
  93 const int rtx_length[NUM_RTX_CODE + 1] = {
  94 #include "rtl.def"
  95 };
  96
  97 #undef DEF_RTL_EXPR
  98
  99 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
 100
 101 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
 102
 103 const char * const rtx_name[] = {
 104 #include "rtl.def"              /* rtl expressions are documented here */
 105 };
 106
 107 #undef DEF_RTL_EXPR
 108
 109 /* Indexed by machine mode, gives the name of that machine mode.
 110    This name does not include the letters "mode".  */
 111
 112 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  NAME,
 113
 114 const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
 115 #include "machmode.def"
 116   /* Add an extra field to avoid a core dump if someone tries to convert
 117      MAX_MACHINE_MODE to a string.   */
 118   ""
 119 };
 120
 121 #undef DEF_MACHMODE
 122
 123 /* Indexed by machine mode, gives the length of the mode, in bytes.
 124    GET_MODE_CLASS uses this.  */
 125
 126 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  CLASS,
 127
 128 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
 129 #include "machmode.def"
 130 };
 131
 132 #undef DEF_MACHMODE
 133
 134 /* Indexed by machine mode, gives the length of the mode, in bytes.
 135    GET_MODE_SIZE uses this.  */
 136
 137 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  SIZE,
 138
 139 const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
 140 #include "machmode.def"
 141 };
 142
 143 #undef DEF_MACHMODE
 144
 145 /* Indexed by machine mode, gives the length of the mode's subunit.
 146    GET_MODE_UNIT_SIZE uses this.  */
 147
 148 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  UNIT,
 149
 150 const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
 151 #include "machmode.def"         /* machine modes are documented here */
 152 };
 153
 154 #undef DEF_MACHMODE
 155
 156 /* Indexed by machine mode, gives next wider natural mode
 157    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
 158    use this.  */
 159
 160 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
 161   (unsigned char) WIDER,
 162
 163 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
 164 #include "machmode.def"         /* machine modes are documented here */
 165 };
 166
 167 #undef DEF_MACHMODE
 168
 169 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
 170   ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1,
 171
 172 /* Indexed by machine mode, gives mask of significant bits in mode.  */
 173
 174 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
 175 #include "machmode.def"
 176 };
 177
 178 /* Indexed by mode class, gives the narrowest mode for each class.
 179    The Q modes are always of width 1 (2 for complex) - it is impossible
 180    for any mode to be narrower.  */
 181
 182 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
 183     /* MODE_RANDOM */           VOIDmode,
 184     /* MODE_INT */              QImode,
 185     /* MODE_FLOAT */            QFmode,
 186     /* MODE_PARTIAL_INT */      PQImode,
 187     /* MODE_CC */               CCmode,
 188     /* MODE_COMPLEX_INT */      CQImode,
 189     /* MODE_COMPLEX_FLOAT */    QCmode
 190 };
 191
 192
 193 /* Indexed by rtx code, gives a sequence of operand-types for
 194    rtx's of that code.  The sequence is a C string in which
 195    each character describes one operand.  */
 196
 197 const char * const rtx_format[] = {
 198   /* "*" undefined.
 199          can cause a warning message
 200      "0" field is unused (or used in a phase-dependent manner)
 201          prints nothing
 202      "i" an integer
 203          prints the integer
 204      "n" like "i", but prints entries from `note_insn_name'
 205      "w" an integer of width HOST_BITS_PER_WIDE_INT
 206          prints the integer
 207      "s" a pointer to a string
 208          prints the string
 209      "S" like "s", but optional:
 210          the containing rtx may end before this operand
 211      "e" a pointer to an rtl expression
 212          prints the expression
 213      "E" a pointer to a vector that points to a number of rtl expressions
 214          prints a list of the rtl expressions
 215      "V" like "E", but optional:
 216          the containing rtx may end before this operand
 217      "u" a pointer to another insn
 218          prints the uid of the insn.
 219      "b" is a pointer to a bitmap header.
 220      "t" is a tree pointer. */
 221
 222 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 223 #include "rtl.def"              /* rtl expressions are defined here */
 224 #undef DEF_RTL_EXPR
 225 };
 226
 227 /* Indexed by rtx code, gives a character representing the "class" of
 228    that rtx code.  See rtl.def for documentation on the defined classes.  */
 229
 230 const char rtx_class[] = {
 231 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 232 #include "rtl.def"              /* rtl expressions are defined here */
 233 #undef DEF_RTL_EXPR
 234 };
 235
 236 /* Names for kinds of NOTEs and REG_NOTEs.  */
 237
 238 const char * const note_insn_name[] =
 239 {
 240   0, "NOTE_INSN_DELETED",
 241   "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 242   "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 243   "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
 244   "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 245   "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 246   "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 247   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 248   "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START",
 249   "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
 250   "NOTE_INSN_BASIC_BLOCK"
 251 };
 252
 253 const char * const reg_note_name[] =
 254 {
 255   "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
 256   "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
 257   "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
 258   "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 259   "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
 260   "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
 261   "REG_EH_RETHROW", "REG_SAVE_NOTE"
 262 };
 263
 264 static void fatal_with_file_and_line PARAMS ((FILE *, const char *, ...))
 265   ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
 266 static void fatal_expected_char PARAMS ((FILE *, int, int)) ATTRIBUTE_NORETURN;
 267 static void read_name           PARAMS ((char *, FILE *));
 268 static const char *trim_filename PARAMS ((const char *));
 269 \f
 270 /* Allocate an rtx vector of N elements.
 271    Store the length, and initialize all elements to zero.  */
 272
 273 rtvec
 274 rtvec_alloc (n)
 275      int n;
 276 {
 277   rtvec rt;
 278
 279   if (ggc_p)
 280     rt = ggc_alloc_rtvec (n);
 281   else
 282     {
 283       int i;
 284
 285       rt = (rtvec) obstack_alloc (rtl_obstack,
 286                                   sizeof (struct rtvec_def)
 287                                   + (( n - 1) * sizeof (rtx)));
 288
 289       /* clear out the vector */
 290       for (i = 0; i < n; i++)
 291         rt->elem[i] = 0;
 292     }
 293
 294   PUT_NUM_ELEM (rt, n);
 295   return rt;
 296 }
 297
 298 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 299    all the rest is initialized to zero.  */
 300
 301 rtx
 302 rtx_alloc (code)
 303   RTX_CODE code;
 304 {
 305   rtx rt;
 306
 307   if (ggc_p)
 308     rt = ggc_alloc_rtx (GET_RTX_LENGTH (code));
 309   else
 310     {
 311       register struct obstack *ob = rtl_obstack;
 312       register int nelts = GET_RTX_LENGTH (code);
 313       register int length = sizeof (struct rtx_def)
 314         + (nelts - 1) * sizeof (rtunion);
 315
 316       /* This function is called more than any other in GCC, so we
 317          manipulate the obstack directly.
 318
 319          Even though rtx objects are word aligned, we may be sharing
 320          an obstack with tree nodes, which may have to be double-word
 321          aligned.  So align our length to the alignment mask in the
 322          obstack.  */
 323
 324       length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
 325
 326       if (ob->chunk_limit - ob->next_free < length)
 327         _obstack_newchunk (ob, length);
 328       rt = (rtx)ob->object_base;
 329       ob->next_free += length;
 330       ob->object_base = ob->next_free;
 331
 332       /* We want to clear everything up to the FLD array.  Normally,
 333          this is one int, but we don't want to assume that and it
 334          isn't very portable anyway; this is.  */
 335
 336       memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 337     }
 338
 339   PUT_CODE (rt, code);
 340   return rt;
 341 }
 342
 343 /* Free the rtx X and all RTL allocated since X.  */
 344
 345 void
 346 rtx_free (x)
 347      rtx x;
 348 {
 349   if (!ggc_p)
 350     obstack_free (rtl_obstack, x);
 351 }
 352 \f
 353 /* Create a new copy of an rtx.
 354    Recursively copies the operands of the rtx,
 355    except for those few rtx codes that are sharable.  */
 356
 357 rtx
 358 copy_rtx (orig)
 359      register rtx orig;
 360 {
 361   register rtx copy;
 362   register int i, j;
 363   register RTX_CODE code;
 364   register const char *format_ptr;
 365
 366   code = GET_CODE (orig);
 367
 368   switch (code)
 369     {
 370     case REG:
 371     case QUEUED:
 372     case CONST_INT:
 373     case CONST_DOUBLE:
 374     case SYMBOL_REF:
 375     case CODE_LABEL:
 376     case PC:
 377     case CC0:
 378     case SCRATCH:
 379       /* SCRATCH must be shared because they represent distinct values.  */
 380     case ADDRESSOF:
 381       return orig;
 382
 383     case CONST:
 384       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 385          a LABEL_REF, it isn't sharable.  */
 386       if (GET_CODE (XEXP (orig, 0)) == PLUS
 387           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 388           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 389         return orig;
 390       break;
 391
 392       /* A MEM with a constant address is not sharable.  The problem is that
 393          the constant address may need to be reloaded.  If the mem is shared,
 394          then reloading one copy of this mem will cause all copies to appear
 395          to have been reloaded.  */
 396
 397     default:
 398       break;
 399     }
 400
 401   copy = rtx_alloc (code);
 402
 403   /* Copy the various flags, and other information.  We assume that
 404      all fields need copying, and then clear the fields that should
 405      not be copied.  That is the sensible default behavior, and forces
 406      us to explicitly document why we are *not* copying a flag.  */
 407   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 408
 409   /* We do not copy the USED flag, which is used as a mark bit during
 410      walks over the RTL.  */
 411   copy->used = 0;
 412
 413   /* We do not copy FRAME_RELATED for INSNs.  */
 414   if (GET_RTX_CLASS (code) == 'i')
 415     copy->frame_related = 0;
 416   copy->jump = orig->jump;
 417   copy->call = orig->call;
 418
 419   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 420
 421   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 422     {
 423       copy->fld[i] = orig->fld[i];
 424       switch (*format_ptr++)
 425         {
 426         case 'e':
 427           if (XEXP (orig, i) != NULL)
 428             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 429           break;
 430
 431         case 'E':
 432         case 'V':
 433           if (XVEC (orig, i) != NULL)
 434             {
 435               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 436               for (j = 0; j < XVECLEN (copy, i); j++)
 437                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 438             }
 439           break;
 440
 441         case 'b':
 442           {
 443             bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack);
 444             bitmap_copy (new_bits, XBITMAP (orig, i));
 445             XBITMAP (copy, i) = new_bits;
 446             break;
 447           }
 448
 449         case 't':
 450         case 'w':
 451         case 'i':
 452         case 's':
 453         case 'S':
 454         case 'u':
 455         case '0':
 456           /* These are left unchanged.  */
 457           break;
 458
 459         default:
 460           abort ();
 461         }
 462     }
 463   return copy;
 464 }
 465
 466 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 467    placed in the result directly, rather than being copied.  */
 468
 469 rtx
 470 copy_most_rtx (orig, may_share)
 471      register rtx orig;
 472      register rtx may_share;
 473 {
 474   register rtx copy;
 475   register int i, j;
 476   register RTX_CODE code;
 477   register const char *format_ptr;
 478
 479   if (orig == may_share)
 480     return orig;
 481
 482   code = GET_CODE (orig);
 483
 484   switch (code)
 485     {
 486     case REG:
 487     case QUEUED:
 488     case CONST_INT:
 489     case CONST_DOUBLE:
 490     case SYMBOL_REF:
 491     case CODE_LABEL:
 492     case PC:
 493     case CC0:
 494       return orig;
 495     default:
 496       break;
 497     }
 498
 499   copy = rtx_alloc (code);
 500   PUT_MODE (copy, GET_MODE (orig));
 501   copy->in_struct = orig->in_struct;
 502   copy->volatil = orig->volatil;
 503   copy->unchanging = orig->unchanging;
 504   copy->integrated = orig->integrated;
 505
 506   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 507
 508   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 509     {
 510       switch (*format_ptr++)
 511         {
 512         case 'e':
 513           XEXP (copy, i) = XEXP (orig, i);
 514           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 515             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 516           break;
 517
 518         case 'u':
 519           XEXP (copy, i) = XEXP (orig, i);
 520           break;
 521
 522         case 'E':
 523         case 'V':
 524           XVEC (copy, i) = XVEC (orig, i);
 525           if (XVEC (orig, i) != NULL)
 526             {
 527               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 528               for (j = 0; j < XVECLEN (copy, i); j++)
 529                 XVECEXP (copy, i, j)
 530                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 531             }
 532           break;
 533
 534         case 'w':
 535           XWINT (copy, i) = XWINT (orig, i);
 536           break;
 537
 538         case 'n':
 539         case 'i':
 540           XINT (copy, i) = XINT (orig, i);
 541           break;
 542
 543         case 't':
 544           XTREE (copy, i) = XTREE (orig, i);
 545           break;
 546
 547         case 's':
 548         case 'S':
 549           XSTR (copy, i) = XSTR (orig, i);
 550           break;
 551
 552         case '0':
 553           /* Copy this through the wide int field; that's safest. */
 554           X0WINT (copy, i) = X0WINT (orig, i);
 555           break;
 556
 557         default:
 558           abort ();
 559         }
 560     }
 561   return copy;
 562 }
 563
 564 /* Create a new copy of an rtx.  Only copy just one level.  */
 565 rtx
 566 shallow_copy_rtx (orig)
 567      rtx orig;
 568 {
 569   register int i;
 570   register RTX_CODE code = GET_CODE (orig);
 571   register rtx copy = rtx_alloc (code);
 572
 573   PUT_MODE (copy, GET_MODE (orig));
 574   copy->in_struct = orig->in_struct;
 575   copy->volatil = orig->volatil;
 576   copy->unchanging = orig->unchanging;
 577   copy->integrated = orig->integrated;
 578
 579   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 580     copy->fld[i] = orig->fld[i];
 581
 582   return copy;
 583 }
 584 \f
 585 /* This is 1 until after the rtl generation pass.  */
 586 int rtx_equal_function_value_matters;
 587 \f
 588 /* Return 1 if X and Y are identical-looking rtx's.
 589    This is the Lisp function EQUAL for rtx arguments.  */
 590
 591 int
 592 rtx_equal_p (x, y)
 593      rtx x, y;
 594 {
 595   register int i;
 596   register int j;
 597   register enum rtx_code code;
 598   register const char *fmt;
 599
 600   if (x == y)
 601     return 1;
 602   if (x == 0 || y == 0)
 603     return 0;
 604
 605   code = GET_CODE (x);
 606   /* Rtx's of different codes cannot be equal.  */
 607   if (code != GET_CODE (y))
 608     return 0;
 609
 610   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 611      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 612
 613   if (GET_MODE (x) != GET_MODE (y))
 614     return 0;
 615
 616   /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively.  */
 617
 618   if (code == REG)
 619     /* Until rtl generation is complete, don't consider a reference to the
 620        return register of the current function the same as the return from a
 621        called function.  This eases the job of function integration.  Once the
 622        distinction is no longer needed, they can be considered equivalent.  */
 623     return (REGNO (x) == REGNO (y)
 624             && (! rtx_equal_function_value_matters
 625                 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 626   else if (code == LABEL_REF)
 627     return XEXP (x, 0) == XEXP (y, 0);
 628   else if (code == SYMBOL_REF)
 629     return XSTR (x, 0) == XSTR (y, 0);
 630   else if (code == SCRATCH || code == CONST_DOUBLE)
 631     return 0;
 632
 633   /* Compare the elements.  If any pair of corresponding elements
 634      fail to match, return 0 for the whole things.  */
 635
 636   fmt = GET_RTX_FORMAT (code);
 637   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 638     {
 639       switch (fmt[i])
 640         {
 641         case 'w':
 642           if (XWINT (x, i) != XWINT (y, i))
 643             return 0;
 644           break;
 645
 646         case 'n':
 647         case 'i':
 648           if (XINT (x, i) != XINT (y, i))
 649             return 0;
 650           break;
 651
 652         case 'V':
 653         case 'E':
 654           /* Two vectors must have the same length.  */
 655           if (XVECLEN (x, i) != XVECLEN (y, i))
 656             return 0;
 657
 658           /* And the corresponding elements must match.  */
 659           for (j = 0; j < XVECLEN (x, i); j++)
 660             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 661               return 0;
 662           break;
 663
 664         case 'e':
 665           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 666             return 0;
 667           break;
 668
 669         case 'S':
 670         case 's':
 671           if (strcmp (XSTR (x, i), XSTR (y, i)))
 672             return 0;
 673           break;
 674
 675         case 'u':
 676           /* These are just backpointers, so they don't matter.  */
 677           break;
 678
 679         case '0':
 680         case 't':
 681           break;
 682
 683           /* It is believed that rtx's at this level will never
 684              contain anything but integers and other rtx's,
 685              except for within LABEL_REFs and SYMBOL_REFs.  */
 686         default:
 687           abort ();
 688         }
 689     }
 690   return 1;
 691 }
 692 \f
 693 /* Subroutines of read_rtx.  */
 694
 695 /* The current line number for the file.  */
 696 int read_rtx_lineno = 1;
 697
 698 /* The filename for aborting with file and line.  */
 699 const char *read_rtx_filename = "<unknown>";
 700
 701 static void
 702 fatal_with_file_and_line VPARAMS ((FILE *infile, const char *msg, ...))
 703 {
 704 #ifndef ANSI_PROTOTYPES
 705   FILE *infile;
 706   const char *msg;
 707 #endif
 708   va_list ap;
 709   char context[64];
 710   size_t i;
 711   int c;
 712
 713   VA_START (ap, msg);
 714
 715 #ifndef ANSI_PROTOTYPES
 716   infile = va_arg (ap, FILE *);
 717   msg = va_arg (ap, const char *);
 718 #endif
 719
 720   fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
 721   vfprintf (stderr, msg, ap);
 722   putc ('\n', stderr);
 723
 724   /* Gather some following context.  */
 725   for (i = 0; i < sizeof(context)-1; ++i)
 726     {
 727       c = getc (infile);
 728       if (c == EOF)
 729         break;
 730       if (c == '\r' || c == '\n')
 731         break;
 732       context[i] = c;
 733     }
 734   context[i] = '\0';
 735
 736   fprintf (stderr, "%s:%d: following context is `%s'\n",
 737            read_rtx_filename, read_rtx_lineno, context);
 738
 739   va_end (ap);
 740   exit (1);
 741 }
 742
 743 /* Dump code after printing a message.  Used when read_rtx finds
 744    invalid data.  */
 745
 746 static void
 747 fatal_expected_char (infile, expected_c, actual_c)
 748      FILE *infile;
 749      int expected_c, actual_c;
 750 {
 751   fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
 752                             expected_c, actual_c);
 753 }
 754
 755 /* Read chars from INFILE until a non-whitespace char
 756    and return that.  Comments, both Lisp style and C style,
 757    are treated as whitespace.
 758    Tools such as genflags use this function.  */
 759
 760 int
 761 read_skip_spaces (infile)
 762      FILE *infile;
 763 {
 764   register int c;
 765   while (1)
 766     {
 767       c = getc (infile);
 768       switch (c)
 769         {
 770         case '\n':
 771           read_rtx_lineno++;
 772           break;
 773
 774         case ' ': case '\t': case '\f': case '\r':
 775           break;
 776
 777         case ';':
 778           do
 779             c = getc (infile);
 780           while (c != '\n' && c != EOF);
 781           read_rtx_lineno++;
 782           break;
 783
 784         case '/':
 785           {
 786             register int prevc;
 787             c = getc (infile);
 788             if (c != '*')
 789               fatal_expected_char (infile, '*', c);
 790
 791             prevc = 0;
 792             while ((c = getc (infile)) && c != EOF)
 793               {
 794                 if (c == '\n')
 795                    read_rtx_lineno++;
 796                 else if (prevc == '*' && c == '/')
 797                   break;
 798                 prevc = c;
 799               }
 800           }
 801           break;
 802
 803         default:
 804           return c;
 805         }
 806     }
 807 }
 808
 809 /* Read an rtx code name into the buffer STR[].
 810    It is terminated by any of the punctuation chars of rtx printed syntax.  */
 811
 812 static void
 813 read_name (str, infile)
 814      char *str;
 815      FILE *infile;
 816 {
 817   register char *p;
 818   register int c;
 819
 820   c = read_skip_spaces(infile);
 821
 822   p = str;
 823   while (1)
 824     {
 825       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
 826         break;
 827       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
 828           || c == '(' || c == '[')
 829         {
 830           ungetc (c, infile);
 831           break;
 832         }
 833       *p++ = c;
 834       c = getc (infile);
 835     }
 836   if (p == str)
 837     fatal_with_file_and_line (infile, "missing name or number");
 838   if (c == '\n')
 839     read_rtx_lineno++;
 840
 841   *p = 0;
 842 }
 843 \f
 844 /* Provide a version of a function to read a long long if the system does
 845    not provide one.  */
 846 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
 847 HOST_WIDE_INT
 848 atoll(p)
 849     const char *p;
 850 {
 851   int neg = 0;
 852   HOST_WIDE_INT tmp_wide;
 853
 854   while (ISSPACE(*p))
 855     p++;
 856   if (*p == '-')
 857     neg = 1, p++;
 858   else if (*p == '+')
 859     p++;
 860
 861   tmp_wide = 0;
 862   while (ISDIGIT(*p))
 863     {
 864       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
 865       if (new_wide < tmp_wide)
 866         {
 867           /* Return INT_MAX equiv on overflow.  */
 868           tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1;
 869           break;
 870         }
 871       tmp_wide = new_wide;
 872       p++;
 873     }
 874
 875   if (neg)
 876     tmp_wide = -tmp_wide;
 877   return tmp_wide;
 878 }
 879 #endif
 880
 881 /* Read an rtx in printed representation from INFILE
 882    and return an actual rtx in core constructed accordingly.
 883    read_rtx is not used in the compiler proper, but rather in
 884    the utilities gen*.c that construct C code from machine descriptions.  */
 885
 886 rtx
 887 read_rtx (infile)
 888      FILE *infile;
 889 {
 890   register int i, j, list_counter;
 891   RTX_CODE tmp_code;
 892   register const char *format_ptr;
 893   /* tmp_char is a buffer used for reading decimal integers
 894      and names of rtx types and machine modes.
 895      Therefore, 256 must be enough.  */
 896   char tmp_char[256];
 897   rtx return_rtx;
 898   register int c;
 899   int tmp_int;
 900   HOST_WIDE_INT tmp_wide;
 901
 902   /* Linked list structure for making RTXs: */
 903   struct rtx_list
 904     {
 905       struct rtx_list *next;
 906       rtx value;                /* Value of this node.  */
 907     };
 908
 909   c = read_skip_spaces (infile); /* Should be open paren.  */
 910   if (c != '(')
 911     fatal_expected_char (infile, '(', c);
 912
 913   read_name (tmp_char, infile);
 914
 915   tmp_code = UNKNOWN;
 916
 917   for (i = 0; i < NUM_RTX_CODE; i++)
 918     if (! strcmp (tmp_char, GET_RTX_NAME (i)))
 919       {
 920         tmp_code = (RTX_CODE) i;        /* get value for name */
 921         break;
 922       }
 923
 924   if (tmp_code == UNKNOWN)
 925     fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char);
 926
 927   /* (NIL) stands for an expression that isn't there.  */
 928   if (tmp_code == NIL)
 929     {
 930       /* Discard the closeparen.  */
 931       while ((c = getc (infile)) && c != ')')
 932         ;
 933
 934       return 0;
 935     }
 936
 937   /* If we end up with an insn expression then we free this space below.  */
 938   return_rtx = rtx_alloc (tmp_code);
 939   format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
 940
 941   /* If what follows is `: mode ', read it and
 942      store the mode in the rtx.  */
 943
 944   i = read_skip_spaces (infile);
 945   if (i == ':')
 946     {
 947       read_name (tmp_char, infile);
 948       for (j = 0; j < NUM_MACHINE_MODES; j++)
 949         if (! strcmp (GET_MODE_NAME (j), tmp_char))
 950           break;
 951
 952       if (j == MAX_MACHINE_MODE)
 953         fatal_with_file_and_line (infile, "unknown mode `%s'", tmp_char);
 954
 955       PUT_MODE (return_rtx, (enum machine_mode) j);
 956     }
 957   else
 958     ungetc (i, infile);
 959
 960   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
 961     switch (*format_ptr++)
 962       {
 963         /* 0 means a field for internal use only.
 964            Don't expect it to be present in the input.  */
 965       case '0':
 966         break;
 967
 968       case 'e':
 969       case 'u':
 970         XEXP (return_rtx, i) = read_rtx (infile);
 971         break;
 972
 973       case 'V':
 974         /* 'V' is an optional vector: if a closeparen follows,
 975            just store NULL for this element.  */
 976         c = read_skip_spaces (infile);
 977         ungetc (c, infile);
 978         if (c == ')')
 979           {
 980             XVEC (return_rtx, i) = 0;
 981             break;
 982           }
 983         /* Now process the vector.  */
 984
 985       case 'E':
 986         {
 987           register struct rtx_list *next_rtx, *rtx_list_link;
 988           struct rtx_list *list_rtx = NULL;
 989
 990           c = read_skip_spaces (infile);
 991           if (c != '[')
 992             fatal_expected_char (infile, '[', c);
 993
 994           /* add expressions to a list, while keeping a count */
 995           next_rtx = NULL;
 996           list_counter = 0;
 997           while ((c = read_skip_spaces (infile)) && c != ']')
 998             {
 999               ungetc (c, infile);
1000               list_counter++;
1001               rtx_list_link = (struct rtx_list *)
1002                 alloca (sizeof (struct rtx_list));
1003               rtx_list_link->value = read_rtx (infile);
1004               if (next_rtx == 0)
1005                 list_rtx = rtx_list_link;
1006               else
1007                 next_rtx->next = rtx_list_link;
1008               next_rtx = rtx_list_link;
1009               rtx_list_link->next = 0;
1010             }
1011           /* get vector length and allocate it */
1012           XVEC (return_rtx, i) = (list_counter
1013                                   ? rtvec_alloc (list_counter) : NULL_RTVEC);
1014           if (list_counter > 0)
1015             {
1016               next_rtx = list_rtx;
1017               for (j = 0; j < list_counter; j++,
1018                    next_rtx = next_rtx->next)
1019                 XVECEXP (return_rtx, i, j) = next_rtx->value;
1020             }
1021           /* close bracket gotten */
1022         }
1023         break;
1024
1025       case 'S':
1026         /* 'S' is an optional string: if a closeparen follows,
1027            just store NULL for this element.  */
1028         c = read_skip_spaces (infile);
1029         ungetc (c, infile);
1030         if (c == ')')
1031           {
1032             XSTR (return_rtx, i) = 0;
1033             break;
1034           }
1035
1036       case 's':
1037         {
1038           int saw_paren = 0;
1039           register char *stringbuf;
1040
1041           c = read_skip_spaces (infile);
1042           if (c == '(')
1043             {
1044               saw_paren = 1;
1045               c = read_skip_spaces (infile);
1046             }
1047           if (c != '"')
1048             fatal_expected_char (infile, '"', c);
1049
1050           while (1)
1051             {
1052               c = getc (infile); /* Read the string  */
1053               if (c == '\n')
1054                 read_rtx_lineno++;
1055               if (c == '\\')
1056                 {
1057                   c = getc (infile);    /* Read the string  */
1058                   /* \; makes stuff for a C string constant containing
1059                      newline and tab.  */
1060                   if (c == ';')
1061                     {
1062                       obstack_grow (rtl_obstack, "\\n\\t", 4);
1063                       continue;
1064                     }
1065                   if (c == '\n')
1066                     read_rtx_lineno++;
1067                 }
1068               else if (c == '"')
1069                 break;
1070
1071               obstack_1grow (rtl_obstack, c);
1072             }
1073
1074           obstack_1grow (rtl_obstack, 0);
1075           stringbuf = (char *) obstack_finish (rtl_obstack);
1076
1077           if (saw_paren)
1078             {
1079               c = read_skip_spaces (infile);
1080               if (c != ')')
1081                 fatal_expected_char (infile, ')', c);
1082             }
1083           XSTR (return_rtx, i) = stringbuf;
1084         }
1085         break;
1086
1087       case 'w':
1088         read_name (tmp_char, infile);
1089 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1090         tmp_wide = atoi (tmp_char);
1091 #else
1092 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1093         tmp_wide = atol (tmp_char);
1094 #else
1095         /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
1096            But prefer not to use our hand-rolled function above either.  */
1097 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1098         tmp_wide = atoll (tmp_char);
1099 #else
1100         tmp_wide = atoq (tmp_char);
1101 #endif
1102 #endif
1103 #endif
1104         XWINT (return_rtx, i) = tmp_wide;
1105         break;
1106
1107       case 'i':
1108       case 'n':
1109         read_name (tmp_char, infile);
1110         tmp_int = atoi (tmp_char);
1111         XINT (return_rtx, i) = tmp_int;
1112         break;
1113
1114       default:
1115         fprintf (stderr,
1116                  "switch format wrong in rtl.read_rtx(). format was: %c.\n",
1117                  format_ptr[-1]);
1118         fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
1119         abort ();
1120       }
1121
1122   c = read_skip_spaces (infile);
1123   if (c != ')')
1124     fatal_expected_char (infile, ')', c);
1125
1126   return return_rtx;
1127 }
1128
1129 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
1130 void
1131 rtl_check_failed_bounds (r, n, file, line, func)
1132     rtx r;
1133     int n;
1134     const char *file;
1135     int line;
1136     const char *func;
1137 {
1138   error ("RTL check: access of elt %d of `%s' with last elt %d",
1139          n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r))-1);
1140   fancy_abort (file, line, func);
1141 }
1142
1143 void
1144 rtl_check_failed_type1 (r, n, c1, file, line, func)
1145     rtx r;
1146     int n;
1147     int c1;
1148     const char *file;
1149     int line;
1150     const char *func;
1151 {
1152   error ("RTL check: expected elt %d type '%c', have '%c' (rtx %s)",
1153          n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)));
1154   fancy_abort (file, line, func);
1155 }
1156
1157 void
1158 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
1159     rtx r;
1160     int n;
1161     int c1;
1162     int c2;
1163     const char *file;
1164     int line;
1165     const char *func;
1166 {
1167   error ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)",
1168          n, c1, c2,
1169          GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE(r)));
1170   fancy_abort (file, line, func);
1171 }
1172
1173 void
1174 rtl_check_failed_code1 (r, code, file, line, func)
1175     rtx r;
1176     enum rtx_code code;
1177     const char *file;
1178     int line;
1179     const char *func;
1180 {
1181   error ("RTL check: expected code `%s', have `%s'",
1182          GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)));
1183   fancy_abort (file, line, func);
1184 }
1185
1186 void
1187 rtl_check_failed_code2 (r, code1, code2, file, line, func)
1188     rtx r;
1189     enum rtx_code code1, code2;
1190     const char *file;
1191     int line;
1192     const char *func;
1193 {
1194   error ("RTL check: expected code `%s' or `%s', have `%s'",
1195          GET_RTX_NAME (code1), GET_RTX_NAME (code2),
1196          GET_RTX_NAME (GET_CODE (r)));
1197   fancy_abort (file, line, func);
1198 }
1199
1200 /* XXX Maybe print the vector?  */
1201 void
1202 rtvec_check_failed_bounds (r, n, file, line, func)
1203     rtvec r;
1204     int n;
1205     const char *file;
1206     int line;
1207     const char *func;
1208 {
1209   error ("RTL check: access of elt %d of vector with last elt %d",
1210          n, GET_NUM_ELEM (r)-1);
1211   fancy_abort (file, line, func);
1212 }
1213 #endif /* ENABLE_RTL_CHECKING */
1214
1215 /* These are utility functions used by fatal-error functions all over the
1216    code.  rtl.c happens to be linked by all the programs that need them,
1217    so these are here.  In the future we want to break out all error handling
1218    to its own module.  */
1219
1220 /* Given a partial pathname as input, return another pathname that
1221    shares no directory elements with the pathname of __FILE__.  This
1222    is used by fancy_abort() to print `Internal compiler error in expr.c'
1223    instead of `Internal compiler error in ../../egcs/gcc/expr.c'.  */
1224 static const char *
1225 trim_filename (name)
1226      const char *name;
1227 {
1228   static const char this_file[] = __FILE__;
1229   const char *p = name, *q = this_file;
1230
1231   while (*p == *q && *p != 0 && *q != 0) p++, q++;
1232   while (p > name && p[-1] != DIR_SEPARATOR
1233 #ifdef DIR_SEPARATOR_2
1234          && p[-1] != DIR_SEPARATOR_2
1235 #endif
1236          )
1237     p--;
1238
1239   return p;
1240 }
1241
1242 /* Report an internal compiler error in a friendly manner and without
1243    dumping core.  */
1244
1245 void
1246 fancy_abort (file, line, function)
1247      const char *file;
1248      int line;
1249      const char *function;
1250 {
1251   if (function == NULL)
1252     function = "?";
1253   fatal (
1254 "Internal compiler error in `%s', at %s:%d\n\
1255 Please submit a full bug report.\n\
1256 See %s for instructions.",
1257          function, trim_filename (file), line, GCCBUGURL);
1258 }