1 /* RTL utility routines. 2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 /* This file is compiled twice: once for the generator programs 22 once for the compiler. */ 23 #ifdef GENERATOR_FILE 24 #include "bconfig.h" 25 #else 26 #include "config.h" 27 #endif 28 29 #include "system.h" 30 #include "coretypes.h" 31 #include "tm.h" 32 #include "rtl.h" 33 #include "real.h" 34 #include "ggc.h" 35 #ifdef GENERATOR_FILE 36 # include "errors.h" 37 #else 38 # include "toplev.h" 39 #endif 40 41 42 /* Indexed by rtx code, gives number of operands for an rtx with that code. 43 Does NOT include rtx header data (code and links). */ 44 45 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 , 46 47 const unsigned char rtx_length[NUM_RTX_CODE] = { 48 #include "rtl.def" 49 }; 50 51 #undef DEF_RTL_EXPR 52 53 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */ 54 55 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , 56 57 const char * const rtx_name[NUM_RTX_CODE] = { 58 #include "rtl.def" /* rtl expressions are documented here */ 59 }; 60 61 #undef DEF_RTL_EXPR 62 63 /* Indexed by rtx code, gives a sequence of operand-types for 64 rtx's of that code. The sequence is a C string in which 65 each character describes one operand. */ 66 67 const char * const rtx_format[NUM_RTX_CODE] = { 68 /* "*" undefined. 69 can cause a warning message 70 "0" field is unused (or used in a phase-dependent manner) 71 prints nothing 72 "i" an integer 73 prints the integer 74 "n" like "i", but prints entries from `note_insn_name' 75 "w" an integer of width HOST_BITS_PER_WIDE_INT 76 prints the integer 77 "s" a pointer to a string 78 prints the string 79 "S" like "s", but optional: 80 the containing rtx may end before this operand 81 "T" like "s", but treated specially by the RTL reader; 82 only found in machine description patterns. 83 "e" a pointer to an rtl expression 84 prints the expression 85 "E" a pointer to a vector that points to a number of rtl expressions 86 prints a list of the rtl expressions 87 "V" like "E", but optional: 88 the containing rtx may end before this operand 89 "u" a pointer to another insn 90 prints the uid of the insn. 91 "b" is a pointer to a bitmap header. 92 "B" is a basic block pointer. 93 "t" is a tree pointer. */ 94 95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 96 #include "rtl.def" /* rtl expressions are defined here */ 97 #undef DEF_RTL_EXPR 98 }; 99 100 /* Indexed by rtx code, gives a character representing the "class" of 101 that rtx code. See rtl.def for documentation on the defined classes. */ 102 103 const enum rtx_class rtx_class[NUM_RTX_CODE] = { 104 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, 105 #include "rtl.def" /* rtl expressions are defined here */ 106 #undef DEF_RTL_EXPR 107 }; 108 109 /* Indexed by rtx code, gives the size of the rtx in bytes. */ 110 111 const unsigned char rtx_code_size[NUM_RTX_CODE] = { 112 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \ 113 ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE || (ENUM) == CONST_FIXED\ 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 #ifdef GATHER_STATISTICS 138 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE]; 139 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE]; 140 static int rtvec_alloc_counts; 141 static int rtvec_alloc_sizes; 142 #endif 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 (n); 154 /* Clear out the vector. */ 155 memset (&rt->elem[0], 0, n * sizeof (rtx)); 156 157 PUT_NUM_ELEM (rt, n); 158 159 #ifdef GATHER_STATISTICS 160 rtvec_alloc_counts++; 161 rtvec_alloc_sizes += n * sizeof (rtx); 162 #endif 163 164 return rt; 165 } 166 167 /* Create a bitwise copy of VEC. */ 168 169 rtvec 170 shallow_copy_rtvec (rtvec vec) 171 { 172 rtvec newvec; 173 int n; 174 175 n = GET_NUM_ELEM (vec); 176 newvec = rtvec_alloc (n); 177 memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n); 178 return newvec; 179 } 180 181 /* Return the number of bytes occupied by rtx value X. */ 182 183 unsigned int 184 rtx_size (const_rtx x) 185 { 186 if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x)) 187 return RTX_HDR_SIZE + sizeof (struct block_symbol); 188 return RTX_CODE_SIZE (GET_CODE (x)); 189 } 190 191 /* Allocate an rtx of code CODE. The CODE is stored in the rtx; 192 all the rest is initialized to zero. */ 193 194 rtx 195 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL) 196 { 197 rtx rt; 198 199 rt = (rtx) ggc_alloc_zone_pass_stat (RTX_CODE_SIZE (code), &rtl_zone); 200 201 /* We want to clear everything up to the FLD array. Normally, this 202 is one int, but we don't want to assume that and it isn't very 203 portable anyway; this is. */ 204 205 memset (rt, 0, RTX_HDR_SIZE); 206 PUT_CODE (rt, code); 207 208 #ifdef GATHER_STATISTICS 209 rtx_alloc_counts[code]++; 210 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code); 211 #endif 212 213 return rt; 214 } 215 216 217 /* Return true if ORIG is a sharable CONST. */ 218 219 bool 220 shared_const_p (const_rtx orig) 221 { 222 gcc_assert (GET_CODE (orig) == CONST); 223 224 /* CONST can be shared if it contains a SYMBOL_REF. If it contains 225 a LABEL_REF, it isn't sharable. */ 226 return (GET_CODE (XEXP (orig, 0)) == PLUS 227 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF 228 && CONST_INT_P(XEXP (XEXP (orig, 0), 1))); 229 } 230 231 232 /* Create a new copy of an rtx. 233 Recursively copies the operands of the rtx, 234 except for those few rtx codes that are sharable. */ 235 236 rtx 237 copy_rtx (rtx orig) 238 { 239 rtx copy; 240 int i, j; 241 RTX_CODE code; 242 const char *format_ptr; 243 244 code = GET_CODE (orig); 245 246 switch (code) 247 { 248 case REG: 249 case DEBUG_EXPR: 250 case VALUE: 251 case CONST_INT: 252 case CONST_DOUBLE: 253 case CONST_FIXED: 254 case CONST_VECTOR: 255 case SYMBOL_REF: 256 case CODE_LABEL: 257 case PC: 258 case CC0: 259 case SCRATCH: 260 /* SCRATCH must be shared because they represent distinct values. */ 261 return orig; 262 case CLOBBER: 263 if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER) 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 /* We do not copy FRAME_RELATED for INSNs. */ 292 if (INSN_P (orig)) 293 RTX_FLAG (copy, frame_related) = 0; 294 RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump); 295 RTX_FLAG (copy, call) = RTX_FLAG (orig, call); 296 297 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 298 299 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 300 switch (*format_ptr++) 301 { 302 case 'e': 303 if (XEXP (orig, i) != NULL) 304 XEXP (copy, i) = copy_rtx (XEXP (orig, i)); 305 break; 306 307 case 'E': 308 case 'V': 309 if (XVEC (orig, i) != NULL) 310 { 311 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 312 for (j = 0; j < XVECLEN (copy, i); j++) 313 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); 314 } 315 break; 316 317 case 't': 318 case 'w': 319 case 'i': 320 case 's': 321 case 'S': 322 case 'T': 323 case 'u': 324 case 'B': 325 case '0': 326 /* These are left unchanged. */ 327 break; 328 329 default: 330 gcc_unreachable (); 331 } 332 return copy; 333 } 334 335 /* Create a new copy of an rtx. Only copy just one level. */ 336 337 rtx 338 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL) 339 { 340 const unsigned int size = rtx_size (orig); 341 rtx const copy = (rtx) ggc_alloc_zone_pass_stat (size, &rtl_zone); 342 return (rtx) memcpy (copy, orig, size); 343 } 344 345 /* Nonzero when we are generating CONCATs. */ 346 int generating_concat_p; 347 348 /* Nonzero when we are expanding trees to RTL. */ 349 int currently_expanding_to_rtl; 350 351 352 353 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL. 354 When the callback returns true, we continue with the new pair. 355 Whenever changing this function check if rtx_equal_p below doesn't need 356 changing as well. */ 357 358 int 359 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb) 360 { 361 int i; 362 int j; 363 enum rtx_code code; 364 const char *fmt; 365 rtx nx, ny; 366 367 if (x == y) 368 return 1; 369 if (x == 0 || y == 0) 370 return 0; 371 372 /* Invoke the callback first. */ 373 if (cb != NULL 374 && ((*cb) (&x, &y, &nx, &ny))) 375 return rtx_equal_p_cb (nx, ny, cb); 376 377 code = GET_CODE (x); 378 /* Rtx's of different codes cannot be equal. */ 379 if (code != GET_CODE (y)) 380 return 0; 381 382 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 383 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 384 385 if (GET_MODE (x) != GET_MODE (y)) 386 return 0; 387 388 /* MEMs refering to different address space are not equivalent. */ 389 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y)) 390 return 0; 391 392 /* Some RTL can be compared nonrecursively. */ 393 switch (code) 394 { 395 case REG: 396 return (REGNO (x) == REGNO (y)); 397 398 case LABEL_REF: 399 return XEXP (x, 0) == XEXP (y, 0); 400 401 case SYMBOL_REF: 402 return XSTR (x, 0) == XSTR (y, 0); 403 404 case DEBUG_EXPR: 405 case VALUE: 406 case SCRATCH: 407 case CONST_DOUBLE: 408 case CONST_INT: 409 case CONST_FIXED: 410 return 0; 411 412 default: 413 break; 414 } 415 416 /* Compare the elements. If any pair of corresponding elements 417 fail to match, return 0 for the whole thing. */ 418 419 fmt = GET_RTX_FORMAT (code); 420 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 421 { 422 switch (fmt[i]) 423 { 424 case 'w': 425 if (XWINT (x, i) != XWINT (y, i)) 426 return 0; 427 break; 428 429 case 'n': 430 case 'i': 431 if (XINT (x, i) != XINT (y, i)) 432 { 433 #ifndef GENERATOR_FILE 434 if (((code == ASM_OPERANDS && i == 6) 435 || (code == ASM_INPUT && i == 1)) 436 && locator_eq (XINT (x, i), XINT (y, i))) 437 break; 438 #endif 439 return 0; 440 } 441 break; 442 443 case 'V': 444 case 'E': 445 /* Two vectors must have the same length. */ 446 if (XVECLEN (x, i) != XVECLEN (y, i)) 447 return 0; 448 449 /* And the corresponding elements must match. */ 450 for (j = 0; j < XVECLEN (x, i); j++) 451 if (rtx_equal_p_cb (XVECEXP (x, i, j), 452 XVECEXP (y, i, j), cb) == 0) 453 return 0; 454 break; 455 456 case 'e': 457 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0) 458 return 0; 459 break; 460 461 case 'S': 462 case 's': 463 if ((XSTR (x, i) || XSTR (y, i)) 464 && (! XSTR (x, i) || ! XSTR (y, i) 465 || strcmp (XSTR (x, i), XSTR (y, i)))) 466 return 0; 467 break; 468 469 case 'u': 470 /* These are just backpointers, so they don't matter. */ 471 break; 472 473 case '0': 474 case 't': 475 break; 476 477 /* It is believed that rtx's at this level will never 478 contain anything but integers and other rtx's, 479 except for within LABEL_REFs and SYMBOL_REFs. */ 480 default: 481 gcc_unreachable (); 482 } 483 } 484 return 1; 485 } 486 487 /* Return 1 if X and Y are identical-looking rtx's. 488 This is the Lisp function EQUAL for rtx arguments. 489 Whenever changing this function check if rtx_equal_p_cb above doesn't need 490 changing as well. */ 491 492 int 493 rtx_equal_p (const_rtx x, const_rtx y) 494 { 495 int i; 496 int j; 497 enum rtx_code code; 498 const char *fmt; 499 500 if (x == y) 501 return 1; 502 if (x == 0 || y == 0) 503 return 0; 504 505 code = GET_CODE (x); 506 /* Rtx's of different codes cannot be equal. */ 507 if (code != GET_CODE (y)) 508 return 0; 509 510 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 511 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 512 513 if (GET_MODE (x) != GET_MODE (y)) 514 return 0; 515 516 /* MEMs refering to different address space are not equivalent. */ 517 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y)) 518 return 0; 519 520 /* Some RTL can be compared nonrecursively. */ 521 switch (code) 522 { 523 case REG: 524 return (REGNO (x) == REGNO (y)); 525 526 case LABEL_REF: 527 return XEXP (x, 0) == XEXP (y, 0); 528 529 case SYMBOL_REF: 530 return XSTR (x, 0) == XSTR (y, 0); 531 532 case DEBUG_EXPR: 533 case VALUE: 534 case SCRATCH: 535 case CONST_DOUBLE: 536 case CONST_INT: 537 case CONST_FIXED: 538 return 0; 539 540 default: 541 break; 542 } 543 544 /* Compare the elements. If any pair of corresponding elements 545 fail to match, return 0 for the whole thing. */ 546 547 fmt = GET_RTX_FORMAT (code); 548 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 549 { 550 switch (fmt[i]) 551 { 552 case 'w': 553 if (XWINT (x, i) != XWINT (y, i)) 554 return 0; 555 break; 556 557 case 'n': 558 case 'i': 559 if (XINT (x, i) != XINT (y, i)) 560 { 561 #ifndef GENERATOR_FILE 562 if (((code == ASM_OPERANDS && i == 6) 563 || (code == ASM_INPUT && i == 1)) 564 && locator_eq (XINT (x, i), XINT (y, i))) 565 break; 566 #endif 567 return 0; 568 } 569 break; 570 571 case 'V': 572 case 'E': 573 /* Two vectors must have the same length. */ 574 if (XVECLEN (x, i) != XVECLEN (y, i)) 575 return 0; 576 577 /* And the corresponding elements must match. */ 578 for (j = 0; j < XVECLEN (x, i); j++) 579 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0) 580 return 0; 581 break; 582 583 case 'e': 584 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0) 585 return 0; 586 break; 587 588 case 'S': 589 case 's': 590 if ((XSTR (x, i) || XSTR (y, i)) 591 && (! XSTR (x, i) || ! XSTR (y, i) 592 || strcmp (XSTR (x, i), XSTR (y, i)))) 593 return 0; 594 break; 595 596 case 'u': 597 /* These are just backpointers, so they don't matter. */ 598 break; 599 600 case '0': 601 case 't': 602 break; 603 604 /* It is believed that rtx's at this level will never 605 contain anything but integers and other rtx's, 606 except for within LABEL_REFs and SYMBOL_REFs. */ 607 default: 608 gcc_unreachable (); 609 } 610 } 611 return 1; 612 } 613 614 void 615 dump_rtx_statistics (void) 616 { 617 #ifdef GATHER_STATISTICS 618 int i; 619 int total_counts = 0; 620 int total_sizes = 0; 621 fprintf (stderr, "\nRTX Kind Count Bytes\n"); 622 fprintf (stderr, "---------------------------------------\n"); 623 for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++) 624 if (rtx_alloc_counts[i]) 625 { 626 fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i), 627 rtx_alloc_counts[i], rtx_alloc_sizes[i]); 628 total_counts += rtx_alloc_counts[i]; 629 total_sizes += rtx_alloc_sizes[i]; 630 } 631 if (rtvec_alloc_counts) 632 { 633 fprintf (stderr, "%-20s %7d %10d\n", "rtvec", 634 rtvec_alloc_counts, rtvec_alloc_sizes); 635 total_counts += rtvec_alloc_counts; 636 total_sizes += rtvec_alloc_sizes; 637 } 638 fprintf (stderr, "---------------------------------------\n"); 639 fprintf (stderr, "%-20s %7d %10d\n", 640 "Total", total_counts, total_sizes); 641 fprintf (stderr, "---------------------------------------\n"); 642 #endif 643 } 644 645 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) 646 void 647 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line, 648 const char *func) 649 { 650 internal_error 651 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d", 652 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1, 653 func, trim_filename (file), line); 654 } 655 656 void 657 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line, 658 const char *func) 659 { 660 internal_error 661 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d", 662 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 663 func, trim_filename (file), line); 664 } 665 666 void 667 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file, 668 int line, const char *func) 669 { 670 internal_error 671 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d", 672 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 673 func, trim_filename (file), line); 674 } 675 676 void 677 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file, 678 int line, const char *func) 679 { 680 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d", 681 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func, 682 trim_filename (file), line); 683 } 684 685 void 686 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2, 687 const char *file, int line, const char *func) 688 { 689 internal_error 690 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d", 691 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)), 692 func, trim_filename (file), line); 693 } 694 695 void 696 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode, 697 bool not_mode, const char *file, int line, 698 const char *func) 699 { 700 internal_error ((not_mode 701 ? ("RTL check: expected code '%s' and not mode '%s', " 702 "have code '%s' and mode '%s' in %s, at %s:%d") 703 : ("RTL check: expected code '%s' and mode '%s', " 704 "have code '%s' and mode '%s' in %s, at %s:%d")), 705 GET_RTX_NAME (code), GET_MODE_NAME (mode), 706 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)), 707 func, trim_filename (file), line); 708 } 709 710 /* Report that line LINE of FILE tried to access the block symbol fields 711 of a non-block symbol. FUNC is the function that contains the line. */ 712 713 void 714 rtl_check_failed_block_symbol (const char *file, int line, const char *func) 715 { 716 internal_error 717 ("RTL check: attempt to treat non-block symbol as a block symbol " 718 "in %s, at %s:%d", func, trim_filename (file), line); 719 } 720 721 /* XXX Maybe print the vector? */ 722 void 723 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line, 724 const char *func) 725 { 726 internal_error 727 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d", 728 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line); 729 } 730 #endif /* ENABLE_RTL_CHECKING */ 731 732 #if defined ENABLE_RTL_FLAG_CHECKING 733 void 734 rtl_check_failed_flag (const char *name, const_rtx r, const char *file, 735 int line, const char *func) 736 { 737 internal_error 738 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d", 739 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line); 740 } 741 #endif /* ENABLE_RTL_FLAG_CHECKING */ 742