2018-07-12 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / rtl.c
blob90bbc7c6861153d87ace20913e5601d7cd62bc2b
1 /* RTL utility routines.
2 Copyright (C) 1987-2018 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 /* 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 \
114 || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT) \
115 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \
116 : (ENUM) == REG \
117 ? RTX_HDR_SIZE + sizeof (reg_info) \
118 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
120 #include "rtl.def"
121 #undef DEF_RTL_EXPR
124 /* Names for kinds of NOTEs and REG_NOTEs. */
126 const char * const note_insn_name[NOTE_INSN_MAX] =
128 #define DEF_INSN_NOTE(NAME) #NAME,
129 #include "insn-notes.def"
130 #undef DEF_INSN_NOTE
133 const char * const reg_note_name[REG_NOTE_MAX] =
135 #define DEF_REG_NOTE(NAME) #NAME,
136 #include "reg-notes.def"
137 #undef DEF_REG_NOTE
140 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
141 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
142 static int rtvec_alloc_counts;
143 static int rtvec_alloc_sizes;
146 /* Allocate an rtx vector of N elements.
147 Store the length, and initialize all elements to zero. */
149 rtvec
150 rtvec_alloc (int n)
152 rtvec rt;
154 rt = ggc_alloc_rtvec_sized (n);
155 /* Clear out the vector. */
156 memset (&rt->elem[0], 0, n * sizeof (rtx));
158 PUT_NUM_ELEM (rt, n);
160 if (GATHER_STATISTICS)
162 rtvec_alloc_counts++;
163 rtvec_alloc_sizes += n * sizeof (rtx);
166 return rt;
169 /* Create a bitwise copy of VEC. */
171 rtvec
172 shallow_copy_rtvec (rtvec vec)
174 rtvec newvec;
175 int n;
177 n = GET_NUM_ELEM (vec);
178 newvec = rtvec_alloc (n);
179 memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
180 return newvec;
183 /* Return the number of bytes occupied by rtx value X. */
185 unsigned int
186 rtx_size (const_rtx x)
188 if (CONST_WIDE_INT_P (x))
189 return (RTX_HDR_SIZE
190 + sizeof (struct hwivec_def)
191 + ((CONST_WIDE_INT_NUNITS (x) - 1)
192 * sizeof (HOST_WIDE_INT)));
193 if (CONST_POLY_INT_P (x))
194 return (RTX_HDR_SIZE
195 + sizeof (struct const_poly_int_def)
196 + CONST_POLY_INT_COEFFS (x).extra_size ());
197 if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
198 return RTX_HDR_SIZE + sizeof (struct block_symbol);
199 return RTX_CODE_SIZE (GET_CODE (x));
202 /* Allocate an rtx of code CODE with EXTRA bytes in it. The CODE is
203 stored in the rtx; all the rest is initialized to zero. */
206 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
208 rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
209 PASS_MEM_STAT);
211 /* We want to clear everything up to the FLD array. Normally, this
212 is one int, but we don't want to assume that and it isn't very
213 portable anyway; this is. */
215 memset (rt, 0, RTX_HDR_SIZE);
216 PUT_CODE (rt, code);
218 if (GATHER_STATISTICS)
220 rtx_alloc_counts[code]++;
221 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
224 return rt;
227 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
228 all the rest is initialized to zero. */
231 rtx_alloc (RTX_CODE code MEM_STAT_DECL)
233 return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
236 /* Write the wide constant X to OUTFILE. */
238 void
239 cwi_output_hex (FILE *outfile, const_rtx x)
241 int i = CWI_GET_NUM_ELEM (x);
242 gcc_assert (i > 0);
243 if (CWI_ELT (x, i - 1) == 0)
244 /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
245 non zero. We want all numbers to have a 0x prefix. */
246 fprintf (outfile, "0x");
247 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
248 while (--i >= 0)
249 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
253 /* Return true if ORIG is a sharable CONST. */
255 bool
256 shared_const_p (const_rtx orig)
258 gcc_assert (GET_CODE (orig) == CONST);
260 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
261 a LABEL_REF, it isn't sharable. */
262 poly_int64 offset;
263 return (GET_CODE (XEXP (orig, 0)) == PLUS
264 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
265 && poly_int_rtx_p (XEXP (XEXP (orig, 0), 1), &offset));
269 /* Create a new copy of an rtx.
270 Recursively copies the operands of the rtx,
271 except for those few rtx codes that are sharable. */
274 copy_rtx (rtx orig)
276 rtx copy;
277 int i, j;
278 RTX_CODE code;
279 const char *format_ptr;
281 code = GET_CODE (orig);
283 switch (code)
285 case REG:
286 case DEBUG_EXPR:
287 case VALUE:
288 CASE_CONST_ANY:
289 case SYMBOL_REF:
290 case CODE_LABEL:
291 case PC:
292 case CC0:
293 case RETURN:
294 case SIMPLE_RETURN:
295 case SCRATCH:
296 /* SCRATCH must be shared because they represent distinct values. */
297 return orig;
298 case CLOBBER:
299 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
300 clobbers or clobbers of hard registers that originated as pseudos.
301 This is needed to allow safe register renaming. */
302 if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
303 && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
304 return orig;
305 break;
307 case CONST:
308 if (shared_const_p (orig))
309 return orig;
310 break;
312 /* A MEM with a constant address is not sharable. The problem is that
313 the constant address may need to be reloaded. If the mem is shared,
314 then reloading one copy of this mem will cause all copies to appear
315 to have been reloaded. */
317 default:
318 break;
321 /* Copy the various flags, fields, and other information. We assume
322 that all fields need copying, and then clear the fields that should
323 not be copied. That is the sensible default behavior, and forces
324 us to explicitly document why we are *not* copying a flag. */
325 copy = shallow_copy_rtx (orig);
327 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
329 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
330 switch (*format_ptr++)
332 case 'e':
333 if (XEXP (orig, i) != NULL)
334 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
335 break;
337 case 'E':
338 case 'V':
339 if (XVEC (orig, i) != NULL)
341 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
342 for (j = 0; j < XVECLEN (copy, i); j++)
343 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
345 break;
347 case 't':
348 case 'w':
349 case 'i':
350 case 'p':
351 case 's':
352 case 'S':
353 case 'T':
354 case 'u':
355 case 'B':
356 case '0':
357 /* These are left unchanged. */
358 break;
360 default:
361 gcc_unreachable ();
363 return copy;
366 /* Create a new copy of an rtx. Only copy just one level. */
369 shallow_copy_rtx (const_rtx orig MEM_STAT_DECL)
371 const unsigned int size = rtx_size (orig);
372 rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
373 memcpy (copy, orig, size);
374 switch (GET_CODE (orig))
376 /* RTX codes copy_rtx_if_shared_1 considers are shareable,
377 the used flag is often used for other purposes. */
378 case REG:
379 case DEBUG_EXPR:
380 case VALUE:
381 CASE_CONST_ANY:
382 case SYMBOL_REF:
383 case CODE_LABEL:
384 case PC:
385 case CC0:
386 case RETURN:
387 case SIMPLE_RETURN:
388 case SCRATCH:
389 break;
390 default:
391 /* For all other RTXes clear the used flag on the copy. */
392 RTX_FLAG (copy, used) = 0;
393 break;
395 return copy;
398 /* Nonzero when we are generating CONCATs. */
399 int generating_concat_p;
401 /* Nonzero when we are expanding trees to RTL. */
402 int currently_expanding_to_rtl;
406 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
407 When the callback returns true, we continue with the new pair.
408 Whenever changing this function check if rtx_equal_p below doesn't need
409 changing as well. */
412 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
414 int i;
415 int j;
416 enum rtx_code code;
417 const char *fmt;
418 rtx nx, ny;
420 if (x == y)
421 return 1;
422 if (x == 0 || y == 0)
423 return 0;
425 /* Invoke the callback first. */
426 if (cb != NULL
427 && ((*cb) (&x, &y, &nx, &ny)))
428 return rtx_equal_p_cb (nx, ny, cb);
430 code = GET_CODE (x);
431 /* Rtx's of different codes cannot be equal. */
432 if (code != GET_CODE (y))
433 return 0;
435 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
436 (REG:SI x) and (REG:HI x) are NOT equivalent. */
438 if (GET_MODE (x) != GET_MODE (y))
439 return 0;
441 /* MEMs referring to different address space are not equivalent. */
442 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
443 return 0;
445 /* Some RTL can be compared nonrecursively. */
446 switch (code)
448 case REG:
449 return (REGNO (x) == REGNO (y));
451 case LABEL_REF:
452 return label_ref_label (x) == label_ref_label (y);
454 case SYMBOL_REF:
455 return XSTR (x, 0) == XSTR (y, 0);
457 case DEBUG_EXPR:
458 case VALUE:
459 case SCRATCH:
460 CASE_CONST_UNIQUE:
461 return 0;
463 case DEBUG_IMPLICIT_PTR:
464 return DEBUG_IMPLICIT_PTR_DECL (x)
465 == DEBUG_IMPLICIT_PTR_DECL (y);
467 case DEBUG_PARAMETER_REF:
468 return DEBUG_PARAMETER_REF_DECL (x)
469 == DEBUG_PARAMETER_REF_DECL (y);
471 case ENTRY_VALUE:
472 return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
474 default:
475 break;
478 /* Compare the elements. If any pair of corresponding elements
479 fail to match, return 0 for the whole thing. */
481 fmt = GET_RTX_FORMAT (code);
482 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
484 switch (fmt[i])
486 case 'w':
487 if (XWINT (x, i) != XWINT (y, i))
488 return 0;
489 break;
491 case 'n':
492 case 'i':
493 if (XINT (x, i) != XINT (y, i))
495 #ifndef GENERATOR_FILE
496 if (((code == ASM_OPERANDS && i == 6)
497 || (code == ASM_INPUT && i == 1))
498 && XINT (x, i) == XINT (y, i))
499 break;
500 #endif
501 return 0;
503 break;
505 case 'p':
506 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
507 return 0;
508 break;
510 case 'V':
511 case 'E':
512 /* Two vectors must have the same length. */
513 if (XVECLEN (x, i) != XVECLEN (y, i))
514 return 0;
516 /* And the corresponding elements must match. */
517 for (j = 0; j < XVECLEN (x, i); j++)
518 if (rtx_equal_p_cb (XVECEXP (x, i, j),
519 XVECEXP (y, i, j), cb) == 0)
520 return 0;
521 break;
523 case 'e':
524 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
525 return 0;
526 break;
528 case 'S':
529 case 's':
530 if ((XSTR (x, i) || XSTR (y, i))
531 && (! XSTR (x, i) || ! XSTR (y, i)
532 || strcmp (XSTR (x, i), XSTR (y, i))))
533 return 0;
534 break;
536 case 'u':
537 /* These are just backpointers, so they don't matter. */
538 break;
540 case '0':
541 case 't':
542 break;
544 /* It is believed that rtx's at this level will never
545 contain anything but integers and other rtx's,
546 except for within LABEL_REFs and SYMBOL_REFs. */
547 default:
548 gcc_unreachable ();
551 return 1;
554 /* Return 1 if X and Y are identical-looking rtx's.
555 This is the Lisp function EQUAL for rtx arguments.
556 Whenever changing this function check if rtx_equal_p_cb above doesn't need
557 changing as well. */
560 rtx_equal_p (const_rtx x, const_rtx y)
562 int i;
563 int j;
564 enum rtx_code code;
565 const char *fmt;
567 if (x == y)
568 return 1;
569 if (x == 0 || y == 0)
570 return 0;
572 code = GET_CODE (x);
573 /* Rtx's of different codes cannot be equal. */
574 if (code != GET_CODE (y))
575 return 0;
577 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
578 (REG:SI x) and (REG:HI x) are NOT equivalent. */
580 if (GET_MODE (x) != GET_MODE (y))
581 return 0;
583 /* MEMs referring to different address space are not equivalent. */
584 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
585 return 0;
587 /* Some RTL can be compared nonrecursively. */
588 switch (code)
590 case REG:
591 return (REGNO (x) == REGNO (y));
593 case LABEL_REF:
594 return label_ref_label (x) == label_ref_label (y);
596 case SYMBOL_REF:
597 return XSTR (x, 0) == XSTR (y, 0);
599 case DEBUG_EXPR:
600 case VALUE:
601 case SCRATCH:
602 CASE_CONST_UNIQUE:
603 return 0;
605 case DEBUG_IMPLICIT_PTR:
606 return DEBUG_IMPLICIT_PTR_DECL (x)
607 == DEBUG_IMPLICIT_PTR_DECL (y);
609 case DEBUG_PARAMETER_REF:
610 return DEBUG_PARAMETER_REF_DECL (x)
611 == DEBUG_PARAMETER_REF_DECL (y);
613 case ENTRY_VALUE:
614 return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
616 default:
617 break;
620 /* Compare the elements. If any pair of corresponding elements
621 fail to match, return 0 for the whole thing. */
623 fmt = GET_RTX_FORMAT (code);
624 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
626 switch (fmt[i])
628 case 'w':
629 if (XWINT (x, i) != XWINT (y, i))
630 return 0;
631 break;
633 case 'n':
634 case 'i':
635 if (XINT (x, i) != XINT (y, i))
637 #ifndef GENERATOR_FILE
638 if (((code == ASM_OPERANDS && i == 6)
639 || (code == ASM_INPUT && i == 1))
640 && XINT (x, i) == XINT (y, i))
641 break;
642 #endif
643 return 0;
645 break;
647 case 'p':
648 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
649 return 0;
650 break;
652 case 'V':
653 case 'E':
654 /* Two vectors must have the same length. */
655 if (XVECLEN (x, i) != XVECLEN (y, i))
656 return 0;
658 /* And the corresponding elements must match. */
659 for (j = 0; j < XVECLEN (x, i); j++)
660 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
661 return 0;
662 break;
664 case 'e':
665 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
666 return 0;
667 break;
669 case 'S':
670 case 's':
671 if ((XSTR (x, i) || XSTR (y, i))
672 && (! XSTR (x, i) || ! XSTR (y, i)
673 || strcmp (XSTR (x, i), XSTR (y, i))))
674 return 0;
675 break;
677 case 'u':
678 /* These are just backpointers, so they don't matter. */
679 break;
681 case '0':
682 case 't':
683 break;
685 /* It is believed that rtx's at this level will never
686 contain anything but integers and other rtx's,
687 except for within LABEL_REFs and SYMBOL_REFs. */
688 default:
689 gcc_unreachable ();
692 return 1;
695 /* Return true if all elements of VEC are equal. */
697 bool
698 rtvec_all_equal_p (const_rtvec vec)
700 const_rtx first = RTVEC_ELT (vec, 0);
701 /* Optimize the important special case of a vector of constants.
702 The main use of this function is to detect whether every element
703 of CONST_VECTOR is the same. */
704 switch (GET_CODE (first))
706 CASE_CONST_UNIQUE:
707 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
708 if (first != RTVEC_ELT (vec, i))
709 return false;
710 return true;
712 default:
713 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
714 if (!rtx_equal_p (first, RTVEC_ELT (vec, i)))
715 return false;
716 return true;
720 /* Return an indication of which type of insn should have X as a body.
721 In generator files, this can be UNKNOWN if the answer is only known
722 at (GCC) runtime. Otherwise the value is CODE_LABEL, INSN, CALL_INSN
723 or JUMP_INSN. */
725 enum rtx_code
726 classify_insn (rtx x)
728 if (LABEL_P (x))
729 return CODE_LABEL;
730 if (GET_CODE (x) == CALL)
731 return CALL_INSN;
732 if (ANY_RETURN_P (x))
733 return JUMP_INSN;
734 if (GET_CODE (x) == SET)
736 if (GET_CODE (SET_DEST (x)) == PC)
737 return JUMP_INSN;
738 else if (GET_CODE (SET_SRC (x)) == CALL)
739 return CALL_INSN;
740 else
741 return INSN;
743 if (GET_CODE (x) == PARALLEL)
745 int j;
746 bool has_return_p = false;
747 for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
748 if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
749 return CALL_INSN;
750 else if (ANY_RETURN_P (XVECEXP (x, 0, j)))
751 has_return_p = true;
752 else if (GET_CODE (XVECEXP (x, 0, j)) == SET
753 && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
754 return JUMP_INSN;
755 else if (GET_CODE (XVECEXP (x, 0, j)) == SET
756 && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
757 return CALL_INSN;
758 if (has_return_p)
759 return JUMP_INSN;
761 #ifdef GENERATOR_FILE
762 if (GET_CODE (x) == MATCH_OPERAND
763 || GET_CODE (x) == MATCH_OPERATOR
764 || GET_CODE (x) == MATCH_PARALLEL
765 || GET_CODE (x) == MATCH_OP_DUP
766 || GET_CODE (x) == MATCH_DUP
767 || GET_CODE (x) == PARALLEL)
768 return UNKNOWN;
769 #endif
770 return INSN;
773 void
774 dump_rtx_statistics (void)
776 int i;
777 int total_counts = 0;
778 int total_sizes = 0;
780 if (! GATHER_STATISTICS)
782 fprintf (stderr, "No RTX statistics\n");
783 return;
786 fprintf (stderr, "\nRTX Kind Count Bytes\n");
787 fprintf (stderr, "---------------------------------------\n");
788 for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
789 if (rtx_alloc_counts[i])
791 fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
792 rtx_alloc_counts[i], rtx_alloc_sizes[i]);
793 total_counts += rtx_alloc_counts[i];
794 total_sizes += rtx_alloc_sizes[i];
796 if (rtvec_alloc_counts)
798 fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
799 rtvec_alloc_counts, rtvec_alloc_sizes);
800 total_counts += rtvec_alloc_counts;
801 total_sizes += rtvec_alloc_sizes;
803 fprintf (stderr, "---------------------------------------\n");
804 fprintf (stderr, "%-20s %7d %10d\n",
805 "Total", total_counts, total_sizes);
806 fprintf (stderr, "---------------------------------------\n");
809 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
810 void
811 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
812 const char *func)
814 internal_error
815 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
816 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
817 func, trim_filename (file), line);
820 void
821 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
822 const char *func)
824 internal_error
825 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
826 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
827 func, trim_filename (file), line);
830 void
831 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
832 int line, const char *func)
834 internal_error
835 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
836 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
837 func, trim_filename (file), line);
840 void
841 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
842 int line, const char *func)
844 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
845 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
846 trim_filename (file), line);
849 void
850 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
851 const char *file, int line, const char *func)
853 internal_error
854 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
855 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
856 func, trim_filename (file), line);
859 void
860 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
861 bool not_mode, const char *file, int line,
862 const char *func)
864 internal_error ((not_mode
865 ? ("RTL check: expected code '%s' and not mode '%s', "
866 "have code '%s' and mode '%s' in %s, at %s:%d")
867 : ("RTL check: expected code '%s' and mode '%s', "
868 "have code '%s' and mode '%s' in %s, at %s:%d")),
869 GET_RTX_NAME (code), GET_MODE_NAME (mode),
870 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
871 func, trim_filename (file), line);
874 /* Report that line LINE of FILE tried to access the block symbol fields
875 of a non-block symbol. FUNC is the function that contains the line. */
877 void
878 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
880 internal_error
881 ("RTL check: attempt to treat non-block symbol as a block symbol "
882 "in %s, at %s:%d", func, trim_filename (file), line);
885 /* XXX Maybe print the vector? */
886 void
887 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
888 const char *func)
890 internal_error
891 ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
892 n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
895 /* XXX Maybe print the vector? */
896 void
897 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
898 const char *func)
900 internal_error
901 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
902 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
904 #endif /* ENABLE_RTL_CHECKING */
906 #if defined ENABLE_RTL_FLAG_CHECKING
907 void
908 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
909 int line, const char *func)
911 internal_error
912 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
913 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
915 #endif /* ENABLE_RTL_FLAG_CHECKING */