1/* RTL utility routines. 2 Copyright (C) 1987-2022 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16You should have received a copy of the GNU General Public License 17along 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 45const 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 55const 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 65const 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 103const 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 123const 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 137const 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 144const 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 151static size_t rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE]; 152static size_t rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE]; 153static size_t rtvec_alloc_counts; 154static 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 160rtvec 161rtvec_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 185rtvec 186shallow_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 199unsigned int 200rtx_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 219rtx 220rtx_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 239rtx 240rtx_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 247void 248cwi_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 264bool 265shared_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 282rtx 283copy_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 376rtx 377shallow_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. */ 408int generating_concat_p; 409 410/* Nonzero when we are expanding trees to RTL. */ 411int 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 420int 421rtx_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 573int 574rtx_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 716bool 717rtvec_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 742bool 743rtvec_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 759enum rtx_code 760classify_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 814static int 815rtx_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 823void 824dump_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 882void 883rtl_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 892void 893rtl_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 902void 903rtl_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 912void 913rtl_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 921void 922rtl_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 931void 932rtl_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 942void 943rtl_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 964void 965rtl_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? */ 973void 974cwi_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? */ 983void 984rtvec_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 994void 995rtl_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