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