1 /* Allocate and read RTL for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
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
35 /* Obstack used for allocating RTL objects.
36 Between functions, this is the permanent_obstack.
37 While parsing and expanding a function, this is maybepermanent_obstack
38 so we can save it if it is an inline function.
39 During optimization and output, this is function_obstack. */
41 extern struct obstack
*rtl_obstack
;
43 /* Calculate the format for CONST_DOUBLE. This depends on the relative
44 widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
46 We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
47 per element in REAL_VALUE_TYPE.
49 This is duplicated in gengenrtl.c.
51 A number of places assume that there are always at least two 'w'
52 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
54 #ifdef REAL_ARITHMETIC
55 #if LONG_DOUBLE_TYPE_SIZE == 96
56 #define REAL_WIDTH (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
57 #elif LONG_DOUBLE_TYPE_SIZE == 128
58 #define REAL_WIDTH (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
59 #elif HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
60 #define REAL_WIDTH (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
62 #endif /* REAL_ARITHMETIC */
65 #if HOST_BITS_PER_WIDE_INT*2 >= LONG_DOUBLE_TYPE_SIZE
67 #elif HOST_BITS_PER_WIDE_INT*3 >= LONG_DOUBLE_TYPE_SIZE
69 #elif HOST_BITS_PER_WIDE_INT*4 >= LONG_DOUBLE_TYPE_SIZE
72 #endif /* REAL_WIDTH */
75 #define CONST_DOUBLE_FORMAT "e0ww"
77 #define CONST_DOUBLE_FORMAT "e0ww"
79 #define CONST_DOUBLE_FORMAT "e0www"
81 #define CONST_DOUBLE_FORMAT "e0wwww"
83 #define CONST_DOUBLE_FORMAT "e0wwwww"
85 #define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
88 /* Indexed by rtx code, gives number of operands for an rtx with that code.
89 Does NOT include rtx header data (code and links). */
91 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
93 const int rtx_length
[NUM_RTX_CODE
+ 1] = {
99 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
101 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
103 const char * const rtx_name
[] = {
104 #include "rtl.def" /* rtl expressions are documented here */
109 /* Indexed by machine mode, gives the name of that machine mode.
110 This name does not include the letters "mode". */
112 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME,
114 const char * const mode_name
[(int) MAX_MACHINE_MODE
+ 1] = {
115 #include "machmode.def"
116 /* Add an extra field to avoid a core dump if someone tries to convert
117 MAX_MACHINE_MODE to a string. */
123 /* Indexed by machine mode, gives the length of the mode, in bytes.
124 GET_MODE_CLASS uses this. */
126 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS,
128 const enum mode_class mode_class
[(int) MAX_MACHINE_MODE
] = {
129 #include "machmode.def"
134 /* Indexed by machine mode, gives the length of the mode, in bytes.
135 GET_MODE_SIZE uses this. */
137 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE,
139 const int mode_size
[(int) MAX_MACHINE_MODE
] = {
140 #include "machmode.def"
145 /* Indexed by machine mode, gives the length of the mode's subunit.
146 GET_MODE_UNIT_SIZE uses this. */
148 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT,
150 const int mode_unit_size
[(int) MAX_MACHINE_MODE
] = {
151 #include "machmode.def" /* machine modes are documented here */
156 /* Indexed by machine mode, gives next wider natural mode
157 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
160 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
161 (unsigned char) WIDER,
163 const unsigned char mode_wider_mode
[(int) MAX_MACHINE_MODE
] = {
164 #include "machmode.def" /* machine modes are documented here */
169 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
170 ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1,
172 /* Indexed by machine mode, gives mask of significant bits in mode. */
174 const unsigned HOST_WIDE_INT mode_mask_array
[(int) MAX_MACHINE_MODE
] = {
175 #include "machmode.def"
178 /* Indexed by mode class, gives the narrowest mode for each class.
179 The Q modes are always of width 1 (2 for complex) - it is impossible
180 for any mode to be narrower. */
182 const enum machine_mode class_narrowest_mode
[(int) MAX_MODE_CLASS
] = {
183 /* MODE_RANDOM */ VOIDmode
,
184 /* MODE_INT */ QImode
,
185 /* MODE_FLOAT */ QFmode
,
186 /* MODE_PARTIAL_INT */ PQImode
,
187 /* MODE_CC */ CCmode
,
188 /* MODE_COMPLEX_INT */ CQImode
,
189 /* MODE_COMPLEX_FLOAT */ QCmode
193 /* Indexed by rtx code, gives a sequence of operand-types for
194 rtx's of that code. The sequence is a C string in which
195 each character describes one operand. */
197 const char * const rtx_format
[] = {
199 can cause a warning message
200 "0" field is unused (or used in a phase-dependent manner)
204 "n" like "i", but prints entries from `note_insn_name'
205 "w" an integer of width HOST_BITS_PER_WIDE_INT
207 "s" a pointer to a string
209 "S" like "s", but optional:
210 the containing rtx may end before this operand
211 "e" a pointer to an rtl expression
212 prints the expression
213 "E" a pointer to a vector that points to a number of rtl expressions
214 prints a list of the rtl expressions
215 "V" like "E", but optional:
216 the containing rtx may end before this operand
217 "u" a pointer to another insn
218 prints the uid of the insn.
219 "b" is a pointer to a bitmap header.
220 "t" is a tree pointer. */
222 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
223 #include "rtl.def" /* rtl expressions are defined here */
227 /* Indexed by rtx code, gives a character representing the "class" of
228 that rtx code. See rtl.def for documentation on the defined classes. */
230 const char rtx_class
[] = {
231 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
232 #include "rtl.def" /* rtl expressions are defined here */
236 /* Names for kinds of NOTEs and REG_NOTEs. */
238 const char * const note_insn_name
[] = { 0 , "NOTE_INSN_DELETED",
239 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
240 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
241 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
242 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
243 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
244 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
245 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
246 "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START",
247 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
248 "NOTE_INSN_BASIC_BLOCK" };
250 const char * const reg_note_name
[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
251 "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
252 "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
253 "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
254 "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
255 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA",
256 "REG_BR_PRED", "REG_EH_CONTEXT",
257 "REG_FRAME_RELATED_EXPR", "REG_EH_REGION",
258 "REG_EH_RETHROW", "REG_SAVE_NOTE" };
260 static void fatal_with_file_and_line
PARAMS ((FILE *, const char *, ...))
262 static void fatal_expected_char
PARAMS ((FILE *, int, int)) ATTRIBUTE_NORETURN
;
263 static void read_name
PARAMS ((char *, FILE *));
264 static const char *trim_filename
PARAMS ((const char *));
266 /* Allocate an rtx vector of N elements.
267 Store the length, and initialize all elements to zero. */
276 rt
= ggc_alloc_rtvec (n
);
281 rt
= (rtvec
) obstack_alloc (rtl_obstack
,
282 sizeof (struct rtvec_def
)
283 + (( n
- 1) * sizeof (rtx
)));
285 /* clear out the vector */
286 for (i
= 0; i
< n
; i
++)
290 PUT_NUM_ELEM (rt
, n
);
294 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
295 all the rest is initialized to zero. */
304 rt
= ggc_alloc_rtx (GET_RTX_LENGTH (code
));
307 register struct obstack
*ob
= rtl_obstack
;
308 register int nelts
= GET_RTX_LENGTH (code
);
309 register int length
= sizeof (struct rtx_def
)
310 + (nelts
- 1) * sizeof (rtunion
);
312 /* This function is called more than any other in GCC, so we
313 manipulate the obstack directly.
315 Even though rtx objects are word aligned, we may be sharing
316 an obstack with tree nodes, which may have to be double-word
317 aligned. So align our length to the alignment mask in the
320 length
= (length
+ ob
->alignment_mask
) & ~ ob
->alignment_mask
;
322 if (ob
->chunk_limit
- ob
->next_free
< length
)
323 _obstack_newchunk (ob
, length
);
324 rt
= (rtx
)ob
->object_base
;
325 ob
->next_free
+= length
;
326 ob
->object_base
= ob
->next_free
;
328 /* We want to clear everything up to the FLD array. Normally,
329 this is one int, but we don't want to assume that and it
330 isn't very portable anyway; this is. */
332 memset (rt
, 0, sizeof (struct rtx_def
) - sizeof (rtunion
));
339 /* Free the rtx X and all RTL allocated since X. */
346 obstack_free (rtl_obstack
, x
);
349 /* Create a new copy of an rtx.
350 Recursively copies the operands of the rtx,
351 except for those few rtx codes that are sharable. */
359 register RTX_CODE code
;
360 register const char *format_ptr
;
362 code
= GET_CODE (orig
);
375 /* SCRATCH must be shared because they represent distinct values. */
380 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
381 a LABEL_REF, it isn't sharable. */
382 if (GET_CODE (XEXP (orig
, 0)) == PLUS
383 && GET_CODE (XEXP (XEXP (orig
, 0), 0)) == SYMBOL_REF
384 && GET_CODE (XEXP (XEXP (orig
, 0), 1)) == CONST_INT
)
388 /* A MEM with a constant address is not sharable. The problem is that
389 the constant address may need to be reloaded. If the mem is shared,
390 then reloading one copy of this mem will cause all copies to appear
391 to have been reloaded. */
397 copy
= rtx_alloc (code
);
399 /* Copy the various flags, and other information. We assume that
400 all fields need copying, and then clear the fields that should
401 not be copied. That is the sensible default behavior, and forces
402 us to explicitly document why we are *not* copying a flag. */
403 memcpy (copy
, orig
, sizeof (struct rtx_def
) - sizeof (rtunion
));
405 /* We do not copy the USED flag, which is used as a mark bit during
406 walks over the RTL. */
409 /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
410 if (GET_RTX_CLASS (code
) == 'i')
414 copy
->frame_related
= 0;
417 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
419 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
421 copy
->fld
[i
] = orig
->fld
[i
];
422 switch (*format_ptr
++)
425 if (XEXP (orig
, i
) != NULL
)
426 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
431 if (XVEC (orig
, i
) != NULL
)
433 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
434 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
435 XVECEXP (copy
, i
, j
) = copy_rtx (XVECEXP (orig
, i
, j
));
441 bitmap new_bits
= BITMAP_OBSTACK_ALLOC (rtl_obstack
);
442 bitmap_copy (new_bits
, XBITMAP (orig
, i
));
443 XBITMAP (copy
, i
) = new_bits
;
454 /* These are left unchanged. */
464 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
465 placed in the result directly, rather than being copied. */
468 copy_most_rtx (orig
, may_share
)
470 register rtx may_share
;
474 register RTX_CODE code
;
475 register const char *format_ptr
;
477 if (orig
== may_share
)
480 code
= GET_CODE (orig
);
497 copy
= rtx_alloc (code
);
498 PUT_MODE (copy
, GET_MODE (orig
));
499 copy
->in_struct
= orig
->in_struct
;
500 copy
->volatil
= orig
->volatil
;
501 copy
->unchanging
= orig
->unchanging
;
502 copy
->integrated
= orig
->integrated
;
504 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
506 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
508 switch (*format_ptr
++)
511 XEXP (copy
, i
) = XEXP (orig
, i
);
512 if (XEXP (orig
, i
) != NULL
&& XEXP (orig
, i
) != may_share
)
513 XEXP (copy
, i
) = copy_most_rtx (XEXP (orig
, i
), may_share
);
517 XEXP (copy
, i
) = XEXP (orig
, i
);
522 XVEC (copy
, i
) = XVEC (orig
, i
);
523 if (XVEC (orig
, i
) != NULL
)
525 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
526 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
528 = copy_most_rtx (XVECEXP (orig
, i
, j
), may_share
);
533 XWINT (copy
, i
) = XWINT (orig
, i
);
538 XINT (copy
, i
) = XINT (orig
, i
);
542 XTREE (copy
, i
) = XTREE (orig
, i
);
547 XSTR (copy
, i
) = XSTR (orig
, i
);
551 /* Copy this through the wide int field; that's safest. */
552 X0WINT (copy
, i
) = X0WINT (orig
, i
);
562 /* Create a new copy of an rtx. Only copy just one level. */
564 shallow_copy_rtx (orig
)
568 register RTX_CODE code
= GET_CODE (orig
);
569 register rtx copy
= rtx_alloc (code
);
571 PUT_MODE (copy
, GET_MODE (orig
));
572 copy
->in_struct
= orig
->in_struct
;
573 copy
->volatil
= orig
->volatil
;
574 copy
->unchanging
= orig
->unchanging
;
575 copy
->integrated
= orig
->integrated
;
577 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
578 copy
->fld
[i
] = orig
->fld
[i
];
583 /* This is 1 until after the rtl generation pass. */
584 int rtx_equal_function_value_matters
;
586 /* Return 1 if X and Y are identical-looking rtx's.
587 This is the Lisp function EQUAL for rtx arguments. */
595 register enum rtx_code code
;
596 register const char *fmt
;
600 if (x
== 0 || y
== 0)
604 /* Rtx's of different codes cannot be equal. */
605 if (code
!= GET_CODE (y
))
608 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
609 (REG:SI x) and (REG:HI x) are NOT equivalent. */
611 if (GET_MODE (x
) != GET_MODE (y
))
614 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
617 /* Until rtl generation is complete, don't consider a reference to the
618 return register of the current function the same as the return from a
619 called function. This eases the job of function integration. Once the
620 distinction is no longer needed, they can be considered equivalent. */
621 return (REGNO (x
) == REGNO (y
)
622 && (! rtx_equal_function_value_matters
623 || REG_FUNCTION_VALUE_P (x
) == REG_FUNCTION_VALUE_P (y
)));
624 else if (code
== LABEL_REF
)
625 return XEXP (x
, 0) == XEXP (y
, 0);
626 else if (code
== SYMBOL_REF
)
627 return XSTR (x
, 0) == XSTR (y
, 0);
628 else if (code
== SCRATCH
|| code
== CONST_DOUBLE
)
631 /* Compare the elements. If any pair of corresponding elements
632 fail to match, return 0 for the whole things. */
634 fmt
= GET_RTX_FORMAT (code
);
635 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
640 if (XWINT (x
, i
) != XWINT (y
, i
))
646 if (XINT (x
, i
) != XINT (y
, i
))
652 /* Two vectors must have the same length. */
653 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
656 /* And the corresponding elements must match. */
657 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
658 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
663 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
669 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
674 /* These are just backpointers, so they don't matter. */
681 /* It is believed that rtx's at this level will never
682 contain anything but integers and other rtx's,
683 except for within LABEL_REFs and SYMBOL_REFs. */
691 /* Subroutines of read_rtx. */
693 /* The current line number for the file. */
694 int read_rtx_lineno
= 1;
696 /* The filename for aborting with file and line. */
697 const char *read_rtx_filename
= "<unknown>";
700 fatal_with_file_and_line
VPARAMS ((FILE *infile
, const char *msg
, ...))
702 #ifndef ANSI_PROTOTYPES
713 #ifndef ANSI_PROTOTYPES
714 infile
= va_arg (ap
, FILE *);
715 msg
= va_arg (ap
, const char *);
718 fprintf (stderr
, "%s:%d: ", read_rtx_filename
, read_rtx_lineno
);
719 vfprintf (stderr
, msg
, ap
);
722 /* Gather some following context. */
723 for (i
= 0; i
< sizeof(context
)-1; ++i
)
728 if (c
== '\r' || c
== '\n')
734 fprintf (stderr
, "%s:%d: following context is `%s'\n",
735 read_rtx_filename
, read_rtx_lineno
, context
);
741 /* Dump code after printing a message. Used when read_rtx finds
745 fatal_expected_char (infile
, expected_c
, actual_c
)
747 int expected_c
, actual_c
;
749 fatal_with_file_and_line (infile
, "expected character `%c', found `%c'",
750 expected_c
, actual_c
);
753 /* Read chars from INFILE until a non-whitespace char
754 and return that. Comments, both Lisp style and C style,
755 are treated as whitespace.
756 Tools such as genflags use this function. */
759 read_skip_spaces (infile
)
772 case ' ': case '\t': case '\f': case '\r':
778 while (c
!= '\n' && c
!= EOF
);
787 fatal_expected_char (infile
, '*', c
);
790 while ((c
= getc (infile
)) && c
!= EOF
)
794 else if (prevc
== '*' && c
== '/')
807 /* Read an rtx code name into the buffer STR[].
808 It is terminated by any of the punctuation chars of rtx printed syntax. */
811 read_name (str
, infile
)
818 c
= read_skip_spaces(infile
);
823 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f')
825 if (c
== ':' || c
== ')' || c
== ']' || c
== '"' || c
== '/'
826 || c
== '(' || c
== '[')
835 fatal_with_file_and_line (infile
, "missing name or number");
842 /* Provide a version of a function to read a long long if the system does
844 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
850 HOST_WIDE_INT tmp_wide
;
862 HOST_WIDE_INT new_wide
= tmp_wide
*10 + (*p
- '0');
863 if (new_wide
< tmp_wide
)
865 /* Return INT_MAX equiv on overflow. */
866 tmp_wide
= (~(unsigned HOST_WIDE_INT
)0) >> 1;
874 tmp_wide
= -tmp_wide
;
879 /* Read an rtx in printed representation from INFILE
880 and return an actual rtx in core constructed accordingly.
881 read_rtx is not used in the compiler proper, but rather in
882 the utilities gen*.c that construct C code from machine descriptions. */
888 register int i
, j
, list_counter
;
890 register const char *format_ptr
;
891 /* tmp_char is a buffer used for reading decimal integers
892 and names of rtx types and machine modes.
893 Therefore, 256 must be enough. */
898 HOST_WIDE_INT tmp_wide
;
900 /* Linked list structure for making RTXs: */
903 struct rtx_list
*next
;
904 rtx value
; /* Value of this node. */
907 c
= read_skip_spaces (infile
); /* Should be open paren. */
909 fatal_expected_char (infile
, '(', c
);
911 read_name (tmp_char
, infile
);
915 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
916 if (! strcmp (tmp_char
, GET_RTX_NAME (i
)))
918 tmp_code
= (RTX_CODE
) i
; /* get value for name */
922 if (tmp_code
== UNKNOWN
)
923 fatal_with_file_and_line (infile
, "unknown rtx code `%s'", tmp_char
);
925 /* (NIL) stands for an expression that isn't there. */
928 /* Discard the closeparen. */
929 while ((c
= getc (infile
)) && c
!= ')')
935 /* If we end up with an insn expression then we free this space below. */
936 return_rtx
= rtx_alloc (tmp_code
);
937 format_ptr
= GET_RTX_FORMAT (GET_CODE (return_rtx
));
939 /* If what follows is `: mode ', read it and
940 store the mode in the rtx. */
942 i
= read_skip_spaces (infile
);
945 read_name (tmp_char
, infile
);
946 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
947 if (! strcmp (GET_MODE_NAME (j
), tmp_char
))
950 if (j
== MAX_MACHINE_MODE
)
951 fatal_with_file_and_line (infile
, "unknown mode `%s'", tmp_char
);
953 PUT_MODE (return_rtx
, (enum machine_mode
) j
);
958 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (return_rtx
)); i
++)
959 switch (*format_ptr
++)
961 /* 0 means a field for internal use only.
962 Don't expect it to be present in the input. */
968 XEXP (return_rtx
, i
) = read_rtx (infile
);
972 /* 'V' is an optional vector: if a closeparen follows,
973 just store NULL for this element. */
974 c
= read_skip_spaces (infile
);
978 XVEC (return_rtx
, i
) = 0;
981 /* Now process the vector. */
985 register struct rtx_list
*next_rtx
, *rtx_list_link
;
986 struct rtx_list
*list_rtx
= NULL
;
988 c
= read_skip_spaces (infile
);
990 fatal_expected_char (infile
, '[', c
);
992 /* add expressions to a list, while keeping a count */
995 while ((c
= read_skip_spaces (infile
)) && c
!= ']')
999 rtx_list_link
= (struct rtx_list
*)
1000 alloca (sizeof (struct rtx_list
));
1001 rtx_list_link
->value
= read_rtx (infile
);
1003 list_rtx
= rtx_list_link
;
1005 next_rtx
->next
= rtx_list_link
;
1006 next_rtx
= rtx_list_link
;
1007 rtx_list_link
->next
= 0;
1009 /* get vector length and allocate it */
1010 XVEC (return_rtx
, i
) = (list_counter
1011 ? rtvec_alloc (list_counter
) : NULL_RTVEC
);
1012 if (list_counter
> 0)
1014 next_rtx
= list_rtx
;
1015 for (j
= 0; j
< list_counter
; j
++,
1016 next_rtx
= next_rtx
->next
)
1017 XVECEXP (return_rtx
, i
, j
) = next_rtx
->value
;
1019 /* close bracket gotten */
1024 /* 'S' is an optional string: if a closeparen follows,
1025 just store NULL for this element. */
1026 c
= read_skip_spaces (infile
);
1030 XSTR (return_rtx
, i
) = 0;
1037 register char *stringbuf
;
1039 c
= read_skip_spaces (infile
);
1043 c
= read_skip_spaces (infile
);
1046 fatal_expected_char (infile
, '"', c
);
1050 c
= getc (infile
); /* Read the string */
1055 c
= getc (infile
); /* Read the string */
1056 /* \; makes stuff for a C string constant containing
1060 obstack_grow (rtl_obstack
, "\\n\\t", 4);
1069 obstack_1grow (rtl_obstack
, c
);
1072 obstack_1grow (rtl_obstack
, 0);
1073 stringbuf
= (char *) obstack_finish (rtl_obstack
);
1077 c
= read_skip_spaces (infile
);
1079 fatal_expected_char (infile
, ')', c
);
1081 XSTR (return_rtx
, i
) = stringbuf
;
1086 read_name (tmp_char
, infile
);
1087 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1088 tmp_wide
= atoi (tmp_char
);
1090 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1091 tmp_wide
= atol (tmp_char
);
1093 /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
1094 But prefer not to use our hand-rolled function above either. */
1095 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1096 tmp_wide
= atoll (tmp_char
);
1098 tmp_wide
= atoq (tmp_char
);
1102 XWINT (return_rtx
, i
) = tmp_wide
;
1107 read_name (tmp_char
, infile
);
1108 tmp_int
= atoi (tmp_char
);
1109 XINT (return_rtx
, i
) = tmp_int
;
1114 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
1116 fprintf (stderr
, "\tfile position: %ld\n", ftell (infile
));
1120 c
= read_skip_spaces (infile
);
1122 fatal_expected_char (infile
, ')', c
);
1127 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
1129 rtl_check_failed_bounds (r
, n
, file
, line
, func
)
1136 error ("RTL check: access of elt %d of `%s' with last elt %d",
1137 n
, GET_RTX_NAME (GET_CODE (r
)), GET_RTX_LENGTH (GET_CODE (r
))-1);
1138 fancy_abort (file
, line
, func
);
1142 rtl_check_failed_type1 (r
, n
, c1
, file
, line
, func
)
1150 error ("RTL check: expected elt %d type '%c', have '%c' (rtx %s)",
1151 n
, c1
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)));
1152 fancy_abort (file
, line
, func
);
1156 rtl_check_failed_type2 (r
, n
, c1
, c2
, file
, line
, func
)
1165 error ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)",
1167 GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE(r
)));
1168 fancy_abort (file
, line
, func
);
1172 rtl_check_failed_code1 (r
, code
, file
, line
, func
)
1179 error ("RTL check: expected code `%s', have `%s'",
1180 GET_RTX_NAME (code
), GET_RTX_NAME (GET_CODE (r
)));
1181 fancy_abort (file
, line
, func
);
1185 rtl_check_failed_code2 (r
, code1
, code2
, file
, line
, func
)
1187 enum rtx_code code1
, code2
;
1192 error ("RTL check: expected code `%s' or `%s', have `%s'",
1193 GET_RTX_NAME (code1
), GET_RTX_NAME (code2
),
1194 GET_RTX_NAME (GET_CODE (r
)));
1195 fancy_abort (file
, line
, func
);
1198 /* XXX Maybe print the vector? */
1200 rtvec_check_failed_bounds (r
, n
, file
, line
, func
)
1207 error ("RTL check: access of elt %d of vector with last elt %d",
1208 n
, GET_NUM_ELEM (r
)-1);
1209 fancy_abort (file
, line
, func
);
1211 #endif /* ENABLE_RTL_CHECKING */
1213 /* These are utility functions used by fatal-error functions all over the
1214 code. rtl.c happens to be linked by all the programs that need them,
1215 so these are here. In the future we want to break out all error handling
1216 to its own module. */
1218 /* Given a partial pathname as input, return another pathname that
1219 shares no directory elements with the pathname of __FILE__. This
1220 is used by fancy_abort() to print `Internal compiler error in expr.c'
1221 instead of `Internal compiler error in ../../egcs/gcc/expr.c'. */
1223 trim_filename (name
)
1226 static const char this_file
[] = __FILE__
;
1227 const char *p
= name
, *q
= this_file
;
1229 while (*p
== *q
&& *p
!= 0 && *q
!= 0) p
++, q
++;
1230 while (p
> name
&& p
[-1] != DIR_SEPARATOR
1231 #ifdef DIR_SEPARATOR_2
1232 && p
[-1] != DIR_SEPARATOR_2
1240 /* Report an internal compiler error in a friendly manner and without
1244 fancy_abort (file
, line
, function
)
1247 const char *function
;
1249 if (function
== NULL
)
1252 "Internal compiler error in `%s', at %s:%d\n\
1253 Please submit a full bug report.\n\
1254 See <URL:http://www.gnu.org/software/gcc/faq.html#bugreport> \
1256 function
, trim_filename (file
), line
);