rtl.c revision 96263
1/* RTL utility routines. 2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002 3 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "rtl.h" 25#include "real.h" 26#include "ggc.h" 27#include "errors.h" 28 29 30/* Calculate the format for CONST_DOUBLE. This depends on the relative 31 widths of HOST_WIDE_INT and REAL_VALUE_TYPE. 32 33 We need to go out to 0wwwww, since REAL_ARITHMETIC assumes 16-bits 34 per element in REAL_VALUE_TYPE. 35 36 This is duplicated in gengenrtl.c. 37 38 A number of places assume that there are always at least two 'w' 39 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ 40 41#ifdef REAL_ARITHMETIC 42# if MAX_LONG_DOUBLE_TYPE_SIZE == 96 43# define REAL_WIDTH \ 44 (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT 45# else 46# if MAX_LONG_DOUBLE_TYPE_SIZE == 128 47# define REAL_WIDTH \ 48 (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT 49# else 50# if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT 51# define REAL_WIDTH \ 52 (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT 53# endif 54# endif 55# endif 56#endif /* REAL_ARITHMETIC */ 57 58#ifndef REAL_WIDTH 59# if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE 60# define REAL_WIDTH 2 61# else 62# if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE 63# define REAL_WIDTH 3 64# else 65# if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE 66# define REAL_WIDTH 4 67# endif 68# endif 69# endif 70#endif /* REAL_WIDTH */ 71 72#if REAL_WIDTH == 1 73# define CONST_DOUBLE_FORMAT "0ww" 74#else 75# if REAL_WIDTH == 2 76# define CONST_DOUBLE_FORMAT "0ww" 77# else 78# if REAL_WIDTH == 3 79# define CONST_DOUBLE_FORMAT "0www" 80# else 81# if REAL_WIDTH == 4 82# define CONST_DOUBLE_FORMAT "0wwww" 83# else 84# if REAL_WIDTH == 5 85# define CONST_DOUBLE_FORMAT "0wwwww" 86# else 87# define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */ 88# endif 89# endif 90# endif 91# endif 92#endif 93 94/* Indexed by rtx code, gives number of operands for an rtx with that code. 95 Does NOT include rtx header data (code and links). */ 96 97#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 , 98 99const unsigned char rtx_length[NUM_RTX_CODE] = { 100#include "rtl.def" 101}; 102 103#undef DEF_RTL_EXPR 104 105/* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */ 106 107#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , 108 109const char * const rtx_name[NUM_RTX_CODE] = { 110#include "rtl.def" /* rtl expressions are documented here */ 111}; 112 113#undef DEF_RTL_EXPR 114 115/* Indexed by machine mode, gives the name of that machine mode. 116 This name does not include the letters "mode". */ 117 118#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) NAME, 119 120const char * const mode_name[NUM_MACHINE_MODES] = { 121#include "machmode.def" 122}; 123 124#undef DEF_MACHMODE 125 126/* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */ 127 128#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) CLASS, 129 130const enum mode_class mode_class[NUM_MACHINE_MODES] = { 131#include "machmode.def" 132}; 133 134#undef DEF_MACHMODE 135 136/* Indexed by machine mode, gives the length of the mode, in bits. 137 GET_MODE_BITSIZE uses this. */ 138 139#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) BITSIZE, 140 141const unsigned short mode_bitsize[NUM_MACHINE_MODES] = { 142#include "machmode.def" 143}; 144 145#undef DEF_MACHMODE 146 147/* Indexed by machine mode, gives the length of the mode, in bytes. 148 GET_MODE_SIZE uses this. */ 149 150#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) SIZE, 151 152const unsigned char mode_size[NUM_MACHINE_MODES] = { 153#include "machmode.def" 154}; 155 156#undef DEF_MACHMODE 157 158/* Indexed by machine mode, gives the length of the mode's subunit. 159 GET_MODE_UNIT_SIZE uses this. */ 160 161#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) UNIT, 162 163const unsigned char mode_unit_size[NUM_MACHINE_MODES] = { 164#include "machmode.def" /* machine modes are documented here */ 165}; 166 167#undef DEF_MACHMODE 168 169/* Indexed by machine mode, gives next wider natural mode 170 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions 171 use this. */ 172 173#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \ 174 (unsigned char) WIDER, 175 176const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = { 177#include "machmode.def" /* machine modes are documented here */ 178}; 179 180#undef DEF_MACHMODE 181 182#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \ 183 ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1, 184 185/* Indexed by machine mode, gives mask of significant bits in mode. */ 186 187const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES] = { 188#include "machmode.def" 189}; 190 191#undef DEF_MACHMODE 192 193#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER, 194 195/* Indexed by machine mode, gives the mode of the inner elements in a 196 vector type. */ 197 198const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = { 199#include "machmode.def" 200}; 201 202/* Indexed by mode class, gives the narrowest mode for each class. 203 The Q modes are always of width 1 (2 for complex) - it is impossible 204 for any mode to be narrower. 205 206 Note that we use QImode instead of BImode for MODE_INT, since 207 otherwise the middle end will try to use it for bitfields in 208 structures and the like, which we do not want. Only the target 209 md file should generate BImode widgets. */ 210 211const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = { 212 /* MODE_RANDOM */ VOIDmode, 213 /* MODE_INT */ QImode, 214 /* MODE_FLOAT */ QFmode, 215 /* MODE_PARTIAL_INT */ PQImode, 216 /* MODE_CC */ CCmode, 217 /* MODE_COMPLEX_INT */ CQImode, 218 /* MODE_COMPLEX_FLOAT */ QCmode, 219 /* MODE_VECTOR_INT */ V2QImode, 220 /* MODE_VECTOR_FLOAT */ V2SFmode 221}; 222 223 224/* Indexed by rtx code, gives a sequence of operand-types for 225 rtx's of that code. The sequence is a C string in which 226 each character describes one operand. */ 227 228const char * const rtx_format[NUM_RTX_CODE] = { 229 /* "*" undefined. 230 can cause a warning message 231 "0" field is unused (or used in a phase-dependent manner) 232 prints nothing 233 "i" an integer 234 prints the integer 235 "n" like "i", but prints entries from `note_insn_name' 236 "w" an integer of width HOST_BITS_PER_WIDE_INT 237 prints the integer 238 "s" a pointer to a string 239 prints the string 240 "S" like "s", but optional: 241 the containing rtx may end before this operand 242 "T" like "s", but treated specially by the RTL reader; 243 only found in machine description patterns. 244 "e" a pointer to an rtl expression 245 prints the expression 246 "E" a pointer to a vector that points to a number of rtl expressions 247 prints a list of the rtl expressions 248 "V" like "E", but optional: 249 the containing rtx may end before this operand 250 "u" a pointer to another insn 251 prints the uid of the insn. 252 "b" is a pointer to a bitmap header. 253 "t" is a tree pointer. */ 254 255#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 256#include "rtl.def" /* rtl expressions are defined here */ 257#undef DEF_RTL_EXPR 258}; 259 260/* Indexed by rtx code, gives a character representing the "class" of 261 that rtx code. See rtl.def for documentation on the defined classes. */ 262 263const char rtx_class[NUM_RTX_CODE] = { 264#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, 265#include "rtl.def" /* rtl expressions are defined here */ 266#undef DEF_RTL_EXPR 267}; 268 269/* Names for kinds of NOTEs and REG_NOTEs. */ 270 271const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] = 272{ 273 "", "NOTE_INSN_DELETED", 274 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END", 275 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END", 276 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP", 277 "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END", 278 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG", 279 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG", 280 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END", 281 "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG", 282 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE", 283 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE" 284}; 285 286const char * const reg_note_name[] = 287{ 288 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL", 289 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG", 290 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER", 291 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB", 292 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED", 293 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION", 294 "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN", 295 "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN", 296 "REG_VTABLE_REF" 297}; 298 299 300/* Allocate an rtx vector of N elements. 301 Store the length, and initialize all elements to zero. */ 302 303rtvec 304rtvec_alloc (n) 305 int n; 306{ 307 rtvec rt; 308 309 rt = ggc_alloc_rtvec (n); 310 /* clear out the vector */ 311 memset (&rt->elem[0], 0, n * sizeof (rtx)); 312 313 PUT_NUM_ELEM (rt, n); 314 return rt; 315} 316 317/* Allocate an rtx of code CODE. The CODE is stored in the rtx; 318 all the rest is initialized to zero. */ 319 320rtx 321rtx_alloc (code) 322 RTX_CODE code; 323{ 324 rtx rt; 325 int n = GET_RTX_LENGTH (code); 326 327 rt = ggc_alloc_rtx (n); 328 329 /* We want to clear everything up to the FLD array. Normally, this 330 is one int, but we don't want to assume that and it isn't very 331 portable anyway; this is. */ 332 333 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion)); 334 PUT_CODE (rt, code); 335 return rt; 336} 337 338 339/* Create a new copy of an rtx. 340 Recursively copies the operands of the rtx, 341 except for those few rtx codes that are sharable. */ 342 343rtx 344copy_rtx (orig) 345 rtx orig; 346{ 347 rtx copy; 348 int i, j; 349 RTX_CODE code; 350 const char *format_ptr; 351 352 code = GET_CODE (orig); 353 354 switch (code) 355 { 356 case REG: 357 case QUEUED: 358 case CONST_INT: 359 case CONST_DOUBLE: 360 case CONST_VECTOR: 361 case SYMBOL_REF: 362 case CODE_LABEL: 363 case PC: 364 case CC0: 365 case SCRATCH: 366 /* SCRATCH must be shared because they represent distinct values. */ 367 case ADDRESSOF: 368 return orig; 369 370 case CONST: 371 /* CONST can be shared if it contains a SYMBOL_REF. If it contains 372 a LABEL_REF, it isn't sharable. */ 373 if (GET_CODE (XEXP (orig, 0)) == PLUS 374 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF 375 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT) 376 return orig; 377 break; 378 379 /* A MEM with a constant address is not sharable. The problem is that 380 the constant address may need to be reloaded. If the mem is shared, 381 then reloading one copy of this mem will cause all copies to appear 382 to have been reloaded. */ 383 384 default: 385 break; 386 } 387 388 copy = rtx_alloc (code); 389 390 /* Copy the various flags, and other information. We assume that 391 all fields need copying, and then clear the fields that should 392 not be copied. That is the sensible default behavior, and forces 393 us to explicitly document why we are *not* copying a flag. */ 394 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion)); 395 396 /* We do not copy the USED flag, which is used as a mark bit during 397 walks over the RTL. */ 398 copy->used = 0; 399 400 /* We do not copy FRAME_RELATED for INSNs. */ 401 if (GET_RTX_CLASS (code) == 'i') 402 copy->frame_related = 0; 403 copy->jump = orig->jump; 404 copy->call = orig->call; 405 406 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 407 408 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 409 { 410 copy->fld[i] = orig->fld[i]; 411 switch (*format_ptr++) 412 { 413 case 'e': 414 if (XEXP (orig, i) != NULL) 415 XEXP (copy, i) = copy_rtx (XEXP (orig, i)); 416 break; 417 418 case 'E': 419 case 'V': 420 if (XVEC (orig, i) != NULL) 421 { 422 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 423 for (j = 0; j < XVECLEN (copy, i); j++) 424 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); 425 } 426 break; 427 428 case 't': 429 case 'w': 430 case 'i': 431 case 's': 432 case 'S': 433 case 'T': 434 case 'u': 435 case '0': 436 /* These are left unchanged. */ 437 break; 438 439 default: 440 abort (); 441 } 442 } 443 return copy; 444} 445 446/* Create a new copy of an rtx. Only copy just one level. */ 447 448rtx 449shallow_copy_rtx (orig) 450 rtx orig; 451{ 452 int i; 453 RTX_CODE code = GET_CODE (orig); 454 rtx copy = rtx_alloc (code); 455 456 PUT_MODE (copy, GET_MODE (orig)); 457 copy->in_struct = orig->in_struct; 458 copy->volatil = orig->volatil; 459 copy->unchanging = orig->unchanging; 460 copy->integrated = orig->integrated; 461 copy->frame_related = orig->frame_related; 462 463 for (i = 0; i < GET_RTX_LENGTH (code); i++) 464 copy->fld[i] = orig->fld[i]; 465 466 return copy; 467} 468 469/* Return the alignment of MODE. This will be bounded by 1 and 470 BIGGEST_ALIGNMENT. */ 471 472unsigned int 473get_mode_alignment (mode) 474 enum machine_mode mode; 475{ 476 unsigned int alignment; 477 478 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT 479 || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT) 480 alignment = GET_MODE_UNIT_SIZE (mode); 481 else 482 alignment = GET_MODE_SIZE (mode); 483 484 /* Extract the LSB of the size. */ 485 alignment = alignment & -alignment; 486 alignment *= BITS_PER_UNIT; 487 488 alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment)); 489 return alignment; 490} 491 492/* This is 1 until after the rtl generation pass. */ 493int rtx_equal_function_value_matters; 494 495/* Nonzero when we are generating CONCATs. */ 496int generating_concat_p; 497 498/* Return 1 if X and Y are identical-looking rtx's. 499 This is the Lisp function EQUAL for rtx arguments. */ 500 501int 502rtx_equal_p (x, y) 503 rtx x, y; 504{ 505 int i; 506 int j; 507 enum rtx_code code; 508 const char *fmt; 509 510 if (x == y) 511 return 1; 512 if (x == 0 || y == 0) 513 return 0; 514 515 code = GET_CODE (x); 516 /* Rtx's of different codes cannot be equal. */ 517 if (code != GET_CODE (y)) 518 return 0; 519 520 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 521 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 522 523 if (GET_MODE (x) != GET_MODE (y)) 524 return 0; 525 526 /* Some RTL can be compared nonrecursively. */ 527 switch (code) 528 { 529 case REG: 530 /* Until rtl generation is complete, don't consider a reference 531 to the return register of the current function the same as 532 the return from a called function. This eases the job of 533 function integration. Once the distinction is no longer 534 needed, they can be considered equivalent. */ 535 return (REGNO (x) == REGNO (y) 536 && (! rtx_equal_function_value_matters 537 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y))); 538 539 case LABEL_REF: 540 return XEXP (x, 0) == XEXP (y, 0); 541 542 case SYMBOL_REF: 543 return XSTR (x, 0) == XSTR (y, 0); 544 545 case SCRATCH: 546 case CONST_DOUBLE: 547 case CONST_INT: 548 case CONST_VECTOR: 549 return 0; 550 551 default: 552 break; 553 } 554 555 /* Compare the elements. If any pair of corresponding elements 556 fail to match, return 0 for the whole things. */ 557 558 fmt = GET_RTX_FORMAT (code); 559 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 560 { 561 switch (fmt[i]) 562 { 563 case 'w': 564 if (XWINT (x, i) != XWINT (y, i)) 565 return 0; 566 break; 567 568 case 'n': 569 case 'i': 570 if (XINT (x, i) != XINT (y, i)) 571 return 0; 572 break; 573 574 case 'V': 575 case 'E': 576 /* Two vectors must have the same length. */ 577 if (XVECLEN (x, i) != XVECLEN (y, i)) 578 return 0; 579 580 /* And the corresponding elements must match. */ 581 for (j = 0; j < XVECLEN (x, i); j++) 582 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0) 583 return 0; 584 break; 585 586 case 'e': 587 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0) 588 return 0; 589 break; 590 591 case 'S': 592 case 's': 593 if ((XSTR (x, i) || XSTR (y, i)) 594 && (! XSTR (x, i) || ! XSTR (y, i) 595 || strcmp (XSTR (x, i), XSTR (y, i)))) 596 return 0; 597 break; 598 599 case 'u': 600 /* These are just backpointers, so they don't matter. */ 601 break; 602 603 case '0': 604 case 't': 605 break; 606 607 /* It is believed that rtx's at this level will never 608 contain anything but integers and other rtx's, 609 except for within LABEL_REFs and SYMBOL_REFs. */ 610 default: 611 abort (); 612 } 613 } 614 return 1; 615} 616 617#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) 618void 619rtl_check_failed_bounds (r, n, file, line, func) 620 rtx r; 621 int n; 622 const char *file; 623 int line; 624 const char *func; 625{ 626 internal_error 627 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d", 628 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1, 629 func, trim_filename (file), line); 630} 631 632void 633rtl_check_failed_type1 (r, n, c1, file, line, func) 634 rtx r; 635 int n; 636 int c1; 637 const char *file; 638 int line; 639 const char *func; 640{ 641 internal_error 642 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d", 643 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 644 func, trim_filename (file), line); 645} 646 647void 648rtl_check_failed_type2 (r, n, c1, c2, file, line, func) 649 rtx r; 650 int n; 651 int c1; 652 int c2; 653 const char *file; 654 int line; 655 const char *func; 656{ 657 internal_error 658 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d", 659 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 660 func, trim_filename (file), line); 661} 662 663void 664rtl_check_failed_code1 (r, code, file, line, func) 665 rtx r; 666 enum rtx_code code; 667 const char *file; 668 int line; 669 const char *func; 670{ 671 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d", 672 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func, 673 trim_filename (file), line); 674} 675 676void 677rtl_check_failed_code2 (r, code1, code2, file, line, func) 678 rtx r; 679 enum rtx_code code1, code2; 680 const char *file; 681 int line; 682 const char *func; 683{ 684 internal_error 685 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d", 686 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)), 687 func, trim_filename (file), line); 688} 689 690/* XXX Maybe print the vector? */ 691void 692rtvec_check_failed_bounds (r, n, file, line, func) 693 rtvec r; 694 int n; 695 const char *file; 696 int line; 697 const char *func; 698{ 699 internal_error 700 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d", 701 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line); 702} 703#endif /* ENABLE_RTL_CHECKING */ 704