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