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 (rtx)));
 216
 217   /* clear out the vector */
 218   PUT_NUM_ELEM (rt, n);
 219
 220   for (i = 0; i < n; i++)
 221     rt->elem[i] = 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   memcpy (copy, orig, 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 't':
 481           XTREE (copy, i) = XTREE (orig, i);
 482           break;
 483
 484         case 's':
 485         case 'S':
 486           XSTR (copy, i) = XSTR (orig, i);
 487           break;
 488
 489         default:
 490           abort ();
 491         }
 492     }
 493   return copy;
 494 }
 495
 496 /* Create a new copy of an rtx.  Only copy just one level.  */
 497 rtx
 498 shallow_copy_rtx (orig)
 499      rtx orig;
 500 {
 501   register int i;
 502   register RTX_CODE code = GET_CODE (orig);
 503   register rtx copy = rtx_alloc (code);
 504
 505   PUT_MODE (copy, GET_MODE (orig));
 506   copy->in_struct = orig->in_struct;
 507   copy->volatil = orig->volatil;
 508   copy->unchanging = orig->unchanging;
 509   copy->integrated = orig->integrated;
 510
 511   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 512     copy->fld[i] = orig->fld[i];
 513
 514   return copy;
 515 }
 516 \f
 517 /* Subroutines of read_rtx.  */
 518
 519 /* Dump code after printing a message.  Used when read_rtx finds
 520    invalid data.  */
 521
 522 static void
 523 dump_and_abort (expected_c, actual_c, infile)
 524      int expected_c, actual_c;
 525      FILE *infile;
 526 {
 527   int c, i;
 528
 529   if (expected_c >= 0)
 530     fprintf (stderr,
 531              "Expected character %c.  Found character %c.",
 532              expected_c, actual_c);
 533   fprintf (stderr, "  At file position: %ld\n", ftell (infile));
 534   fprintf (stderr, "Following characters are:\n\t");
 535   for (i = 0; i < 200; i++)
 536     {
 537       c = getc (infile);
 538       if (EOF == c) break;
 539       putc (c, stderr);
 540     }
 541   fprintf (stderr, "Aborting.\n");
 542   abort ();
 543 }
 544
 545 /* Read chars from INFILE until a non-whitespace char
 546    and return that.  Comments, both Lisp style and C style,
 547    are treated as whitespace.
 548    Tools such as genflags use this function.  */
 549
 550 int
 551 read_skip_spaces (infile)
 552      FILE *infile;
 553 {
 554   register int c;
 555   while ((c = getc (infile)))
 556     {
 557       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
 558         ;
 559       else if (c == ';')
 560         {
 561           while ((c = getc (infile)) && c != '\n' && c != EOF)
 562             ;
 563         }
 564       else if (c == '/')
 565         {
 566           register int prevc;
 567           c = getc (infile);
 568           if (c != '*')
 569             dump_and_abort ('*', c, infile);
 570
 571           prevc = 0;
 572           while ((c = getc (infile)) && c != EOF)
 573             {
 574               if (prevc == '*' && c == '/')
 575                 break;
 576               prevc = c;
 577             }
 578         }
 579       else break;
 580     }
 581   return c;
 582 }
 583
 584 /* Read an rtx code name into the buffer STR[].
 585    It is terminated by any of the punctuation chars of rtx printed syntax.  */
 586
 587 static void
 588 read_name (str, infile)
 589      char *str;
 590      FILE *infile;
 591 {
 592   register char *p;
 593   register int c;
 594
 595   c = read_skip_spaces(infile);
 596
 597   p = str;
 598   while (1)
 599     {
 600       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
 601         break;
 602       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
 603           || c == '(' || c == '[')
 604         {
 605           ungetc (c, infile);
 606           break;
 607         }
 608       *p++ = c;
 609       c = getc (infile);
 610     }
 611   if (p == str)
 612     {
 613       fprintf (stderr, "missing name or number");
 614       dump_and_abort (-1, -1, infile);
 615     }
 616
 617   *p = 0;
 618 }
 619 \f
 620 /* Provide a version of a function to read a long long if the system does
 621    not provide one.  */
 622 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
 623 HOST_WIDE_INT
 624 atoll(p)
 625     const char *p;
 626 {
 627   int neg = 0;
 628   HOST_WIDE_INT tmp_wide;
 629
 630   while (ISSPACE(*p))
 631     p++;
 632   if (*p == '-')
 633     neg = 1, p++;
 634   else if (*p == '+')
 635     p++;
 636
 637   tmp_wide = 0;
 638   while (ISDIGIT(*p))
 639     {
 640       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
 641       if (new_wide < tmp_wide)
 642         {
 643           /* Return INT_MAX equiv on overflow.  */
 644           tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1;
 645           break;
 646         }
 647       tmp_wide = new_wide;
 648       p++;
 649     }
 650
 651   if (neg)
 652     tmp_wide = -tmp_wide;
 653   return tmp_wide;
 654 }
 655 #endif
 656
 657 /* Read an rtx in printed representation from INFILE
 658    and return an actual rtx in core constructed accordingly.
 659    read_rtx is not used in the compiler proper, but rather in
 660    the utilities gen*.c that construct C code from machine descriptions.  */
 661
 662 rtx
 663 read_rtx (infile)
 664      FILE *infile;
 665 {
 666   register int i, j, list_counter;
 667   RTX_CODE tmp_code;
 668   register char *format_ptr;
 669   /* tmp_char is a buffer used for reading decimal integers
 670      and names of rtx types and machine modes.
 671      Therefore, 256 must be enough.  */
 672   char tmp_char[256];
 673   rtx return_rtx;
 674   register int c;
 675   int tmp_int;
 676   HOST_WIDE_INT tmp_wide;
 677
 678   /* Linked list structure for making RTXs: */
 679   struct rtx_list
 680     {
 681       struct rtx_list *next;
 682       rtx value;                /* Value of this node...                */
 683     };
 684
 685   c = read_skip_spaces (infile); /* Should be open paren.  */
 686   if (c != '(')
 687     dump_and_abort ('(', c, infile);
 688
 689   read_name (tmp_char, infile);
 690
 691   tmp_code = UNKNOWN;
 692
 693   for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */
 694     {
 695       if (!(strcmp (tmp_char, GET_RTX_NAME (i))))
 696         {
 697           tmp_code = (RTX_CODE) i;      /* get value for name */
 698           break;
 699         }
 700     }
 701   if (tmp_code == UNKNOWN)
 702     {
 703       fprintf (stderr,
 704                "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
 705                tmp_char);
 706     }
 707   /* (NIL) stands for an expression that isn't there.  */
 708   if (tmp_code == NIL)
 709     {
 710       /* Discard the closeparen.  */
 711       while ((c = getc (infile)) && c != ')');
 712       return 0;
 713     }
 714
 715   return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression
 716                                        then we free this space below.  */
 717   format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
 718
 719   /* If what follows is `: mode ', read it and
 720      store the mode in the rtx.  */
 721
 722   i = read_skip_spaces (infile);
 723   if (i == ':')
 724     {
 725       register int k;
 726       read_name (tmp_char, infile);
 727       for (k = 0; k < NUM_MACHINE_MODES; k++)
 728         if (!strcmp (GET_MODE_NAME (k), tmp_char))
 729           break;
 730
 731       PUT_MODE (return_rtx, (enum machine_mode) k );
 732     }
 733   else
 734     ungetc (i, infile);
 735
 736   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
 737     switch (*format_ptr++)
 738       {
 739         /* 0 means a field for internal use only.
 740            Don't expect it to be present in the input.  */
 741       case '0':
 742         break;
 743
 744       case 'e':
 745       case 'u':
 746         XEXP (return_rtx, i) = read_rtx (infile);
 747         break;
 748
 749       case 'V':
 750         /* 'V' is an optional vector: if a closeparen follows,
 751            just store NULL for this element.  */
 752         c = read_skip_spaces (infile);
 753         ungetc (c, infile);
 754         if (c == ')')
 755           {
 756             XVEC (return_rtx, i) = 0;
 757             break;
 758           }
 759         /* Now process the vector.  */
 760
 761       case 'E':
 762         {
 763           register struct rtx_list *next_rtx, *rtx_list_link;
 764           struct rtx_list *list_rtx = NULL;
 765
 766           c = read_skip_spaces (infile);
 767           if (c != '[')
 768             dump_and_abort ('[', c, infile);
 769
 770           /* add expressions to a list, while keeping a count */
 771           next_rtx = NULL;
 772           list_counter = 0;
 773           while ((c = read_skip_spaces (infile)) && c != ']')
 774             {
 775               ungetc (c, infile);
 776               list_counter++;
 777               rtx_list_link = (struct rtx_list *)
 778                 alloca (sizeof (struct rtx_list));
 779               rtx_list_link->value = read_rtx (infile);
 780               if (next_rtx == 0)
 781                 list_rtx = rtx_list_link;
 782               else
 783                 next_rtx->next = rtx_list_link;
 784               next_rtx = rtx_list_link;
 785               rtx_list_link->next = 0;
 786             }
 787           /* get vector length and allocate it */
 788           XVEC (return_rtx, i) = (list_counter
 789                                   ? rtvec_alloc (list_counter) : NULL_RTVEC);
 790           if (list_counter > 0)
 791             {
 792               next_rtx = list_rtx;
 793               for (j = 0; j < list_counter; j++,
 794                    next_rtx = next_rtx->next)
 795                 XVECEXP (return_rtx, i, j) = next_rtx->value;
 796             }
 797           /* close bracket gotten */
 798         }
 799         break;
 800
 801       case 'S':
 802         /* 'S' is an optional string: if a closeparen follows,
 803            just store NULL for this element.  */
 804         c = read_skip_spaces (infile);
 805         ungetc (c, infile);
 806         if (c == ')')
 807           {
 808             XSTR (return_rtx, i) = 0;
 809             break;
 810           }
 811
 812       case 's':
 813         {
 814           int saw_paren = 0;
 815           register char *stringbuf;
 816
 817           c = read_skip_spaces (infile);
 818           if (c == '(')
 819             {
 820               saw_paren = 1;
 821               c = read_skip_spaces (infile);
 822             }
 823           if (c != '"')
 824             dump_and_abort ('"', c, infile);
 825
 826           while (1)
 827             {
 828               c = getc (infile); /* Read the string  */
 829               if (c == '\\')
 830                 {
 831                   c = getc (infile);    /* Read the string  */
 832                   /* \; makes stuff for a C string constant containing
 833                      newline and tab.  */
 834                   if (c == ';')
 835                     {
 836                       obstack_grow (rtl_obstack, "\\n\\t", 4);
 837                       continue;
 838                     }
 839                 }
 840               else if (c == '"')
 841                 break;
 842
 843               obstack_1grow (rtl_obstack, c);
 844             }
 845
 846           obstack_1grow (rtl_obstack, 0);
 847           stringbuf = (char *) obstack_finish (rtl_obstack);
 848
 849           if (saw_paren)
 850             {
 851               c = read_skip_spaces (infile);
 852               if (c != ')')
 853                 dump_and_abort (')', c, infile);
 854             }
 855           XSTR (return_rtx, i) = stringbuf;
 856         }
 857         break;
 858
 859       case 'w':
 860         read_name (tmp_char, infile);
 861 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 862         tmp_wide = atoi (tmp_char);
 863 #else
 864 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
 865         tmp_wide = atol (tmp_char);
 866 #else
 867         /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
 868            But prefer not to use our hand-rolled function above either.  */
 869 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
 870         tmp_wide = atoll (tmp_char);
 871 #else
 872         tmp_wide = atoq (tmp_char);
 873 #endif
 874 #endif
 875 #endif
 876         XWINT (return_rtx, i) = tmp_wide;
 877         break;
 878
 879       case 'i':
 880       case 'n':
 881         read_name (tmp_char, infile);
 882         tmp_int = atoi (tmp_char);
 883         XINT (return_rtx, i) = tmp_int;
 884         break;
 885
 886       default:
 887         fprintf (stderr,
 888                  "switch format wrong in rtl.read_rtx(). format was: %c.\n",
 889                  format_ptr[-1]);
 890         fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
 891         abort ();
 892       }
 893
 894   c = read_skip_spaces (infile);
 895   if (c != ')')
 896     dump_and_abort (')', c, infile);
 897
 898   return return_rtx;
 899 }
 900 \f
 901 /* This is called once per compilation, before any rtx's are constructed.
 902    It initializes the vector `rtx_length', the extra CC modes, if any,
 903    and computes certain commonly-used modes.  */
 904
 905 void
 906 init_rtl ()
 907 {
 908   int min_class_size[(int) MAX_MODE_CLASS];
 909   enum machine_mode mode;
 910   int i;
 911
 912   for (i = 0; i < NUM_RTX_CODE; i++)
 913     rtx_length[i] = strlen (rtx_format[i]);
 914
 915   /* Make CONST_DOUBLE bigger, if real values are bigger than
 916      it normally expects to have room for.
 917      Note that REAL_VALUE_TYPE is not defined by default,
 918      since tree.h is not included.  But the default dfn as `double'
 919      would do no harm.  */
 920 #ifdef REAL_VALUE_TYPE
 921   i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2;
 922   if (rtx_length[(int) CONST_DOUBLE] < i)
 923     {
 924       char *s = (char *) xmalloc (i + 1);
 925       rtx_length[(int) CONST_DOUBLE] = i;
 926       rtx_format[(int) CONST_DOUBLE] = s;
 927       *s++ = 'e';
 928       *s++ = '0';
 929       /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
 930          of as many `w's as we now have elements.  Subtract two from
 931          the size to account for the 'e' and the '0'.  */
 932       for (i = 2; i < rtx_length[(int) CONST_DOUBLE]; i++)
 933         *s++ = 'w';
 934       *s++ = 0;
 935     }
 936 #endif
 937
 938 #ifdef EXTRA_CC_MODES
 939   for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++)
 940     {
 941       mode_class[i] = MODE_CC;
 942       mode_mask_array[i] = mode_mask_array[(int) CCmode];
 943       mode_size[i] = mode_size[(int) CCmode];
 944       mode_unit_size[i] = mode_unit_size[(int) CCmode];
 945       mode_wider_mode[i - 1] = i;
 946       mode_wider_mode[i] = (unsigned char)VOIDmode;
 947     }
 948 #endif
 949
 950   /* Find the narrowest mode for each class.  */
 951
 952   for (i = 0; i < (int) MAX_MODE_CLASS; i++)
 953     min_class_size[i] = 1000;
 954
 955   for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
 956        mode = (enum machine_mode) ((int) mode + 1))
 957     {
 958       if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)])
 959         {
 960           class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode;
 961           min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode);
 962         }
 963     }
 964 }