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