rtl.c revision 90075
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) 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) 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) 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) 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) 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) \ 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) \ 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/* Indexed by mode class, gives the narrowest mode for each class. 192 The Q modes are always of width 1 (2 for complex) - it is impossible 193 for any mode to be narrower. 194 195 Note that we use QImode instead of BImode for MODE_INT, since 196 otherwise the middle end will try to use it for bitfields in 197 structures and the like, which we do not want. Only the target 198 md file should generate BImode widgets. */ 199 200const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = { 201 /* MODE_RANDOM */ VOIDmode, 202 /* MODE_INT */ QImode, 203 /* MODE_FLOAT */ QFmode, 204 /* MODE_PARTIAL_INT */ PQImode, 205 /* MODE_CC */ CCmode, 206 /* MODE_COMPLEX_INT */ CQImode, 207 /* MODE_COMPLEX_FLOAT */ QCmode, 208 /* MODE_VECTOR_INT */ V2QImode, 209 /* MODE_VECTOR_FLOAT */ V2SFmode 210}; 211 212 213/* Indexed by rtx code, gives a sequence of operand-types for 214 rtx's of that code. The sequence is a C string in which 215 each character describes one operand. */ 216 217const char * const rtx_format[NUM_RTX_CODE] = { 218 /* "*" undefined. 219 can cause a warning message 220 "0" field is unused (or used in a phase-dependent manner) 221 prints nothing 222 "i" an integer 223 prints the integer 224 "n" like "i", but prints entries from `note_insn_name' 225 "w" an integer of width HOST_BITS_PER_WIDE_INT 226 prints the integer 227 "s" a pointer to a string 228 prints the string 229 "S" like "s", but optional: 230 the containing rtx may end before this operand 231 "T" like "s", but treated specially by the RTL reader; 232 only found in machine description patterns. 233 "e" a pointer to an rtl expression 234 prints the expression 235 "E" a pointer to a vector that points to a number of rtl expressions 236 prints a list of the rtl expressions 237 "V" like "E", but optional: 238 the containing rtx may end before this operand 239 "u" a pointer to another insn 240 prints the uid of the insn. 241 "b" is a pointer to a bitmap header. 242 "t" is a tree pointer. */ 243 244#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 245#include "rtl.def" /* rtl expressions are defined here */ 246#undef DEF_RTL_EXPR 247}; 248 249/* Indexed by rtx code, gives a character representing the "class" of 250 that rtx code. See rtl.def for documentation on the defined classes. */ 251 252const char rtx_class[NUM_RTX_CODE] = { 253#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, 254#include "rtl.def" /* rtl expressions are defined here */ 255#undef DEF_RTL_EXPR 256}; 257 258/* Names for kinds of NOTEs and REG_NOTEs. */ 259 260const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] = 261{ 262 "", "NOTE_INSN_DELETED", 263 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END", 264 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END", 265 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP", 266 "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END", 267 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG", 268 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG", 269 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END", 270 "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG", 271 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE", 272 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE" 273}; 274 275const char * const reg_note_name[] = 276{ 277 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL", 278 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG", 279 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER", 280 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB", 281 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED", 282 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION", 283 "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN", 284 "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN", 285 "REG_VTABLE_REF" 286}; 287 288 289/* Allocate an rtx vector of N elements. 290 Store the length, and initialize all elements to zero. */ 291 292rtvec 293rtvec_alloc (n) 294 int n; 295{ 296 rtvec rt; 297 298 rt = ggc_alloc_rtvec (n); 299 /* clear out the vector */ 300 memset (&rt->elem[0], 0, n * sizeof (rtx)); 301 302 PUT_NUM_ELEM (rt, n); 303 return rt; 304} 305 306/* Allocate an rtx of code CODE. The CODE is stored in the rtx; 307 all the rest is initialized to zero. */ 308 309rtx 310rtx_alloc (code) 311 RTX_CODE code; 312{ 313 rtx rt; 314 int n = GET_RTX_LENGTH (code); 315 316 rt = ggc_alloc_rtx (n); 317 318 /* We want to clear everything up to the FLD array. Normally, this 319 is one int, but we don't want to assume that and it isn't very 320 portable anyway; this is. */ 321 322 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion)); 323 PUT_CODE (rt, code); 324 return rt; 325} 326 327 328/* Create a new copy of an rtx. 329 Recursively copies the operands of the rtx, 330 except for those few rtx codes that are sharable. */ 331 332rtx 333copy_rtx (orig) 334 rtx orig; 335{ 336 rtx copy; 337 int i, j; 338 RTX_CODE code; 339 const char *format_ptr; 340 341 code = GET_CODE (orig); 342 343 switch (code) 344 { 345 case REG: 346 case QUEUED: 347 case CONST_INT: 348 case CONST_DOUBLE: 349 case SYMBOL_REF: 350 case CODE_LABEL: 351 case PC: 352 case CC0: 353 case SCRATCH: 354 /* SCRATCH must be shared because they represent distinct values. */ 355 case ADDRESSOF: 356 return orig; 357 358 case CONST: 359 /* CONST can be shared if it contains a SYMBOL_REF. If it contains 360 a LABEL_REF, it isn't sharable. */ 361 if (GET_CODE (XEXP (orig, 0)) == PLUS 362 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF 363 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT) 364 return orig; 365 break; 366 367 /* A MEM with a constant address is not sharable. The problem is that 368 the constant address may need to be reloaded. If the mem is shared, 369 then reloading one copy of this mem will cause all copies to appear 370 to have been reloaded. */ 371 372 default: 373 break; 374 } 375 376 copy = rtx_alloc (code); 377 378 /* Copy the various flags, and other information. We assume that 379 all fields need copying, and then clear the fields that should 380 not be copied. That is the sensible default behavior, and forces 381 us to explicitly document why we are *not* copying a flag. */ 382 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion)); 383 384 /* We do not copy the USED flag, which is used as a mark bit during 385 walks over the RTL. */ 386 copy->used = 0; 387 388 /* We do not copy FRAME_RELATED for INSNs. */ 389 if (GET_RTX_CLASS (code) == 'i') 390 copy->frame_related = 0; 391 copy->jump = orig->jump; 392 copy->call = orig->call; 393 394 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 395 396 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 397 { 398 copy->fld[i] = orig->fld[i]; 399 switch (*format_ptr++) 400 { 401 case 'e': 402 if (XEXP (orig, i) != NULL) 403 XEXP (copy, i) = copy_rtx (XEXP (orig, i)); 404 break; 405 406 case 'E': 407 case 'V': 408 if (XVEC (orig, i) != NULL) 409 { 410 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 411 for (j = 0; j < XVECLEN (copy, i); j++) 412 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); 413 } 414 break; 415 416 case 't': 417 case 'w': 418 case 'i': 419 case 's': 420 case 'S': 421 case 'T': 422 case 'u': 423 case '0': 424 /* These are left unchanged. */ 425 break; 426 427 default: 428 abort (); 429 } 430 } 431 return copy; 432} 433 434/* Similar to `copy_rtx' except that if MAY_SHARE is present, it is 435 placed in the result directly, rather than being copied. */ 436 437rtx 438copy_most_rtx (orig, may_share) 439 rtx orig; 440 rtx may_share; 441{ 442 rtx copy; 443 int i, j; 444 RTX_CODE code; 445 const char *format_ptr; 446 447 if (orig == may_share) 448 return orig; 449 450 code = GET_CODE (orig); 451 452 switch (code) 453 { 454 case REG: 455 case QUEUED: 456 case CONST_INT: 457 case CONST_DOUBLE: 458 case SYMBOL_REF: 459 case CODE_LABEL: 460 case PC: 461 case CC0: 462 return orig; 463 default: 464 break; 465 } 466 467 copy = rtx_alloc (code); 468 PUT_MODE (copy, GET_MODE (orig)); 469 copy->in_struct = orig->in_struct; 470 copy->volatil = orig->volatil; 471 copy->unchanging = orig->unchanging; 472 copy->integrated = orig->integrated; 473 copy->frame_related = orig->frame_related; 474 475 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 476 477 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 478 { 479 switch (*format_ptr++) 480 { 481 case 'e': 482 XEXP (copy, i) = XEXP (orig, i); 483 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share) 484 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share); 485 break; 486 487 case 'u': 488 XEXP (copy, i) = XEXP (orig, i); 489 break; 490 491 case 'E': 492 case 'V': 493 XVEC (copy, i) = XVEC (orig, i); 494 if (XVEC (orig, i) != NULL) 495 { 496 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 497 for (j = 0; j < XVECLEN (copy, i); j++) 498 XVECEXP (copy, i, j) 499 = copy_most_rtx (XVECEXP (orig, i, j), may_share); 500 } 501 break; 502 503 case 'w': 504 XWINT (copy, i) = XWINT (orig, i); 505 break; 506 507 case 'n': 508 case 'i': 509 XINT (copy, i) = XINT (orig, i); 510 break; 511 512 case 't': 513 XTREE (copy, i) = XTREE (orig, i); 514 break; 515 516 case 's': 517 case 'S': 518 XSTR (copy, i) = XSTR (orig, i); 519 break; 520 521 case '0': 522 /* Copy this through the wide int field; that's safest. */ 523 X0WINT (copy, i) = X0WINT (orig, i); 524 break; 525 526 default: 527 abort (); 528 } 529 } 530 return copy; 531} 532 533/* Create a new copy of an rtx. Only copy just one level. */ 534 535rtx 536shallow_copy_rtx (orig) 537 rtx orig; 538{ 539 int i; 540 RTX_CODE code = GET_CODE (orig); 541 rtx copy = rtx_alloc (code); 542 543 PUT_MODE (copy, GET_MODE (orig)); 544 copy->in_struct = orig->in_struct; 545 copy->volatil = orig->volatil; 546 copy->unchanging = orig->unchanging; 547 copy->integrated = orig->integrated; 548 copy->frame_related = orig->frame_related; 549 550 for (i = 0; i < GET_RTX_LENGTH (code); i++) 551 copy->fld[i] = orig->fld[i]; 552 553 return copy; 554} 555 556/* Return the alignment of MODE. This will be bounded by 1 and 557 BIGGEST_ALIGNMENT. */ 558 559unsigned int 560get_mode_alignment (mode) 561 enum machine_mode mode; 562{ 563 unsigned int alignment = GET_MODE_UNIT_SIZE (mode); 564 565 /* Extract the LSB of the size. */ 566 alignment = alignment & -alignment; 567 alignment *= BITS_PER_UNIT; 568 569 alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment)); 570 return alignment; 571} 572 573/* This is 1 until after the rtl generation pass. */ 574int rtx_equal_function_value_matters; 575 576/* Nonzero when we are generating CONCATs. */ 577int generating_concat_p; 578 579/* Return 1 if X and Y are identical-looking rtx's. 580 This is the Lisp function EQUAL for rtx arguments. */ 581 582int 583rtx_equal_p (x, y) 584 rtx x, y; 585{ 586 int i; 587 int j; 588 enum rtx_code code; 589 const char *fmt; 590 591 if (x == y) 592 return 1; 593 if (x == 0 || y == 0) 594 return 0; 595 596 code = GET_CODE (x); 597 /* Rtx's of different codes cannot be equal. */ 598 if (code != GET_CODE (y)) 599 return 0; 600 601 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. 602 (REG:SI x) and (REG:HI x) are NOT equivalent. */ 603 604 if (GET_MODE (x) != GET_MODE (y)) 605 return 0; 606 607 /* Some RTL can be compared nonrecursively. */ 608 switch (code) 609 { 610 case REG: 611 /* Until rtl generation is complete, don't consider a reference 612 to the return register of the current function the same as 613 the return from a called function. This eases the job of 614 function integration. Once the distinction is no longer 615 needed, they can be considered equivalent. */ 616 return (REGNO (x) == REGNO (y) 617 && (! rtx_equal_function_value_matters 618 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y))); 619 620 case LABEL_REF: 621 return XEXP (x, 0) == XEXP (y, 0); 622 623 case SYMBOL_REF: 624 return XSTR (x, 0) == XSTR (y, 0); 625 626 case SCRATCH: 627 case CONST_DOUBLE: 628 case CONST_INT: 629 return 0; 630 631 default: 632 break; 633 } 634 635 /* Compare the elements. If any pair of corresponding elements 636 fail to match, return 0 for the whole things. */ 637 638 fmt = GET_RTX_FORMAT (code); 639 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 640 { 641 switch (fmt[i]) 642 { 643 case 'w': 644 if (XWINT (x, i) != XWINT (y, i)) 645 return 0; 646 break; 647 648 case 'n': 649 case 'i': 650 if (XINT (x, i) != XINT (y, i)) 651 return 0; 652 break; 653 654 case 'V': 655 case 'E': 656 /* Two vectors must have the same length. */ 657 if (XVECLEN (x, i) != XVECLEN (y, i)) 658 return 0; 659 660 /* And the corresponding elements must match. */ 661 for (j = 0; j < XVECLEN (x, i); j++) 662 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0) 663 return 0; 664 break; 665 666 case 'e': 667 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0) 668 return 0; 669 break; 670 671 case 'S': 672 case 's': 673 if ((XSTR (x, i) || XSTR (y, i)) 674 && (! XSTR (x, i) || ! XSTR (y, i) 675 || strcmp (XSTR (x, i), XSTR (y, i)))) 676 return 0; 677 break; 678 679 case 'u': 680 /* These are just backpointers, so they don't matter. */ 681 break; 682 683 case '0': 684 case 't': 685 break; 686 687 /* It is believed that rtx's at this level will never 688 contain anything but integers and other rtx's, 689 except for within LABEL_REFs and SYMBOL_REFs. */ 690 default: 691 abort (); 692 } 693 } 694 return 1; 695} 696 697#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) 698void 699rtl_check_failed_bounds (r, n, file, line, func) 700 rtx r; 701 int n; 702 const char *file; 703 int line; 704 const char *func; 705{ 706 internal_error 707 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d", 708 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1, 709 func, trim_filename (file), line); 710} 711 712void 713rtl_check_failed_type1 (r, n, c1, file, line, func) 714 rtx r; 715 int n; 716 int c1; 717 const char *file; 718 int line; 719 const char *func; 720{ 721 internal_error 722 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d", 723 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 724 func, trim_filename (file), line); 725} 726 727void 728rtl_check_failed_type2 (r, n, c1, c2, file, line, func) 729 rtx r; 730 int n; 731 int c1; 732 int c2; 733 const char *file; 734 int line; 735 const char *func; 736{ 737 internal_error 738 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d", 739 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)), 740 func, trim_filename (file), line); 741} 742 743void 744rtl_check_failed_code1 (r, code, file, line, func) 745 rtx r; 746 enum rtx_code code; 747 const char *file; 748 int line; 749 const char *func; 750{ 751 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d", 752 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func, 753 trim_filename (file), line); 754} 755 756void 757rtl_check_failed_code2 (r, code1, code2, file, line, func) 758 rtx r; 759 enum rtx_code code1, code2; 760 const char *file; 761 int line; 762 const char *func; 763{ 764 internal_error 765 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d", 766 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)), 767 func, trim_filename (file), line); 768} 769 770/* XXX Maybe print the vector? */ 771void 772rtvec_check_failed_bounds (r, n, file, line, func) 773 rtvec r; 774 int n; 775 const char *file; 776 int line; 777 const char *func; 778{ 779 internal_error 780 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d", 781 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line); 782} 783#endif /* ENABLE_RTL_CHECKING */ 784