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