1 /* Allocate and read RTL for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #define obstack_chunk_alloc xmalloc
33 #define obstack_chunk_free free
36 #define DIR_SEPARATOR '/'
39 /* Obstack used for allocating RTL objects.
40 Between functions, this is the permanent_obstack.
41 While parsing and expanding a function, this is maybepermanent_obstack
42 so we can save it if it is an inline function.
43 During optimization and output, this is function_obstack. */
45 extern struct obstack *rtl_obstack;
47 /* Calculate the format for CONST_DOUBLE. This depends on the relative
48 widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
50 We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
51 per element in REAL_VALUE_TYPE.
53 This is duplicated in gengenrtl.c.
55 A number of places assume that there are always at least two 'w'
56 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
58 #ifdef REAL_ARITHMETIC
59 #if LONG_DOUBLE_TYPE_SIZE == 96
60 #define REAL_WIDTH (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
61 #elif LONG_DOUBLE_TYPE_SIZE == 128
62 #define REAL_WIDTH (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
63 #elif HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
64 #define REAL_WIDTH (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
66 #endif /* REAL_ARITHMETIC */
69 #if HOST_BITS_PER_WIDE_INT*2 >= LONG_DOUBLE_TYPE_SIZE
71 #elif HOST_BITS_PER_WIDE_INT*3 >= LONG_DOUBLE_TYPE_SIZE
73 #elif HOST_BITS_PER_WIDE_INT*4 >= LONG_DOUBLE_TYPE_SIZE
76 #endif /* REAL_WIDTH */
79 #define CONST_DOUBLE_FORMAT "e0ww"
81 #define CONST_DOUBLE_FORMAT "e0ww"
83 #define CONST_DOUBLE_FORMAT "e0www"
85 #define CONST_DOUBLE_FORMAT "e0wwww"
87 #define CONST_DOUBLE_FORMAT "e0wwwww"
89 #define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
92 /* Indexed by rtx code, gives number of operands for an rtx with that code.
93 Does NOT include rtx header data (code and links). */
95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
97 const int rtx_length[NUM_RTX_CODE + 1] = {
103 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
105 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
107 const char * const rtx_name[] = {
108 #include "rtl.def" /* rtl expressions are documented here */
113 /* Indexed by machine mode, gives the name of that machine mode.
114 This name does not include the letters "mode". */
116 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME,
118 const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
119 #include "machmode.def"
120 /* Add an extra field to avoid a core dump if someone tries to convert
121 MAX_MACHINE_MODE to a string. */
127 /* Indexed by machine mode, gives the length of the mode, in bytes.
128 GET_MODE_CLASS uses this. */
130 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS,
132 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
133 #include "machmode.def"
138 /* Indexed by machine mode, gives the length of the mode, in bytes.
139 GET_MODE_SIZE uses this. */
141 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE,
143 const int mode_size[(int) MAX_MACHINE_MODE] = {
144 #include "machmode.def"
149 /* Indexed by machine mode, gives the length of the mode's subunit.
150 GET_MODE_UNIT_SIZE uses this. */
152 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT,
154 const int mode_unit_size[(int) MAX_MACHINE_MODE] = {
155 #include "machmode.def" /* machine modes are documented here */
160 /* Indexed by machine mode, gives next wider natural mode
161 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
164 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
165 (unsigned char) WIDER,
167 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
168 #include "machmode.def" /* machine modes are documented here */
173 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
174 ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1,
176 /* Indexed by machine mode, gives mask of significant bits in mode. */
178 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
179 #include "machmode.def"
182 /* Indexed by mode class, gives the narrowest mode for each class.
183 The Q modes are always of width 1 (2 for complex) - it is impossible
184 for any mode to be narrower. */
186 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
187 /* MODE_RANDOM */ VOIDmode,
188 /* MODE_INT */ QImode,
189 /* MODE_FLOAT */ QFmode,
190 /* MODE_PARTIAL_INT */ PQImode,
191 /* MODE_CC */ CCmode,
192 /* MODE_COMPLEX_INT */ CQImode,
193 /* MODE_COMPLEX_FLOAT */ QCmode
197 /* Indexed by rtx code, gives a sequence of operand-types for
198 rtx's of that code. The sequence is a C string in which
199 each character describes one operand. */
201 const char * const rtx_format[] = {
203 can cause a warning message
204 "0" field is unused (or used in a phase-dependent manner)
208 "n" like "i", but prints entries from `note_insn_name'
209 "w" an integer of width HOST_BITS_PER_WIDE_INT
211 "s" a pointer to a string
213 "S" like "s", but optional:
214 the containing rtx may end before this operand
215 "e" a pointer to an rtl expression
216 prints the expression
217 "E" a pointer to a vector that points to a number of rtl expressions
218 prints a list of the rtl expressions
219 "V" like "E", but optional:
220 the containing rtx may end before this operand
221 "u" a pointer to another insn
222 prints the uid of the insn.
223 "b" is a pointer to a bitmap header.
224 "t" is a tree pointer. */
226 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
227 #include "rtl.def" /* rtl expressions are defined here */
231 /* Indexed by rtx code, gives a character representing the "class" of
232 that rtx code. See rtl.def for documentation on the defined classes. */
234 const char rtx_class[] = {
235 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
236 #include "rtl.def" /* rtl expressions are defined here */
240 /* Names for kinds of NOTEs and REG_NOTEs. */
242 const char * const note_insn_name[] = { 0 , "NOTE_INSN_DELETED",
243 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
244 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
245 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
246 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
247 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
248 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
249 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
250 "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START",
251 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
252 "NOTE_INSN_BASIC_BLOCK" };
254 const char * const reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
255 "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
256 "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
257 "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
258 "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
259 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA",
260 "REG_BR_PRED", "REG_EH_CONTEXT",
261 "REG_FRAME_RELATED_EXPR", "REG_EH_REGION",
262 "REG_EH_RETHROW", "REG_SAVE_NOTE" };
264 static void fatal_with_file_and_line PVPROTO((FILE *, const char *, ...))
266 static void fatal_expected_char PROTO((FILE *, int, int)) ATTRIBUTE_NORETURN;
267 static void read_name PROTO((char *, FILE *));
268 static const char *trim_filename PROTO((const char *));
270 /* Allocate an rtx vector of N elements.
271 Store the length, and initialize all elements to zero. */
280 rt = ggc_alloc_rtvec (n);
285 rt = (rtvec) obstack_alloc (rtl_obstack,
286 sizeof (struct rtvec_def)
287 + (( n - 1) * sizeof (rtx)));
289 /* clear out the vector */
290 for (i = 0; i < n; i++)
294 PUT_NUM_ELEM (rt, n);
298 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
299 all the rest is initialized to zero. */
308 rt = ggc_alloc_rtx (GET_RTX_LENGTH (code));
311 register struct obstack *ob = rtl_obstack;
312 register int nelts = GET_RTX_LENGTH (code);
313 register int length = sizeof (struct rtx_def)
314 + (nelts - 1) * sizeof (rtunion);
316 /* This function is called more than any other in GCC, so we
317 manipulate the obstack directly.
319 Even though rtx objects are word aligned, we may be sharing
320 an obstack with tree nodes, which may have to be double-word
321 aligned. So align our length to the alignment mask in the
324 length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
326 if (ob->chunk_limit - ob->next_free < length)
327 _obstack_newchunk (ob, length);
328 rt = (rtx)ob->object_base;
329 ob->next_free += length;
330 ob->object_base = ob->next_free;
332 /* We want to clear everything up to the FLD array. Normally,
333 this is one int, but we don't want to assume that and it
334 isn't very portable anyway; this is. */
336 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
343 /* Free the rtx X and all RTL allocated since X. */
350 obstack_free (rtl_obstack, x);
353 /* Create a new copy of an rtx.
354 Recursively copies the operands of the rtx,
355 except for those few rtx codes that are sharable. */
363 register RTX_CODE code;
364 register const char *format_ptr;
366 code = GET_CODE (orig);
379 /* SCRATCH must be shared because they represent distinct values. */
384 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
385 a LABEL_REF, it isn't sharable. */
386 if (GET_CODE (XEXP (orig, 0)) == PLUS
387 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
388 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
392 /* A MEM with a constant address is not sharable. The problem is that
393 the constant address may need to be reloaded. If the mem is shared,
394 then reloading one copy of this mem will cause all copies to appear
395 to have been reloaded. */
401 copy = rtx_alloc (code);
403 /* Copy the various flags, and other information. We assume that
404 all fields need copying, and then clear the fields that should
405 not be copied. That is the sensible default behavior, and forces
406 us to explicitly document why we are *not* copying a flag. */
407 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
409 /* We do not copy the USED flag, which is used as a mark bit during
410 walks over the RTL. */
413 /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
414 if (GET_RTX_CLASS (code) == 'i')
418 copy->frame_related = 0;
421 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
423 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
425 copy->fld[i] = orig->fld[i];
426 switch (*format_ptr++)
429 if (XEXP (orig, i) != NULL)
430 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
435 if (XVEC (orig, i) != NULL)
437 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
438 for (j = 0; j < XVECLEN (copy, i); j++)
439 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
445 bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack);
446 bitmap_copy (new_bits, XBITMAP (orig, i));
447 XBITMAP (copy, i) = new_bits;
458 /* These are left unchanged. */
468 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
469 placed in the result directly, rather than being copied. */
472 copy_most_rtx (orig, may_share)
474 register rtx may_share;
478 register RTX_CODE code;
479 register const char *format_ptr;
481 if (orig == may_share)
484 code = GET_CODE (orig);
501 copy = rtx_alloc (code);
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;
508 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
510 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
512 switch (*format_ptr++)
515 XEXP (copy, i) = XEXP (orig, i);
516 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
517 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
521 XEXP (copy, i) = XEXP (orig, i);
526 XVEC (copy, i) = XVEC (orig, i);
527 if (XVEC (orig, i) != NULL)
529 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
530 for (j = 0; j < XVECLEN (copy, i); j++)
532 = copy_most_rtx (XVECEXP (orig, i, j), may_share);
537 XWINT (copy, i) = XWINT (orig, i);
542 XINT (copy, i) = XINT (orig, i);
546 XTREE (copy, i) = XTREE (orig, i);
551 XSTR (copy, i) = XSTR (orig, i);
555 /* Copy this through the wide int field; that's safest. */
556 X0WINT (copy, i) = X0WINT (orig, i);
566 /* Create a new copy of an rtx. Only copy just one level. */
568 shallow_copy_rtx (orig)
572 register RTX_CODE code = GET_CODE (orig);
573 register rtx copy = rtx_alloc (code);
575 PUT_MODE (copy, GET_MODE (orig));
576 copy->in_struct = orig->in_struct;
577 copy->volatil = orig->volatil;
578 copy->unchanging = orig->unchanging;
579 copy->integrated = orig->integrated;
581 for (i = 0; i < GET_RTX_LENGTH (code); i++)
582 copy->fld[i] = orig->fld[i];
587 /* This is 1 until after the rtl generation pass. */
588 int rtx_equal_function_value_matters;
590 /* Return 1 if X and Y are identical-looking rtx's.
591 This is the Lisp function EQUAL for rtx arguments. */
599 register enum rtx_code code;
600 register const char *fmt;
604 if (x == 0 || y == 0)
608 /* Rtx's of different codes cannot be equal. */
609 if (code != GET_CODE (y))
612 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
613 (REG:SI x) and (REG:HI x) are NOT equivalent. */
615 if (GET_MODE (x) != GET_MODE (y))
618 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
621 /* Until rtl generation is complete, don't consider a reference to the
622 return register of the current function the same as the return from a
623 called function. This eases the job of function integration. Once the
624 distinction is no longer needed, they can be considered equivalent. */
625 return (REGNO (x) == REGNO (y)
626 && (! rtx_equal_function_value_matters
627 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
628 else if (code == LABEL_REF)
629 return XEXP (x, 0) == XEXP (y, 0);
630 else if (code == SYMBOL_REF)
631 return XSTR (x, 0) == XSTR (y, 0);
632 else if (code == SCRATCH || code == CONST_DOUBLE)
635 /* Compare the elements. If any pair of corresponding elements
636 fail to match, return 0 for the whole things. */
638 fmt = GET_RTX_FORMAT (code);
639 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
644 if (XWINT (x, i) != XWINT (y, i))
650 if (XINT (x, i) != XINT (y, i))
656 /* Two vectors must have the same length. */
657 if (XVECLEN (x, i) != XVECLEN (y, i))
660 /* And the corresponding elements must match. */
661 for (j = 0; j < XVECLEN (x, i); j++)
662 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
667 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
673 if (strcmp (XSTR (x, i), XSTR (y, i)))
678 /* These are just backpointers, so they don't matter. */
685 /* It is believed that rtx's at this level will never
686 contain anything but integers and other rtx's,
687 except for within LABEL_REFs and SYMBOL_REFs. */
695 /* Subroutines of read_rtx. */
697 /* The current line number for the file. */
698 int read_rtx_lineno = 1;
700 /* The filename for aborting with file and line. */
701 const char *read_rtx_filename = "<unknown>";
704 fatal_with_file_and_line VPROTO((FILE *infile, const char *msg, ...))
706 #ifndef ANSI_PROTOTYPES
717 #ifndef ANSI_PROTOTYPES
718 infile = va_arg (ap, FILE *);
719 msg = va_arg (ap, const char *);
722 fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
723 vfprintf (stderr, msg, ap);
726 /* Gather some following context. */
727 for (i = 0; i < sizeof(context)-1; ++i)
732 if (c == '\r' || c == '\n')
738 fprintf (stderr, "%s:%d: following context is `%s'\n",
739 read_rtx_filename, read_rtx_lineno, context);
745 /* Dump code after printing a message. Used when read_rtx finds
749 fatal_expected_char (infile, expected_c, actual_c)
751 int expected_c, actual_c;
753 fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
754 expected_c, actual_c);
757 /* Read chars from INFILE until a non-whitespace char
758 and return that. Comments, both Lisp style and C style,
759 are treated as whitespace.
760 Tools such as genflags use this function. */
763 read_skip_spaces (infile)
776 case ' ': case '\t': case '\f': case '\r':
782 while (c != '\n' && c != EOF);
791 fatal_expected_char (infile, '*', c);
794 while ((c = getc (infile)) && c != EOF)
798 else if (prevc == '*' && c == '/')
811 /* Read an rtx code name into the buffer STR[].
812 It is terminated by any of the punctuation chars of rtx printed syntax. */
815 read_name (str, infile)
822 c = read_skip_spaces(infile);
827 if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
829 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
830 || c == '(' || c == '[')
839 fatal_with_file_and_line (infile, "missing name or number");
846 /* Provide a version of a function to read a long long if the system does
848 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
854 HOST_WIDE_INT tmp_wide;
866 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
867 if (new_wide < tmp_wide)
869 /* Return INT_MAX equiv on overflow. */
870 tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1;
878 tmp_wide = -tmp_wide;
883 /* Read an rtx in printed representation from INFILE
884 and return an actual rtx in core constructed accordingly.
885 read_rtx is not used in the compiler proper, but rather in
886 the utilities gen*.c that construct C code from machine descriptions. */
892 register int i, j, list_counter;
894 register const char *format_ptr;
895 /* tmp_char is a buffer used for reading decimal integers
896 and names of rtx types and machine modes.
897 Therefore, 256 must be enough. */
902 HOST_WIDE_INT tmp_wide;
904 /* Linked list structure for making RTXs: */
907 struct rtx_list *next;
908 rtx value; /* Value of this node. */
911 c = read_skip_spaces (infile); /* Should be open paren. */
913 fatal_expected_char (infile, '(', c);
915 read_name (tmp_char, infile);
919 for (i = 0; i < NUM_RTX_CODE; i++)
920 if (! strcmp (tmp_char, GET_RTX_NAME (i)))
922 tmp_code = (RTX_CODE) i; /* get value for name */
926 if (tmp_code == UNKNOWN)
927 fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char);
929 /* (NIL) stands for an expression that isn't there. */
932 /* Discard the closeparen. */
933 while ((c = getc (infile)) && c != ')')
939 /* If we end up with an insn expression then we free this space below. */
940 return_rtx = rtx_alloc (tmp_code);
941 format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
943 /* If what follows is `: mode ', read it and
944 store the mode in the rtx. */
946 i = read_skip_spaces (infile);
949 read_name (tmp_char, infile);
950 for (j = 0; j < NUM_MACHINE_MODES; j++)
951 if (! strcmp (GET_MODE_NAME (j), tmp_char))
954 if (j == MAX_MACHINE_MODE)
955 fatal_with_file_and_line (infile, "unknown mode `%s'", tmp_char);
957 PUT_MODE (return_rtx, (enum machine_mode) j);
962 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
963 switch (*format_ptr++)
965 /* 0 means a field for internal use only.
966 Don't expect it to be present in the input. */
972 XEXP (return_rtx, i) = read_rtx (infile);
976 /* 'V' is an optional vector: if a closeparen follows,
977 just store NULL for this element. */
978 c = read_skip_spaces (infile);
982 XVEC (return_rtx, i) = 0;
985 /* Now process the vector. */
989 register struct rtx_list *next_rtx, *rtx_list_link;
990 struct rtx_list *list_rtx = NULL;
992 c = read_skip_spaces (infile);
994 fatal_expected_char (infile, '[', c);
996 /* add expressions to a list, while keeping a count */
999 while ((c = read_skip_spaces (infile)) && c != ']')
1003 rtx_list_link = (struct rtx_list *)
1004 alloca (sizeof (struct rtx_list));
1005 rtx_list_link->value = read_rtx (infile);
1007 list_rtx = rtx_list_link;
1009 next_rtx->next = rtx_list_link;
1010 next_rtx = rtx_list_link;
1011 rtx_list_link->next = 0;
1013 /* get vector length and allocate it */
1014 XVEC (return_rtx, i) = (list_counter
1015 ? rtvec_alloc (list_counter) : NULL_RTVEC);
1016 if (list_counter > 0)
1018 next_rtx = list_rtx;
1019 for (j = 0; j < list_counter; j++,
1020 next_rtx = next_rtx->next)
1021 XVECEXP (return_rtx, i, j) = next_rtx->value;
1023 /* close bracket gotten */
1028 /* 'S' is an optional string: if a closeparen follows,
1029 just store NULL for this element. */
1030 c = read_skip_spaces (infile);
1034 XSTR (return_rtx, i) = 0;
1041 register char *stringbuf;
1043 c = read_skip_spaces (infile);
1047 c = read_skip_spaces (infile);
1050 fatal_expected_char (infile, '"', c);
1054 c = getc (infile); /* Read the string */
1059 c = getc (infile); /* Read the string */
1060 /* \; makes stuff for a C string constant containing
1064 obstack_grow (rtl_obstack, "\\n\\t", 4);
1073 obstack_1grow (rtl_obstack, c);
1076 obstack_1grow (rtl_obstack, 0);
1077 stringbuf = (char *) obstack_finish (rtl_obstack);
1081 c = read_skip_spaces (infile);
1083 fatal_expected_char (infile, ')', c);
1085 XSTR (return_rtx, i) = stringbuf;
1090 read_name (tmp_char, infile);
1091 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1092 tmp_wide = atoi (tmp_char);
1094 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1095 tmp_wide = atol (tmp_char);
1097 /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
1098 But prefer not to use our hand-rolled function above either. */
1099 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1100 tmp_wide = atoll (tmp_char);
1102 tmp_wide = atoq (tmp_char);
1106 XWINT (return_rtx, i) = tmp_wide;
1111 read_name (tmp_char, infile);
1112 tmp_int = atoi (tmp_char);
1113 XINT (return_rtx, i) = tmp_int;
1118 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
1120 fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
1124 c = read_skip_spaces (infile);
1126 fatal_expected_char (infile, ')', c);
1131 #if defined ENABLE_CHECKING && HAVE_GCC_VERSION(2,7)
1133 rtl_check_failed_bounds (r, n, file, line, func)
1140 error ("RTL check: access of elt %d of `%s' with last elt %d",
1141 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r))-1);
1142 fancy_abort (file, line, func);
1146 rtl_check_failed_type1 (r, n, c1, file, line, func)
1154 error ("RTL check: expected elt %d type '%c', have '%c' (rtx %s)",
1155 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)));
1156 fancy_abort (file, line, func);
1160 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
1169 error ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)",
1171 GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE(r)));
1172 fancy_abort (file, line, func);
1176 rtl_check_failed_code1 (r, code, file, line, func)
1183 error ("RTL check: expected code `%s', have `%s'",
1184 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)));
1185 fancy_abort (file, line, func);
1189 rtl_check_failed_code2 (r, code1, code2, file, line, func)
1191 enum rtx_code code1, code2;
1196 error ("RTL check: expected code `%s' or `%s', have `%s'",
1197 GET_RTX_NAME (code1), GET_RTX_NAME (code2),
1198 GET_RTX_NAME (GET_CODE (r)));
1199 fancy_abort (file, line, func);
1202 /* XXX Maybe print the vector? */
1204 rtvec_check_failed_bounds (r, n, file, line, func)
1211 error ("RTL check: access of elt %d of vector with last elt %d",
1212 n, GET_NUM_ELEM (r)-1);
1213 fancy_abort (file, line, func);
1215 #endif /* ENABLE_CHECKING */
1217 /* These are utility functions used by fatal-error functions all over the
1218 code. rtl.c happens to be linked by all the programs that need them,
1219 so these are here. In the future we want to break out all error handling
1220 to its own module. */
1222 /* Given a partial pathname as input, return another pathname that
1223 shares no directory elements with the pathname of __FILE__. This
1224 is used by fancy_abort() to print `Internal compiler error in expr.c'
1225 instead of `Internal compiler error in ../../egcs/gcc/expr.c'. */
1227 trim_filename (name)
1230 static const char this_file[] = __FILE__;
1231 const char *p = name, *q = this_file;
1233 while (*p == *q && *p != 0 && *q != 0) p++, q++;
1234 while (p > name && p[-1] != DIR_SEPARATOR
1235 #ifdef DIR_SEPARATOR_2
1236 && p[-1] != DIR_SEPARATOR_2
1244 /* Report an internal compiler error in a friendly manner and without
1248 fancy_abort (file, line, function)
1251 const char *function;
1253 if (function == NULL)
1256 "Internal compiler error in `%s', at %s:%d\n\
1257 Please submit a full bug report.\n\
1258 See <URL:http://www.gnu.org/software/gcc/faq.html#bugreport> \
1260 function, trim_filename (file), line);