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