1 /* RTL utility routines.
2 Copyright (C) 1987-2022 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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.
10
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.
15
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/>. */
19
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
27
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
38
39
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). */
42
43 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
44
45 const unsigned char rtx_length[NUM_RTX_CODE] = {
46 #include "rtl.def"
47 };
48
49 #undef DEF_RTL_EXPR
50
51 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
52
53 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
54
55 const char * const rtx_name[NUM_RTX_CODE] = {
56 #include "rtl.def" /* rtl expressions are documented here */
57 };
58
59 #undef DEF_RTL_EXPR
60
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. */
64
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. */
94
95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
96 #include "rtl.def" /* rtl expressions are defined here */
97 #undef DEF_RTL_EXPR
98 };
99
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. */
102
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
107 };
108
109 /* Whether rtxs with the given code store data in the hwint field. */
110
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
120
121 /* Indexed by rtx code, gives the size of the rtx in bytes. */
122
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)),
130
131 #include "rtl.def"
132 #undef DEF_RTL_EXPR
133 };
134
135 /* Names for kinds of NOTEs and REG_NOTEs. */
136
137 const char * const note_insn_name[NOTE_INSN_MAX] =
138 {
139 #define DEF_INSN_NOTE(NAME) #NAME,
140 #include "insn-notes.def"
141 #undef DEF_INSN_NOTE
142 };
143
144 const char * const reg_note_name[REG_NOTE_MAX] =
145 {
146 #define DEF_REG_NOTE(NAME) #NAME,
147 #include "reg-notes.def"
148 #undef DEF_REG_NOTE
149 };
150
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;
155
156
157 /* Allocate an rtx vector of N elements.
158 Store the length, and initialize all elements to zero. */
159
160 rtvec
rtvec_alloc(size_t n)161 rtvec_alloc (size_t n)
162 {
163 rtvec rt;
164
165 /* rtvec_def.num_elem is an int. */
166 gcc_assert (n < INT_MAX);
167
168 rt = ggc_alloc_rtvec_sized (n);
169 /* Clear out the vector. */
170 memset (&rt->elem[0], 0, n * sizeof (rtx));
171
172 PUT_NUM_ELEM (rt, n);
173
174 if (GATHER_STATISTICS)
175 {
176 rtvec_alloc_counts++;
177 rtvec_alloc_sizes += n * sizeof (rtx);
178 }
179
180 return rt;
181 }
182
183 /* Create a bitwise copy of VEC. */
184
185 rtvec
shallow_copy_rtvec(rtvec vec)186 shallow_copy_rtvec (rtvec vec)
187 {
188 rtvec newvec;
189 int n;
190
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;
195 }
196
197 /* Return the number of bytes occupied by rtx value X. */
198
199 unsigned int
rtx_size(const_rtx x)200 rtx_size (const_rtx x)
201 {
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));
214 }
215
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. */
218
219 rtx
rtx_alloc_stat_v(RTX_CODE code MEM_STAT_DECL,int extra)220 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
221 {
222 rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
223 PASS_MEM_STAT);
224
225 rtx_init (rt, code);
226
227 if (GATHER_STATISTICS)
228 {
229 rtx_alloc_counts[code]++;
230 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
231 }
232
233 return rt;
234 }
235
236 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
237 all the rest is initialized to zero. */
238
239 rtx
rtx_alloc(RTX_CODE code MEM_STAT_DECL)240 rtx_alloc (RTX_CODE code MEM_STAT_DECL)
241 {
242 return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
243 }
244
245 /* Write the wide constant X to OUTFILE. */
246
247 void
cwi_output_hex(FILE * outfile,const_rtx x)248 cwi_output_hex (FILE *outfile, const_rtx x)
249 {
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));
259 }
260
261
262 /* Return true if ORIG is a sharable CONST. */
263
264 bool
shared_const_p(const_rtx orig)265 shared_const_p (const_rtx orig)
266 {
267 gcc_assert (GET_CODE (orig) == CONST);
268
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));
275 }
276
277
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. */
281
282 rtx
copy_rtx(rtx orig)283 copy_rtx (rtx orig)
284 {
285 rtx copy;
286 int i, j;
287 RTX_CODE code;
288 const char *format_ptr;
289
290 code = GET_CODE (orig);
291
292 switch (code)
293 {
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;
314
315 case CONST:
316 if (shared_const_p (orig))
317 return orig;
318 break;
319
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. */
324
325 default:
326 break;
327 }
328
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);
334
335 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
336
337 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
338 switch (*format_ptr++)
339 {
340 case 'e':
341 if (XEXP (orig, i) != NULL)
342 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
343 break;
344
345 case 'E':
346 case 'V':
347 if (XVEC (orig, i) != NULL)
348 {
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));
352 }
353 break;
354
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;
367
368 default:
369 gcc_unreachable ();
370 }
371 return copy;
372 }
373
374 /* Create a new copy of an rtx. Only copy just one level. */
375
376 rtx
shallow_copy_rtx(const_rtx orig MEM_STAT_DECL)377 shallow_copy_rtx (const_rtx orig MEM_STAT_DECL)
378 {
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))
383 {
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;
403 }
404 return copy;
405 }
406
407 /* Nonzero when we are generating CONCATs. */
408 int generating_concat_p;
409
410 /* Nonzero when we are expanding trees to RTL. */
411 int currently_expanding_to_rtl;
412
413
414
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. */
419
420 int
rtx_equal_p_cb(const_rtx x,const_rtx y,rtx_equal_p_callback_function cb)421 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
422 {
423 int i;
424 int j;
425 enum rtx_code code;
426 const char *fmt;
427 rtx nx, ny;
428
429 if (x == y)
430 return 1;
431 if (x == 0 || y == 0)
432 return 0;
433
434 /* Invoke the callback first. */
435 if (cb != NULL
436 && ((*cb) (&x, &y, &nx, &ny)))
437 return rtx_equal_p_cb (nx, ny, cb);
438
439 code = GET_CODE (x);
440 /* Rtx's of different codes cannot be equal. */
441 if (code != GET_CODE (y))
442 return 0;
443
444 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
445 (REG:SI x) and (REG:HI x) are NOT equivalent. */
446
447 if (GET_MODE (x) != GET_MODE (y))
448 return 0;
449
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;
453
454 /* Some RTL can be compared nonrecursively. */
455 switch (code)
456 {
457 case REG:
458 return (REGNO (x) == REGNO (y));
459
460 case LABEL_REF:
461 return label_ref_label (x) == label_ref_label (y);
462
463 case SYMBOL_REF:
464 return XSTR (x, 0) == XSTR (y, 0);
465
466 case DEBUG_EXPR:
467 case VALUE:
468 case SCRATCH:
469 CASE_CONST_UNIQUE:
470 return 0;
471
472 case CONST_VECTOR:
473 if (!same_vector_encodings_p (x, y))
474 return false;
475 break;
476
477 case DEBUG_IMPLICIT_PTR:
478 return DEBUG_IMPLICIT_PTR_DECL (x)
479 == DEBUG_IMPLICIT_PTR_DECL (y);
480
481 case DEBUG_PARAMETER_REF:
482 return DEBUG_PARAMETER_REF_DECL (x)
483 == DEBUG_PARAMETER_REF_DECL (y);
484
485 case ENTRY_VALUE:
486 return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
487
488 default:
489 break;
490 }
491
492 /* Compare the elements. If any pair of corresponding elements
493 fail to match, return 0 for the whole thing. */
494
495 fmt = GET_RTX_FORMAT (code);
496 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
497 {
498 switch (fmt[i])
499 {
500 case 'w':
501 if (XWINT (x, i) != XWINT (y, i))
502 return 0;
503 break;
504
505 case 'n':
506 case 'i':
507 if (XINT (x, i) != XINT (y, i))
508 {
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;
516 }
517 break;
518
519 case 'p':
520 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
521 return 0;
522 break;
523
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;
529
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;
536
537 case 'e':
538 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
539 return 0;
540 break;
541
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;
549
550 case 'u':
551 /* These are just backpointers, so they don't matter. */
552 break;
553
554 case '0':
555 case 't':
556 break;
557
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 ();
563 }
564 }
565 return 1;
566 }
567
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. */
572
573 int
rtx_equal_p(const_rtx x,const_rtx y)574 rtx_equal_p (const_rtx x, const_rtx y)
575 {
576 int i;
577 int j;
578 enum rtx_code code;
579 const char *fmt;
580
581 if (x == y)
582 return 1;
583 if (x == 0 || y == 0)
584 return 0;
585
586 code = GET_CODE (x);
587 /* Rtx's of different codes cannot be equal. */
588 if (code != GET_CODE (y))
589 return 0;
590
591 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
592 (REG:SI x) and (REG:HI x) are NOT equivalent. */
593
594 if (GET_MODE (x) != GET_MODE (y))
595 return 0;
596
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;
600
601 /* Some RTL can be compared nonrecursively. */
602 switch (code)
603 {
604 case REG:
605 return (REGNO (x) == REGNO (y));
606
607 case LABEL_REF:
608 return label_ref_label (x) == label_ref_label (y);
609
610 case SYMBOL_REF:
611 return XSTR (x, 0) == XSTR (y, 0);
612
613 case DEBUG_EXPR:
614 case VALUE:
615 case SCRATCH:
616 CASE_CONST_UNIQUE:
617 return 0;
618
619 case CONST_VECTOR:
620 if (!same_vector_encodings_p (x, y))
621 return false;
622 break;
623
624 case DEBUG_IMPLICIT_PTR:
625 return DEBUG_IMPLICIT_PTR_DECL (x)
626 == DEBUG_IMPLICIT_PTR_DECL (y);
627
628 case DEBUG_PARAMETER_REF:
629 return DEBUG_PARAMETER_REF_DECL (x)
630 == DEBUG_PARAMETER_REF_DECL (y);
631
632 case ENTRY_VALUE:
633 return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
634
635 default:
636 break;
637 }
638
639 /* Compare the elements. If any pair of corresponding elements
640 fail to match, return 0 for the whole thing. */
641
642 fmt = GET_RTX_FORMAT (code);
643 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
644 {
645 switch (fmt[i])
646 {
647 case 'w':
648 if (XWINT (x, i) != XWINT (y, i))
649 return 0;
650 break;
651
652 case 'n':
653 case 'i':
654 if (XINT (x, i) != XINT (y, i))
655 {
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;
663 }
664 break;
665
666 case 'p':
667 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
668 return 0;
669 break;
670
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;
676
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;
682
683 case 'e':
684 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
685 return 0;
686 break;
687
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;
695
696 case 'u':
697 /* These are just backpointers, so they don't matter. */
698 break;
699
700 case '0':
701 case 't':
702 break;
703
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 ();
709 }
710 }
711 return 1;
712 }
713
714 /* Return true if all elements of VEC are equal. */
715
716 bool
rtvec_all_equal_p(const_rtvec vec)717 rtvec_all_equal_p (const_rtvec vec)
718 {
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))
724 {
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;
730
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;
736 }
737 }
738
739 /* Return true if VEC contains a linear series of integers
740 { START, START+1, START+2, ... }. */
741
742 bool
rtvec_series_p(rtvec vec,int start)743 rtvec_series_p (rtvec vec, int start)
744 {
745 for (int i = 0; i < GET_NUM_ELEM (vec); i++)
746 {
747 rtx x = RTVEC_ELT (vec, i);
748 if (!CONST_INT_P (x) || INTVAL (x) != i + start)
749 return false;
750 }
751 return true;
752 }
753
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. */
758
759 enum rtx_code
classify_insn(rtx x)760 classify_insn (rtx x)
761 {
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_LENGTH (x))
769 return JUMP_INSN;
770 if (GET_CODE (x) == SET)
771 {
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;
778 }
779 if (GET_CODE (x) == PARALLEL)
780 {
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_LENGTH (XVECEXP (x, 0, 0)))
798 return JUMP_INSN;
799 }
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;
810 }
811
812 /* Comparator of indices based on rtx_alloc_counts. */
813
814 static int
rtx_count_cmp(const void * p1,const void * p2)815 rtx_count_cmp (const void *p1, const void *p2)
816 {
817 const unsigned *n1 = (const unsigned *)p1;
818 const unsigned *n2 = (const unsigned *)p2;
819
820 return rtx_alloc_counts[*n1] - rtx_alloc_counts[*n2];
821 }
822
823 void
dump_rtx_statistics(void)824 dump_rtx_statistics (void)
825 {
826 int total_counts = 0;
827 int total_sizes = 0;
828
829 if (! GATHER_STATISTICS)
830 {
831 fprintf (stderr, "No RTX statistics\n");
832 return;
833 }
834
835 fprintf (stderr, "\nRTX Kind Count Bytes\n");
836 fprintf (stderr, "-------------------------------------------\n");
837
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);
842
843 for (unsigned i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
844 {
845 unsigned j = indices[i];
846 if (rtx_alloc_counts[j])
847 {
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];
854 }
855 }
856
857 if (rtvec_alloc_counts)
858 {
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;
864 }
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");
870 }
871
872 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
873
874 /* Disable warnings about missing quoting in GCC diagnostics for
875 the internal_error calls. Their format strings deliberately don't
876 follow GCC diagnostic conventions. */
877 #if __GNUC__ >= 10
878 #pragma GCC diagnostic push
879 #pragma GCC diagnostic ignored "-Wformat-diag"
880 #endif
881
882 void
rtl_check_failed_bounds(const_rtx r,int n,const char * file,int line,const char * func)883 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
884 const char *func)
885 {
886 internal_error
887 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
888 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
889 func, trim_filename (file), line);
890 }
891
892 void
rtl_check_failed_type1(const_rtx r,int n,int c1,const char * file,int line,const char * func)893 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
894 const char *func)
895 {
896 internal_error
897 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
898 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
899 func, trim_filename (file), line);
900 }
901
902 void
rtl_check_failed_type2(const_rtx r,int n,int c1,int c2,const char * file,int line,const char * func)903 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
904 int line, const char *func)
905 {
906 internal_error
907 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
908 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
909 func, trim_filename (file), line);
910 }
911
912 void
rtl_check_failed_code1(const_rtx r,enum rtx_code code,const char * file,int line,const char * func)913 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
914 int line, const char *func)
915 {
916 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
917 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
918 trim_filename (file), line);
919 }
920
921 void
rtl_check_failed_code2(const_rtx r,enum rtx_code code1,enum rtx_code code2,const char * file,int line,const char * func)922 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
923 const char *file, int line, const char *func)
924 {
925 internal_error
926 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
927 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
928 func, trim_filename (file), line);
929 }
930
931 void
rtl_check_failed_code3(const_rtx r,enum rtx_code code1,enum rtx_code code2,enum rtx_code code3,const char * file,int line,const char * func)932 rtl_check_failed_code3 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
933 enum rtx_code code3, const char *file, int line,
934 const char *func)
935 {
936 internal_error
937 ("RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d",
938 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (code3),
939 GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
940 }
941
942 void
rtl_check_failed_code_mode(const_rtx r,enum rtx_code code,machine_mode mode,bool not_mode,const char * file,int line,const char * func)943 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
944 bool not_mode, const char *file, int line,
945 const char *func)
946 {
947 internal_error ((not_mode
948 ? ("RTL check: expected code '%s' and not mode '%s', "
949 "have code '%s' and mode '%s' in %s, at %s:%d")
950 : ("RTL check: expected code '%s' and mode '%s', "
951 "have code '%s' and mode '%s' in %s, at %s:%d")),
952 GET_RTX_NAME (code), GET_MODE_NAME (mode),
953 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
954 func, trim_filename (file), line);
955 }
956
957 #if __GNUC__ >= 10
958 #pragma GCC diagnostic pop
959 #endif
960
961 /* Report that line LINE of FILE tried to access the block symbol fields
962 of a non-block symbol. FUNC is the function that contains the line. */
963
964 void
rtl_check_failed_block_symbol(const char * file,int line,const char * func)965 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
966 {
967 internal_error
968 ("RTL check: attempt to treat non-block symbol as a block symbol "
969 "in %s, at %s:%d", func, trim_filename (file), line);
970 }
971
972 /* XXX Maybe print the vector? */
973 void
cwi_check_failed_bounds(const_rtx x,int n,const char * file,int line,const char * func)974 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
975 const char *func)
976 {
977 internal_error
978 ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
979 n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
980 }
981
982 /* XXX Maybe print the vector? */
983 void
rtvec_check_failed_bounds(const_rtvec r,int n,const char * file,int line,const char * func)984 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
985 const char *func)
986 {
987 internal_error
988 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
989 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
990 }
991 #endif /* ENABLE_RTL_CHECKING */
992
993 #if defined ENABLE_RTL_FLAG_CHECKING
994 void
rtl_check_failed_flag(const char * name,const_rtx r,const char * file,int line,const char * func)995 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
996 int line, const char *func)
997 {
998 internal_error
999 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
1000 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
1001 }
1002 #endif /* ENABLE_RTL_FLAG_CHECKING */
1003