1 /* Allocate and read RTL for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
28 #define obstack_chunk_alloc xmalloc
29 #define obstack_chunk_free free
31 /* Obstack used for allocating RTL objects.
32 Between functions, this is the permanent_obstack.
33 While parsing and expanding a function, this is maybepermanent_obstack
34 so we can save it if it is an inline function.
35 During optimization and output, this is function_obstack. */
37 extern struct obstack
*rtl_obstack
;
39 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
43 /* Indexed by rtx code, gives number of operands for an rtx with that code.
44 Does NOT include rtx header data (code and links).
45 This array is initialized in init_rtl. */
47 int rtx_length
[NUM_RTX_CODE
+ 1];
49 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
51 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
54 #include "rtl.def" /* rtl expressions are documented here */
59 /* Indexed by machine mode, gives the name of that machine mode.
60 This name does not include the letters "mode". */
62 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME,
64 char *mode_name
[(int) MAX_MACHINE_MODE
] = {
65 #include "machmode.def"
75 /* Indexed by machine mode, gives the length of the mode, in bytes.
76 GET_MODE_CLASS uses this. */
78 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS,
80 enum mode_class mode_class
[(int) MAX_MACHINE_MODE
] = {
81 #include "machmode.def"
86 /* Indexed by machine mode, gives the length of the mode, in bytes.
87 GET_MODE_SIZE uses this. */
89 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE,
91 int mode_size
[(int) MAX_MACHINE_MODE
] = {
92 #include "machmode.def"
97 /* Indexed by machine mode, gives the length of the mode's subunit.
98 GET_MODE_UNIT_SIZE uses this. */
100 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT,
102 int mode_unit_size
[(int) MAX_MACHINE_MODE
] = {
103 #include "machmode.def" /* machine modes are documented here */
108 /* Indexed by machine mode, gives next wider natural mode
109 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
112 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
113 (enum machine_mode) WIDER,
115 enum machine_mode mode_wider_mode
[(int) MAX_MACHINE_MODE
] = {
116 #include "machmode.def" /* machine modes are documented here */
121 /* Indexed by mode class, gives the narrowest mode for each class. */
123 enum machine_mode class_narrowest_mode
[(int) MAX_MODE_CLASS
];
125 /* Commonly used modes. */
127 enum machine_mode byte_mode
; /* Mode whose width is BITS_PER_UNIT */
128 enum machine_mode word_mode
; /* Mode whose width is BITS_PER_WORD */
130 /* Indexed by rtx code, gives a sequence of operand-types for
131 rtx's of that code. The sequence is a C string in which
132 each character describes one operand. */
134 char *rtx_format
[] = {
136 can cause a warning message
137 "0" field is unused (or used in a phase-dependent manner)
141 "n" like "i", but prints entries from `note_insn_name'
142 "w" an integer of width HOST_BITS_PER_WIDE_INT
144 "s" a pointer to a string
146 "S" like "s", but optional:
147 the containing rtx may end before this operand
148 "e" a pointer to an rtl expression
149 prints the expression
150 "E" a pointer to a vector that points to a number of rtl expressions
151 prints a list of the rtl expressions
152 "V" like "E", but optional:
153 the containing rtx may end before this operand
154 "u" a pointer to another insn
155 prints the uid of the insn. */
157 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
158 #include "rtl.def" /* rtl expressions are defined here */
162 /* Indexed by rtx code, gives a character representing the "class" of
163 that rtx code. See rtl.def for documentation on the defined classes. */
166 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
167 #include "rtl.def" /* rtl expressions are defined here */
171 /* Names for kinds of NOTEs and REG_NOTEs. */
173 char *note_insn_name
[] = { 0 , "NOTE_INSN_DELETED",
174 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
175 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
176 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
177 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
178 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
179 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG"};
181 char *reg_note_name
[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
182 "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
183 "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
184 "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
185 "REG_DEP_ANTI", "REG_DEP_OUTPUT" };
187 /* Allocate an rtx vector of N elements.
188 Store the length, and initialize all elements to zero. */
197 rt
= (rtvec
) obstack_alloc (rtl_obstack
,
198 sizeof (struct rtvec_def
)
199 + (( n
- 1) * sizeof (rtunion
)));
201 /* clear out the vector */
203 for (i
=0; i
< n
; i
++)
204 rt
->elem
[i
].rtvec
= NULL
; /* @@ not portable due to rtunion */
209 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
210 all the rest is initialized to zero. */
217 register struct obstack
*ob
= rtl_obstack
;
218 register int nelts
= GET_RTX_LENGTH (code
);
219 register int length
= sizeof (struct rtx_def
)
220 + (nelts
- 1) * sizeof (rtunion
);
222 /* This function is called more than any other in GCC,
223 so we manipulate the obstack directly.
225 Even though rtx objects are word aligned, we may be sharing an obstack
226 with tree nodes, which may have to be double-word aligned. So align
227 our length to the alignment mask in the obstack. */
229 length
= (length
+ ob
->alignment_mask
) & ~ ob
->alignment_mask
;
231 if (ob
->chunk_limit
- ob
->next_free
< length
)
232 _obstack_newchunk (ob
, length
);
233 rt
= (rtx
)ob
->object_base
;
234 ob
->next_free
+= length
;
235 ob
->object_base
= ob
->next_free
;
237 /* We want to clear everything up to the FLD array. Normally, this is
238 one int, but we don't want to assume that and it isn't very portable
241 length
= (sizeof (struct rtx_def
) - sizeof (rtunion
) - 1) / sizeof (int);
242 for (; length
>= 0; length
--)
243 ((int *) rt
)[length
] = 0;
250 /* Create a new copy of an rtx.
251 Recursively copies the operands of the rtx,
252 except for those few rtx codes that are sharable. */
260 register RTX_CODE code
;
261 register char *format_ptr
;
263 code
= GET_CODE (orig
);
276 /* SCRATCH must be shared because they represent distinct values. */
280 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
281 a LABEL_REF, it isn't sharable. */
282 if (GET_CODE (XEXP (orig
, 0)) == PLUS
283 && GET_CODE (XEXP (XEXP (orig
, 0), 0)) == SYMBOL_REF
284 && GET_CODE (XEXP (XEXP (orig
, 0), 1)) == CONST_INT
)
288 /* A MEM with a constant address is not sharable. The problem is that
289 the constant address may need to be reloaded. If the mem is shared,
290 then reloading one copy of this mem will cause all copies to appear
291 to have been reloaded. */
294 copy
= rtx_alloc (code
);
295 PUT_MODE (copy
, GET_MODE (orig
));
296 copy
->in_struct
= orig
->in_struct
;
297 copy
->volatil
= orig
->volatil
;
298 copy
->unchanging
= orig
->unchanging
;
299 copy
->integrated
= orig
->integrated
;
301 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
303 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
305 switch (*format_ptr
++)
308 XEXP (copy
, i
) = XEXP (orig
, i
);
309 if (XEXP (orig
, i
) != NULL
)
310 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
315 XEXP (copy
, i
) = XEXP (orig
, i
);
320 XVEC (copy
, i
) = XVEC (orig
, i
);
321 if (XVEC (orig
, i
) != NULL
)
323 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
324 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
325 XVECEXP (copy
, i
, j
) = copy_rtx (XVECEXP (orig
, i
, j
));
330 XWINT (copy
, i
) = XWINT (orig
, i
);
334 XINT (copy
, i
) = XINT (orig
, i
);
339 XSTR (copy
, i
) = XSTR (orig
, i
);
349 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
350 placed in the result directly, rather than being copied. */
353 copy_most_rtx (orig
, may_share
)
355 register rtx may_share
;
359 register RTX_CODE code
;
360 register char *format_ptr
;
362 if (orig
== may_share
)
365 code
= GET_CODE (orig
);
380 copy
= rtx_alloc (code
);
381 PUT_MODE (copy
, GET_MODE (orig
));
382 copy
->in_struct
= orig
->in_struct
;
383 copy
->volatil
= orig
->volatil
;
384 copy
->unchanging
= orig
->unchanging
;
385 copy
->integrated
= orig
->integrated
;
387 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
389 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
391 switch (*format_ptr
++)
394 XEXP (copy
, i
) = XEXP (orig
, i
);
395 if (XEXP (orig
, i
) != NULL
&& XEXP (orig
, i
) != may_share
)
396 XEXP (copy
, i
) = copy_most_rtx (XEXP (orig
, i
), may_share
);
401 XEXP (copy
, i
) = XEXP (orig
, i
);
406 XVEC (copy
, i
) = XVEC (orig
, i
);
407 if (XVEC (orig
, i
) != NULL
)
409 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
410 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
412 = copy_most_rtx (XVECEXP (orig
, i
, j
), may_share
);
417 XWINT (copy
, i
) = XWINT (orig
, i
);
422 XINT (copy
, i
) = XINT (orig
, i
);
427 XSTR (copy
, i
) = XSTR (orig
, i
);
437 /* Subroutines of read_rtx. */
439 /* Dump code after printing a message. Used when read_rtx finds
443 dump_and_abort (expected_c
, actual_c
, infile
)
444 int expected_c
, actual_c
;
451 "Expected character %c. Found character %c.",
452 expected_c
, actual_c
);
453 fprintf (stderr
, " At file position: %ld\n", ftell (infile
));
454 fprintf (stderr
, "Following characters are:\n\t");
455 for (i
= 0; i
< 200; i
++)
461 fprintf (stderr
, "Aborting.\n");
465 /* Read chars from INFILE until a non-whitespace char
466 and return that. Comments, both Lisp style and C style,
467 are treated as whitespace.
468 Tools such as genflags use this function. */
471 read_skip_spaces (infile
)
475 while (c
= getc (infile
))
477 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f')
481 while ((c
= getc (infile
)) && c
!= '\n') ;
488 dump_and_abort ('*', c
, infile
);
491 while (c
= getc (infile
))
493 if (prevc
== '*' && c
== '/')
503 /* Read an rtx code name into the buffer STR[].
504 It is terminated by any of the punctuation chars of rtx printed syntax. */
507 read_name (str
, infile
)
514 c
= read_skip_spaces(infile
);
519 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f')
521 if (c
== ':' || c
== ')' || c
== ']' || c
== '"' || c
== '/'
522 || c
== '(' || c
== '[')
532 fprintf (stderr
, "missing name or number");
533 dump_and_abort (-1, -1, infile
);
539 /* Read an rtx in printed representation from INFILE
540 and return an actual rtx in core constructed accordingly.
541 read_rtx is not used in the compiler proper, but rather in
542 the utilities gen*.c that construct C code from machine descriptions. */
548 register int i
, j
, list_counter
;
550 register char *format_ptr
;
551 /* tmp_char is a buffer used for reading decimal integers
552 and names of rtx types and machine modes.
553 Therefore, 256 must be enough. */
558 HOST_WIDE_INT tmp_wide
;
560 /* Linked list structure for making RTXs: */
563 struct rtx_list
*next
;
564 rtx value
; /* Value of this node... */
567 c
= read_skip_spaces (infile
); /* Should be open paren. */
569 dump_and_abort ('(', c
, infile
);
571 read_name (tmp_char
, infile
);
575 for (i
=0; i
< NUM_RTX_CODE
; i
++) /* @@ might speed this search up */
577 if (!(strcmp (tmp_char
, GET_RTX_NAME (i
))))
579 tmp_code
= (RTX_CODE
) i
; /* get value for name */
583 if (tmp_code
== UNKNOWN
)
586 "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
589 /* (NIL) stands for an expression that isn't there. */
592 /* Discard the closeparen. */
593 while ((c
= getc (infile
)) && c
!= ')');
597 return_rtx
= rtx_alloc (tmp_code
); /* if we end up with an insn expression
598 then we free this space below. */
599 format_ptr
= GET_RTX_FORMAT (GET_CODE (return_rtx
));
601 /* If what follows is `: mode ', read it and
602 store the mode in the rtx. */
604 i
= read_skip_spaces (infile
);
608 read_name (tmp_char
, infile
);
609 for (k
= 0; k
< NUM_MACHINE_MODES
; k
++)
610 if (!strcmp (GET_MODE_NAME (k
), tmp_char
))
613 PUT_MODE (return_rtx
, (enum machine_mode
) k
);
618 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (return_rtx
)); i
++)
619 switch (*format_ptr
++)
621 /* 0 means a field for internal use only.
622 Don't expect it to be present in the input. */
628 XEXP (return_rtx
, i
) = read_rtx (infile
);
632 /* 'V' is an optional vector: if a closeparen follows,
633 just store NULL for this element. */
634 c
= read_skip_spaces (infile
);
638 XVEC (return_rtx
, i
) = 0;
641 /* Now process the vector. */
645 register struct rtx_list
*next_rtx
, *rtx_list_link
;
646 struct rtx_list
*list_rtx
;
648 c
= read_skip_spaces (infile
);
650 dump_and_abort ('[', c
, infile
);
652 /* add expressions to a list, while keeping a count */
655 while ((c
= read_skip_spaces (infile
)) && c
!= ']')
659 rtx_list_link
= (struct rtx_list
*)
660 alloca (sizeof (struct rtx_list
));
661 rtx_list_link
->value
= read_rtx (infile
);
663 list_rtx
= rtx_list_link
;
665 next_rtx
->next
= rtx_list_link
;
666 next_rtx
= rtx_list_link
;
667 rtx_list_link
->next
= 0;
669 /* get vector length and allocate it */
670 XVEC (return_rtx
, i
) = (list_counter
671 ? rtvec_alloc (list_counter
) : NULL_RTVEC
);
672 if (list_counter
> 0)
675 for (j
= 0; j
< list_counter
; j
++,
676 next_rtx
= next_rtx
->next
)
677 XVECEXP (return_rtx
, i
, j
) = next_rtx
->value
;
679 /* close bracket gotten */
684 /* 'S' is an optional string: if a closeparen follows,
685 just store NULL for this element. */
686 c
= read_skip_spaces (infile
);
690 XSTR (return_rtx
, i
) = 0;
697 register char *stringbuf
;
700 c
= read_skip_spaces (infile
);
704 c
= read_skip_spaces (infile
);
707 dump_and_abort ('"', c
, infile
);
711 c
= getc (infile
); /* Read the string */
714 c
= getc (infile
); /* Read the string */
715 /* \; makes stuff for a C string constant containing
719 obstack_grow (rtl_obstack
, "\\n\\t", 4);
726 obstack_1grow (rtl_obstack
, c
);
729 obstack_1grow (rtl_obstack
, 0);
730 stringbuf
= (char *) obstack_finish (rtl_obstack
);
734 c
= read_skip_spaces (infile
);
736 dump_and_abort (')', c
, infile
);
738 XSTR (return_rtx
, i
) = stringbuf
;
743 read_name (tmp_char
, infile
);
744 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
745 tmp_wide
= atoi (tmp_char
);
747 tmp_wide
= atol (tmp_char
);
749 XWINT (return_rtx
, i
) = tmp_wide
;
754 read_name (tmp_char
, infile
);
755 tmp_int
= atoi (tmp_char
);
756 XINT (return_rtx
, i
) = tmp_int
;
761 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
763 fprintf (stderr
, "\tfile position: %ld\n", ftell (infile
));
767 c
= read_skip_spaces (infile
);
769 dump_and_abort (')', c
, infile
);
774 /* This is called once per compilation, before any rtx's are constructed.
775 It initializes the vector `rtx_length', the extra CC modes, if any,
776 and computes certain commonly-used modes. */
781 int min_class_size
[(int) MAX_MODE_CLASS
];
782 enum machine_mode mode
;
785 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
786 rtx_length
[i
] = strlen (rtx_format
[i
]);
788 /* Make CONST_DOUBLE bigger, if real values are bigger than
789 it normally expects to have room for.
790 Note that REAL_VALUE_TYPE is not defined by default,
791 since tree.h is not included. But the default dfn as `double'
793 #ifdef REAL_VALUE_TYPE
794 i
= sizeof (REAL_VALUE_TYPE
) / sizeof (rtunion
) + 2;
795 if (rtx_length
[(int) CONST_DOUBLE
] < i
)
797 char *s
= (char *) xmalloc (i
+ 1);
798 rtx_length
[(int) CONST_DOUBLE
] = i
;
799 rtx_format
[(int) CONST_DOUBLE
] = s
;
802 /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
803 of as many `w's as we now have elements. Subtract two from
804 the size to account for the 'e' and the '0'. */
805 for (i
= 2; i
< rtx_length
[(int) CONST_DOUBLE
]; i
++)
811 #ifdef EXTRA_CC_MODES
812 for (i
= (int) CCmode
+ 1; i
< (int) MAX_MACHINE_MODE
; i
++)
814 mode_class
[i
] = MODE_CC
;
815 mode_size
[i
] = mode_size
[(int) CCmode
];
816 mode_unit_size
[i
] = mode_unit_size
[(int) CCmode
];
817 mode_wider_mode
[i
- 1] = (enum machine_mode
) i
;
818 mode_wider_mode
[i
] = VOIDmode
;
822 /* Find the narrowest mode for each class and compute the word and byte
825 for (i
= 0; i
< (int) MAX_MODE_CLASS
; i
++)
826 min_class_size
[i
] = 1000;
828 byte_mode
= VOIDmode
;
829 word_mode
= VOIDmode
;
831 for (mode
= VOIDmode
; (int) mode
< (int) MAX_MACHINE_MODE
;
832 mode
= (enum machine_mode
) ((int) mode
+ 1))
834 if (GET_MODE_SIZE (mode
) < min_class_size
[(int) GET_MODE_CLASS (mode
)])
836 class_narrowest_mode
[(int) GET_MODE_CLASS (mode
)] = mode
;
837 min_class_size
[(int) GET_MODE_CLASS (mode
)] = GET_MODE_SIZE (mode
);
839 if (GET_MODE_CLASS (mode
) == MODE_INT
840 && GET_MODE_BITSIZE (mode
) == BITS_PER_UNIT
841 && byte_mode
== VOIDmode
)
844 if (GET_MODE_CLASS (mode
) == MODE_INT
845 && GET_MODE_BITSIZE (mode
) == BITS_PER_WORD
846 && word_mode
== VOIDmode
)
852 gcc_memset (dest
, value
, len
)