Mark ChangeLog
[official-gcc.git] / gcc / rtl.c
blob3a5a4876c5bdc2b69c3268767d1a54c2c8127b07
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)
10 any later version.
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. */
23 #include "config.h"
24 #include "system.h"
25 #include "rtl.h"
26 #include "real.h"
27 #include "bitmap.h"
28 #include "ggc.h"
29 #include "obstack.h"
30 #include "toplev.h"
31 #include "hashtab.h"
33 #define obstack_chunk_alloc xmalloc
34 #define obstack_chunk_free free
37 /* Calculate the format for CONST_DOUBLE. This depends on the relative
38 widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
40 We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
41 per element in REAL_VALUE_TYPE.
43 This is duplicated in gengenrtl.c.
45 A number of places assume that there are always at least two 'w'
46 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
48 #ifdef REAL_ARITHMETIC
49 # if MAX_LONG_DOUBLE_TYPE_SIZE == 96
50 # define REAL_WIDTH \
51 (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
52 # else
53 # if MAX_LONG_DOUBLE_TYPE_SIZE == 128
54 # define REAL_WIDTH \
55 (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
56 # else
57 # if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
58 # define REAL_WIDTH \
59 (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
60 # endif
61 # endif
62 # endif
63 #endif /* REAL_ARITHMETIC */
65 #ifndef REAL_WIDTH
66 # if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
67 # define REAL_WIDTH 2
68 # else
69 # if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
70 # define REAL_WIDTH 3
71 # else
72 # if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
73 # define REAL_WIDTH 4
74 # endif
75 # endif
76 # endif
77 #endif /* REAL_WIDTH */
79 #if REAL_WIDTH == 1
80 # define CONST_DOUBLE_FORMAT "e0ww"
81 #else
82 # if REAL_WIDTH == 2
83 # define CONST_DOUBLE_FORMAT "e0ww"
84 # else
85 # if REAL_WIDTH == 3
86 # define CONST_DOUBLE_FORMAT "e0www"
87 # else
88 # if REAL_WIDTH == 4
89 # define CONST_DOUBLE_FORMAT "e0wwww"
90 # else
91 # if REAL_WIDTH == 5
92 # define CONST_DOUBLE_FORMAT "e0wwwww"
93 # else
94 # define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
95 # endif
96 # endif
97 # endif
98 # endif
99 #endif
101 /* Indexed by rtx code, gives number of operands for an rtx with that code.
102 Does NOT include rtx header data (code and links). */
104 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
106 const int rtx_length[NUM_RTX_CODE + 1] = {
107 #include "rtl.def"
110 #undef DEF_RTL_EXPR
112 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
114 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
116 const char * const rtx_name[] = {
117 #include "rtl.def" /* rtl expressions are documented here */
120 #undef DEF_RTL_EXPR
122 /* Indexed by machine mode, gives the name of that machine mode.
123 This name does not include the letters "mode". */
125 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) NAME,
127 const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
128 #include "machmode.def"
129 /* Add an extra field to avoid a core dump if someone tries to convert
130 MAX_MACHINE_MODE to a string. */
134 #undef DEF_MACHMODE
136 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */
138 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) CLASS,
140 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
141 #include "machmode.def"
144 #undef DEF_MACHMODE
146 /* Indexed by machine mode, gives the length of the mode, in bits.
147 GET_MODE_BITSIZE uses this. */
149 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) BITSIZE,
151 const unsigned int mode_bitsize[(int) MAX_MACHINE_MODE] = {
152 #include "machmode.def"
155 #undef DEF_MACHMODE
157 /* Indexed by machine mode, gives the length of the mode, in bytes.
158 GET_MODE_SIZE uses this. */
160 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) SIZE,
162 const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
163 #include "machmode.def"
166 #undef DEF_MACHMODE
168 /* Indexed by machine mode, gives the length of the mode's subunit.
169 GET_MODE_UNIT_SIZE uses this. */
171 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) UNIT,
173 const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
174 #include "machmode.def" /* machine modes are documented here */
177 #undef DEF_MACHMODE
179 /* Indexed by machine mode, gives next wider natural mode
180 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
181 use this. */
183 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) \
184 (unsigned char) WIDER,
186 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
187 #include "machmode.def" /* machine modes are documented here */
190 #undef DEF_MACHMODE
192 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) \
193 ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
195 /* Indexed by machine mode, gives mask of significant bits in mode. */
197 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
198 #include "machmode.def"
201 /* Indexed by mode class, gives the narrowest mode for each class.
202 The Q modes are always of width 1 (2 for complex) - it is impossible
203 for any mode to be narrower.
205 Note that we use QImode instead of BImode for MODE_INT, since
206 otherwise the middle end will try to use it for bitfields in
207 structures and the like, which we do not want. Only the target
208 md file should generate BImode widgets. */
210 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
211 /* MODE_RANDOM */ VOIDmode,
212 /* MODE_INT */ QImode,
213 /* MODE_FLOAT */ QFmode,
214 /* MODE_PARTIAL_INT */ PQImode,
215 /* MODE_CC */ CCmode,
216 /* MODE_COMPLEX_INT */ CQImode,
217 /* MODE_COMPLEX_FLOAT */ QCmode,
218 /* MODE_VECTOR_INT */ V2QImode,
219 /* MODE_VECTOR_FLOAT */ V2SFmode
223 /* Indexed by rtx code, gives a sequence of operand-types for
224 rtx's of that code. The sequence is a C string in which
225 each character describes one operand. */
227 const char * const rtx_format[] = {
228 /* "*" undefined.
229 can cause a warning message
230 "0" field is unused (or used in a phase-dependent manner)
231 prints nothing
232 "i" an integer
233 prints the integer
234 "n" like "i", but prints entries from `note_insn_name'
235 "w" an integer of width HOST_BITS_PER_WIDE_INT
236 prints the integer
237 "s" a pointer to a string
238 prints the string
239 "S" like "s", but optional:
240 the containing rtx may end before this operand
241 "e" a pointer to an rtl expression
242 prints the expression
243 "E" a pointer to a vector that points to a number of rtl expressions
244 prints a list of the rtl expressions
245 "V" like "E", but optional:
246 the containing rtx may end before this operand
247 "u" a pointer to another insn
248 prints the uid of the insn.
249 "b" is a pointer to a bitmap header.
250 "t" is a tree pointer. */
252 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
253 #include "rtl.def" /* rtl expressions are defined here */
254 #undef DEF_RTL_EXPR
257 /* Indexed by rtx code, gives a character representing the "class" of
258 that rtx code. See rtl.def for documentation on the defined classes. */
260 const char rtx_class[] = {
261 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
262 #include "rtl.def" /* rtl expressions are defined here */
263 #undef DEF_RTL_EXPR
266 /* Names for kinds of NOTEs and REG_NOTEs. */
268 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
270 "", "NOTE_INSN_DELETED",
271 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
272 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
273 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
274 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
275 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
276 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
277 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
278 "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
279 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
280 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
283 const char * const reg_note_name[] =
285 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
286 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
287 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
288 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
289 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
290 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
291 "REG_EH_RETHROW", "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
292 "REG_NON_LOCAL_GOTO"
295 static htab_t md_constants;
297 static void fatal_with_file_and_line PARAMS ((FILE *, const char *, ...))
298 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
299 static void fatal_expected_char PARAMS ((FILE *, int, int)) ATTRIBUTE_NORETURN;
300 static void read_name PARAMS ((char *, FILE *));
301 static unsigned def_hash PARAMS ((const void *));
302 static int def_name_eq_p PARAMS ((const void *, const void *));
303 static void read_constants PARAMS ((FILE *infile, char *tmp_char));
306 /* Allocate an rtx vector of N elements.
307 Store the length, and initialize all elements to zero. */
309 rtvec
310 rtvec_alloc (n)
311 int n;
313 rtvec rt;
315 rt = ggc_alloc_rtvec (n);
316 /* clear out the vector */
317 memset (&rt->elem[0], 0, n * sizeof (rtx));
319 PUT_NUM_ELEM (rt, n);
320 return rt;
323 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
324 all the rest is initialized to zero. */
327 rtx_alloc (code)
328 RTX_CODE code;
330 rtx rt;
331 int n = GET_RTX_LENGTH (code);
333 rt = ggc_alloc_rtx (n);
335 /* We want to clear everything up to the FLD array. Normally, this
336 is one int, but we don't want to assume that and it isn't very
337 portable anyway; this is. */
339 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
340 PUT_CODE (rt, code);
341 return rt;
345 /* Create a new copy of an rtx.
346 Recursively copies the operands of the rtx,
347 except for those few rtx codes that are sharable. */
350 copy_rtx (orig)
351 register rtx orig;
353 register rtx copy;
354 register int i, j;
355 register RTX_CODE code;
356 register const char *format_ptr;
358 code = GET_CODE (orig);
360 switch (code)
362 case REG:
363 case QUEUED:
364 case CONST_INT:
365 case CONST_DOUBLE:
366 case SYMBOL_REF:
367 case CODE_LABEL:
368 case PC:
369 case CC0:
370 case SCRATCH:
371 /* SCRATCH must be shared because they represent distinct values. */
372 case ADDRESSOF:
373 return orig;
375 case CONST:
376 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
377 a LABEL_REF, it isn't sharable. */
378 if (GET_CODE (XEXP (orig, 0)) == PLUS
379 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
380 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
381 return orig;
382 break;
384 /* A MEM with a constant address is not sharable. The problem is that
385 the constant address may need to be reloaded. If the mem is shared,
386 then reloading one copy of this mem will cause all copies to appear
387 to have been reloaded. */
389 default:
390 break;
393 copy = rtx_alloc (code);
395 /* Copy the various flags, and other information. We assume that
396 all fields need copying, and then clear the fields that should
397 not be copied. That is the sensible default behavior, and forces
398 us to explicitly document why we are *not* copying a flag. */
399 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
401 /* We do not copy the USED flag, which is used as a mark bit during
402 walks over the RTL. */
403 copy->used = 0;
405 /* We do not copy FRAME_RELATED for INSNs. */
406 if (GET_RTX_CLASS (code) == 'i')
407 copy->frame_related = 0;
408 copy->jump = orig->jump;
409 copy->call = orig->call;
411 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
413 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
415 copy->fld[i] = orig->fld[i];
416 switch (*format_ptr++)
418 case 'e':
419 if (XEXP (orig, i) != NULL)
420 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
421 break;
423 case 'E':
424 case 'V':
425 if (XVEC (orig, i) != NULL)
427 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
428 for (j = 0; j < XVECLEN (copy, i); j++)
429 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
431 break;
433 case 't':
434 case 'w':
435 case 'i':
436 case 's':
437 case 'S':
438 case 'u':
439 case '0':
440 /* These are left unchanged. */
441 break;
443 default:
444 abort ();
447 return copy;
450 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
451 placed in the result directly, rather than being copied. */
454 copy_most_rtx (orig, may_share)
455 register rtx orig;
456 register rtx may_share;
458 register rtx copy;
459 register int i, j;
460 register RTX_CODE code;
461 register const char *format_ptr;
463 if (orig == may_share)
464 return orig;
466 code = GET_CODE (orig);
468 switch (code)
470 case REG:
471 case QUEUED:
472 case CONST_INT:
473 case CONST_DOUBLE:
474 case SYMBOL_REF:
475 case CODE_LABEL:
476 case PC:
477 case CC0:
478 return orig;
479 default:
480 break;
483 copy = rtx_alloc (code);
484 PUT_MODE (copy, GET_MODE (orig));
485 copy->in_struct = orig->in_struct;
486 copy->volatil = orig->volatil;
487 copy->unchanging = orig->unchanging;
488 copy->integrated = orig->integrated;
489 copy->frame_related = orig->frame_related;
491 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
493 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
495 switch (*format_ptr++)
497 case 'e':
498 XEXP (copy, i) = XEXP (orig, i);
499 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
500 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
501 break;
503 case 'u':
504 XEXP (copy, i) = XEXP (orig, i);
505 break;
507 case 'E':
508 case 'V':
509 XVEC (copy, i) = XVEC (orig, i);
510 if (XVEC (orig, i) != NULL)
512 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
513 for (j = 0; j < XVECLEN (copy, i); j++)
514 XVECEXP (copy, i, j)
515 = copy_most_rtx (XVECEXP (orig, i, j), may_share);
517 break;
519 case 'w':
520 XWINT (copy, i) = XWINT (orig, i);
521 break;
523 case 'n':
524 case 'i':
525 XINT (copy, i) = XINT (orig, i);
526 break;
528 case 't':
529 XTREE (copy, i) = XTREE (orig, i);
530 break;
532 case 's':
533 case 'S':
534 XSTR (copy, i) = XSTR (orig, i);
535 break;
537 case '0':
538 /* Copy this through the wide int field; that's safest. */
539 X0WINT (copy, i) = X0WINT (orig, i);
540 break;
542 default:
543 abort ();
546 return copy;
549 /* Create a new copy of an rtx. Only copy just one level. */
551 shallow_copy_rtx (orig)
552 rtx orig;
554 register int i;
555 register RTX_CODE code = GET_CODE (orig);
556 register rtx copy = rtx_alloc (code);
558 PUT_MODE (copy, GET_MODE (orig));
559 copy->in_struct = orig->in_struct;
560 copy->volatil = orig->volatil;
561 copy->unchanging = orig->unchanging;
562 copy->integrated = orig->integrated;
563 copy->frame_related = orig->frame_related;
565 for (i = 0; i < GET_RTX_LENGTH (code); i++)
566 copy->fld[i] = orig->fld[i];
568 return copy;
571 /* This is 1 until after the rtl generation pass. */
572 int rtx_equal_function_value_matters;
574 /* Nonzero when we are generating CONCATs. */
575 int generating_concat_p;
577 /* Return 1 if X and Y are identical-looking rtx's.
578 This is the Lisp function EQUAL for rtx arguments. */
581 rtx_equal_p (x, y)
582 rtx x, y;
584 register int i;
585 register int j;
586 register enum rtx_code code;
587 register const char *fmt;
589 if (x == y)
590 return 1;
591 if (x == 0 || y == 0)
592 return 0;
594 code = GET_CODE (x);
595 /* Rtx's of different codes cannot be equal. */
596 if (code != GET_CODE (y))
597 return 0;
599 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
600 (REG:SI x) and (REG:HI x) are NOT equivalent. */
602 if (GET_MODE (x) != GET_MODE (y))
603 return 0;
605 /* Some RTL can be compared nonrecursively. */
606 switch (code)
608 case REG:
609 /* Until rtl generation is complete, don't consider a reference to the
610 return register of the current function the same as the return from a
611 called function. This eases the job of function integration. Once the
612 distinction is no longer needed, they can be considered equivalent. */
613 return (REGNO (x) == REGNO (y)
614 && (! rtx_equal_function_value_matters
615 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
617 case LABEL_REF:
618 return XEXP (x, 0) == XEXP (y, 0);
620 case SYMBOL_REF:
621 return XSTR (x, 0) == XSTR (y, 0);
623 case SCRATCH:
624 case CONST_DOUBLE:
625 case CONST_INT:
626 return 0;
628 default:
629 break;
632 /* Compare the elements. If any pair of corresponding elements
633 fail to match, return 0 for the whole things. */
635 fmt = GET_RTX_FORMAT (code);
636 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
638 switch (fmt[i])
640 case 'w':
641 if (XWINT (x, i) != XWINT (y, i))
642 return 0;
643 break;
645 case 'n':
646 case 'i':
647 if (XINT (x, i) != XINT (y, i))
648 return 0;
649 break;
651 case 'V':
652 case 'E':
653 /* Two vectors must have the same length. */
654 if (XVECLEN (x, i) != XVECLEN (y, i))
655 return 0;
657 /* And the corresponding elements must match. */
658 for (j = 0; j < XVECLEN (x, i); j++)
659 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
660 return 0;
661 break;
663 case 'e':
664 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
665 return 0;
666 break;
668 case 'S':
669 case 's':
670 if (strcmp (XSTR (x, i), XSTR (y, i)))
671 return 0;
672 break;
674 case 'u':
675 /* These are just backpointers, so they don't matter. */
676 break;
678 case '0':
679 case 't':
680 break;
682 /* It is believed that rtx's at this level will never
683 contain anything but integers and other rtx's,
684 except for within LABEL_REFs and SYMBOL_REFs. */
685 default:
686 abort ();
689 return 1;
692 /* Subroutines of read_rtx. */
694 /* The current line number for the file. */
695 int read_rtx_lineno = 1;
697 /* The filename for aborting with file and line. */
698 const char *read_rtx_filename = "<unknown>";
700 static void
701 fatal_with_file_and_line VPARAMS ((FILE *infile, const char *msg, ...))
703 #ifndef ANSI_PROTOTYPES
704 FILE *infile;
705 const char *msg;
706 #endif
707 va_list ap;
708 char context[64];
709 size_t i;
710 int c;
712 VA_START (ap, msg);
714 #ifndef ANSI_PROTOTYPES
715 infile = va_arg (ap, FILE *);
716 msg = va_arg (ap, const char *);
717 #endif
719 fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
720 vfprintf (stderr, msg, ap);
721 putc ('\n', stderr);
723 /* Gather some following context. */
724 for (i = 0; i < sizeof(context)-1; ++i)
726 c = getc (infile);
727 if (c == EOF)
728 break;
729 if (c == '\r' || c == '\n')
730 break;
731 context[i] = c;
733 context[i] = '\0';
735 fprintf (stderr, "%s:%d: following context is `%s'\n",
736 read_rtx_filename, read_rtx_lineno, context);
738 va_end (ap);
739 exit (1);
742 /* Dump code after printing a message. Used when read_rtx finds
743 invalid data. */
745 static void
746 fatal_expected_char (infile, expected_c, actual_c)
747 FILE *infile;
748 int expected_c, actual_c;
750 fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
751 expected_c, actual_c);
754 /* Read chars from INFILE until a non-whitespace char
755 and return that. Comments, both Lisp style and C style,
756 are treated as whitespace.
757 Tools such as genflags use this function. */
760 read_skip_spaces (infile)
761 FILE *infile;
763 register int c;
764 while (1)
766 c = getc (infile);
767 switch (c)
769 case '\n':
770 read_rtx_lineno++;
771 break;
773 case ' ': case '\t': case '\f': case '\r':
774 break;
776 case ';':
778 c = getc (infile);
779 while (c != '\n' && c != EOF);
780 read_rtx_lineno++;
781 break;
783 case '/':
785 register int prevc;
786 c = getc (infile);
787 if (c != '*')
788 fatal_expected_char (infile, '*', c);
790 prevc = 0;
791 while ((c = getc (infile)) && c != EOF)
793 if (c == '\n')
794 read_rtx_lineno++;
795 else if (prevc == '*' && c == '/')
796 break;
797 prevc = c;
800 break;
802 default:
803 return c;
808 /* Read an rtx code name into the buffer STR[].
809 It is terminated by any of the punctuation chars of rtx printed syntax. */
811 static void
812 read_name (str, infile)
813 char *str;
814 FILE *infile;
816 register char *p;
817 register int c;
819 c = read_skip_spaces(infile);
821 p = str;
822 while (1)
824 if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
825 break;
826 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
827 || c == '(' || c == '[')
829 ungetc (c, infile);
830 break;
832 *p++ = c;
833 c = getc (infile);
835 if (p == str)
836 fatal_with_file_and_line (infile, "missing name or number");
837 if (c == '\n')
838 read_rtx_lineno++;
840 *p = 0;
842 if (md_constants)
844 /* Do constant expansion. */
845 struct md_constant *def;
847 p = str;
850 struct md_constant tmp_def;
852 tmp_def.name = p;
853 def = htab_find (md_constants, &tmp_def);
854 if (def)
855 p = def->value;
856 } while (def);
857 if (p != str)
858 strcpy (str, p);
862 /* Provide a version of a function to read a long long if the system does
863 not provide one. */
864 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
865 HOST_WIDE_INT
866 atoll(p)
867 const char *p;
869 int neg = 0;
870 HOST_WIDE_INT tmp_wide;
872 while (ISSPACE(*p))
873 p++;
874 if (*p == '-')
875 neg = 1, p++;
876 else if (*p == '+')
877 p++;
879 tmp_wide = 0;
880 while (ISDIGIT(*p))
882 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
883 if (new_wide < tmp_wide)
885 /* Return INT_MAX equiv on overflow. */
886 tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1;
887 break;
889 tmp_wide = new_wide;
890 p++;
893 if (neg)
894 tmp_wide = -tmp_wide;
895 return tmp_wide;
897 #endif
899 /* Given a constant definition, return a hash code for its name. */
900 static unsigned
901 def_hash (def)
902 const void *def;
904 unsigned result, i;
905 const char *string = ((const struct md_constant *)def)->name;
907 for (result = i = 0;*string++ != '\0'; i++)
908 result += ((unsigned char) *string << (i % CHAR_BIT));
909 return result;
912 /* Given two constant definitions, return true if they have the same name. */
913 static int
914 def_name_eq_p (def1, def2)
915 const void *def1, *def2;
917 return ! strcmp (((const struct md_constant *)def1)->name,
918 ((const struct md_constant *)def2)->name);
921 /* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer suitable
922 to read a name or number into. Process a define_constants directive,
923 starting with the optional space after the "define_constants". */
924 static void
925 read_constants (infile, tmp_char)
926 FILE *infile;
927 char *tmp_char;
929 int c;
930 htab_t defs;
932 c = read_skip_spaces (infile);
933 if (c != '[')
934 fatal_expected_char (infile, '[', c);
935 defs = md_constants;
936 if (! defs)
937 defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0);
938 /* Disable constant expansion during definition processing. */
939 md_constants = 0;
940 while ( (c = read_skip_spaces (infile)) != ']')
942 struct md_constant *def;
943 void **entry_ptr;
945 if (c != '(')
946 fatal_expected_char (infile, '(', c);
947 def = xmalloc (sizeof (struct md_constant));
948 def->name = tmp_char;
949 read_name (tmp_char, infile);
950 entry_ptr = htab_find_slot (defs, def, TRUE);
951 if (! *entry_ptr)
952 def->name = xstrdup (tmp_char);
953 c = read_skip_spaces (infile);
954 ungetc (c, infile);
955 read_name (tmp_char, infile);
956 if (! *entry_ptr)
958 def->value = xstrdup (tmp_char);
959 *entry_ptr = def;
961 else
963 def = *entry_ptr;
964 if (strcmp (def->value, tmp_char))
965 fatal_with_file_and_line (infile,
966 "redefinition of %s, was %s, now %s",
967 def->name, def->value, tmp_char);
969 c = read_skip_spaces (infile);
970 if (c != ')')
971 fatal_expected_char (infile, ')', c);
973 md_constants = defs;
974 c = read_skip_spaces (infile);
975 if (c != ')')
976 fatal_expected_char (infile, ')', c);
979 /* For every constant definition, call CALLBACK with two arguments:
980 a pointer a pointer to the constant definition and INFO.
981 Stops when CALLBACK returns zero. */
982 void
983 traverse_md_constants (callback, info)
984 htab_trav callback;
985 void *info;
987 if (md_constants)
988 htab_traverse (md_constants, callback, info);
991 /* Read an rtx in printed representation from INFILE
992 and return an actual rtx in core constructed accordingly.
993 read_rtx is not used in the compiler proper, but rather in
994 the utilities gen*.c that construct C code from machine descriptions. */
997 read_rtx (infile)
998 FILE *infile;
1000 register int i, j, list_counter;
1001 RTX_CODE tmp_code;
1002 register const char *format_ptr;
1003 /* tmp_char is a buffer used for reading decimal integers
1004 and names of rtx types and machine modes.
1005 Therefore, 256 must be enough. */
1006 char tmp_char[256];
1007 rtx return_rtx;
1008 register int c;
1009 int tmp_int;
1010 HOST_WIDE_INT tmp_wide;
1012 /* Obstack used for allocating RTL objects. */
1013 static struct obstack rtl_obstack;
1014 static int initialized;
1016 /* Linked list structure for making RTXs: */
1017 struct rtx_list
1019 struct rtx_list *next;
1020 rtx value; /* Value of this node. */
1023 if (!initialized) {
1024 _obstack_begin (&rtl_obstack,0, 0,
1025 (void *(*) PARAMS ((long))) xmalloc,
1026 (void (*) PARAMS ((void *))) free);
1027 initialized = 1;
1030 again:
1031 c = read_skip_spaces (infile); /* Should be open paren. */
1032 if (c != '(')
1033 fatal_expected_char (infile, '(', c);
1035 read_name (tmp_char, infile);
1037 tmp_code = UNKNOWN;
1039 if (! strcmp (tmp_char, "define_constants"))
1041 read_constants (infile, tmp_char);
1042 goto again;
1044 for (i = 0; i < NUM_RTX_CODE; i++)
1045 if (! strcmp (tmp_char, GET_RTX_NAME (i)))
1047 tmp_code = (RTX_CODE) i; /* get value for name */
1048 break;
1051 if (tmp_code == UNKNOWN)
1052 fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char);
1054 /* (NIL) stands for an expression that isn't there. */
1055 if (tmp_code == NIL)
1057 /* Discard the closeparen. */
1058 while ((c = getc (infile)) && c != ')')
1061 return 0;
1064 /* If we end up with an insn expression then we free this space below. */
1065 return_rtx = rtx_alloc (tmp_code);
1066 format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
1068 /* If what follows is `: mode ', read it and
1069 store the mode in the rtx. */
1071 i = read_skip_spaces (infile);
1072 if (i == ':')
1074 read_name (tmp_char, infile);
1075 for (j = 0; j < NUM_MACHINE_MODES; j++)
1076 if (! strcmp (GET_MODE_NAME (j), tmp_char))
1077 break;
1079 if (j == MAX_MACHINE_MODE)
1080 fatal_with_file_and_line (infile, "unknown mode `%s'", tmp_char);
1082 PUT_MODE (return_rtx, (enum machine_mode) j);
1084 else
1085 ungetc (i, infile);
1087 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
1088 switch (*format_ptr++)
1090 /* 0 means a field for internal use only.
1091 Don't expect it to be present in the input. */
1092 case '0':
1093 break;
1095 case 'e':
1096 case 'u':
1097 XEXP (return_rtx, i) = read_rtx (infile);
1098 break;
1100 case 'V':
1101 /* 'V' is an optional vector: if a closeparen follows,
1102 just store NULL for this element. */
1103 c = read_skip_spaces (infile);
1104 ungetc (c, infile);
1105 if (c == ')')
1107 XVEC (return_rtx, i) = 0;
1108 break;
1110 /* Now process the vector. */
1112 case 'E':
1114 register struct rtx_list *next_rtx, *rtx_list_link;
1115 struct rtx_list *list_rtx = NULL;
1117 c = read_skip_spaces (infile);
1118 if (c != '[')
1119 fatal_expected_char (infile, '[', c);
1121 /* add expressions to a list, while keeping a count */
1122 next_rtx = NULL;
1123 list_counter = 0;
1124 while ((c = read_skip_spaces (infile)) && c != ']')
1126 ungetc (c, infile);
1127 list_counter++;
1128 rtx_list_link = (struct rtx_list *)
1129 alloca (sizeof (struct rtx_list));
1130 rtx_list_link->value = read_rtx (infile);
1131 if (next_rtx == 0)
1132 list_rtx = rtx_list_link;
1133 else
1134 next_rtx->next = rtx_list_link;
1135 next_rtx = rtx_list_link;
1136 rtx_list_link->next = 0;
1138 /* get vector length and allocate it */
1139 XVEC (return_rtx, i) = (list_counter
1140 ? rtvec_alloc (list_counter) : NULL_RTVEC);
1141 if (list_counter > 0)
1143 next_rtx = list_rtx;
1144 for (j = 0; j < list_counter; j++,
1145 next_rtx = next_rtx->next)
1146 XVECEXP (return_rtx, i, j) = next_rtx->value;
1148 /* close bracket gotten */
1150 break;
1152 case 'S':
1153 /* 'S' is an optional string: if a closeparen follows,
1154 just store NULL for this element. */
1155 c = read_skip_spaces (infile);
1156 ungetc (c, infile);
1157 if (c == ')')
1159 XSTR (return_rtx, i) = 0;
1160 break;
1163 case 's':
1165 int saw_paren = 0;
1166 register char *stringbuf;
1167 int saw_anything = 0;
1169 c = read_skip_spaces (infile);
1170 if (c == '(')
1172 saw_paren = 1;
1173 c = read_skip_spaces (infile);
1175 if (c != '"')
1176 fatal_expected_char (infile, '"', c);
1178 while (1)
1180 c = getc (infile); /* Read the string */
1181 if (c == '\n')
1182 read_rtx_lineno++;
1183 if (c == '\\')
1185 c = getc (infile); /* Read the string */
1186 /* \; makes stuff for a C string constant containing
1187 newline and tab. */
1188 if (c == ';')
1190 obstack_grow (&rtl_obstack, "\\n\\t", 4);
1191 continue;
1193 if (c == '\n')
1194 read_rtx_lineno++;
1196 else if (c == '"')
1197 break;
1199 obstack_1grow (&rtl_obstack, c);
1200 saw_anything = 1;
1203 /* For insn patterns, we want to provide a default name
1204 based on the file and line, like "*foo.md:12", if the
1205 given name is blank. These are only for define_insn and
1206 define_insn_and_split, to aid debugging. */
1207 if (!saw_anything
1208 && i == 0
1209 && (GET_CODE (return_rtx) == DEFINE_INSN
1210 || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
1212 char line_name[20];
1213 const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx");
1214 const char *slash;
1215 for (slash = fn; *slash; slash ++)
1216 if (*slash == '/' || *slash == '\\' || *slash == ':')
1217 fn = slash + 1;
1218 obstack_1grow (&rtl_obstack, '*');
1219 obstack_grow (&rtl_obstack, fn, strlen (fn));
1220 sprintf (line_name, ":%d", read_rtx_lineno);
1221 obstack_grow (&rtl_obstack, line_name, strlen (line_name));
1224 obstack_1grow (&rtl_obstack, 0);
1225 stringbuf = (char *) obstack_finish (&rtl_obstack);
1227 if (saw_paren)
1229 c = read_skip_spaces (infile);
1230 if (c != ')')
1231 fatal_expected_char (infile, ')', c);
1233 XSTR (return_rtx, i) = stringbuf;
1235 break;
1237 case 'w':
1238 read_name (tmp_char, infile);
1239 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1240 tmp_wide = atoi (tmp_char);
1241 #else
1242 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1243 tmp_wide = atol (tmp_char);
1244 #else
1245 /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
1246 But prefer not to use our hand-rolled function above either. */
1247 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1248 tmp_wide = atoll (tmp_char);
1249 #else
1250 tmp_wide = atoq (tmp_char);
1251 #endif
1252 #endif
1253 #endif
1254 XWINT (return_rtx, i) = tmp_wide;
1255 break;
1257 case 'i':
1258 case 'n':
1259 read_name (tmp_char, infile);
1260 tmp_int = atoi (tmp_char);
1261 XINT (return_rtx, i) = tmp_int;
1262 break;
1264 default:
1265 fprintf (stderr,
1266 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
1267 format_ptr[-1]);
1268 fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
1269 abort ();
1272 c = read_skip_spaces (infile);
1273 if (c != ')')
1274 fatal_expected_char (infile, ')', c);
1276 return return_rtx;
1279 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
1280 void
1281 rtl_check_failed_bounds (r, n, file, line, func)
1282 rtx r;
1283 int n;
1284 const char *file;
1285 int line;
1286 const char *func;
1288 internal_error
1289 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
1290 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
1291 func, trim_filename (file), line);
1294 void
1295 rtl_check_failed_type1 (r, n, c1, file, line, func)
1296 rtx r;
1297 int n;
1298 int c1;
1299 const char *file;
1300 int line;
1301 const char *func;
1303 internal_error
1304 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
1305 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
1306 func, trim_filename (file), line);
1309 void
1310 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
1311 rtx r;
1312 int n;
1313 int c1;
1314 int c2;
1315 const char *file;
1316 int line;
1317 const char *func;
1319 internal_error
1320 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
1321 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
1322 func, trim_filename (file), line);
1325 void
1326 rtl_check_failed_code1 (r, code, file, line, func)
1327 rtx r;
1328 enum rtx_code code;
1329 const char *file;
1330 int line;
1331 const char *func;
1333 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
1334 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
1335 trim_filename (file), line);
1338 void
1339 rtl_check_failed_code2 (r, code1, code2, file, line, func)
1340 rtx r;
1341 enum rtx_code code1, code2;
1342 const char *file;
1343 int line;
1344 const char *func;
1346 internal_error
1347 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
1348 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
1349 func, trim_filename (file), line);
1352 /* XXX Maybe print the vector? */
1353 void
1354 rtvec_check_failed_bounds (r, n, file, line, func)
1355 rtvec r;
1356 int n;
1357 const char *file;
1358 int line;
1359 const char *func;
1361 internal_error
1362 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
1363 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
1365 #endif /* ENABLE_RTL_CHECKING */