1 /* RTL utility routines.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 /* Indexed by rtx code, gives number of operands for an rtx with that code.
31 Does NOT include rtx header data (code and links). */
33 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
35 const unsigned char rtx_length[NUM_RTX_CODE] = {
41 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
43 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
45 const char * const rtx_name[NUM_RTX_CODE] = {
46 #include "rtl.def" /* rtl expressions are documented here */
51 /* Indexed by machine mode, gives the name of that machine mode.
52 This name does not include the letters "mode". */
54 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) NAME,
56 const char * const mode_name[NUM_MACHINE_MODES] = {
57 #include "machmode.def"
62 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */
64 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) CLASS,
66 const enum mode_class mode_class[NUM_MACHINE_MODES] = {
67 #include "machmode.def"
72 /* Indexed by machine mode, gives the length of the mode, in bits.
73 GET_MODE_BITSIZE uses this. */
75 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) BITSIZE,
77 const unsigned short mode_bitsize[NUM_MACHINE_MODES] = {
78 #include "machmode.def"
83 /* Indexed by machine mode, gives the length of the mode, in bytes.
84 GET_MODE_SIZE uses this. */
86 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) SIZE,
88 const unsigned char mode_size[NUM_MACHINE_MODES] = {
89 #include "machmode.def"
94 /* Indexed by machine mode, gives the length of the mode's subunit.
95 GET_MODE_UNIT_SIZE uses this. */
97 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) UNIT,
99 const unsigned char mode_unit_size[NUM_MACHINE_MODES] = {
100 #include "machmode.def" /* machine modes are documented here */
105 /* Indexed by machine mode, gives next wider natural mode
106 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
109 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
110 (unsigned char) WIDER,
112 const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = {
113 #include "machmode.def" /* machine modes are documented here */
118 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
119 ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
121 /* Indexed by machine mode, gives mask of significant bits in mode. */
123 const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES] = {
124 #include "machmode.def"
129 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
131 /* Indexed by machine mode, gives the mode of the inner elements in a
134 const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = {
135 #include "machmode.def"
138 /* Indexed by mode class, gives the narrowest mode for each class.
139 The Q modes are always of width 1 (2 for complex) - it is impossible
140 for any mode to be narrower.
142 Note that we use QImode instead of BImode for MODE_INT, since
143 otherwise the middle end will try to use it for bitfields in
144 structures and the like, which we do not want. Only the target
145 md file should generate BImode widgets. */
147 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
148 /* MODE_RANDOM */ VOIDmode,
149 /* MODE_INT */ QImode,
150 /* MODE_FLOAT */ QFmode,
151 /* MODE_PARTIAL_INT */ PQImode,
152 /* MODE_CC */ CCmode,
153 /* MODE_COMPLEX_INT */ CQImode,
154 /* MODE_COMPLEX_FLOAT */ QCmode,
155 /* MODE_VECTOR_INT */ V1DImode,
156 /* MODE_VECTOR_FLOAT */ V2SFmode
160 /* Indexed by rtx code, gives a sequence of operand-types for
161 rtx's of that code. The sequence is a C string in which
162 each character describes one operand. */
164 const char * const rtx_format[NUM_RTX_CODE] = {
166 can cause a warning message
167 "0" field is unused (or used in a phase-dependent manner)
171 "n" like "i", but prints entries from `note_insn_name'
172 "w" an integer of width HOST_BITS_PER_WIDE_INT
174 "s" a pointer to a string
176 "S" like "s", but optional:
177 the containing rtx may end before this operand
178 "T" like "s", but treated specially by the RTL reader;
179 only found in machine description patterns.
180 "e" a pointer to an rtl expression
181 prints the expression
182 "E" a pointer to a vector that points to a number of rtl expressions
183 prints a list of the rtl expressions
184 "V" like "E", but optional:
185 the containing rtx may end before this operand
186 "u" a pointer to another insn
187 prints the uid of the insn.
188 "b" is a pointer to a bitmap header.
189 "B" is a basic block pointer.
190 "t" is a tree pointer. */
192 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
193 #include "rtl.def" /* rtl expressions are defined here */
197 /* Indexed by rtx code, gives a character representing the "class" of
198 that rtx code. See rtl.def for documentation on the defined classes. */
200 const char rtx_class[NUM_RTX_CODE] = {
201 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
202 #include "rtl.def" /* rtl expressions are defined here */
206 /* Names for kinds of NOTEs and REG_NOTEs. */
208 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
210 "", "NOTE_INSN_DELETED",
211 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
212 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
213 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
214 "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
215 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
216 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
217 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
218 "NOTE_INSN_REPEATED_LINE_NUMBER",
219 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE",
220 "NOTE_INSN_PREDICTION"
223 const char * const reg_note_name[] =
225 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
226 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
227 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
228 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
229 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
230 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
231 "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
232 "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
237 /* Allocate an rtx vector of N elements.
238 Store the length, and initialize all elements to zero. */
246 rt = ggc_alloc_rtvec (n);
247 /* clear out the vector */
248 memset (&rt->elem[0], 0, n * sizeof (rtx));
250 PUT_NUM_ELEM (rt, n);
254 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
255 all the rest is initialized to zero. */
262 int n = GET_RTX_LENGTH (code);
264 rt = ggc_alloc_rtx (n);
266 /* We want to clear everything up to the FLD array. Normally, this
267 is one int, but we don't want to assume that and it isn't very
268 portable anyway; this is. */
270 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
276 /* Create a new copy of an rtx.
277 Recursively copies the operands of the rtx,
278 except for those few rtx codes that are sharable. */
287 const char *format_ptr;
289 code = GET_CODE (orig);
303 /* SCRATCH must be shared because they represent distinct values. */
308 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
309 a LABEL_REF, it isn't sharable. */
310 if (GET_CODE (XEXP (orig, 0)) == PLUS
311 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
312 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
316 /* A MEM with a constant address is not sharable. The problem is that
317 the constant address may need to be reloaded. If the mem is shared,
318 then reloading one copy of this mem will cause all copies to appear
319 to have been reloaded. */
325 copy = rtx_alloc (code);
327 /* Copy the various flags, and other information. We assume that
328 all fields need copying, and then clear the fields that should
329 not be copied. That is the sensible default behavior, and forces
330 us to explicitly document why we are *not* copying a flag. */
331 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
333 /* We do not copy the USED flag, which is used as a mark bit during
334 walks over the RTL. */
335 RTX_FLAG (copy, used) = 0;
337 /* We do not copy FRAME_RELATED for INSNs. */
338 if (GET_RTX_CLASS (code) == 'i')
339 RTX_FLAG (copy, frame_related) = 0;
340 RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
341 RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
343 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
345 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
347 copy->fld[i] = orig->fld[i];
348 switch (*format_ptr++)
351 if (XEXP (orig, i) != NULL)
352 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
357 if (XVEC (orig, i) != NULL)
359 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
360 for (j = 0; j < XVECLEN (copy, i); j++)
361 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
374 /* These are left unchanged. */
384 /* Create a new copy of an rtx. Only copy just one level. */
387 shallow_copy_rtx (orig)
391 RTX_CODE code = GET_CODE (orig);
392 rtx copy = rtx_alloc (code);
394 PUT_MODE (copy, GET_MODE (orig));
395 RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
396 RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
397 RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
398 RTX_FLAG (copy, integrated) = RTX_FLAG (orig, integrated);
399 RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
401 for (i = 0; i < GET_RTX_LENGTH (code); i++)
402 copy->fld[i] = orig->fld[i];
407 /* Return the alignment of MODE. This will be bounded by 1 and
408 BIGGEST_ALIGNMENT. */
411 get_mode_alignment (mode)
412 enum machine_mode mode;
414 unsigned int alignment;
416 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
417 || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
418 alignment = GET_MODE_UNIT_SIZE (mode);
420 alignment = GET_MODE_SIZE (mode);
422 /* Extract the LSB of the size. */
423 alignment = alignment & -alignment;
424 alignment *= BITS_PER_UNIT;
426 alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
430 /* This is 1 until after the rtl generation pass. */
431 int rtx_equal_function_value_matters;
433 /* Nonzero when we are generating CONCATs. */
434 int generating_concat_p;
436 /* Return 1 if X and Y are identical-looking rtx's.
437 This is the Lisp function EQUAL for rtx arguments. */
450 if (x == 0 || y == 0)
454 /* Rtx's of different codes cannot be equal. */
455 if (code != GET_CODE (y))
458 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
459 (REG:SI x) and (REG:HI x) are NOT equivalent. */
461 if (GET_MODE (x) != GET_MODE (y))
464 /* Some RTL can be compared nonrecursively. */
468 /* Until rtl generation is complete, don't consider a reference
469 to the return register of the current function the same as
470 the return from a called function. This eases the job of
471 function integration. Once the distinction is no longer
472 needed, they can be considered equivalent. */
473 return (REGNO (x) == REGNO (y)
474 && (! rtx_equal_function_value_matters
475 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
478 return XEXP (x, 0) == XEXP (y, 0);
481 return XSTR (x, 0) == XSTR (y, 0);
493 /* Compare the elements. If any pair of corresponding elements
494 fail to match, return 0 for the whole things. */
496 fmt = GET_RTX_FORMAT (code);
497 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
502 if (XWINT (x, i) != XWINT (y, i))
508 if (XINT (x, i) != XINT (y, i))
514 /* Two vectors must have the same length. */
515 if (XVECLEN (x, i) != XVECLEN (y, i))
518 /* And the corresponding elements must match. */
519 for (j = 0; j < XVECLEN (x, i); j++)
520 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
525 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
531 if ((XSTR (x, i) || XSTR (y, i))
532 && (! XSTR (x, i) || ! XSTR (y, i)
533 || strcmp (XSTR (x, i), XSTR (y, i))))
538 /* These are just backpointers, so they don't matter. */
545 /* It is believed that rtx's at this level will never
546 contain anything but integers and other rtx's,
547 except for within LABEL_REFs and SYMBOL_REFs. */
555 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
557 rtl_check_failed_bounds (r, n, file, line, func)
565 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
566 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
567 func, trim_filename (file), line);
571 rtl_check_failed_type1 (r, n, c1, file, line, func)
580 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
581 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
582 func, trim_filename (file), line);
586 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
596 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
597 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
598 func, trim_filename (file), line);
602 rtl_check_failed_code1 (r, code, file, line, func)
609 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
610 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
611 trim_filename (file), line);
615 rtl_check_failed_code2 (r, code1, code2, file, line, func)
617 enum rtx_code code1, code2;
623 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
624 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
625 func, trim_filename (file), line);
628 /* XXX Maybe print the vector? */
630 rtvec_check_failed_bounds (r, n, file, line, func)
638 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
639 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
641 #endif /* ENABLE_RTL_CHECKING */
643 #if defined ENABLE_RTL_FLAG_CHECKING
645 rtl_check_failed_flag (name, r, file, line, func)
653 ("RTL flag check: %s used with unexpected rtx code `%s' in %s, at %s:%d",
654 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
656 #endif /* ENABLE_RTL_FLAG_CHECKING */