gcc/rtl.c

   1 /* Allocate and read RTL for GNU C Compiler.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "real.h"
  26 #include "bitmap.h"
  27
  28 #include "obstack.h"
  29 #define obstack_chunk_alloc     xmalloc
  30 #define obstack_chunk_free      free
  31
  32 /* Obstack used for allocating RTL objects.
  33    Between functions, this is the permanent_obstack.
  34    While parsing and expanding a function, this is maybepermanent_obstack
  35    so we can save it if it is an inline function.
  36    During optimization and output, this is function_obstack.  */
  37
  38 extern struct obstack *rtl_obstack;
  39 \f
  40 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  41    Does NOT include rtx header data (code and links).
  42    This array is initialized in init_rtl.  */
  43
  44 int rtx_length[NUM_RTX_CODE + 1];
  45
  46 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
  47
  48 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
  49
  50 char *rtx_name[] = {
  51 #include "rtl.def"              /* rtl expressions are documented here */
  52 };
  53
  54 #undef DEF_RTL_EXPR
  55
  56 /* Indexed by machine mode, gives the name of that machine mode.
  57    This name does not include the letters "mode".  */
  58
  59 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  NAME,
  60
  61 char *mode_name[(int) MAX_MACHINE_MODE + 1] = {
  62 #include "machmode.def"
  63
  64 #ifdef EXTRA_CC_MODES
  65   EXTRA_CC_NAMES,
  66 #endif
  67   /* Add an extra field to avoid a core dump if someone tries to convert
  68      MAX_MACHINE_MODE to a string.   */
  69   ""
  70 };
  71
  72 #undef DEF_MACHMODE
  73
  74 /* Indexed by machine mode, gives the length of the mode, in bytes.
  75    GET_MODE_CLASS uses this.  */
  76
  77 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  CLASS,
  78
  79 enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
  80 #include "machmode.def"
  81 };
  82
  83 #undef DEF_MACHMODE
  84
  85 /* Indexed by machine mode, gives the length of the mode, in bytes.
  86    GET_MODE_SIZE uses this.  */
  87
  88 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  SIZE,
  89
  90 int mode_size[(int) MAX_MACHINE_MODE] = {
  91 #include "machmode.def"
  92 };
  93
  94 #undef DEF_MACHMODE
  95
  96 /* Indexed by machine mode, gives the length of the mode's subunit.
  97    GET_MODE_UNIT_SIZE uses this.  */
  98
  99 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  UNIT,
 100
 101 int mode_unit_size[(int) MAX_MACHINE_MODE] = {
 102 #include "machmode.def"         /* machine modes are documented here */
 103 };
 104
 105 #undef DEF_MACHMODE
 106
 107 /* Indexed by machine mode, gives next wider natural mode
 108    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
 109    use this.  */
 110
 111 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
 112   (unsigned char) WIDER,
 113
 114 unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
 115 #include "machmode.def"         /* machine modes are documented here */
 116 };
 117
 118 #undef DEF_MACHMODE
 119
 120 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
 121   ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1,
 122
 123 /* Indexed by machine mode, gives mask of significant bits in mode.  */
 124
 125 unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
 126 #include "machmode.def"
 127 };
 128
 129 /* Indexed by mode class, gives the narrowest mode for each class.  */
 130
 131 enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS];
 132
 133 /* Indexed by rtx code, gives a sequence of operand-types for
 134    rtx's of that code.  The sequence is a C string in which
 135    each character describes one operand.  */
 136
 137 char *rtx_format[] = {
 138   /* "*" undefined.
 139          can cause a warning message
 140      "0" field is unused (or used in a phase-dependent manner)
 141          prints nothing
 142      "i" an integer
 143          prints the integer
 144      "n" like "i", but prints entries from `note_insn_name'
 145      "w" an integer of width HOST_BITS_PER_WIDE_INT
 146          prints the integer
 147      "s" a pointer to a string
 148          prints the string
 149      "S" like "s", but optional:
 150          the containing rtx may end before this operand
 151      "e" a pointer to an rtl expression
 152          prints the expression
 153      "E" a pointer to a vector that points to a number of rtl expressions
 154          prints a list of the rtl expressions
 155      "V" like "E", but optional:
 156          the containing rtx may end before this operand
 157      "u" a pointer to another insn
 158          prints the uid of the insn.
 159      "b" is a pointer to a bitmap header.
 160      "t" is a tree pointer. */
 161
 162 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 163 #include "rtl.def"              /* rtl expressions are defined here */
 164 #undef DEF_RTL_EXPR
 165 };
 166
 167 /* Indexed by rtx code, gives a character representing the "class" of
 168    that rtx code.  See rtl.def for documentation on the defined classes.  */
 169
 170 char rtx_class[] = {
 171 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 172 #include "rtl.def"              /* rtl expressions are defined here */
 173 #undef DEF_RTL_EXPR
 174 };
 175
 176 /* Names for kinds of NOTEs and REG_NOTEs.  */
 177
 178 char *note_insn_name[] = { 0                    , "NOTE_INSN_DELETED",
 179                            "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 180                            "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 181                            "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
 182                            "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 183                            "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 184                            "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 185                            "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 186                            "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START",
 187                            "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
 188                            "NOTE_INSN_BASIC_BLOCK" };
 189
 190 char *reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
 191                           "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
 192                           "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
 193                           "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
 194                           "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 195                           "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA",
 196                           "REG_BR_PRED", "REG_EH_CONTEXT",
 197                           "REG_FRAME_RELATED_EXPR", "REG_EH_REGION",
 198                           "REG_EH_RETHROW" };
 199
 200 static void dump_and_abort      PROTO((int, int, FILE *)) ATTRIBUTE_NORETURN;
 201 static void read_name           PROTO((char *, FILE *));
 202 \f
 203 /* Allocate an rtx vector of N elements.
 204    Store the length, and initialize all elements to zero.  */
 205
 206 rtvec
 207 rtvec_alloc (n)
 208      int n;
 209 {
 210   rtvec rt;
 211   int i;
 212
 213   rt = (rtvec) obstack_alloc (rtl_obstack,
 214                               sizeof (struct rtvec_def)
 215                               + (( n - 1) * sizeof (rtunion)));
 216
 217   /* clear out the vector */
 218   PUT_NUM_ELEM (rt, n);
 219
 220   for (i = 0; i < n; i++)
 221     rt->elem[i].rtwint = 0;
 222
 223   return rt;
 224 }
 225
 226 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 227    all the rest is initialized to zero.  */
 228
 229 rtx
 230 rtx_alloc (code)
 231   RTX_CODE code;
 232 {
 233   rtx rt;
 234   register struct obstack *ob = rtl_obstack;
 235   register int nelts = GET_RTX_LENGTH (code);
 236   register int length = sizeof (struct rtx_def)
 237     + (nelts - 1) * sizeof (rtunion);
 238
 239   /* This function is called more than any other in GCC,
 240      so we manipulate the obstack directly.
 241
 242      Even though rtx objects are word aligned, we may be sharing an obstack
 243      with tree nodes, which may have to be double-word aligned.  So align
 244      our length to the alignment mask in the obstack.  */
 245
 246   length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
 247
 248   if (ob->chunk_limit - ob->next_free < length)
 249     _obstack_newchunk (ob, length);
 250   rt = (rtx)ob->object_base;
 251   ob->next_free += length;
 252   ob->object_base = ob->next_free;
 253
 254   /* We want to clear everything up to the FLD array.  Normally, this is
 255      one int, but we don't want to assume that and it isn't very portable
 256      anyway; this is.  */
 257
 258   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 259
 260   PUT_CODE (rt, code);
 261
 262   return rt;
 263 }
 264
 265 /* Free the rtx X and all RTL allocated since X.  */
 266
 267 void
 268 rtx_free (x)
 269      rtx x;
 270 {
 271   obstack_free (rtl_obstack, x);
 272 }
 273 \f
 274 /* Create a new copy of an rtx.
 275    Recursively copies the operands of the rtx,
 276    except for those few rtx codes that are sharable.  */
 277
 278 rtx
 279 copy_rtx (orig)
 280      register rtx orig;
 281 {
 282   register rtx copy;
 283   register int i, j;
 284   register RTX_CODE code;
 285   register char *format_ptr;
 286
 287   code = GET_CODE (orig);
 288
 289   switch (code)
 290     {
 291     case REG:
 292     case QUEUED:
 293     case CONST_INT:
 294     case CONST_DOUBLE:
 295     case SYMBOL_REF:
 296     case CODE_LABEL:
 297     case PC:
 298     case CC0:
 299     case SCRATCH:
 300       /* SCRATCH must be shared because they represent distinct values.  */
 301     case ADDRESSOF:
 302       return orig;
 303
 304     case CONST:
 305       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 306          a LABEL_REF, it isn't sharable.  */
 307       if (GET_CODE (XEXP (orig, 0)) == PLUS
 308           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 309           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 310         return orig;
 311       break;
 312
 313       /* A MEM with a constant address is not sharable.  The problem is that
 314          the constant address may need to be reloaded.  If the mem is shared,
 315          then reloading one copy of this mem will cause all copies to appear
 316          to have been reloaded.  */
 317
 318     default:
 319       break;
 320     }
 321
 322   copy = rtx_alloc (code);
 323
 324   /* Copy the various flags, and other information.  We assume that
 325      all fields need copying, and then clear the fields that should
 326      not be copied.  That is the sensible default behavior, and forces
 327      us to explicitly document why we are *not* copying a flag.  */
 328   bcopy (orig, copy, sizeof (struct rtx_def) - sizeof (rtunion));
 329
 330   /* We do not copy the USED flag, which is used as a mark bit during
 331      walks over the RTL.  */
 332   copy->used = 0;
 333
 334   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
 335   if (GET_RTX_CLASS (code) == 'i')
 336     {
 337       copy->jump = 0;
 338       copy->call = 0;
 339       copy->frame_related = 0;
 340     }
 341
 342   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 343
 344   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 345     {
 346       switch (*format_ptr++)
 347         {
 348         case 'e':
 349           XEXP (copy, i) = XEXP (orig, i);
 350           if (XEXP (orig, i) != NULL)
 351             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 352           break;
 353
 354         case '0':
 355         case 'u':
 356           XEXP (copy, i) = XEXP (orig, i);
 357           break;
 358
 359         case 'E':
 360         case 'V':
 361           XVEC (copy, i) = XVEC (orig, i);
 362           if (XVEC (orig, i) != NULL)
 363             {
 364               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 365               for (j = 0; j < XVECLEN (copy, i); j++)
 366                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 367             }
 368           break;
 369
 370         case 'b':
 371           {
 372             bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack);
 373             bitmap_copy (new_bits, XBITMAP (orig, i));
 374             XBITMAP (copy, i) = new_bits;
 375             break;
 376           }
 377
 378         case 't':
 379           XTREE (copy, i) = XTREE (orig, i);
 380           break;
 381
 382         case 'w':
 383           XWINT (copy, i) = XWINT (orig, i);
 384           break;
 385
 386         case 'i':
 387           XINT (copy, i) = XINT (orig, i);
 388           break;
 389
 390         case 's':
 391         case 'S':
 392           XSTR (copy, i) = XSTR (orig, i);
 393           break;
 394
 395         default:
 396           abort ();
 397         }
 398     }
 399   return copy;
 400 }
 401
 402 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 403    placed in the result directly, rather than being copied.  */
 404
 405 rtx
 406 copy_most_rtx (orig, may_share)
 407      register rtx orig;
 408      register rtx may_share;
 409 {
 410   register rtx copy;
 411   register int i, j;
 412   register RTX_CODE code;
 413   register char *format_ptr;
 414
 415   if (orig == may_share)
 416     return orig;
 417
 418   code = GET_CODE (orig);
 419
 420   switch (code)
 421     {
 422     case REG:
 423     case QUEUED:
 424     case CONST_INT:
 425     case CONST_DOUBLE:
 426     case SYMBOL_REF:
 427     case CODE_LABEL:
 428     case PC:
 429     case CC0:
 430       return orig;
 431     default:
 432       break;
 433     }
 434
 435   copy = rtx_alloc (code);
 436   PUT_MODE (copy, GET_MODE (orig));
 437   copy->in_struct = orig->in_struct;
 438   copy->volatil = orig->volatil;
 439   copy->unchanging = orig->unchanging;
 440   copy->integrated = orig->integrated;
 441
 442   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 443
 444   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 445     {
 446       switch (*format_ptr++)
 447         {
 448         case 'e':
 449           XEXP (copy, i) = XEXP (orig, i);
 450           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 451             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 452           break;
 453
 454         case '0':
 455         case 'u':
 456           XEXP (copy, i) = XEXP (orig, i);
 457           break;
 458
 459         case 'E':
 460         case 'V':
 461           XVEC (copy, i) = XVEC (orig, i);
 462           if (XVEC (orig, i) != NULL)
 463             {
 464               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 465               for (j = 0; j < XVECLEN (copy, i); j++)
 466                 XVECEXP (copy, i, j)
 467                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 468             }
 469           break;
 470
 471         case 'w':
 472           XWINT (copy, i) = XWINT (orig, i);
 473           break;
 474
 475         case 'n':
 476         case 'i':
 477           XINT (copy, i) = XINT (orig, i);
 478           break;
 479
 480         case 's':
 481         case 'S':
 482           XSTR (copy, i) = XSTR (orig, i);
 483           break;
 484
 485         default:
 486           abort ();
 487         }
 488     }
 489   return copy;
 490 }
 491 \f
 492 /* Subroutines of read_rtx.  */
 493
 494 /* Dump code after printing a message.  Used when read_rtx finds
 495    invalid data.  */
 496
 497 static void
 498 dump_and_abort (expected_c, actual_c, infile)
 499      int expected_c, actual_c;
 500      FILE *infile;
 501 {
 502   int c, i;
 503
 504   if (expected_c >= 0)
 505     fprintf (stderr,
 506              "Expected character %c.  Found character %c.",
 507              expected_c, actual_c);
 508   fprintf (stderr, "  At file position: %ld\n", ftell (infile));
 509   fprintf (stderr, "Following characters are:\n\t");
 510   for (i = 0; i < 200; i++)
 511     {
 512       c = getc (infile);
 513       if (EOF == c) break;
 514       putc (c, stderr);
 515     }
 516   fprintf (stderr, "Aborting.\n");
 517   abort ();
 518 }
 519
 520 /* Read chars from INFILE until a non-whitespace char
 521    and return that.  Comments, both Lisp style and C style,
 522    are treated as whitespace.
 523    Tools such as genflags use this function.  */
 524
 525 int
 526 read_skip_spaces (infile)
 527      FILE *infile;
 528 {
 529   register int c;
 530   while ((c = getc (infile)))
 531     {
 532       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
 533         ;
 534       else if (c == ';')
 535         {
 536           while ((c = getc (infile)) && c != '\n' && c != EOF)
 537             ;
 538         }
 539       else if (c == '/')
 540         {
 541           register int prevc;
 542           c = getc (infile);
 543           if (c != '*')
 544             dump_and_abort ('*', c, infile);
 545
 546           prevc = 0;
 547           while ((c = getc (infile)) && c != EOF)
 548             {
 549               if (prevc == '*' && c == '/')
 550                 break;
 551               prevc = c;
 552             }
 553         }
 554       else break;
 555     }
 556   return c;
 557 }
 558
 559 /* Read an rtx code name into the buffer STR[].
 560    It is terminated by any of the punctuation chars of rtx printed syntax.  */
 561
 562 static void
 563 read_name (str, infile)
 564      char *str;
 565      FILE *infile;
 566 {
 567   register char *p;
 568   register int c;
 569
 570   c = read_skip_spaces(infile);
 571
 572   p = str;
 573   while (1)
 574     {
 575       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
 576         break;
 577       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
 578           || c == '(' || c == '[')
 579         {
 580           ungetc (c, infile);
 581           break;
 582         }
 583       *p++ = c;
 584       c = getc (infile);
 585     }
 586   if (p == str)
 587     {
 588       fprintf (stderr, "missing name or number");
 589       dump_and_abort (-1, -1, infile);
 590     }
 591
 592   *p = 0;
 593 }
 594 \f
 595 /* Provide a version of a function to read a long long if the system does
 596    not provide one.  */
 597 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
 598 HOST_WIDE_INT
 599 atoll(p)
 600     const char *p;
 601 {
 602   int neg = 0;
 603   HOST_WIDE_INT tmp_wide;
 604
 605   while (ISSPACE(*p))
 606     p++;
 607   if (*p == '-')
 608     neg = 1, p++;
 609   else if (*p == '+')
 610     p++;
 611
 612   tmp_wide = 0;
 613   while (ISDIGIT(*p))
 614     {
 615       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
 616       if (new_wide < tmp_wide)
 617         {
 618           /* Return INT_MAX equiv on overflow.  */
 619           tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1;
 620           break;
 621         }
 622       tmp_wide = new_wide;
 623       p++;
 624     }
 625
 626   if (neg)
 627     tmp_wide = -tmp_wide;
 628   return tmp_wide;
 629 }
 630 #endif
 631
 632 /* Read an rtx in printed representation from INFILE
 633    and return an actual rtx in core constructed accordingly.
 634    read_rtx is not used in the compiler proper, but rather in
 635    the utilities gen*.c that construct C code from machine descriptions.  */
 636
 637 rtx
 638 read_rtx (infile)
 639      FILE *infile;
 640 {
 641   register int i, j, list_counter;
 642   RTX_CODE tmp_code;
 643   register char *format_ptr;
 644   /* tmp_char is a buffer used for reading decimal integers
 645      and names of rtx types and machine modes.
 646      Therefore, 256 must be enough.  */
 647   char tmp_char[256];
 648   rtx return_rtx;
 649   register int c;
 650   int tmp_int;
 651   HOST_WIDE_INT tmp_wide;
 652
 653   /* Linked list structure for making RTXs: */
 654   struct rtx_list
 655     {
 656       struct rtx_list *next;
 657       rtx value;                /* Value of this node...                */
 658     };
 659
 660   c = read_skip_spaces (infile); /* Should be open paren.  */
 661   if (c != '(')
 662     dump_and_abort ('(', c, infile);
 663
 664   read_name (tmp_char, infile);
 665
 666   tmp_code = UNKNOWN;
 667
 668   for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */
 669     {
 670       if (!(strcmp (tmp_char, GET_RTX_NAME (i))))
 671         {
 672           tmp_code = (RTX_CODE) i;      /* get value for name */
 673           break;
 674         }
 675     }
 676   if (tmp_code == UNKNOWN)
 677     {
 678       fprintf (stderr,
 679                "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
 680                tmp_char);
 681     }
 682   /* (NIL) stands for an expression that isn't there.  */
 683   if (tmp_code == NIL)
 684     {
 685       /* Discard the closeparen.  */
 686       while ((c = getc (infile)) && c != ')');
 687       return 0;
 688     }
 689
 690   return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression
 691                                        then we free this space below.  */
 692   format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
 693
 694   /* If what follows is `: mode ', read it and
 695      store the mode in the rtx.  */
 696
 697   i = read_skip_spaces (infile);
 698   if (i == ':')
 699     {
 700       register int k;
 701       read_name (tmp_char, infile);
 702       for (k = 0; k < NUM_MACHINE_MODES; k++)
 703         if (!strcmp (GET_MODE_NAME (k), tmp_char))
 704           break;
 705
 706       PUT_MODE (return_rtx, (enum machine_mode) k );
 707     }
 708   else
 709     ungetc (i, infile);
 710
 711   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
 712     switch (*format_ptr++)
 713       {
 714         /* 0 means a field for internal use only.
 715            Don't expect it to be present in the input.  */
 716       case '0':
 717         break;
 718
 719       case 'e':
 720       case 'u':
 721         XEXP (return_rtx, i) = read_rtx (infile);
 722         break;
 723
 724       case 'V':
 725         /* 'V' is an optional vector: if a closeparen follows,
 726            just store NULL for this element.  */
 727         c = read_skip_spaces (infile);
 728         ungetc (c, infile);
 729         if (c == ')')
 730           {
 731             XVEC (return_rtx, i) = 0;
 732             break;
 733           }
 734         /* Now process the vector.  */
 735
 736       case 'E':
 737         {
 738           register struct rtx_list *next_rtx, *rtx_list_link;
 739           struct rtx_list *list_rtx = NULL;
 740
 741           c = read_skip_spaces (infile);
 742           if (c != '[')
 743             dump_and_abort ('[', c, infile);
 744
 745           /* add expressions to a list, while keeping a count */
 746           next_rtx = NULL;
 747           list_counter = 0;
 748           while ((c = read_skip_spaces (infile)) && c != ']')
 749             {
 750               ungetc (c, infile);
 751               list_counter++;
 752               rtx_list_link = (struct rtx_list *)
 753                 alloca (sizeof (struct rtx_list));
 754               rtx_list_link->value = read_rtx (infile);
 755               if (next_rtx == 0)
 756                 list_rtx = rtx_list_link;
 757               else
 758                 next_rtx->next = rtx_list_link;
 759               next_rtx = rtx_list_link;
 760               rtx_list_link->next = 0;
 761             }
 762           /* get vector length and allocate it */
 763           XVEC (return_rtx, i) = (list_counter
 764                                   ? rtvec_alloc (list_counter) : NULL_RTVEC);
 765           if (list_counter > 0)
 766             {
 767               next_rtx = list_rtx;
 768               for (j = 0; j < list_counter; j++,
 769                    next_rtx = next_rtx->next)
 770                 XVECEXP (return_rtx, i, j) = next_rtx->value;
 771             }
 772           /* close bracket gotten */
 773         }
 774         break;
 775
 776       case 'S':
 777         /* 'S' is an optional string: if a closeparen follows,
 778            just store NULL for this element.  */
 779         c = read_skip_spaces (infile);
 780         ungetc (c, infile);
 781         if (c == ')')
 782           {
 783             XSTR (return_rtx, i) = 0;
 784             break;
 785           }
 786
 787       case 's':
 788         {
 789           int saw_paren = 0;
 790           register char *stringbuf;
 791
 792           c = read_skip_spaces (infile);
 793           if (c == '(')
 794             {
 795               saw_paren = 1;
 796               c = read_skip_spaces (infile);
 797             }
 798           if (c != '"')
 799             dump_and_abort ('"', c, infile);
 800
 801           while (1)
 802             {
 803               c = getc (infile); /* Read the string  */
 804               if (c == '\\')
 805                 {
 806                   c = getc (infile);    /* Read the string  */
 807                   /* \; makes stuff for a C string constant containing
 808                      newline and tab.  */
 809                   if (c == ';')
 810                     {
 811                       obstack_grow (rtl_obstack, "\\n\\t", 4);
 812                       continue;
 813                     }
 814                 }
 815               else if (c == '"')
 816                 break;
 817
 818               obstack_1grow (rtl_obstack, c);
 819             }
 820
 821           obstack_1grow (rtl_obstack, 0);
 822           stringbuf = (char *) obstack_finish (rtl_obstack);
 823
 824           if (saw_paren)
 825             {
 826               c = read_skip_spaces (infile);
 827               if (c != ')')
 828                 dump_and_abort (')', c, infile);
 829             }
 830           XSTR (return_rtx, i) = stringbuf;
 831         }
 832         break;
 833
 834       case 'w':
 835         read_name (tmp_char, infile);
 836 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 837         tmp_wide = atoi (tmp_char);
 838 #else
 839 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
 840         tmp_wide = atol (tmp_char);
 841 #else
 842         /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
 843            But prefer not to use our hand-rolled function above either.  */
 844 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
 845         tmp_wide = atoll (tmp_char);
 846 #else
 847         tmp_wide = atoq (tmp_char);
 848 #endif
 849 #endif
 850 #endif
 851         XWINT (return_rtx, i) = tmp_wide;
 852         break;
 853
 854       case 'i':
 855       case 'n':
 856         read_name (tmp_char, infile);
 857         tmp_int = atoi (tmp_char);
 858         XINT (return_rtx, i) = tmp_int;
 859         break;
 860
 861       default:
 862         fprintf (stderr,
 863                  "switch format wrong in rtl.read_rtx(). format was: %c.\n",
 864                  format_ptr[-1]);
 865         fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
 866         abort ();
 867       }
 868
 869   c = read_skip_spaces (infile);
 870   if (c != ')')
 871     dump_and_abort (')', c, infile);
 872
 873   return return_rtx;
 874 }
 875 \f
 876 /* This is called once per compilation, before any rtx's are constructed.
 877    It initializes the vector `rtx_length', the extra CC modes, if any,
 878    and computes certain commonly-used modes.  */
 879
 880 void
 881 init_rtl ()
 882 {
 883   int min_class_size[(int) MAX_MODE_CLASS];
 884   enum machine_mode mode;
 885   int i;
 886
 887   for (i = 0; i < NUM_RTX_CODE; i++)
 888     rtx_length[i] = strlen (rtx_format[i]);
 889
 890   /* Make CONST_DOUBLE bigger, if real values are bigger than
 891      it normally expects to have room for.
 892      Note that REAL_VALUE_TYPE is not defined by default,
 893      since tree.h is not included.  But the default dfn as `double'
 894      would do no harm.  */
 895 #ifdef REAL_VALUE_TYPE
 896   i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2;
 897   if (rtx_length[(int) CONST_DOUBLE] < i)
 898     {
 899       char *s = (char *) xmalloc (i + 1);
 900       rtx_length[(int) CONST_DOUBLE] = i;
 901       rtx_format[(int) CONST_DOUBLE] = s;
 902       *s++ = 'e';
 903       *s++ = '0';
 904       /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
 905          of as many `w's as we now have elements.  Subtract two from
 906          the size to account for the 'e' and the '0'.  */
 907       for (i = 2; i < rtx_length[(int) CONST_DOUBLE]; i++)
 908         *s++ = 'w';
 909       *s++ = 0;
 910     }
 911 #endif
 912
 913 #ifdef EXTRA_CC_MODES
 914   for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++)
 915     {
 916       mode_class[i] = MODE_CC;
 917       mode_mask_array[i] = mode_mask_array[(int) CCmode];
 918       mode_size[i] = mode_size[(int) CCmode];
 919       mode_unit_size[i] = mode_unit_size[(int) CCmode];
 920       mode_wider_mode[i - 1] = i;
 921       mode_wider_mode[i] = (unsigned char)VOIDmode;
 922     }
 923 #endif
 924
 925   /* Find the narrowest mode for each class.  */
 926
 927   for (i = 0; i < (int) MAX_MODE_CLASS; i++)
 928     min_class_size[i] = 1000;
 929
 930   for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
 931        mode = (enum machine_mode) ((int) mode + 1))
 932     {
 933       if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)])
 934         {
 935           class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode;
 936           min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode);
 937         }
 938     }
 939 }