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 /* Calculate the format for CONST_DOUBLE. This depends on the relative
31 widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
33 We need to go out to 0wwwww, since REAL_ARITHMETIC assumes 16-bits
34 per element in REAL_VALUE_TYPE.
36 This is duplicated in gengenrtl.c.
38 A number of places assume that there are always at least two 'w'
39 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
41 #ifdef REAL_ARITHMETIC
42 # if MAX_LONG_DOUBLE_TYPE_SIZE == 96
44 (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
46 # if MAX_LONG_DOUBLE_TYPE_SIZE == 128
48 (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
50 # if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
52 (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
56 #endif /* REAL_ARITHMETIC */
59 # if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
62 # if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
65 # if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
70 #endif /* REAL_WIDTH */
73 # define CONST_DOUBLE_FORMAT "0ww"
76 # define CONST_DOUBLE_FORMAT "0ww"
79 # define CONST_DOUBLE_FORMAT "0www"
82 # define CONST_DOUBLE_FORMAT "0wwww"
85 # define CONST_DOUBLE_FORMAT "0wwwww"
87 # define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
94 /* Indexed by rtx code, gives number of operands for an rtx with that code.
95 Does NOT include rtx header data (code and links). */
97 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
99 const unsigned char rtx_length
[NUM_RTX_CODE
] = {
105 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
107 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
109 const char * const rtx_name
[NUM_RTX_CODE
] = {
110 #include "rtl.def" /* rtl expressions are documented here */
115 /* Indexed by machine mode, gives the name of that machine mode.
116 This name does not include the letters "mode". */
118 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) NAME,
120 const char * const mode_name
[NUM_MACHINE_MODES
] = {
121 #include "machmode.def"
126 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */
128 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) CLASS,
130 const enum mode_class mode_class
[NUM_MACHINE_MODES
] = {
131 #include "machmode.def"
136 /* Indexed by machine mode, gives the length of the mode, in bits.
137 GET_MODE_BITSIZE uses this. */
139 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) BITSIZE,
141 const unsigned short mode_bitsize
[NUM_MACHINE_MODES
] = {
142 #include "machmode.def"
147 /* Indexed by machine mode, gives the length of the mode, in bytes.
148 GET_MODE_SIZE uses this. */
150 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) SIZE,
152 const unsigned char mode_size
[NUM_MACHINE_MODES
] = {
153 #include "machmode.def"
158 /* Indexed by machine mode, gives the length of the mode's subunit.
159 GET_MODE_UNIT_SIZE uses this. */
161 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) UNIT,
163 const unsigned char mode_unit_size
[NUM_MACHINE_MODES
] = {
164 #include "machmode.def" /* machine modes are documented here */
169 /* Indexed by machine mode, gives next wider natural mode
170 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
173 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
174 (unsigned char) WIDER,
176 const unsigned char mode_wider_mode
[NUM_MACHINE_MODES
] = {
177 #include "machmode.def" /* machine modes are documented here */
182 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
183 ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
185 /* Indexed by machine mode, gives mask of significant bits in mode. */
187 const unsigned HOST_WIDE_INT mode_mask_array
[NUM_MACHINE_MODES
] = {
188 #include "machmode.def"
193 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
195 /* Indexed by machine mode, gives the mode of the inner elements in a
198 const enum machine_mode inner_mode_array
[NUM_MACHINE_MODES
] = {
199 #include "machmode.def"
202 /* Indexed by mode class, gives the narrowest mode for each class.
203 The Q modes are always of width 1 (2 for complex) - it is impossible
204 for any mode to be narrower.
206 Note that we use QImode instead of BImode for MODE_INT, since
207 otherwise the middle end will try to use it for bitfields in
208 structures and the like, which we do not want. Only the target
209 md file should generate BImode widgets. */
211 const enum machine_mode class_narrowest_mode
[(int) MAX_MODE_CLASS
] = {
212 /* MODE_RANDOM */ VOIDmode
,
213 /* MODE_INT */ QImode
,
214 /* MODE_FLOAT */ QFmode
,
215 /* MODE_PARTIAL_INT */ PQImode
,
216 /* MODE_CC */ CCmode
,
217 /* MODE_COMPLEX_INT */ CQImode
,
218 /* MODE_COMPLEX_FLOAT */ QCmode
,
219 /* MODE_VECTOR_INT */ V2QImode
,
220 /* MODE_VECTOR_FLOAT */ V2SFmode
224 /* Indexed by rtx code, gives a sequence of operand-types for
225 rtx's of that code. The sequence is a C string in which
226 each character describes one operand. */
228 const char * const rtx_format
[NUM_RTX_CODE
] = {
230 can cause a warning message
231 "0" field is unused (or used in a phase-dependent manner)
235 "n" like "i", but prints entries from `note_insn_name'
236 "w" an integer of width HOST_BITS_PER_WIDE_INT
238 "s" a pointer to a string
240 "S" like "s", but optional:
241 the containing rtx may end before this operand
242 "T" like "s", but treated specially by the RTL reader;
243 only found in machine description patterns.
244 "e" a pointer to an rtl expression
245 prints the expression
246 "E" a pointer to a vector that points to a number of rtl expressions
247 prints a list of the rtl expressions
248 "V" like "E", but optional:
249 the containing rtx may end before this operand
250 "u" a pointer to another insn
251 prints the uid of the insn.
252 "b" is a pointer to a bitmap header.
253 "t" is a tree pointer. */
255 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
256 #include "rtl.def" /* rtl expressions are defined here */
260 /* Indexed by rtx code, gives a character representing the "class" of
261 that rtx code. See rtl.def for documentation on the defined classes. */
263 const char rtx_class
[NUM_RTX_CODE
] = {
264 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
265 #include "rtl.def" /* rtl expressions are defined here */
269 /* Names for kinds of NOTEs and REG_NOTEs. */
271 const char * const note_insn_name
[NOTE_INSN_MAX
- NOTE_INSN_BIAS
] =
273 "", "NOTE_INSN_DELETED",
274 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
275 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
276 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
277 "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
278 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
279 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
280 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
281 "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
282 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
283 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
286 const char * const reg_note_name
[] =
288 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
289 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
290 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
291 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
292 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
293 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
294 "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
295 "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
300 /* Allocate an rtx vector of N elements.
301 Store the length, and initialize all elements to zero. */
309 rt
= ggc_alloc_rtvec (n
);
310 /* clear out the vector */
311 memset (&rt
->elem
[0], 0, n
* sizeof (rtx
));
313 PUT_NUM_ELEM (rt
, n
);
317 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
318 all the rest is initialized to zero. */
325 int n
= GET_RTX_LENGTH (code
);
327 rt
= ggc_alloc_rtx (n
);
329 /* We want to clear everything up to the FLD array. Normally, this
330 is one int, but we don't want to assume that and it isn't very
331 portable anyway; this is. */
333 memset (rt
, 0, sizeof (struct rtx_def
) - sizeof (rtunion
));
339 /* Create a new copy of an rtx.
340 Recursively copies the operands of the rtx,
341 except for those few rtx codes that are sharable. */
350 const char *format_ptr
;
352 code
= GET_CODE (orig
);
366 /* SCRATCH must be shared because they represent distinct values. */
371 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
372 a LABEL_REF, it isn't sharable. */
373 if (GET_CODE (XEXP (orig
, 0)) == PLUS
374 && GET_CODE (XEXP (XEXP (orig
, 0), 0)) == SYMBOL_REF
375 && GET_CODE (XEXP (XEXP (orig
, 0), 1)) == CONST_INT
)
379 /* A MEM with a constant address is not sharable. The problem is that
380 the constant address may need to be reloaded. If the mem is shared,
381 then reloading one copy of this mem will cause all copies to appear
382 to have been reloaded. */
388 copy
= rtx_alloc (code
);
390 /* Copy the various flags, and other information. We assume that
391 all fields need copying, and then clear the fields that should
392 not be copied. That is the sensible default behavior, and forces
393 us to explicitly document why we are *not* copying a flag. */
394 memcpy (copy
, orig
, sizeof (struct rtx_def
) - sizeof (rtunion
));
396 /* We do not copy the USED flag, which is used as a mark bit during
397 walks over the RTL. */
400 /* We do not copy FRAME_RELATED for INSNs. */
401 if (GET_RTX_CLASS (code
) == 'i')
402 copy
->frame_related
= 0;
403 copy
->jump
= orig
->jump
;
404 copy
->call
= orig
->call
;
406 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
408 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
410 copy
->fld
[i
] = orig
->fld
[i
];
411 switch (*format_ptr
++)
414 if (XEXP (orig
, i
) != NULL
)
415 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
420 if (XVEC (orig
, i
) != NULL
)
422 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
423 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
424 XVECEXP (copy
, i
, j
) = copy_rtx (XVECEXP (orig
, i
, j
));
436 /* These are left unchanged. */
446 /* Create a new copy of an rtx. Only copy just one level. */
449 shallow_copy_rtx (orig
)
453 RTX_CODE code
= GET_CODE (orig
);
454 rtx copy
= rtx_alloc (code
);
456 PUT_MODE (copy
, GET_MODE (orig
));
457 copy
->in_struct
= orig
->in_struct
;
458 copy
->volatil
= orig
->volatil
;
459 copy
->unchanging
= orig
->unchanging
;
460 copy
->integrated
= orig
->integrated
;
461 copy
->frame_related
= orig
->frame_related
;
463 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
464 copy
->fld
[i
] = orig
->fld
[i
];
469 /* Return the alignment of MODE. This will be bounded by 1 and
470 BIGGEST_ALIGNMENT. */
473 get_mode_alignment (mode
)
474 enum machine_mode mode
;
476 unsigned int alignment
;
478 if (GET_MODE_CLASS (mode
) == MODE_COMPLEX_FLOAT
479 || GET_MODE_CLASS (mode
) == MODE_COMPLEX_INT
)
480 alignment
= GET_MODE_UNIT_SIZE (mode
);
482 alignment
= GET_MODE_SIZE (mode
);
484 /* Extract the LSB of the size. */
485 alignment
= alignment
& -alignment
;
486 alignment
*= BITS_PER_UNIT
;
488 alignment
= MIN (BIGGEST_ALIGNMENT
, MAX (1, alignment
));
492 /* This is 1 until after the rtl generation pass. */
493 int rtx_equal_function_value_matters
;
495 /* Nonzero when we are generating CONCATs. */
496 int generating_concat_p
;
498 /* Return 1 if X and Y are identical-looking rtx's.
499 This is the Lisp function EQUAL for rtx arguments. */
512 if (x
== 0 || y
== 0)
516 /* Rtx's of different codes cannot be equal. */
517 if (code
!= GET_CODE (y
))
520 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
521 (REG:SI x) and (REG:HI x) are NOT equivalent. */
523 if (GET_MODE (x
) != GET_MODE (y
))
526 /* Some RTL can be compared nonrecursively. */
530 /* Until rtl generation is complete, don't consider a reference
531 to the return register of the current function the same as
532 the return from a called function. This eases the job of
533 function integration. Once the distinction is no longer
534 needed, they can be considered equivalent. */
535 return (REGNO (x
) == REGNO (y
)
536 && (! rtx_equal_function_value_matters
537 || REG_FUNCTION_VALUE_P (x
) == REG_FUNCTION_VALUE_P (y
)));
540 return XEXP (x
, 0) == XEXP (y
, 0);
543 return XSTR (x
, 0) == XSTR (y
, 0);
555 /* Compare the elements. If any pair of corresponding elements
556 fail to match, return 0 for the whole things. */
558 fmt
= GET_RTX_FORMAT (code
);
559 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
564 if (XWINT (x
, i
) != XWINT (y
, i
))
570 if (XINT (x
, i
) != XINT (y
, i
))
576 /* Two vectors must have the same length. */
577 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
580 /* And the corresponding elements must match. */
581 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
582 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
587 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
593 if ((XSTR (x
, i
) || XSTR (y
, i
))
594 && (! XSTR (x
, i
) || ! XSTR (y
, i
)
595 || strcmp (XSTR (x
, i
), XSTR (y
, i
))))
600 /* These are just backpointers, so they don't matter. */
607 /* It is believed that rtx's at this level will never
608 contain anything but integers and other rtx's,
609 except for within LABEL_REFs and SYMBOL_REFs. */
617 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
619 rtl_check_failed_bounds (r
, n
, file
, line
, func
)
627 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
628 n
, GET_RTX_NAME (GET_CODE (r
)), GET_RTX_LENGTH (GET_CODE (r
)) - 1,
629 func
, trim_filename (file
), line
);
633 rtl_check_failed_type1 (r
, n
, c1
, file
, line
, func
)
642 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
643 n
, c1
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
644 func
, trim_filename (file
), line
);
648 rtl_check_failed_type2 (r
, n
, c1
, c2
, file
, line
, func
)
658 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
659 n
, c1
, c2
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
660 func
, trim_filename (file
), line
);
664 rtl_check_failed_code1 (r
, code
, file
, line
, func
)
671 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
672 GET_RTX_NAME (code
), GET_RTX_NAME (GET_CODE (r
)), func
,
673 trim_filename (file
), line
);
677 rtl_check_failed_code2 (r
, code1
, code2
, file
, line
, func
)
679 enum rtx_code code1
, code2
;
685 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
686 GET_RTX_NAME (code1
), GET_RTX_NAME (code2
), GET_RTX_NAME (GET_CODE (r
)),
687 func
, trim_filename (file
), line
);
690 /* XXX Maybe print the vector? */
692 rtvec_check_failed_bounds (r
, n
, file
, line
, func
)
700 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
701 n
, GET_NUM_ELEM (r
) - 1, func
, trim_filename (file
), line
);
703 #endif /* ENABLE_RTL_CHECKING */