1 /* RTL utility routines.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file is compiled twice: once for the generator programs
22 once for the compiler. */
30 #include "coretypes.h"
42 /* Indexed by rtx code, gives number of operands for an rtx with that code.
43 Does NOT include rtx header data (code and links). */
45 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
47 const unsigned char rtx_length
[NUM_RTX_CODE
] = {
53 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
55 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
57 const char * const rtx_name
[NUM_RTX_CODE
] = {
58 #include "rtl.def" /* rtl expressions are documented here */
63 /* Indexed by rtx code, gives a sequence of operand-types for
64 rtx's of that code. The sequence is a C string in which
65 each character describes one operand. */
67 const char * const rtx_format
[NUM_RTX_CODE
] = {
69 can cause a warning message
70 "0" field is unused (or used in a phase-dependent manner)
74 "n" like "i", but prints entries from `note_insn_name'
75 "w" an integer of width HOST_BITS_PER_WIDE_INT
77 "s" a pointer to a string
79 "S" like "s", but optional:
80 the containing rtx may end before this operand
81 "T" like "s", but treated specially by the RTL reader;
82 only found in machine description patterns.
83 "e" a pointer to an rtl expression
85 "E" a pointer to a vector that points to a number of rtl expressions
86 prints a list of the rtl expressions
87 "V" like "E", but optional:
88 the containing rtx may end before this operand
89 "u" a pointer to another insn
90 prints the uid of the insn.
91 "b" is a pointer to a bitmap header.
92 "B" is a basic block pointer.
93 "t" is a tree pointer. */
95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
96 #include "rtl.def" /* rtl expressions are defined here */
100 /* Indexed by rtx code, gives a character representing the "class" of
101 that rtx code. See rtl.def for documentation on the defined classes. */
103 const enum rtx_class rtx_class
[NUM_RTX_CODE
] = {
104 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
105 #include "rtl.def" /* rtl expressions are defined here */
109 /* Indexed by rtx code, gives the size of the rtx in bytes. */
111 const unsigned char rtx_code_size
[NUM_RTX_CODE
] = {
112 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \
113 ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE || (ENUM) == CONST_FIXED\
114 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \
115 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
121 /* Names for kinds of NOTEs and REG_NOTEs. */
123 const char * const note_insn_name
[NOTE_INSN_MAX
] =
125 #define DEF_INSN_NOTE(NAME) #NAME,
126 #include "insn-notes.def"
130 const char * const reg_note_name
[REG_NOTE_MAX
] =
132 #define DEF_REG_NOTE(NAME) #NAME,
133 #include "reg-notes.def"
137 #ifdef GATHER_STATISTICS
138 static int rtx_alloc_counts
[(int) LAST_AND_UNUSED_RTX_CODE
];
139 static int rtx_alloc_sizes
[(int) LAST_AND_UNUSED_RTX_CODE
];
140 static int rtvec_alloc_counts
;
141 static int rtvec_alloc_sizes
;
145 /* Allocate an rtx vector of N elements.
146 Store the length, and initialize all elements to zero. */
153 rt
= ggc_alloc_rtvec (n
);
154 /* Clear out the vector. */
155 memset (&rt
->elem
[0], 0, n
* sizeof (rtx
));
157 PUT_NUM_ELEM (rt
, n
);
159 #ifdef GATHER_STATISTICS
160 rtvec_alloc_counts
++;
161 rtvec_alloc_sizes
+= n
* sizeof (rtx
);
167 /* Create a bitwise copy of VEC. */
170 shallow_copy_rtvec (rtvec vec
)
175 n
= GET_NUM_ELEM (vec
);
176 newvec
= rtvec_alloc (n
);
177 memcpy (&newvec
->elem
[0], &vec
->elem
[0], sizeof (rtx
) * n
);
181 /* Return the number of bytes occupied by rtx value X. */
184 rtx_size (const_rtx x
)
186 if (GET_CODE (x
) == SYMBOL_REF
&& SYMBOL_REF_HAS_BLOCK_INFO_P (x
))
187 return RTX_HDR_SIZE
+ sizeof (struct block_symbol
);
188 return RTX_CODE_SIZE (GET_CODE (x
));
191 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
192 all the rest is initialized to zero. */
195 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL
)
199 rt
= (rtx
) ggc_alloc_zone_pass_stat (RTX_CODE_SIZE (code
), &rtl_zone
);
201 /* We want to clear everything up to the FLD array. Normally, this
202 is one int, but we don't want to assume that and it isn't very
203 portable anyway; this is. */
205 memset (rt
, 0, RTX_HDR_SIZE
);
208 #ifdef GATHER_STATISTICS
209 rtx_alloc_counts
[code
]++;
210 rtx_alloc_sizes
[code
] += RTX_CODE_SIZE (code
);
217 /* Return true if ORIG is a sharable CONST. */
220 shared_const_p (const_rtx orig
)
222 gcc_assert (GET_CODE (orig
) == CONST
);
224 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
225 a LABEL_REF, it isn't sharable. */
226 return (GET_CODE (XEXP (orig
, 0)) == PLUS
227 && GET_CODE (XEXP (XEXP (orig
, 0), 0)) == SYMBOL_REF
228 && CONST_INT_P(XEXP (XEXP (orig
, 0), 1)));
232 /* Create a new copy of an rtx.
233 Recursively copies the operands of the rtx,
234 except for those few rtx codes that are sharable. */
242 const char *format_ptr
;
244 code
= GET_CODE (orig
);
260 /* SCRATCH must be shared because they represent distinct values. */
263 if (REG_P (XEXP (orig
, 0)) && REGNO (XEXP (orig
, 0)) < FIRST_PSEUDO_REGISTER
)
268 if (shared_const_p (orig
))
272 /* A MEM with a constant address is not sharable. The problem is that
273 the constant address may need to be reloaded. If the mem is shared,
274 then reloading one copy of this mem will cause all copies to appear
275 to have been reloaded. */
281 /* Copy the various flags, fields, and other information. We assume
282 that all fields need copying, and then clear the fields that should
283 not be copied. That is the sensible default behavior, and forces
284 us to explicitly document why we are *not* copying a flag. */
285 copy
= shallow_copy_rtx (orig
);
287 /* We do not copy the USED flag, which is used as a mark bit during
288 walks over the RTL. */
289 RTX_FLAG (copy
, used
) = 0;
291 /* We do not copy FRAME_RELATED for INSNs. */
293 RTX_FLAG (copy
, frame_related
) = 0;
294 RTX_FLAG (copy
, jump
) = RTX_FLAG (orig
, jump
);
295 RTX_FLAG (copy
, call
) = RTX_FLAG (orig
, call
);
297 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
299 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
300 switch (*format_ptr
++)
303 if (XEXP (orig
, i
) != NULL
)
304 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
309 if (XVEC (orig
, i
) != NULL
)
311 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
312 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
313 XVECEXP (copy
, i
, j
) = copy_rtx (XVECEXP (orig
, i
, j
));
326 /* These are left unchanged. */
335 /* Create a new copy of an rtx. Only copy just one level. */
338 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL
)
340 const unsigned int size
= rtx_size (orig
);
341 rtx
const copy
= (rtx
) ggc_alloc_zone_pass_stat (size
, &rtl_zone
);
342 return (rtx
) memcpy (copy
, orig
, size
);
345 /* Nonzero when we are generating CONCATs. */
346 int generating_concat_p
;
348 /* Nonzero when we are expanding trees to RTL. */
349 int currently_expanding_to_rtl
;
353 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
354 When the callback returns true, we continue with the new pair.
355 Whenever changing this function check if rtx_equal_p below doesn't need
359 rtx_equal_p_cb (const_rtx x
, const_rtx y
, rtx_equal_p_callback_function cb
)
369 if (x
== 0 || y
== 0)
372 /* Invoke the callback first. */
374 && ((*cb
) (&x
, &y
, &nx
, &ny
)))
375 return rtx_equal_p_cb (nx
, ny
, cb
);
378 /* Rtx's of different codes cannot be equal. */
379 if (code
!= GET_CODE (y
))
382 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
383 (REG:SI x) and (REG:HI x) are NOT equivalent. */
385 if (GET_MODE (x
) != GET_MODE (y
))
388 /* Some RTL can be compared nonrecursively. */
392 return (REGNO (x
) == REGNO (y
));
395 return XEXP (x
, 0) == XEXP (y
, 0);
398 return XSTR (x
, 0) == XSTR (y
, 0);
412 /* Compare the elements. If any pair of corresponding elements
413 fail to match, return 0 for the whole thing. */
415 fmt
= GET_RTX_FORMAT (code
);
416 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
421 if (XWINT (x
, i
) != XWINT (y
, i
))
427 if (XINT (x
, i
) != XINT (y
, i
))
433 /* Two vectors must have the same length. */
434 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
437 /* And the corresponding elements must match. */
438 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
439 if (rtx_equal_p_cb (XVECEXP (x
, i
, j
),
440 XVECEXP (y
, i
, j
), cb
) == 0)
445 if (rtx_equal_p_cb (XEXP (x
, i
), XEXP (y
, i
), cb
) == 0)
451 if ((XSTR (x
, i
) || XSTR (y
, i
))
452 && (! XSTR (x
, i
) || ! XSTR (y
, i
)
453 || strcmp (XSTR (x
, i
), XSTR (y
, i
))))
458 /* These are just backpointers, so they don't matter. */
465 /* It is believed that rtx's at this level will never
466 contain anything but integers and other rtx's,
467 except for within LABEL_REFs and SYMBOL_REFs. */
475 /* Return 1 if X and Y are identical-looking rtx's.
476 This is the Lisp function EQUAL for rtx arguments.
477 Whenever changing this function check if rtx_equal_p_cb above doesn't need
481 rtx_equal_p (const_rtx x
, const_rtx y
)
490 if (x
== 0 || y
== 0)
494 /* Rtx's of different codes cannot be equal. */
495 if (code
!= GET_CODE (y
))
498 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
499 (REG:SI x) and (REG:HI x) are NOT equivalent. */
501 if (GET_MODE (x
) != GET_MODE (y
))
504 /* Some RTL can be compared nonrecursively. */
508 return (REGNO (x
) == REGNO (y
));
511 return XEXP (x
, 0) == XEXP (y
, 0);
514 return XSTR (x
, 0) == XSTR (y
, 0);
528 /* Compare the elements. If any pair of corresponding elements
529 fail to match, return 0 for the whole thing. */
531 fmt
= GET_RTX_FORMAT (code
);
532 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
537 if (XWINT (x
, i
) != XWINT (y
, i
))
543 if (XINT (x
, i
) != XINT (y
, i
))
549 /* Two vectors must have the same length. */
550 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
553 /* And the corresponding elements must match. */
554 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
555 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
560 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
566 if ((XSTR (x
, i
) || XSTR (y
, i
))
567 && (! XSTR (x
, i
) || ! XSTR (y
, i
)
568 || strcmp (XSTR (x
, i
), XSTR (y
, i
))))
573 /* These are just backpointers, so they don't matter. */
580 /* It is believed that rtx's at this level will never
581 contain anything but integers and other rtx's,
582 except for within LABEL_REFs and SYMBOL_REFs. */
591 dump_rtx_statistics (void)
593 #ifdef GATHER_STATISTICS
595 int total_counts
= 0;
597 fprintf (stderr
, "\nRTX Kind Count Bytes\n");
598 fprintf (stderr
, "---------------------------------------\n");
599 for (i
= 0; i
< LAST_AND_UNUSED_RTX_CODE
; i
++)
600 if (rtx_alloc_counts
[i
])
602 fprintf (stderr
, "%-20s %7d %10d\n", GET_RTX_NAME (i
),
603 rtx_alloc_counts
[i
], rtx_alloc_sizes
[i
]);
604 total_counts
+= rtx_alloc_counts
[i
];
605 total_sizes
+= rtx_alloc_sizes
[i
];
607 if (rtvec_alloc_counts
)
609 fprintf (stderr
, "%-20s %7d %10d\n", "rtvec",
610 rtvec_alloc_counts
, rtvec_alloc_sizes
);
611 total_counts
+= rtvec_alloc_counts
;
612 total_sizes
+= rtvec_alloc_sizes
;
614 fprintf (stderr
, "---------------------------------------\n");
615 fprintf (stderr
, "%-20s %7d %10d\n",
616 "Total", total_counts
, total_sizes
);
617 fprintf (stderr
, "---------------------------------------\n");
621 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
623 rtl_check_failed_bounds (const_rtx r
, int n
, const char *file
, int line
,
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 (const_rtx r
, int n
, int c1
, const char *file
, int line
,
637 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
638 n
, c1
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
639 func
, trim_filename (file
), line
);
643 rtl_check_failed_type2 (const_rtx r
, int n
, int c1
, int c2
, const char *file
,
644 int line
, const char *func
)
647 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
648 n
, c1
, c2
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
649 func
, trim_filename (file
), line
);
653 rtl_check_failed_code1 (const_rtx r
, enum rtx_code code
, const char *file
,
654 int line
, const char *func
)
656 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
657 GET_RTX_NAME (code
), GET_RTX_NAME (GET_CODE (r
)), func
,
658 trim_filename (file
), line
);
662 rtl_check_failed_code2 (const_rtx r
, enum rtx_code code1
, enum rtx_code code2
,
663 const char *file
, int line
, const char *func
)
666 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
667 GET_RTX_NAME (code1
), GET_RTX_NAME (code2
), GET_RTX_NAME (GET_CODE (r
)),
668 func
, trim_filename (file
), line
);
672 rtl_check_failed_code_mode (const_rtx r
, enum rtx_code code
, enum machine_mode mode
,
673 bool not_mode
, const char *file
, int line
,
676 internal_error ((not_mode
677 ? ("RTL check: expected code '%s' and not mode '%s', "
678 "have code '%s' and mode '%s' in %s, at %s:%d")
679 : ("RTL check: expected code '%s' and mode '%s', "
680 "have code '%s' and mode '%s' in %s, at %s:%d")),
681 GET_RTX_NAME (code
), GET_MODE_NAME (mode
),
682 GET_RTX_NAME (GET_CODE (r
)), GET_MODE_NAME (GET_MODE (r
)),
683 func
, trim_filename (file
), line
);
686 /* Report that line LINE of FILE tried to access the block symbol fields
687 of a non-block symbol. FUNC is the function that contains the line. */
690 rtl_check_failed_block_symbol (const char *file
, int line
, const char *func
)
693 ("RTL check: attempt to treat non-block symbol as a block symbol "
694 "in %s, at %s:%d", func
, trim_filename (file
), line
);
697 /* XXX Maybe print the vector? */
699 rtvec_check_failed_bounds (const_rtvec r
, int n
, const char *file
, int line
,
703 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
704 n
, GET_NUM_ELEM (r
) - 1, func
, trim_filename (file
), line
);
706 #endif /* ENABLE_RTL_CHECKING */
708 #if defined ENABLE_RTL_FLAG_CHECKING
710 rtl_check_failed_flag (const char *name
, const_rtx r
, const char *file
,
711 int line
, const char *func
)
714 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
715 name
, GET_RTX_NAME (GET_CODE (r
)), func
, trim_filename (file
), line
);
717 #endif /* ENABLE_RTL_FLAG_CHECKING */