1 /* RTL utility routines. 2 Copyright (C) 1987-2017 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 94 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 95 #include "rtl.def" /* rtl expressions are defined here */ 96 #undef DEF_RTL_EXPR 97 }; 98 99 /* Indexed by rtx code, gives a character representing the "class" of 100 that rtx code. See rtl.def for documentation on the defined classes. */ 101 102 const enum rtx_class rtx_class[NUM_RTX_CODE] = { 103 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, 104 #include "rtl.def" /* rtl expressions are defined here */ 105 #undef DEF_RTL_EXPR 106 }; 107 108 /* Indexed by rtx code, gives the size of the rtx in bytes. */ 109 110 const unsigned char rtx_code_size[NUM_RTX_CODE] = { 111 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \ 112 (((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE \ 113 || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT) \ 114 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \ 115 : (ENUM) == REG \ 116 ? RTX_HDR_SIZE + sizeof (reg_info) \ 117 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)), 118 119 #include "rtl.def" 120 #undef DEF_RTL_EXPR 121 }; 122 123 /* Names for kinds of NOTEs and REG_NOTEs. */ 124 125 const char * const note_insn_name[NOTE_INSN_MAX] = 126 { 127 #define DEF_INSN_NOTE(NAME) #NAME, 128 #include "insn-notes.def" 129 #undef DEF_INSN_NOTE 130 }; 131 132 const char * const reg_note_name[REG_NOTE_MAX] = 133 { 134 #define DEF_REG_NOTE(NAME) #NAME, 135 #include "reg-notes.def" 136 #undef DEF_REG_NOTE 137 }; 138 139 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE]; 140 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE]; 141 static int rtvec_alloc_counts; 142 static int rtvec_alloc_sizes; 143 144 145 /* Allocate an rtx vector of N elements. 146 Store the length, and initialize all elements to zero. */ 147 148 rtvec 149 rtvec_alloc (int n) 150 { 151 rtvec rt; 152 153 rt = ggc_alloc_rtvec_sized (n); 154 /* Clear out the vector. */ 155 memset (&rt->elem[0], 0, n * sizeof (rtx)); 156 157 PUT_NUM_ELEM (rt, n); 158 159 if (GATHER_STATISTICS) 160 { 161 rtvec_alloc_counts++; 162 rtvec_alloc_sizes += n * sizeof (rtx); 163 } 164 165 return rt; 166 } 167 168 /* Create a bitwise copy of VEC. */ 169 170 rtvec 171 shallow_copy_rtvec (rtvec vec) 172 { 173 rtvec newvec; 174 int n; 175 176 n = GET_NUM_ELEM (vec); 177 newvec = rtvec_alloc (n); 178 memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n); 179 return newvec; 180 } 181 182 /* Return the number of bytes occupied by rtx value X. */ 183 184 unsigned int 185 rtx_size (const_rtx x) 186 { 187 if (CONST_WIDE_INT_P (x)) 188 return (RTX_HDR_SIZE 189 + sizeof (struct hwivec_def) 190 + ((CONST_WIDE_INT_NUNITS (x) - 1) 191 * sizeof (HOST_WIDE_INT))); 192 if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x)) 193 return RTX_HDR_SIZE + sizeof (struct block_symbol); 194 return RTX_CODE_SIZE (GET_CODE (x)); 195 } 196 197 /* Allocate an rtx of code CODE with EXTRA bytes in it. The CODE is 198 stored in the rtx; all the rest is initialized to zero. */ 199 200 rtx 201 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra) 202 { 203 rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra 204 PASS_MEM_STAT); 205 206 /* We want to clear everything up to the FLD array. Normally, this 207 is one int, but we don't want to assume that and it isn't very 208 portable anyway; this is. */ 209 210 memset (rt, 0, RTX_HDR_SIZE); 211 PUT_CODE (rt, code); 212 213 if (GATHER_STATISTICS) 214 { 215 rtx_alloc_counts[code]++; 216 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code); 217 } 218 219 return rt; 220 } 221 222 /* Allocate an rtx of code CODE. The CODE is stored in the rtx; 223 all the rest is initialized to zero. */ 224 225 rtx 226 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL) 227 { 228 return rtx_alloc_stat_v (code PASS_MEM_STAT, 0); 229 } 230 231 /* Write the wide constant X to OUTFILE. */ 232 233 void 234 cwi_output_hex (FILE *outfile, const_rtx x) 235 { 236 int i = CWI_GET_NUM_ELEM (x); 237 gcc_assert (i > 0); 238 if (CWI_ELT (x, i - 1) == 0) 239 /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is 240 non zero. We want all numbers to have a 0x prefix. */ 241 fprintf (outfile, "0x"); 242 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i)); 243 while (--i >= 0) 244 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i)); 245 } 246 247 248 /* Return true if ORIG is a sharable CONST. */ 249 250 bool 251 shared_const_p (const_rtx orig) 252 { 253 gcc_assert (GET_CODE (orig) == CONST); 254 255 /* CONST can be shared if it contains a SYMBOL_REF. If it contains 256 a LABEL_REF, it isn't sharable. */ 257 return (GET_CODE (XEXP (orig, 0)) == PLUS 258 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF 259 && CONST_INT_P (XEXP (XEXP (orig, 0), 1))); 260 } 261 262 263 /* Create a new copy of an rtx. 264 Recursively copies the operands of the rtx, 265 except for those few rtx codes that are sharable. */ 266 267 rtx 268 copy_rtx (rtx orig) 269 { 270 rtx copy; 271 int i, j; 272 RTX_CODE code; 273 const char *format_ptr; 274 275 code = GET_CODE (orig); 276 277 switch (code) 278 { 279 case REG: 280 case DEBUG_EXPR: 281 case VALUE: 282 CASE_CONST_ANY: 283 case SYMBOL_REF: 284 case CODE_LABEL: 285 case PC: 286 case CC0: 287 case RETURN: 288 case SIMPLE_RETURN: 289 case SCRATCH: 290 /* SCRATCH must be shared because they represent distinct values. */ 291 return orig; 292 case CLOBBER: 293 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg 294 clobbers or clobbers of hard registers that originated as pseudos. 295 This is needed to allow safe register renaming. */ 296 if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER 297 && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0))) 298 return orig; 299 break; 300 301 case CONST: 302 if (shared_const_p (orig)) 303 return orig; 304 break; 305 306 /* A MEM with a constant address is not sharable. The problem is that 307 the constant address may need to be reloaded. If the mem is shared, 308 then reloading one copy of this mem will cause all copies to appear 309 to have been reloaded. */ 310 311 default: 312 break; 313 } 314 315 /* Copy the various flags, fields, and other information. We assume 316 that all fields need copying, and then clear the fields that should 317 not be copied. That is the sensible default behavior, and forces 318 us to explicitly document why we are *not* copying a flag. */ 319 copy = shallow_copy_rtx (orig); 320 321 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 322 323 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 324 switch (*format_ptr++) 325 { 326 case 'e': 327 if (XEXP (orig, i) != NULL) 328 XEXP (copy, i) = copy_rtx (XEXP (orig, i)); 329 break; 330 331 case 'E': 332 case 'V': 333 if (XVEC (orig, i) != NULL) 334 { 335 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 336 for (j = 0; j < XVECLEN (copy, i); j++) 337 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); 338 } 339 break; 340 341 case 't': 342 case 'w': 343 case 'i': 344 case 's': 345 case 'S': 346 case 'T': 347 case 'u': 348 case 'B': 349 case '0': 350 /* These are left unchanged. */ 351 break; 352 353 default: 354 gcc_unreachable (); 355 } 356 return copy; 357 } 358 359 /* Create a new copy of an rtx. Only copy just one level. */ 360 361 rtx 362 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL) 363 { 364 const unsigned int size = rtx_size (orig); 365 rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT); 366 memcpy (copy, orig, size); 367 switch (GET_CODE (orig)) 368 { 369 /* RTX codes copy_rtx_if_shared_1 considers are shareable, 370 the used flag is often used for other purposes. */ 371 case REG: 372 case DEBUG_EXPR: 373 case VALUE: 374 CASE_CONST_ANY: 375 case SYMBOL_REF: 376 case CODE_LABEL: 377 case PC: 378 case CC0: 379 case RETURN: 380 case SIMPLE_RETURN: 381 case SCRATCH: 382 break; 383 default: 384 /* For all other RTXes clear the used flag on the copy. */ 385 RTX_FLAG (copy, used) = 0; 386 break; 387 } 388 return copy; 389 } 390 391 /* Nonzero when we are generating CONCATs. */ 392 int generating_concat_p; 393 394 /* Nonzero when we are expanding trees to RTL. */ 395 int currently_expanding_to_rtl; 396 397 398 399 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL. 400 When the callback returns true, we continue with the new pair. 401 Whenever changing this function check if rtx_equal_p below doesn't need 402 changing as well. */ 403 404 int 405 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb) 406 { 407 int i; 408 int j; 409 enum rtx_code code; 410 const char *fmt; 411 rtx nx, ny; 412 413 if (x == y) 414 return 1; 415 if (x == 0 || y == 0) 416 return 0; 417 418 /* Invoke the callback first. */ 419 if (cb != NULL 420 && ((*cb) (&x, &y, &nx, &ny))) 421 return rtx_equal_p_cb (nx, ny, cb); 422 423 code = GET_CODE (x); 424 /* Rtx's of different codes cannot be equal. */ 425 if (code != GET_CODE (y)) 426 return 0; 427 428 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 429 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 430 431 if (GET_MODE (x) != GET_MODE (y)) 432 return 0; 433 434 /* MEMs referring to different address space are not equivalent. */ 435 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y)) 436 return 0; 437 438 /* Some RTL can be compared nonrecursively. */ 439 switch (code) 440 { 441 case REG: 442 return (REGNO (x) == REGNO (y)); 443 444 case LABEL_REF: 445 return label_ref_label (x) == label_ref_label (y); 446 447 case SYMBOL_REF: 448 return XSTR (x, 0) == XSTR (y, 0); 449 450 case DEBUG_EXPR: 451 case VALUE: 452 case SCRATCH: 453 CASE_CONST_UNIQUE: 454 return 0; 455 456 case DEBUG_IMPLICIT_PTR: 457 return DEBUG_IMPLICIT_PTR_DECL (x) 458 == DEBUG_IMPLICIT_PTR_DECL (y); 459 460 case DEBUG_PARAMETER_REF: 461 return DEBUG_PARAMETER_REF_DECL (x) 462 == DEBUG_PARAMETER_REF_DECL (y); 463 464 case ENTRY_VALUE: 465 return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb); 466 467 default: 468 break; 469 } 470 471 /* Compare the elements. If any pair of corresponding elements 472 fail to match, return 0 for the whole thing. */ 473 474 fmt = GET_RTX_FORMAT (code); 475 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 476 { 477 switch (fmt[i]) 478 { 479 case 'w': 480 if (XWINT (x, i) != XWINT (y, i)) 481 return 0; 482 break; 483 484 case 'n': 485 case 'i': 486 if (XINT (x, i) != XINT (y, i)) 487 { 488 #ifndef GENERATOR_FILE 489 if (((code == ASM_OPERANDS && i == 6) 490 || (code == ASM_INPUT && i == 1)) 491 && XINT (x, i) == XINT (y, i)) 492 break; 493 #endif 494 return 0; 495 } 496 break; 497 498 case 'V': 499 case 'E': 500 /* Two vectors must have the same length. */ 501 if (XVECLEN (x, i) != XVECLEN (y, i)) 502 return 0; 503 504 /* And the corresponding elements must match. */ 505 for (j = 0; j < XVECLEN (x, i); j++) 506 if (rtx_equal_p_cb (XVECEXP (x, i, j), 507 XVECEXP (y, i, j), cb) == 0) 508 return 0; 509 break; 510 511 case 'e': 512 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0) 513 return 0; 514 break; 515 516 case 'S': 517 case 's': 518 if ((XSTR (x, i) || XSTR (y, i)) 519 && (! XSTR (x, i) || ! XSTR (y, i) 520 || strcmp (XSTR (x, i), XSTR (y, i)))) 521 return 0; 522 break; 523 524 case 'u': 525 /* These are just backpointers, so they don't matter. */ 526 break; 527 528 case '0': 529 case 't': 530 break; 531 532 /* It is believed that rtx's at this level will never 533 contain anything but integers and other rtx's, 534 except for within LABEL_REFs and SYMBOL_REFs. */ 535 default: 536 gcc_unreachable (); 537 } 538 } 539 return 1; 540 } 541 542 /* Return 1 if X and Y are identical-looking rtx's. 543 This is the Lisp function EQUAL for rtx arguments. 544 Whenever changing this function check if rtx_equal_p_cb above doesn't need 545 changing as well. */ 546 547 int 548 rtx_equal_p (const_rtx x, const_rtx y) 549 { 550 int i; 551 int j; 552 enum rtx_code code; 553 const char *fmt; 554 555 if (x == y) 556 return 1; 557 if (x == 0 || y == 0) 558 return 0; 559 560 code = GET_CODE (x); 561 /* Rtx's of different codes cannot be equal. */ 562 if (code != GET_CODE (y)) 563 return 0; 564 565 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 566 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 567 568 if (GET_MODE (x) != GET_MODE (y)) 569 return 0; 570 571 /* MEMs referring to different address space are not equivalent. */ 572 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y)) 573 return 0; 574 575 /* Some RTL can be compared nonrecursively. */ 576 switch (code) 577 { 578 case REG: 579 return (REGNO (x) == REGNO (y)); 580 581 case LABEL_REF: 582 return label_ref_label (x) == label_ref_label (y); 583 584 case SYMBOL_REF: 585 return XSTR (x, 0) == XSTR (y, 0); 586 587 case DEBUG_EXPR: 588 case VALUE: 589 case SCRATCH: 590 CASE_CONST_UNIQUE: 591 return 0; 592 593 case DEBUG_IMPLICIT_PTR: 594 return DEBUG_IMPLICIT_PTR_DECL (x) 595 == DEBUG_IMPLICIT_PTR_DECL (y); 596 597 case DEBUG_PARAMETER_REF: 598 return DEBUG_PARAMETER_REF_DECL (x) 599 == DEBUG_PARAMETER_REF_DECL (y); 600 601 case ENTRY_VALUE: 602 return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y)); 603 604 default: 605 break; 606 } 607 608 /* Compare the elements. If any pair of corresponding elements 609 fail to match, return 0 for the whole thing. */ 610 611 fmt = GET_RTX_FORMAT (code); 612 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 613 { 614 switch (fmt[i]) 615 { 616 case 'w': 617 if (XWINT (x, i) != XWINT (y, i)) 618 return 0; 619 break; 620 621 case 'n': 622 case 'i': 623 if (XINT (x, i) != XINT (y, i)) 624 { 625 #ifndef GENERATOR_FILE 626 if (((code == ASM_OPERANDS && i == 6) 627 || (code == ASM_INPUT && i == 1)) 628 && XINT (x, i) == XINT (y, i)) 629 break; 630 #endif 631 return 0; 632 } 633 break; 634 635 case 'V': 636 case 'E': 637 /* Two vectors must have the same length. */ 638 if (XVECLEN (x, i) != XVECLEN (y, i)) 639 return 0; 640 641 /* And the corresponding elements must match. */ 642 for (j = 0; j < XVECLEN (x, i); j++) 643 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0) 644 return 0; 645 break; 646 647 case 'e': 648 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0) 649 return 0; 650 break; 651 652 case 'S': 653 case 's': 654 if ((XSTR (x, i) || XSTR (y, i)) 655 && (! XSTR (x, i) || ! XSTR (y, i) 656 || strcmp (XSTR (x, i), XSTR (y, i)))) 657 return 0; 658 break; 659 660 case 'u': 661 /* These are just backpointers, so they don't matter. */ 662 break; 663 664 case '0': 665 case 't': 666 break; 667 668 /* It is believed that rtx's at this level will never 669 contain anything but integers and other rtx's, 670 except for within LABEL_REFs and SYMBOL_REFs. */ 671 default: 672 gcc_unreachable (); 673 } 674 } 675 return 1; 676 } 677 678 /* Return true if all elements of VEC are equal. */ 679 680 bool 681 rtvec_all_equal_p (const_rtvec vec) 682 { 683 const_rtx first = RTVEC_ELT (vec, 0); 684 /* Optimize the important special case of a vector of constants. 685 The main use of this function is to detect whether every element 686 of CONST_VECTOR is the same. */ 687 switch (GET_CODE (first)) 688 { 689 CASE_CONST_UNIQUE: 690 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i) 691 if (first != RTVEC_ELT (vec, i)) 692 return false; 693 return true; 694 695 default: 696 for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i) 697 if (!rtx_equal_p (first, RTVEC_ELT (vec, i))) 698 return false; 699 return true; 700 } 701 } 702 703 /* Return an indication of which type of insn should have X as a body. 704 In generator files, this can be UNKNOWN if the answer is only known 705 at (GCC) runtime. Otherwise the value is CODE_LABEL, INSN, CALL_INSN 706 or JUMP_INSN. */ 707 708 enum rtx_code 709 classify_insn (rtx x) 710 { 711 if (LABEL_P (x)) 712 return CODE_LABEL; 713 if (GET_CODE (x) == CALL) 714 return CALL_INSN; 715 if (ANY_RETURN_P (x)) 716 return JUMP_INSN; 717 if (GET_CODE (x) == SET) 718 { 719 if (GET_CODE (SET_DEST (x)) == PC) 720 return JUMP_INSN; 721 else if (GET_CODE (SET_SRC (x)) == CALL) 722 return CALL_INSN; 723 else 724 return INSN; 725 } 726 if (GET_CODE (x) == PARALLEL) 727 { 728 int j; 729 bool has_return_p = false; 730 for (j = XVECLEN (x, 0) - 1; j >= 0; j--) 731 if (GET_CODE (XVECEXP (x, 0, j)) == CALL) 732 return CALL_INSN; 733 else if (ANY_RETURN_P (XVECEXP (x, 0, j))) 734 has_return_p = true; 735 else if (GET_CODE (XVECEXP (x, 0, j)) == SET 736 && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC) 737 return JUMP_INSN; 738 else if (GET_CODE (XVECEXP (x, 0, j)) == SET 739 && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL) 740 return CALL_INSN; 741 if (has_return_p) 742 return JUMP_INSN; 743 } 744 #ifdef GENERATOR_FILE 745 if (GET_CODE (x) == MATCH_OPERAND 746 || GET_CODE (x) == MATCH_OPERATOR 747 || GET_CODE (x) == MATCH_PARALLEL 748 || GET_CODE (x) == MATCH_OP_DUP 749 || GET_CODE (x) == MATCH_DUP 750 || GET_CODE (x) == PARALLEL) 751 return UNKNOWN; 752 #endif 753 return INSN; 754 } 755 756 void 757 dump_rtx_statistics (void) 758 { 759 int i; 760 int total_counts = 0; 761 int total_sizes = 0; 762 763 if (! GATHER_STATISTICS) 764 { 765 fprintf (stderr, "No RTX statistics\n"); 766 return; 767 } 768 769 fprintf (stderr, "\nRTX Kind Count Bytes\n"); 770 fprintf (stderr, "---------------------------------------\n"); 771 for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++) 772 if (rtx_alloc_counts[i]) 773 { 774 fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i), 775 rtx_alloc_counts[i], rtx_alloc_sizes[i]); 776 total_counts += rtx_alloc_counts[i]; 777 total_sizes += rtx_alloc_sizes[i]; 778 } 779 if (rtvec_alloc_counts) 780 { 781 fprintf (stderr, "%-20s %7d %10d\n", "rtvec", 782 rtvec_alloc_counts, rtvec_alloc_sizes); 783 total_counts += rtvec_alloc_counts; 784 total_sizes += rtvec_alloc_sizes; 785 } 786 fprintf (stderr, "---------------------------------------\n"); 787 fprintf (stderr, "%-20s %7d %10d\n", 788 "Total", total_counts, total_sizes); 789 fprintf (stderr, "---------------------------------------\n"); 790 } 791 792 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) 793 void 794 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line, 795 const char *func) 796 { 797 internal_error 798 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d", 799 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1, 800 func, trim_filename (file), line); 801 } 802 803 void 804 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line, 805 const char *func) 806 { 807 internal_error 808 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d", 809 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 810 func, trim_filename (file), line); 811 } 812 813 void 814 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file, 815 int line, const char *func) 816 { 817 internal_error 818 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d", 819 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 820 func, trim_filename (file), line); 821 } 822 823 void 824 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file, 825 int line, const char *func) 826 { 827 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d", 828 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func, 829 trim_filename (file), line); 830 } 831 832 void 833 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2, 834 const char *file, int line, const char *func) 835 { 836 internal_error 837 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d", 838 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)), 839 func, trim_filename (file), line); 840 } 841 842 void 843 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode, 844 bool not_mode, const char *file, int line, 845 const char *func) 846 { 847 internal_error ((not_mode 848 ? ("RTL check: expected code '%s' and not mode '%s', " 849 "have code '%s' and mode '%s' in %s, at %s:%d") 850 : ("RTL check: expected code '%s' and mode '%s', " 851 "have code '%s' and mode '%s' in %s, at %s:%d")), 852 GET_RTX_NAME (code), GET_MODE_NAME (mode), 853 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)), 854 func, trim_filename (file), line); 855 } 856 857 /* Report that line LINE of FILE tried to access the block symbol fields 858 of a non-block symbol. FUNC is the function that contains the line. */ 859 860 void 861 rtl_check_failed_block_symbol (const char *file, int line, const char *func) 862 { 863 internal_error 864 ("RTL check: attempt to treat non-block symbol as a block symbol " 865 "in %s, at %s:%d", func, trim_filename (file), line); 866 } 867 868 /* XXX Maybe print the vector? */ 869 void 870 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line, 871 const char *func) 872 { 873 internal_error 874 ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d", 875 n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line); 876 } 877 878 /* XXX Maybe print the vector? */ 879 void 880 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line, 881 const char *func) 882 { 883 internal_error 884 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d", 885 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line); 886 } 887 #endif /* ENABLE_RTL_CHECKING */ 888 889 #if defined ENABLE_RTL_FLAG_CHECKING 890 void 891 rtl_check_failed_flag (const char *name, const_rtx r, const char *file, 892 int line, const char *func) 893 { 894 internal_error 895 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d", 896 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line); 897 } 898 #endif /* ENABLE_RTL_FLAG_CHECKING */ 899