Daily bump.
[official-gcc.git] / gcc / rtl.c
blob4a30d2174e2ba01f566b9d4a9b3a442b877b7f64
1 /* RTL utility routines.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file is compiled twice: once for the generator programs
21 once for the compiler. */
22 #ifdef GENERATOR_FILE
23 #include "bconfig.h"
24 #else
25 #include "config.h"
26 #endif
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "rtl.h"
32 #ifdef GENERATOR_FILE
33 # include "errors.h"
34 #else
35 # include "rtlhash.h"
36 # include "diagnostic-core.h"
37 #endif
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). */
43 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
45 const unsigned char rtx_length[NUM_RTX_CODE] = {
46 #include "rtl.def"
49 #undef DEF_RTL_EXPR
51 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
53 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
55 const char * const rtx_name[NUM_RTX_CODE] = {
56 #include "rtl.def" /* rtl expressions are documented here */
59 #undef DEF_RTL_EXPR
61 /* Indexed by rtx code, gives a sequence of operand-types for
62 rtx's of that code. The sequence is a C string in which
63 each character describes one operand. */
65 const char * const rtx_format[NUM_RTX_CODE] = {
66 /* "*" undefined.
67 can cause a warning message
68 "0" field is unused (or used in a phase-dependent manner)
69 prints nothing
70 "i" an integer
71 prints the integer
72 "n" like "i", but prints entries from `note_insn_name'
73 "w" an integer of width HOST_BITS_PER_WIDE_INT
74 prints the integer
75 "s" a pointer to a string
76 prints the string
77 "S" like "s", but optional:
78 the containing rtx may end before this operand
79 "T" like "s", but treated specially by the RTL reader;
80 only found in machine description patterns.
81 "e" a pointer to an rtl expression
82 prints the expression
83 "E" a pointer to a vector that points to a number of rtl expressions
84 prints a list of the rtl expressions
85 "V" like "E", but optional:
86 the containing rtx may end before this operand
87 "u" a pointer to another insn
88 prints the uid of the insn.
89 "b" is a pointer to a bitmap header.
90 "B" is a basic block pointer.
91 "t" is a tree pointer.
92 "r" a register.
93 "p" is a poly_uint16 offset. */
95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
96 #include "rtl.def" /* rtl expressions are defined here */
97 #undef DEF_RTL_EXPR
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 */
106 #undef DEF_RTL_EXPR
109 /* Whether rtxs with the given code store data in the hwint field. */
111 #define RTX_CODE_HWINT_P_1(ENUM) \
112 ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE \
113 || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT)
114 #ifdef GENERATOR_FILE
115 #define RTX_CODE_HWINT_P(ENUM) \
116 (RTX_CODE_HWINT_P_1 (ENUM) || (ENUM) == EQ_ATTR_ALT)
117 #else
118 #define RTX_CODE_HWINT_P RTX_CODE_HWINT_P_1
119 #endif
121 /* Indexed by rtx code, gives the size of the rtx in bytes. */
123 const unsigned char rtx_code_size[NUM_RTX_CODE] = {
124 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \
125 (RTX_CODE_HWINT_P (ENUM) \
126 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \
127 : (ENUM) == REG \
128 ? RTX_HDR_SIZE + sizeof (reg_info) \
129 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
131 #include "rtl.def"
132 #undef DEF_RTL_EXPR
135 /* Names for kinds of NOTEs and REG_NOTEs. */
137 const char * const note_insn_name[NOTE_INSN_MAX] =
139 #define DEF_INSN_NOTE(NAME) #NAME,
140 #include "insn-notes.def"
141 #undef DEF_INSN_NOTE
144 const char * const reg_note_name[REG_NOTE_MAX] =
146 #define DEF_REG_NOTE(NAME) #NAME,
147 #include "reg-notes.def"
148 #undef DEF_REG_NOTE
151 static size_t rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
152 static size_t rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
153 static size_t rtvec_alloc_counts;
154 static size_t rtvec_alloc_sizes;
157 /* Allocate an rtx vector of N elements.
158 Store the length, and initialize all elements to zero. */
160 rtvec
161 rtvec_alloc (size_t n)
163 rtvec rt;
165 /* rtvec_def.num_elem is an int. */
166 gcc_assert (n < INT_MAX);
168 rt = ggc_alloc_rtvec_sized (n);
169 /* Clear out the vector. */
170 memset (&rt->elem[0], 0, n * sizeof (rtx));
172 PUT_NUM_ELEM (rt, n);
174 if (GATHER_STATISTICS)
176 rtvec_alloc_counts++;
177 rtvec_alloc_sizes += n * sizeof (rtx);
180 return rt;
183 /* Create a bitwise copy of VEC. */
185 rtvec
186 shallow_copy_rtvec (rtvec vec)
188 rtvec newvec;
189 int n;
191 n = GET_NUM_ELEM (vec);
192 newvec = rtvec_alloc (n);
193 memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
194 return newvec;
197 /* Return the number of bytes occupied by rtx value X. */
199 unsigned int
200 rtx_size (const_rtx x)
202 if (CONST_WIDE_INT_P (x))
203 return (RTX_HDR_SIZE
204 + sizeof (struct hwivec_def)
205 + ((CONST_WIDE_INT_NUNITS (x) - 1)
206 * sizeof (HOST_WIDE_INT)));
207 if (CONST_POLY_INT_P (x))
208 return (RTX_HDR_SIZE
209 + sizeof (struct const_poly_int_def)
210 + CONST_POLY_INT_COEFFS (x).extra_size ());
211 if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
212 return RTX_HDR_SIZE + sizeof (struct block_symbol);
213 return RTX_CODE_SIZE (GET_CODE (x));
216 /* Allocate an rtx of code CODE with EXTRA bytes in it. The CODE is
217 stored in the rtx; all the rest is initialized to zero. */
220 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
222 rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
223 PASS_MEM_STAT);
225 rtx_init (rt, code);
227 if (GATHER_STATISTICS)
229 rtx_alloc_counts[code]++;
230 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
233 return rt;
236 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
237 all the rest is initialized to zero. */
240 rtx_alloc (RTX_CODE code MEM_STAT_DECL)
242 return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
245 /* Write the wide constant X to OUTFILE. */
247 void
248 cwi_output_hex (FILE *outfile, const_rtx x)
250 int i = CWI_GET_NUM_ELEM (x);
251 gcc_assert (i > 0);
252 if (CWI_ELT (x, i - 1) == 0)
253 /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
254 non zero. We want all numbers to have a 0x prefix. */
255 fprintf (outfile, "0x");
256 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
257 while (--i >= 0)
258 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
262 /* Return true if ORIG is a sharable CONST. */
264 bool
265 shared_const_p (const_rtx orig)
267 gcc_assert (GET_CODE (orig) == CONST);
269 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
270 a LABEL_REF, it isn't sharable. */
271 poly_int64 offset;
272 return (GET_CODE (XEXP (orig, 0)) == PLUS
273 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
274 && poly_int_rtx_p (XEXP (XEXP (orig, 0), 1), &offset));
278 /* Create a new copy of an rtx.
279 Recursively copies the operands of the rtx,
280 except for those few rtx codes that are sharable. */
283 copy_rtx (rtx orig)
285 rtx copy;
286 int i, j;
287 RTX_CODE code;
288 const char *format_ptr;
290 code = GET_CODE (orig);
292 switch (code)
294 case REG:
295 case DEBUG_EXPR:
296 case VALUE:
297 CASE_CONST_ANY:
298 case SYMBOL_REF:
299 case CODE_LABEL:
300 case PC:
301 case RETURN:
302 case SIMPLE_RETURN:
303 case SCRATCH:
304 /* SCRATCH must be shared because they represent distinct values. */
305 return orig;
306 case CLOBBER:
307 /* Share clobbers of hard registers, but do not share pseudo reg
308 clobbers or clobbers of hard registers that originated as pseudos.
309 This is needed to allow safe register renaming. */
310 if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
311 && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
312 return orig;
313 break;
315 case CONST:
316 if (shared_const_p (orig))
317 return orig;
318 break;
320 /* A MEM with a constant address is not sharable. The problem is that
321 the constant address may need to be reloaded. If the mem is shared,
322 then reloading one copy of this mem will cause all copies to appear
323 to have been reloaded. */
325 default:
326 break;
329 /* Copy the various flags, fields, and other information. We assume
330 that all fields need copying, and then clear the fields that should
331 not be copied. That is the sensible default behavior, and forces
332 us to explicitly document why we are *not* copying a flag. */
333 copy = shallow_copy_rtx (orig);
335 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
337 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
338 switch (*format_ptr++)
340 case 'e':
341 if (XEXP (orig, i) != NULL)
342 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
343 break;
345 case 'E':
346 case 'V':
347 if (XVEC (orig, i) != NULL)
349 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
350 for (j = 0; j < XVECLEN (copy, i); j++)
351 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
353 break;
355 case 't':
356 case 'w':
357 case 'i':
358 case 'p':
359 case 's':
360 case 'S':
361 case 'T':
362 case 'u':
363 case 'B':
364 case '0':
365 /* These are left unchanged. */
366 break;
368 default:
369 gcc_unreachable ();
371 return copy;
374 /* Create a new copy of an rtx. Only copy just one level. */
377 shallow_copy_rtx (const_rtx orig MEM_STAT_DECL)
379 const unsigned int size = rtx_size (orig);
380 rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
381 memcpy (copy, orig, size);
382 switch (GET_CODE (orig))
384 /* RTX codes copy_rtx_if_shared_1 considers are shareable,
385 the used flag is often used for other purposes. */
386 case REG:
387 case DEBUG_EXPR:
388 case VALUE:
389 CASE_CONST_ANY:
390 case SYMBOL_REF:
391 case CODE_LABEL:
392 case PC:
393 case RETURN:
394 case SIMPLE_RETURN:
395 case SCRATCH:
396 break;
397 default:
398 /* For all other RTXes clear the used flag on the copy.
399 CALL_INSN use "used" flag to indicate it's a fake call. */
400 if (!INSN_P (orig))
401 RTX_FLAG (copy, used) = 0;
402 break;
404 return copy;
407 /* Nonzero when we are generating CONCATs. */
408 int generating_concat_p;
410 /* Nonzero when we are expanding trees to RTL. */
411 int currently_expanding_to_rtl;
415 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
416 When the callback returns true, we continue with the new pair.
417 Whenever changing this function check if rtx_equal_p below doesn't need
418 changing as well. */
421 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
423 int i;
424 int j;
425 enum rtx_code code;
426 const char *fmt;
427 rtx nx, ny;
429 if (x == y)
430 return 1;
431 if (x == 0 || y == 0)
432 return 0;
434 /* Invoke the callback first. */
435 if (cb != NULL
436 && ((*cb) (&x, &y, &nx, &ny)))
437 return rtx_equal_p_cb (nx, ny, cb);
439 code = GET_CODE (x);
440 /* Rtx's of different codes cannot be equal. */
441 if (code != GET_CODE (y))
442 return 0;
444 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
445 (REG:SI x) and (REG:HI x) are NOT equivalent. */
447 if (GET_MODE (x) != GET_MODE (y))
448 return 0;
450 /* MEMs referring to different address space are not equivalent. */
451 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
452 return 0;
454 /* Some RTL can be compared nonrecursively. */
455 switch (code)
457 case REG:
458 return (REGNO (x) == REGNO (y));
460 case LABEL_REF:
461 return label_ref_label (x) == label_ref_label (y);
463 case SYMBOL_REF:
464 return XSTR (x, 0) == XSTR (y, 0);
466 case DEBUG_EXPR:
467 case VALUE:
468 case SCRATCH:
469 CASE_CONST_UNIQUE:
470 return 0;
472 case CONST_VECTOR:
473 if (!same_vector_encodings_p (x, y))
474 return false;
475 break;
477 case DEBUG_IMPLICIT_PTR:
478 return DEBUG_IMPLICIT_PTR_DECL (x)
479 == DEBUG_IMPLICIT_PTR_DECL (y);
481 case DEBUG_PARAMETER_REF:
482 return DEBUG_PARAMETER_REF_DECL (x)
483 == DEBUG_PARAMETER_REF_DECL (y);
485 case ENTRY_VALUE:
486 return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
488 default:
489 break;
492 /* Compare the elements. If any pair of corresponding elements
493 fail to match, return 0 for the whole thing. */
495 fmt = GET_RTX_FORMAT (code);
496 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
498 switch (fmt[i])
500 case 'w':
501 if (XWINT (x, i) != XWINT (y, i))
502 return 0;
503 break;
505 case 'n':
506 case 'i':
507 if (XINT (x, i) != XINT (y, i))
509 #ifndef GENERATOR_FILE
510 if (((code == ASM_OPERANDS && i == 6)
511 || (code == ASM_INPUT && i == 1))
512 && XINT (x, i) == XINT (y, i))
513 break;
514 #endif
515 return 0;
517 break;
519 case 'p':
520 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
521 return 0;
522 break;
524 case 'V':
525 case 'E':
526 /* Two vectors must have the same length. */
527 if (XVECLEN (x, i) != XVECLEN (y, i))
528 return 0;
530 /* And the corresponding elements must match. */
531 for (j = 0; j < XVECLEN (x, i); j++)
532 if (rtx_equal_p_cb (XVECEXP (x, i, j),
533 XVECEXP (y, i, j), cb) == 0)
534 return 0;
535 break;
537 case 'e':
538 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
539 return 0;
540 break;
542 case 'S':
543 case 's':
544 if ((XSTR (x, i) || XSTR (y, i))
545 && (! XSTR (x, i) || ! XSTR (y, i)
546 || strcmp (XSTR (x, i), XSTR (y, i))))
547 return 0;
548 break;
550 case 'u':
551 /* These are just backpointers, so they don't matter. */
552 break;
554 case '0':
555 case 't':
556 break;
558 /* It is believed that rtx's at this level will never
559 contain anything but integers and other rtx's,
560 except for within LABEL_REFs and SYMBOL_REFs. */
561 default:
562 gcc_unreachable ();
565 return 1;
568 /* Return 1 if X and Y are identical-looking rtx's.
569 This is the Lisp function EQUAL for rtx arguments.
570 Whenever changing this function check if rtx_equal_p_cb above doesn't need
571 changing as well. */
574 rtx_equal_p (const_rtx x, const_rtx y)
576 int i;
577 int j;
578 enum rtx_code code;
579 const char *fmt;
581 if (x == y)
582 return 1;
583 if (x == 0 || y == 0)
584 return 0;
586 code = GET_CODE (x);
587 /* Rtx's of different codes cannot be equal. */
588 if (code != GET_CODE (y))
589 return 0;
591 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
592 (REG:SI x) and (REG:HI x) are NOT equivalent. */
594 if (GET_MODE (x) != GET_MODE (y))
595 return 0;
597 /* MEMs referring to different address space are not equivalent. */
598 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
599 return 0;
601 /* Some RTL can be compared nonrecursively. */
602 switch (code)
604 case REG:
605 return (REGNO (x) == REGNO (y));
607 case LABEL_REF:
608 return label_ref_label (x) == label_ref_label (y);
610 case SYMBOL_REF:
611 return XSTR (x, 0) == XSTR (y, 0);
613 case DEBUG_EXPR:
614 case VALUE:
615 case SCRATCH:
616 CASE_CONST_UNIQUE:
617 return 0;
619 case CONST_VECTOR:
620 if (!same_vector_encodings_p (x, y))
621 return false;
622 break;
624 case DEBUG_IMPLICIT_PTR:
625 return DEBUG_IMPLICIT_PTR_DECL (x)
626 == DEBUG_IMPLICIT_PTR_DECL (y);
628 case DEBUG_PARAMETER_REF:
629 return DEBUG_PARAMETER_REF_DECL (x)
630 == DEBUG_PARAMETER_REF_DECL (y);
632 case ENTRY_VALUE:
633 return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
635 default:
636 break;
639 /* Compare the elements. If any pair of corresponding elements
640 fail to match, return 0 for the whole thing. */
642 fmt = GET_RTX_FORMAT (code);
643 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
645 switch (fmt[i])
647 case 'w':
648 if (XWINT (x, i) != XWINT (y, i))
649 return 0;
650 break;
652 case 'n':
653 case 'i':
654 if (XINT (x, i) != XINT (y, i))
656 #ifndef GENERATOR_FILE
657 if (((code == ASM_OPERANDS && i == 6)
658 || (code == ASM_INPUT && i == 1))
659 && XINT (x, i) == XINT (y, i))
660 break;
661 #endif
662 return 0;
664 break;
666 case 'p':
667 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
668 return 0;
669 break;
671 case 'V':
672 case 'E':
673 /* Two vectors must have the same length. */
674 if (XVECLEN (x, i) != XVECLEN (y, i))
675 return 0;
677 /* And the corresponding elements must match. */
678 for (j = 0; j < XVECLEN (x, i); j++)
679 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
680 return 0;
681 break;
683 case 'e':
684 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
685 return 0;
686 break;
688 case 'S':
689 case 's':
690 if ((XSTR (x, i) || XSTR (y, i))
691 && (! XSTR (x, i) || ! XSTR (y, i)
692 || strcmp (XSTR (x, i), XSTR (y, i))))
693 return 0;
694 break;
696 case 'u':
697 /* These are just backpointers, so they don't matter. */
698 break;
700 case '0':
701 case 't':
702 break;
704 /* It is believed that rtx's at this level will never
705 contain anything but integers and other rtx's,
706 except for within LABEL_REFs and SYMBOL_REFs. */
707 default:
708 gcc_unreachable ();
711 return 1;
714 /* Return true if all elements of VEC are equal. */
716 bool
717 rtvec_all_equal_p (const_rtvec vec)
719 const_rtx first = RTVEC_ELT (vec, 0);
720 /* Optimize the important special case of a vector of constants.
721 The main use of this function is to detect whether every element
722 of CONST_VECTOR is the same. */
723 switch (GET_CODE (first))
725 CASE_CONST_UNIQUE:
726 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
727 if (first != RTVEC_ELT (vec, i))
728 return false;
729 return true;
731 default:
732 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
733 if (!rtx_equal_p (first, RTVEC_ELT (vec, i)))
734 return false;
735 return true;
739 /* Return true if VEC contains a linear series of integers
740 { START, START+1, START+2, ... }. */
742 bool
743 rtvec_series_p (rtvec vec, int start)
745 for (int i = 0; i < GET_NUM_ELEM (vec); i++)
747 rtx x = RTVEC_ELT (vec, i);
748 if (!CONST_INT_P (x) || INTVAL (x) != i + start)
749 return false;
751 return true;
754 /* Return an indication of which type of insn should have X as a body.
755 In generator files, this can be UNKNOWN if the answer is only known
756 at (GCC) runtime. Otherwise the value is CODE_LABEL, INSN, CALL_INSN
757 or JUMP_INSN. */
759 enum rtx_code
760 classify_insn (rtx x)
762 if (LABEL_P (x))
763 return CODE_LABEL;
764 if (GET_CODE (x) == CALL)
765 return CALL_INSN;
766 if (ANY_RETURN_P (x))
767 return JUMP_INSN;
768 if (GET_CODE (x) == ASM_OPERANDS && ASM_OPERANDS_LABEL_VEC (x))
769 return JUMP_INSN;
770 if (GET_CODE (x) == SET)
772 if (GET_CODE (SET_DEST (x)) == PC)
773 return JUMP_INSN;
774 else if (GET_CODE (SET_SRC (x)) == CALL)
775 return CALL_INSN;
776 else
777 return INSN;
779 if (GET_CODE (x) == PARALLEL)
781 int j;
782 bool has_return_p = false;
783 for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
784 if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
785 return CALL_INSN;
786 else if (ANY_RETURN_P (XVECEXP (x, 0, j)))
787 has_return_p = true;
788 else if (GET_CODE (XVECEXP (x, 0, j)) == SET
789 && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
790 return JUMP_INSN;
791 else if (GET_CODE (XVECEXP (x, 0, j)) == SET
792 && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
793 return CALL_INSN;
794 if (has_return_p)
795 return JUMP_INSN;
796 if (GET_CODE (XVECEXP (x, 0, 0)) == ASM_OPERANDS
797 && ASM_OPERANDS_LABEL_VEC (XVECEXP (x, 0, 0)))
798 return JUMP_INSN;
800 #ifdef GENERATOR_FILE
801 if (GET_CODE (x) == MATCH_OPERAND
802 || GET_CODE (x) == MATCH_OPERATOR
803 || GET_CODE (x) == MATCH_PARALLEL
804 || GET_CODE (x) == MATCH_OP_DUP
805 || GET_CODE (x) == MATCH_DUP
806 || GET_CODE (x) == PARALLEL)
807 return UNKNOWN;
808 #endif
809 return INSN;
812 /* Comparator of indices based on rtx_alloc_counts. */
814 static int
815 rtx_count_cmp (const void *p1, const void *p2)
817 const unsigned *n1 = (const unsigned *)p1;
818 const unsigned *n2 = (const unsigned *)p2;
820 return rtx_alloc_counts[*n1] - rtx_alloc_counts[*n2];
823 void
824 dump_rtx_statistics (void)
826 int total_counts = 0;
827 int total_sizes = 0;
829 if (! GATHER_STATISTICS)
831 fprintf (stderr, "No RTX statistics\n");
832 return;
835 fprintf (stderr, "\nRTX Kind Count Bytes\n");
836 fprintf (stderr, "-------------------------------------------\n");
838 auto_vec<unsigned> indices (LAST_AND_UNUSED_RTX_CODE);
839 for (unsigned i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
840 indices.quick_push (i);
841 indices.qsort (rtx_count_cmp);
843 for (unsigned i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
845 unsigned j = indices[i];
846 if (rtx_alloc_counts[j])
848 fprintf (stderr, "%-24s " PRsa (6) " " PRsa (9) "\n",
849 GET_RTX_NAME (j),
850 SIZE_AMOUNT (rtx_alloc_counts[j]),
851 SIZE_AMOUNT (rtx_alloc_sizes[j]));
852 total_counts += rtx_alloc_counts[j];
853 total_sizes += rtx_alloc_sizes[j];
857 if (rtvec_alloc_counts)
859 fprintf (stderr, "%-24s " PRsa (6) " " PRsa (9) "\n", "rtvec",
860 SIZE_AMOUNT (rtvec_alloc_counts),
861 SIZE_AMOUNT (rtvec_alloc_sizes));
862 total_counts += rtvec_alloc_counts;
863 total_sizes += rtvec_alloc_sizes;
865 fprintf (stderr, "-----------------------------------------------\n");
866 fprintf (stderr, "%-24s " PRsa (6) " " PRsa (9) "\n",
867 "Total", SIZE_AMOUNT (total_counts),
868 SIZE_AMOUNT (total_sizes));
869 fprintf (stderr, "-----------------------------------------------\n");
872 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
873 void
874 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
875 const char *func)
877 internal_error
878 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
879 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
880 func, trim_filename (file), line);
883 void
884 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
885 const char *func)
887 internal_error
888 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
889 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
890 func, trim_filename (file), line);
893 void
894 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
895 int line, const char *func)
897 internal_error
898 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
899 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
900 func, trim_filename (file), line);
903 void
904 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
905 int line, const char *func)
907 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
908 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
909 trim_filename (file), line);
912 void
913 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
914 const char *file, int line, const char *func)
916 internal_error
917 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
918 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
919 func, trim_filename (file), line);
922 void
923 rtl_check_failed_code3 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
924 enum rtx_code code3, const char *file, int line,
925 const char *func)
927 internal_error
928 ("RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d",
929 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (code3),
930 GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
933 void
934 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
935 bool not_mode, const char *file, int line,
936 const char *func)
938 internal_error ((not_mode
939 ? ("RTL check: expected code '%s' and not mode '%s', "
940 "have code '%s' and mode '%s' in %s, at %s:%d")
941 : ("RTL check: expected code '%s' and mode '%s', "
942 "have code '%s' and mode '%s' in %s, at %s:%d")),
943 GET_RTX_NAME (code), GET_MODE_NAME (mode),
944 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
945 func, trim_filename (file), line);
948 /* Report that line LINE of FILE tried to access the block symbol fields
949 of a non-block symbol. FUNC is the function that contains the line. */
951 void
952 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
954 internal_error
955 ("RTL check: attempt to treat non-block symbol as a block symbol "
956 "in %s, at %s:%d", func, trim_filename (file), line);
959 /* XXX Maybe print the vector? */
960 void
961 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
962 const char *func)
964 internal_error
965 ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
966 n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
969 /* XXX Maybe print the vector? */
970 void
971 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
972 const char *func)
974 internal_error
975 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
976 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
978 #endif /* ENABLE_RTL_CHECKING */
980 #if defined ENABLE_RTL_FLAG_CHECKING
981 void
982 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
983 int line, const char *func)
985 internal_error
986 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
987 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
989 #endif /* ENABLE_RTL_FLAG_CHECKING */