1 /* Allocate and read RTL for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
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)
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.
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. */
29 #define obstack_chunk_alloc xmalloc
30 #define obstack_chunk_free free
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. */
38 extern struct obstack
*rtl_obstack
;
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. */
44 int rtx_length
[NUM_RTX_CODE
+ 1];
46 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
48 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
51 #include "rtl.def" /* rtl expressions are documented here */
56 /* Indexed by machine mode, gives the name of that machine mode.
57 This name does not include the letters "mode". */
59 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME,
61 char *mode_name
[(int) MAX_MACHINE_MODE
+ 1] = {
62 #include "machmode.def"
67 /* Add an extra field to avoid a core dump if someone tries to convert
68 MAX_MACHINE_MODE to a string. */
74 /* Indexed by machine mode, gives the length of the mode, in bytes.
75 GET_MODE_CLASS uses this. */
77 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS,
79 enum mode_class mode_class
[(int) MAX_MACHINE_MODE
] = {
80 #include "machmode.def"
85 /* Indexed by machine mode, gives the length of the mode, in bytes.
86 GET_MODE_SIZE uses this. */
88 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE,
90 int mode_size
[(int) MAX_MACHINE_MODE
] = {
91 #include "machmode.def"
96 /* Indexed by machine mode, gives the length of the mode's subunit.
97 GET_MODE_UNIT_SIZE uses this. */
99 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT,
101 int mode_unit_size
[(int) MAX_MACHINE_MODE
] = {
102 #include "machmode.def" /* machine modes are documented here */
107 /* Indexed by machine mode, gives next wider natural mode
108 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
111 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
112 (unsigned char) WIDER,
114 unsigned char mode_wider_mode
[(int) MAX_MACHINE_MODE
] = {
115 #include "machmode.def" /* machine modes are documented here */
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,
123 /* Indexed by machine mode, gives mask of significant bits in mode. */
125 unsigned HOST_WIDE_INT mode_mask_array
[(int) MAX_MACHINE_MODE
] = {
126 #include "machmode.def"
129 /* Indexed by mode class, gives the narrowest mode for each class. */
131 enum machine_mode class_narrowest_mode
[(int) MAX_MODE_CLASS
];
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. */
137 char *rtx_format
[] = {
139 can cause a warning message
140 "0" field is unused (or used in a phase-dependent manner)
144 "n" like "i", but prints entries from `note_insn_name'
145 "w" an integer of width HOST_BITS_PER_WIDE_INT
147 "s" a pointer to a 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. */
162 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
163 #include "rtl.def" /* rtl expressions are defined here */
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. */
171 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
172 #include "rtl.def" /* rtl expressions are defined here */
176 /* Names for kinds of NOTEs and REG_NOTEs. */
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" };
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",
200 static void dump_and_abort
PROTO((int, int, FILE *)) ATTRIBUTE_NORETURN
;
201 static void read_name
PROTO((char *, FILE *));
203 /* Allocate an rtx vector of N elements.
204 Store the length, and initialize all elements to zero. */
213 rt
= (rtvec
) obstack_alloc (rtl_obstack
,
214 sizeof (struct rtvec_def
)
215 + (( n
- 1) * sizeof (rtunion
)));
217 /* clear out the vector */
218 PUT_NUM_ELEM (rt
, n
);
220 for (i
= 0; i
< n
; i
++)
221 rt
->elem
[i
].rtwint
= 0;
226 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
227 all the rest is initialized to zero. */
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
);
239 /* This function is called more than any other in GCC,
240 so we manipulate the obstack directly.
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. */
246 length
= (length
+ ob
->alignment_mask
) & ~ ob
->alignment_mask
;
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
;
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
258 memset (rt
, 0, sizeof (struct rtx_def
) - sizeof (rtunion
));
265 /* Free the rtx X and all RTL allocated since X. */
271 obstack_free (rtl_obstack
, x
);
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. */
284 register RTX_CODE code
;
285 register char *format_ptr
;
287 code
= GET_CODE (orig
);
300 /* SCRATCH must be shared because they represent distinct values. */
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
)
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. */
322 copy
= rtx_alloc (code
);
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 bcopy (orig
, copy
, sizeof (struct rtx_def
) - sizeof (rtunion
));
330 /* We do not copy the USED flag, which is used as a mark bit during
331 walks over the RTL. */
334 /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
335 if (GET_RTX_CLASS (code
) == 'i')
339 copy
->frame_related
= 0;
342 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
344 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
346 switch (*format_ptr
++)
349 XEXP (copy
, i
) = XEXP (orig
, i
);
350 if (XEXP (orig
, i
) != NULL
)
351 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
356 XEXP (copy
, i
) = XEXP (orig
, i
);
361 XVEC (copy
, i
) = XVEC (orig
, i
);
362 if (XVEC (orig
, i
) != NULL
)
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
));
372 bitmap new_bits
= BITMAP_OBSTACK_ALLOC (rtl_obstack
);
373 bitmap_copy (new_bits
, XBITMAP (orig
, i
));
374 XBITMAP (copy
, i
) = new_bits
;
379 XTREE (copy
, i
) = XTREE (orig
, i
);
383 XWINT (copy
, i
) = XWINT (orig
, i
);
387 XINT (copy
, i
) = XINT (orig
, i
);
392 XSTR (copy
, i
) = XSTR (orig
, i
);
402 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
403 placed in the result directly, rather than being copied. */
406 copy_most_rtx (orig
, may_share
)
408 register rtx may_share
;
412 register RTX_CODE code
;
413 register char *format_ptr
;
415 if (orig
== may_share
)
418 code
= GET_CODE (orig
);
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
;
442 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
444 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
446 switch (*format_ptr
++)
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
);
456 XEXP (copy
, i
) = XEXP (orig
, i
);
461 XVEC (copy
, i
) = XVEC (orig
, i
);
462 if (XVEC (orig
, i
) != NULL
)
464 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
465 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
467 = copy_most_rtx (XVECEXP (orig
, i
, j
), may_share
);
472 XWINT (copy
, i
) = XWINT (orig
, i
);
477 XINT (copy
, i
) = XINT (orig
, i
);
482 XSTR (copy
, i
) = XSTR (orig
, i
);
492 /* Subroutines of read_rtx. */
494 /* Dump code after printing a message. Used when read_rtx finds
498 dump_and_abort (expected_c
, actual_c
, infile
)
499 int expected_c
, actual_c
;
506 "Expected character %c. Found character %c.",
507 expected_c
, actual_c
);
508 fprintf (stderr
, " At file position: %ld\n", ftell (infile
));
509 fprintf (stderr
, "Following characters are:\n\t");
510 for (i
= 0; i
< 200; i
++)
516 fprintf (stderr
, "Aborting.\n");
520 /* Read chars from INFILE until a non-whitespace char
521 and return that. Comments, both Lisp style and C style,
522 are treated as whitespace.
523 Tools such as genflags use this function. */
526 read_skip_spaces (infile
)
530 while ((c
= getc (infile
)))
532 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f')
536 while ((c
= getc (infile
)) && c
!= '\n' && c
!= EOF
)
544 dump_and_abort ('*', c
, infile
);
547 while ((c
= getc (infile
)) && c
!= EOF
)
549 if (prevc
== '*' && c
== '/')
559 /* Read an rtx code name into the buffer STR[].
560 It is terminated by any of the punctuation chars of rtx printed syntax. */
563 read_name (str
, infile
)
570 c
= read_skip_spaces(infile
);
575 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f')
577 if (c
== ':' || c
== ')' || c
== ']' || c
== '"' || c
== '/'
578 || c
== '(' || c
== '[')
588 fprintf (stderr
, "missing name or number");
589 dump_and_abort (-1, -1, infile
);
595 /* Provide a version of a function to read a long long if the system does
597 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
603 HOST_WIDE_INT tmp_wide
;
615 HOST_WIDE_INT new_wide
= tmp_wide
*10 + (*p
- '0');
616 if (new_wide
< tmp_wide
)
618 /* Return INT_MAX equiv on overflow. */
619 tmp_wide
= (~(unsigned HOST_WIDE_INT
)0) >> 1;
627 tmp_wide
= -tmp_wide
;
632 /* Read an rtx in printed representation from INFILE
633 and return an actual rtx in core constructed accordingly.
634 read_rtx is not used in the compiler proper, but rather in
635 the utilities gen*.c that construct C code from machine descriptions. */
641 register int i
, j
, list_counter
;
643 register char *format_ptr
;
644 /* tmp_char is a buffer used for reading decimal integers
645 and names of rtx types and machine modes.
646 Therefore, 256 must be enough. */
651 HOST_WIDE_INT tmp_wide
;
653 /* Linked list structure for making RTXs: */
656 struct rtx_list
*next
;
657 rtx value
; /* Value of this node... */
660 c
= read_skip_spaces (infile
); /* Should be open paren. */
662 dump_and_abort ('(', c
, infile
);
664 read_name (tmp_char
, infile
);
668 for (i
=0; i
< NUM_RTX_CODE
; i
++) /* @@ might speed this search up */
670 if (!(strcmp (tmp_char
, GET_RTX_NAME (i
))))
672 tmp_code
= (RTX_CODE
) i
; /* get value for name */
676 if (tmp_code
== UNKNOWN
)
679 "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
682 /* (NIL) stands for an expression that isn't there. */
685 /* Discard the closeparen. */
686 while ((c
= getc (infile
)) && c
!= ')');
690 return_rtx
= rtx_alloc (tmp_code
); /* if we end up with an insn expression
691 then we free this space below. */
692 format_ptr
= GET_RTX_FORMAT (GET_CODE (return_rtx
));
694 /* If what follows is `: mode ', read it and
695 store the mode in the rtx. */
697 i
= read_skip_spaces (infile
);
701 read_name (tmp_char
, infile
);
702 for (k
= 0; k
< NUM_MACHINE_MODES
; k
++)
703 if (!strcmp (GET_MODE_NAME (k
), tmp_char
))
706 PUT_MODE (return_rtx
, (enum machine_mode
) k
);
711 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (return_rtx
)); i
++)
712 switch (*format_ptr
++)
714 /* 0 means a field for internal use only.
715 Don't expect it to be present in the input. */
721 XEXP (return_rtx
, i
) = read_rtx (infile
);
725 /* 'V' is an optional vector: if a closeparen follows,
726 just store NULL for this element. */
727 c
= read_skip_spaces (infile
);
731 XVEC (return_rtx
, i
) = 0;
734 /* Now process the vector. */
738 register struct rtx_list
*next_rtx
, *rtx_list_link
;
739 struct rtx_list
*list_rtx
= NULL
;
741 c
= read_skip_spaces (infile
);
743 dump_and_abort ('[', c
, infile
);
745 /* add expressions to a list, while keeping a count */
748 while ((c
= read_skip_spaces (infile
)) && c
!= ']')
752 rtx_list_link
= (struct rtx_list
*)
753 alloca (sizeof (struct rtx_list
));
754 rtx_list_link
->value
= read_rtx (infile
);
756 list_rtx
= rtx_list_link
;
758 next_rtx
->next
= rtx_list_link
;
759 next_rtx
= rtx_list_link
;
760 rtx_list_link
->next
= 0;
762 /* get vector length and allocate it */
763 XVEC (return_rtx
, i
) = (list_counter
764 ? rtvec_alloc (list_counter
) : NULL_RTVEC
);
765 if (list_counter
> 0)
768 for (j
= 0; j
< list_counter
; j
++,
769 next_rtx
= next_rtx
->next
)
770 XVECEXP (return_rtx
, i
, j
) = next_rtx
->value
;
772 /* close bracket gotten */
777 /* 'S' is an optional string: if a closeparen follows,
778 just store NULL for this element. */
779 c
= read_skip_spaces (infile
);
783 XSTR (return_rtx
, i
) = 0;
790 register char *stringbuf
;
792 c
= read_skip_spaces (infile
);
796 c
= read_skip_spaces (infile
);
799 dump_and_abort ('"', c
, infile
);
803 c
= getc (infile
); /* Read the string */
806 c
= getc (infile
); /* Read the string */
807 /* \; makes stuff for a C string constant containing
811 obstack_grow (rtl_obstack
, "\\n\\t", 4);
818 obstack_1grow (rtl_obstack
, c
);
821 obstack_1grow (rtl_obstack
, 0);
822 stringbuf
= (char *) obstack_finish (rtl_obstack
);
826 c
= read_skip_spaces (infile
);
828 dump_and_abort (')', c
, infile
);
830 XSTR (return_rtx
, i
) = stringbuf
;
835 read_name (tmp_char
, infile
);
836 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
837 tmp_wide
= atoi (tmp_char
);
839 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
840 tmp_wide
= atol (tmp_char
);
842 /* Prefer atoll over atoq, since the former is in the ISO C9X draft.
843 But prefer not to use our hand-rolled function above either. */
844 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
845 tmp_wide
= atoll (tmp_char
);
847 tmp_wide
= atoq (tmp_char
);
851 XWINT (return_rtx
, i
) = tmp_wide
;
856 read_name (tmp_char
, infile
);
857 tmp_int
= atoi (tmp_char
);
858 XINT (return_rtx
, i
) = tmp_int
;
863 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
865 fprintf (stderr
, "\tfile position: %ld\n", ftell (infile
));
869 c
= read_skip_spaces (infile
);
871 dump_and_abort (')', c
, infile
);
876 /* This is called once per compilation, before any rtx's are constructed.
877 It initializes the vector `rtx_length', the extra CC modes, if any,
878 and computes certain commonly-used modes. */
883 int min_class_size
[(int) MAX_MODE_CLASS
];
884 enum machine_mode mode
;
887 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
888 rtx_length
[i
] = strlen (rtx_format
[i
]);
890 /* Make CONST_DOUBLE bigger, if real values are bigger than
891 it normally expects to have room for.
892 Note that REAL_VALUE_TYPE is not defined by default,
893 since tree.h is not included. But the default dfn as `double'
895 #ifdef REAL_VALUE_TYPE
896 i
= sizeof (REAL_VALUE_TYPE
) / sizeof (rtunion
) + 2;
897 if (rtx_length
[(int) CONST_DOUBLE
] < i
)
899 char *s
= (char *) xmalloc (i
+ 1);
900 rtx_length
[(int) CONST_DOUBLE
] = i
;
901 rtx_format
[(int) CONST_DOUBLE
] = s
;
904 /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
905 of as many `w's as we now have elements. Subtract two from
906 the size to account for the 'e' and the '0'. */
907 for (i
= 2; i
< rtx_length
[(int) CONST_DOUBLE
]; i
++)
913 #ifdef EXTRA_CC_MODES
914 for (i
= (int) CCmode
+ 1; i
< (int) MAX_MACHINE_MODE
; i
++)
916 mode_class
[i
] = MODE_CC
;
917 mode_mask_array
[i
] = mode_mask_array
[(int) CCmode
];
918 mode_size
[i
] = mode_size
[(int) CCmode
];
919 mode_unit_size
[i
] = mode_unit_size
[(int) CCmode
];
920 mode_wider_mode
[i
- 1] = i
;
921 mode_wider_mode
[i
] = (unsigned char)VOIDmode
;
925 /* Find the narrowest mode for each class. */
927 for (i
= 0; i
< (int) MAX_MODE_CLASS
; i
++)
928 min_class_size
[i
] = 1000;
930 for (mode
= VOIDmode
; (int) mode
< (int) MAX_MACHINE_MODE
;
931 mode
= (enum machine_mode
) ((int) mode
+ 1))
933 if (GET_MODE_SIZE (mode
) < min_class_size
[(int) GET_MODE_CLASS (mode
)])
935 class_narrowest_mode
[(int) GET_MODE_CLASS (mode
)] = mode
;
936 min_class_size
[(int) GET_MODE_CLASS (mode
)] = GET_MODE_SIZE (mode
);