1 /* Register Transfer Language (RTL) definitions for GCC 2 Copyright (C) 1987-2017 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 #ifndef GCC_RTL_H 21 #define GCC_RTL_H 22 23 /* This file is occasionally included by generator files which expect 24 machmode.h and other files to exist and would not normally have been 25 included by coretypes.h. */ 26 #ifdef GENERATOR_FILE 27 #include "machmode.h" 28 #include "signop.h" 29 #include "wide-int.h" 30 #include "double-int.h" 31 #include "real.h" 32 #include "fixed-value.h" 33 #include "statistics.h" 34 #include "vec.h" 35 #include "hash-table.h" 36 #include "hash-set.h" 37 #include "input.h" 38 #include "is-a.h" 39 #endif /* GENERATOR_FILE */ 40 41 #include "hard-reg-set.h" 42 43 /* Value used by some passes to "recognize" noop moves as valid 44 instructions. */ 45 #define NOOP_MOVE_INSN_CODE INT_MAX 46 47 /* Register Transfer Language EXPRESSIONS CODES */ 48 49 #define RTX_CODE enum rtx_code 50 enum rtx_code { 51 52 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM , 53 #include "rtl.def" /* rtl expressions are documented here */ 54 #undef DEF_RTL_EXPR 55 56 LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for 57 NUM_RTX_CODE. 58 Assumes default enum value assignment. */ 59 60 /* The cast here, saves many elsewhere. */ 61 #define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE) 62 63 /* Similar, but since generator files get more entries... */ 64 #ifdef GENERATOR_FILE 65 # define NON_GENERATOR_NUM_RTX_CODE ((int) MATCH_OPERAND) 66 #endif 67 68 /* Register Transfer Language EXPRESSIONS CODE CLASSES */ 69 70 enum rtx_class { 71 /* We check bit 0-1 of some rtx class codes in the predicates below. */ 72 73 /* Bit 0 = comparison if 0, arithmetic is 1 74 Bit 1 = 1 if commutative. */ 75 RTX_COMPARE, /* 0 */ 76 RTX_COMM_COMPARE, 77 RTX_BIN_ARITH, 78 RTX_COMM_ARITH, 79 80 /* Must follow the four preceding values. */ 81 RTX_UNARY, /* 4 */ 82 83 RTX_EXTRA, 84 RTX_MATCH, 85 RTX_INSN, 86 87 /* Bit 0 = 1 if constant. */ 88 RTX_OBJ, /* 8 */ 89 RTX_CONST_OBJ, 90 91 RTX_TERNARY, 92 RTX_BITFIELD_OPS, 93 RTX_AUTOINC 94 }; 95 96 #define RTX_OBJ_MASK (~1) 97 #define RTX_OBJ_RESULT (RTX_OBJ & RTX_OBJ_MASK) 98 #define RTX_COMPARE_MASK (~1) 99 #define RTX_COMPARE_RESULT (RTX_COMPARE & RTX_COMPARE_MASK) 100 #define RTX_ARITHMETIC_MASK (~1) 101 #define RTX_ARITHMETIC_RESULT (RTX_COMM_ARITH & RTX_ARITHMETIC_MASK) 102 #define RTX_BINARY_MASK (~3) 103 #define RTX_BINARY_RESULT (RTX_COMPARE & RTX_BINARY_MASK) 104 #define RTX_COMMUTATIVE_MASK (~2) 105 #define RTX_COMMUTATIVE_RESULT (RTX_COMM_COMPARE & RTX_COMMUTATIVE_MASK) 106 #define RTX_NON_COMMUTATIVE_RESULT (RTX_COMPARE & RTX_COMMUTATIVE_MASK) 107 108 extern const unsigned char rtx_length[NUM_RTX_CODE]; 109 #define GET_RTX_LENGTH(CODE) (rtx_length[(int) (CODE)]) 110 111 extern const char * const rtx_name[NUM_RTX_CODE]; 112 #define GET_RTX_NAME(CODE) (rtx_name[(int) (CODE)]) 113 114 extern const char * const rtx_format[NUM_RTX_CODE]; 115 #define GET_RTX_FORMAT(CODE) (rtx_format[(int) (CODE)]) 116 117 extern const enum rtx_class rtx_class[NUM_RTX_CODE]; 118 #define GET_RTX_CLASS(CODE) (rtx_class[(int) (CODE)]) 119 120 /* True if CODE is part of the insn chain (i.e. has INSN_UID, PREV_INSN 121 and NEXT_INSN fields). */ 122 #define INSN_CHAIN_CODE_P(CODE) IN_RANGE (CODE, DEBUG_INSN, NOTE) 123 124 extern const unsigned char rtx_code_size[NUM_RTX_CODE]; 125 extern const unsigned char rtx_next[NUM_RTX_CODE]; 126 127 /* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label 128 relative to which the offsets are calculated, as explained in rtl.def. */ 129 struct addr_diff_vec_flags 130 { 131 /* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */ 132 unsigned min_align: 8; 133 /* Flags: */ 134 unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */ 135 unsigned min_after_vec: 1; /* minimum address target label is 136 after the ADDR_DIFF_VEC. */ 137 unsigned max_after_vec: 1; /* maximum address target label is 138 after the ADDR_DIFF_VEC. */ 139 unsigned min_after_base: 1; /* minimum address target label is 140 after BASE. */ 141 unsigned max_after_base: 1; /* maximum address target label is 142 after BASE. */ 143 /* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */ 144 unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */ 145 unsigned : 2; 146 unsigned scale : 8; 147 }; 148 149 /* Structure used to describe the attributes of a MEM. These are hashed 150 so MEMs that the same attributes share a data structure. This means 151 they cannot be modified in place. */ 152 struct GTY(()) mem_attrs 153 { 154 /* The expression that the MEM accesses, or null if not known. 155 This expression might be larger than the memory reference itself. 156 (In other words, the MEM might access only part of the object.) */ 157 tree expr; 158 159 /* The offset of the memory reference from the start of EXPR. 160 Only valid if OFFSET_KNOWN_P. */ 161 HOST_WIDE_INT offset; 162 163 /* The size of the memory reference in bytes. Only valid if 164 SIZE_KNOWN_P. */ 165 HOST_WIDE_INT size; 166 167 /* The alias set of the memory reference. */ 168 alias_set_type alias; 169 170 /* The alignment of the reference in bits. Always a multiple of 171 BITS_PER_UNIT. Note that EXPR may have a stricter alignment 172 than the memory reference itself. */ 173 unsigned int align; 174 175 /* The address space that the memory reference uses. */ 176 unsigned char addrspace; 177 178 /* True if OFFSET is known. */ 179 bool offset_known_p; 180 181 /* True if SIZE is known. */ 182 bool size_known_p; 183 }; 184 185 /* Structure used to describe the attributes of a REG in similar way as 186 mem_attrs does for MEM above. Note that the OFFSET field is calculated 187 in the same way as for mem_attrs, rather than in the same way as a 188 SUBREG_BYTE. For example, if a big-endian target stores a byte 189 object in the low part of a 4-byte register, the OFFSET field 190 will be -3 rather than 0. */ 191 192 struct GTY((for_user)) reg_attrs { 193 tree decl; /* decl corresponding to REG. */ 194 HOST_WIDE_INT offset; /* Offset from start of DECL. */ 195 }; 196 197 /* Common union for an element of an rtx. */ 198 199 union rtunion 200 { 201 int rt_int; 202 unsigned int rt_uint; 203 const char *rt_str; 204 rtx rt_rtx; 205 rtvec rt_rtvec; 206 machine_mode rt_type; 207 addr_diff_vec_flags rt_addr_diff_vec_flags; 208 struct cselib_val *rt_cselib; 209 tree rt_tree; 210 basic_block rt_bb; 211 mem_attrs *rt_mem; 212 struct constant_descriptor_rtx *rt_constant; 213 struct dw_cfi_node *rt_cfi; 214 }; 215 216 /* Describes the properties of a REG. */ 217 struct GTY(()) reg_info { 218 /* The value of REGNO. */ 219 unsigned int regno; 220 221 /* The value of REG_NREGS. */ 222 unsigned int nregs : 8; 223 unsigned int unused : 24; 224 225 /* The value of REG_ATTRS. */ 226 reg_attrs *attrs; 227 }; 228 229 /* This structure remembers the position of a SYMBOL_REF within an 230 object_block structure. A SYMBOL_REF only provides this information 231 if SYMBOL_REF_HAS_BLOCK_INFO_P is true. */ 232 struct GTY(()) block_symbol { 233 /* The usual SYMBOL_REF fields. */ 234 rtunion GTY ((skip)) fld[2]; 235 236 /* The block that contains this object. */ 237 struct object_block *block; 238 239 /* The offset of this object from the start of its block. It is negative 240 if the symbol has not yet been assigned an offset. */ 241 HOST_WIDE_INT offset; 242 }; 243 244 /* Describes a group of objects that are to be placed together in such 245 a way that their relative positions are known. */ 246 struct GTY((for_user)) object_block { 247 /* The section in which these objects should be placed. */ 248 section *sect; 249 250 /* The alignment of the first object, measured in bits. */ 251 unsigned int alignment; 252 253 /* The total size of the objects, measured in bytes. */ 254 HOST_WIDE_INT size; 255 256 /* The SYMBOL_REFs for each object. The vector is sorted in 257 order of increasing offset and the following conditions will 258 hold for each element X: 259 260 SYMBOL_REF_HAS_BLOCK_INFO_P (X) 261 !SYMBOL_REF_ANCHOR_P (X) 262 SYMBOL_REF_BLOCK (X) == [address of this structure] 263 SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */ 264 vec<rtx, va_gc> *objects; 265 266 /* All the anchor SYMBOL_REFs used to address these objects, sorted 267 in order of increasing offset, and then increasing TLS model. 268 The following conditions will hold for each element X in this vector: 269 270 SYMBOL_REF_HAS_BLOCK_INFO_P (X) 271 SYMBOL_REF_ANCHOR_P (X) 272 SYMBOL_REF_BLOCK (X) == [address of this structure] 273 SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */ 274 vec<rtx, va_gc> *anchors; 275 }; 276 277 struct GTY((variable_size)) hwivec_def { 278 HOST_WIDE_INT elem[1]; 279 }; 280 281 /* Number of elements of the HWIVEC if RTX is a CONST_WIDE_INT. */ 282 #define CWI_GET_NUM_ELEM(RTX) \ 283 ((int)RTL_FLAG_CHECK1("CWI_GET_NUM_ELEM", (RTX), CONST_WIDE_INT)->u2.num_elem) 284 #define CWI_PUT_NUM_ELEM(RTX, NUM) \ 285 (RTL_FLAG_CHECK1("CWI_PUT_NUM_ELEM", (RTX), CONST_WIDE_INT)->u2.num_elem = (NUM)) 286 287 /* RTL expression ("rtx"). */ 288 289 /* The GTY "desc" and "tag" options below are a kludge: we need a desc 290 field for gengtype to recognize that inheritance is occurring, 291 so that all subclasses are redirected to the traversal hook for the 292 base class. 293 However, all of the fields are in the base class, and special-casing 294 is at work. Hence we use desc and tag of 0, generating a switch 295 statement of the form: 296 switch (0) 297 { 298 case 0: // all the work happens here 299 } 300 in order to work with the existing special-casing in gengtype. */ 301 302 struct GTY((desc("0"), tag("0"), 303 chain_next ("RTX_NEXT (&%h)"), 304 chain_prev ("RTX_PREV (&%h)"))) rtx_def { 305 /* The kind of expression this is. */ 306 ENUM_BITFIELD(rtx_code) code: 16; 307 308 /* The kind of value the expression has. */ 309 ENUM_BITFIELD(machine_mode) mode : 8; 310 311 /* 1 in a MEM if we should keep the alias set for this mem unchanged 312 when we access a component. 313 1 in a JUMP_INSN if it is a crossing jump. 314 1 in a CALL_INSN if it is a sibling call. 315 1 in a SET that is for a return. 316 In a CODE_LABEL, part of the two-bit alternate entry field. 317 1 in a CONCAT is VAL_EXPR_IS_COPIED in var-tracking.c. 318 1 in a VALUE is SP_BASED_VALUE_P in cselib.c. 319 1 in a SUBREG generated by LRA for reload insns. 320 1 in a REG if this is a static chain register. 321 1 in a CALL for calls instrumented by Pointer Bounds Checker. 322 Dumped as "/j" in RTL dumps. */ 323 unsigned int jump : 1; 324 /* In a CODE_LABEL, part of the two-bit alternate entry field. 325 1 in a MEM if it cannot trap. 326 1 in a CALL_INSN logically equivalent to 327 ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. 328 Dumped as "/c" in RTL dumps. */ 329 unsigned int call : 1; 330 /* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere. 331 1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P. 332 1 in a SYMBOL_REF if it addresses something in the per-function 333 constants pool. 334 1 in a CALL_INSN logically equivalent to ECF_CONST and TREE_READONLY. 335 1 in a NOTE, or EXPR_LIST for a const call. 336 1 in a JUMP_INSN of an annulling branch. 337 1 in a CONCAT is VAL_EXPR_IS_CLOBBERED in var-tracking.c. 338 1 in a preserved VALUE is PRESERVED_VALUE_P in cselib.c. 339 1 in a clobber temporarily created for LRA. 340 Dumped as "/u" in RTL dumps. */ 341 unsigned int unchanging : 1; 342 /* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile. 343 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE 344 if it has been deleted. 345 1 in a REG expression if corresponds to a variable declared by the user, 346 0 for an internally generated temporary. 347 1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P. 348 1 in a LABEL_REF, REG_LABEL_TARGET or REG_LABEL_OPERAND note for a 349 non-local label. 350 In a SYMBOL_REF, this flag is used for machine-specific purposes. 351 In a PREFETCH, this flag indicates that it should be considered a 352 scheduling barrier. 353 1 in a CONCAT is VAL_NEEDS_RESOLUTION in var-tracking.c. 354 Dumped as "/v" in RTL dumps. */ 355 unsigned int volatil : 1; 356 /* 1 in a REG if the register is used only in exit code a loop. 357 1 in a SUBREG expression if was generated from a variable with a 358 promoted mode. 359 1 in a CODE_LABEL if the label is used for nonlocal gotos 360 and must not be deleted even if its count is zero. 361 1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled 362 together with the preceding insn. Valid only within sched. 363 1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and 364 from the target of a branch. Valid from reorg until end of compilation; 365 cleared before used. 366 367 The name of the field is historical. It used to be used in MEMs 368 to record whether the MEM accessed part of a structure. 369 Dumped as "/s" in RTL dumps. */ 370 unsigned int in_struct : 1; 371 /* At the end of RTL generation, 1 if this rtx is used. This is used for 372 copying shared structure. See `unshare_all_rtl'. 373 In a REG, this is not needed for that purpose, and used instead 374 in `leaf_renumber_regs_insn'. 375 1 in a SYMBOL_REF, means that emit_library_call 376 has used it as the function. 377 1 in a CONCAT is VAL_HOLDS_TRACK_EXPR in var-tracking.c. 378 1 in a VALUE or DEBUG_EXPR is VALUE_RECURSED_INTO in var-tracking.c. */ 379 unsigned int used : 1; 380 /* 1 in an INSN or a SET if this rtx is related to the call frame, 381 either changing how we compute the frame address or saving and 382 restoring registers in the prologue and epilogue. 383 1 in a REG or MEM if it is a pointer. 384 1 in a SYMBOL_REF if it addresses something in the per-function 385 constant string pool. 386 1 in a VALUE is VALUE_CHANGED in var-tracking.c. 387 Dumped as "/f" in RTL dumps. */ 388 unsigned frame_related : 1; 389 /* 1 in a REG or PARALLEL that is the current function's return value. 390 1 in a SYMBOL_REF for a weak symbol. 391 1 in a CALL_INSN logically equivalent to ECF_PURE and DECL_PURE_P. 392 1 in a CONCAT is VAL_EXPR_HAS_REVERSE in var-tracking.c. 393 1 in a VALUE or DEBUG_EXPR is NO_LOC_P in var-tracking.c. 394 Dumped as "/i" in RTL dumps. */ 395 unsigned return_val : 1; 396 397 union { 398 /* The final union field is aligned to 64 bits on LP64 hosts, 399 giving a 32-bit gap after the fields above. We optimize the 400 layout for that case and use the gap for extra code-specific 401 information. */ 402 403 /* The ORIGINAL_REGNO of a REG. */ 404 unsigned int original_regno; 405 406 /* The INSN_UID of an RTX_INSN-class code. */ 407 int insn_uid; 408 409 /* The SYMBOL_REF_FLAGS of a SYMBOL_REF. */ 410 unsigned int symbol_ref_flags; 411 412 /* The PAT_VAR_LOCATION_STATUS of a VAR_LOCATION. */ 413 enum var_init_status var_location_status; 414 415 /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of 416 HOST_WIDE_INTs in the hwivec_def. */ 417 unsigned int num_elem; 418 } GTY ((skip)) u2; 419 420 /* The first element of the operands of this rtx. 421 The number of operands and their types are controlled 422 by the `code' field, according to rtl.def. */ 423 union u { 424 rtunion fld[1]; 425 HOST_WIDE_INT hwint[1]; 426 struct reg_info reg; 427 struct block_symbol block_sym; 428 struct real_value rv; 429 struct fixed_value fv; 430 struct hwivec_def hwiv; 431 } GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u; 432 }; 433 434 /* A node for constructing singly-linked lists of rtx. */ 435 436 class GTY(()) rtx_expr_list : public rtx_def 437 { 438 /* No extra fields, but adds invariant: (GET_CODE (X) == EXPR_LIST). */ 439 440 public: 441 /* Get next in list. */ 442 rtx_expr_list *next () const; 443 444 /* Get at the underlying rtx. */ 445 rtx element () const; 446 }; 447 448 template <> 449 template <> 450 inline bool 451 is_a_helper <rtx_expr_list *>::test (rtx rt) 452 { 453 return rt->code == EXPR_LIST; 454 } 455 456 class GTY(()) rtx_insn_list : public rtx_def 457 { 458 /* No extra fields, but adds invariant: (GET_CODE (X) == INSN_LIST). 459 460 This is an instance of: 461 462 DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA) 463 464 i.e. a node for constructing singly-linked lists of rtx_insn *, where 465 the list is "external" to the insn (as opposed to the doubly-linked 466 list embedded within rtx_insn itself). */ 467 468 public: 469 /* Get next in list. */ 470 rtx_insn_list *next () const; 471 472 /* Get at the underlying instruction. */ 473 rtx_insn *insn () const; 474 475 }; 476 477 template <> 478 template <> 479 inline bool 480 is_a_helper <rtx_insn_list *>::test (rtx rt) 481 { 482 return rt->code == INSN_LIST; 483 } 484 485 /* A node with invariant GET_CODE (X) == SEQUENCE i.e. a vector of rtx, 486 typically (but not always) of rtx_insn *, used in the late passes. */ 487 488 class GTY(()) rtx_sequence : public rtx_def 489 { 490 /* No extra fields, but adds invariant: (GET_CODE (X) == SEQUENCE). */ 491 492 public: 493 /* Get number of elements in sequence. */ 494 int len () const; 495 496 /* Get i-th element of the sequence. */ 497 rtx element (int index) const; 498 499 /* Get i-th element of the sequence, with a checked cast to 500 rtx_insn *. */ 501 rtx_insn *insn (int index) const; 502 }; 503 504 template <> 505 template <> 506 inline bool 507 is_a_helper <rtx_sequence *>::test (rtx rt) 508 { 509 return rt->code == SEQUENCE; 510 } 511 512 template <> 513 template <> 514 inline bool 515 is_a_helper <const rtx_sequence *>::test (const_rtx rt) 516 { 517 return rt->code == SEQUENCE; 518 } 519 520 class GTY(()) rtx_insn : public rtx_def 521 { 522 public: 523 /* No extra fields, but adds the invariant: 524 525 (INSN_P (X) 526 || NOTE_P (X) 527 || JUMP_TABLE_DATA_P (X) 528 || BARRIER_P (X) 529 || LABEL_P (X)) 530 531 i.e. that we must be able to use the following: 532 INSN_UID () 533 NEXT_INSN () 534 PREV_INSN () 535 i.e. we have an rtx that has an INSN_UID field and can be part of 536 a linked list of insns. 537 */ 538 539 /* Returns true if this insn has been deleted. */ 540 541 bool deleted () const { return volatil; } 542 543 /* Mark this insn as deleted. */ 544 545 void set_deleted () { volatil = true; } 546 547 /* Mark this insn as not deleted. */ 548 549 void set_undeleted () { volatil = false; } 550 }; 551 552 /* Subclasses of rtx_insn. */ 553 554 class GTY(()) rtx_debug_insn : public rtx_insn 555 { 556 /* No extra fields, but adds the invariant: 557 DEBUG_INSN_P (X) aka (GET_CODE (X) == DEBUG_INSN) 558 i.e. an annotation for tracking variable assignments. 559 560 This is an instance of: 561 DEF_RTL_EXPR(DEBUG_INSN, "debug_insn", "uuBeiie", RTX_INSN) 562 from rtl.def. */ 563 }; 564 565 class GTY(()) rtx_nonjump_insn : public rtx_insn 566 { 567 /* No extra fields, but adds the invariant: 568 NONJUMP_INSN_P (X) aka (GET_CODE (X) == INSN) 569 i.e an instruction that cannot jump. 570 571 This is an instance of: 572 DEF_RTL_EXPR(INSN, "insn", "uuBeiie", RTX_INSN) 573 from rtl.def. */ 574 }; 575 576 class GTY(()) rtx_jump_insn : public rtx_insn 577 { 578 public: 579 /* No extra fields, but adds the invariant: 580 JUMP_P (X) aka (GET_CODE (X) == JUMP_INSN) 581 i.e. an instruction that can possibly jump. 582 583 This is an instance of: 584 DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "uuBeiie0", RTX_INSN) 585 from rtl.def. */ 586 587 /* Returns jump target of this instruction. The returned value is not 588 necessarily a code label: it may also be a RETURN or SIMPLE_RETURN 589 expression. Also, when the code label is marked "deleted", it is 590 replaced by a NOTE. In some cases the value is NULL_RTX. */ 591 592 inline rtx jump_label () const; 593 594 /* Returns jump target cast to rtx_code_label *. */ 595 596 inline rtx_code_label *jump_target () const; 597 598 /* Set jump target. */ 599 600 inline void set_jump_target (rtx_code_label *); 601 }; 602 603 class GTY(()) rtx_call_insn : public rtx_insn 604 { 605 /* No extra fields, but adds the invariant: 606 CALL_P (X) aka (GET_CODE (X) == CALL_INSN) 607 i.e. an instruction that can possibly call a subroutine 608 but which will not change which instruction comes next 609 in the current function. 610 611 This is an instance of: 612 DEF_RTL_EXPR(CALL_INSN, "call_insn", "uuBeiiee", RTX_INSN) 613 from rtl.def. */ 614 }; 615 616 class GTY(()) rtx_jump_table_data : public rtx_insn 617 { 618 /* No extra fields, but adds the invariant: 619 JUMP_TABLE_DATA_P (X) aka (GET_CODE (INSN) == JUMP_TABLE_DATA) 620 i.e. a data for a jump table, considered an instruction for 621 historical reasons. 622 623 This is an instance of: 624 DEF_RTL_EXPR(JUMP_TABLE_DATA, "jump_table_data", "uuBe0000", RTX_INSN) 625 from rtl.def. */ 626 627 public: 628 629 /* This can be either: 630 631 (a) a table of absolute jumps, in which case PATTERN (this) is an 632 ADDR_VEC with arg 0 a vector of labels, or 633 634 (b) a table of relative jumps (e.g. for -fPIC), in which case 635 PATTERN (this) is an ADDR_DIFF_VEC, with arg 0 a LABEL_REF and 636 arg 1 the vector of labels. 637 638 This method gets the underlying vec. */ 639 640 inline rtvec get_labels () const; 641 }; 642 643 class GTY(()) rtx_barrier : public rtx_insn 644 { 645 /* No extra fields, but adds the invariant: 646 BARRIER_P (X) aka (GET_CODE (X) == BARRIER) 647 i.e. a marker that indicates that control will not flow through. 648 649 This is an instance of: 650 DEF_RTL_EXPR(BARRIER, "barrier", "uu00000", RTX_EXTRA) 651 from rtl.def. */ 652 }; 653 654 class GTY(()) rtx_code_label : public rtx_insn 655 { 656 /* No extra fields, but adds the invariant: 657 LABEL_P (X) aka (GET_CODE (X) == CODE_LABEL) 658 i.e. a label in the assembler. 659 660 This is an instance of: 661 DEF_RTL_EXPR(CODE_LABEL, "code_label", "uuB00is", RTX_EXTRA) 662 from rtl.def. */ 663 }; 664 665 class GTY(()) rtx_note : public rtx_insn 666 { 667 /* No extra fields, but adds the invariant: 668 NOTE_P(X) aka (GET_CODE (X) == NOTE) 669 i.e. a note about the corresponding source code. 670 671 This is an instance of: 672 DEF_RTL_EXPR(NOTE, "note", "uuB0ni", RTX_EXTRA) 673 from rtl.def. */ 674 }; 675 676 /* The size in bytes of an rtx header (code, mode and flags). */ 677 #define RTX_HDR_SIZE offsetof (struct rtx_def, u) 678 679 /* The size in bytes of an rtx with code CODE. */ 680 #define RTX_CODE_SIZE(CODE) rtx_code_size[CODE] 681 682 #define NULL_RTX (rtx) 0 683 684 /* The "next" and "previous" RTX, relative to this one. */ 685 686 #define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL \ 687 : *(rtx *)(((char *)X) + rtx_next[GET_CODE (X)])) 688 689 /* FIXME: the "NEXT_INSN (PREV_INSN (X)) == X" condition shouldn't be needed. 690 */ 691 #define RTX_PREV(X) ((INSN_P (X) \ 692 || NOTE_P (X) \ 693 || JUMP_TABLE_DATA_P (X) \ 694 || BARRIER_P (X) \ 695 || LABEL_P (X)) \ 696 && PREV_INSN (as_a <rtx_insn *> (X)) != NULL \ 697 && NEXT_INSN (PREV_INSN (as_a <rtx_insn *> (X))) == X \ 698 ? PREV_INSN (as_a <rtx_insn *> (X)) : NULL) 699 700 /* Define macros to access the `code' field of the rtx. */ 701 702 #define GET_CODE(RTX) ((enum rtx_code) (RTX)->code) 703 #define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE)) 704 705 #define GET_MODE(RTX) ((machine_mode) (RTX)->mode) 706 #define PUT_MODE_RAW(RTX, MODE) ((RTX)->mode = (MODE)) 707 708 /* RTL vector. These appear inside RTX's when there is a need 709 for a variable number of things. The principle use is inside 710 PARALLEL expressions. */ 711 712 struct GTY(()) rtvec_def { 713 int num_elem; /* number of elements */ 714 rtx GTY ((length ("%h.num_elem"))) elem[1]; 715 }; 716 717 #define NULL_RTVEC (rtvec) 0 718 719 #define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem) 720 #define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM)) 721 722 /* Predicate yielding nonzero iff X is an rtx for a register. */ 723 #define REG_P(X) (GET_CODE (X) == REG) 724 725 /* Predicate yielding nonzero iff X is an rtx for a memory location. */ 726 #define MEM_P(X) (GET_CODE (X) == MEM) 727 728 #if TARGET_SUPPORTS_WIDE_INT 729 730 /* Match CONST_*s that can represent compile-time constant integers. */ 731 #define CASE_CONST_SCALAR_INT \ 732 case CONST_INT: \ 733 case CONST_WIDE_INT 734 735 /* Match CONST_*s for which pointer equality corresponds to value 736 equality. */ 737 #define CASE_CONST_UNIQUE \ 738 case CONST_INT: \ 739 case CONST_WIDE_INT: \ 740 case CONST_DOUBLE: \ 741 case CONST_FIXED 742 743 /* Match all CONST_* rtxes. */ 744 #define CASE_CONST_ANY \ 745 case CONST_INT: \ 746 case CONST_WIDE_INT: \ 747 case CONST_DOUBLE: \ 748 case CONST_FIXED: \ 749 case CONST_VECTOR 750 751 #else 752 753 /* Match CONST_*s that can represent compile-time constant integers. */ 754 #define CASE_CONST_SCALAR_INT \ 755 case CONST_INT: \ 756 case CONST_DOUBLE 757 758 /* Match CONST_*s for which pointer equality corresponds to value 759 equality. */ 760 #define CASE_CONST_UNIQUE \ 761 case CONST_INT: \ 762 case CONST_DOUBLE: \ 763 case CONST_FIXED 764 765 /* Match all CONST_* rtxes. */ 766 #define CASE_CONST_ANY \ 767 case CONST_INT: \ 768 case CONST_DOUBLE: \ 769 case CONST_FIXED: \ 770 case CONST_VECTOR 771 #endif 772 773 /* Predicate yielding nonzero iff X is an rtx for a constant integer. */ 774 #define CONST_INT_P(X) (GET_CODE (X) == CONST_INT) 775 776 /* Predicate yielding nonzero iff X is an rtx for a constant integer. */ 777 #define CONST_WIDE_INT_P(X) (GET_CODE (X) == CONST_WIDE_INT) 778 779 /* Predicate yielding nonzero iff X is an rtx for a constant fixed-point. */ 780 #define CONST_FIXED_P(X) (GET_CODE (X) == CONST_FIXED) 781 782 /* Predicate yielding true iff X is an rtx for a double-int 783 or floating point constant. */ 784 #define CONST_DOUBLE_P(X) (GET_CODE (X) == CONST_DOUBLE) 785 786 /* Predicate yielding true iff X is an rtx for a double-int. */ 787 #define CONST_DOUBLE_AS_INT_P(X) \ 788 (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == VOIDmode) 789 790 /* Predicate yielding true iff X is an rtx for a integer const. */ 791 #if TARGET_SUPPORTS_WIDE_INT 792 #define CONST_SCALAR_INT_P(X) \ 793 (CONST_INT_P (X) || CONST_WIDE_INT_P (X)) 794 #else 795 #define CONST_SCALAR_INT_P(X) \ 796 (CONST_INT_P (X) || CONST_DOUBLE_AS_INT_P (X)) 797 #endif 798 799 /* Predicate yielding true iff X is an rtx for a double-int. */ 800 #define CONST_DOUBLE_AS_FLOAT_P(X) \ 801 (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode) 802 803 /* Predicate yielding nonzero iff X is a label insn. */ 804 #define LABEL_P(X) (GET_CODE (X) == CODE_LABEL) 805 806 /* Predicate yielding nonzero iff X is a jump insn. */ 807 #define JUMP_P(X) (GET_CODE (X) == JUMP_INSN) 808 809 /* Predicate yielding nonzero iff X is a call insn. */ 810 #define CALL_P(X) (GET_CODE (X) == CALL_INSN) 811 812 /* Predicate yielding nonzero iff X is an insn that cannot jump. */ 813 #define NONJUMP_INSN_P(X) (GET_CODE (X) == INSN) 814 815 /* Predicate yielding nonzero iff X is a debug note/insn. */ 816 #define DEBUG_INSN_P(X) (GET_CODE (X) == DEBUG_INSN) 817 818 /* Predicate yielding nonzero iff X is an insn that is not a debug insn. */ 819 #define NONDEBUG_INSN_P(X) (INSN_P (X) && !DEBUG_INSN_P (X)) 820 821 /* Nonzero if DEBUG_INSN_P may possibly hold. */ 822 #define MAY_HAVE_DEBUG_INSNS (flag_var_tracking_assignments) 823 824 /* Predicate yielding nonzero iff X is a real insn. */ 825 #define INSN_P(X) \ 826 (NONJUMP_INSN_P (X) || DEBUG_INSN_P (X) || JUMP_P (X) || CALL_P (X)) 827 828 /* Predicate yielding nonzero iff X is a note insn. */ 829 #define NOTE_P(X) (GET_CODE (X) == NOTE) 830 831 /* Predicate yielding nonzero iff X is a barrier insn. */ 832 #define BARRIER_P(X) (GET_CODE (X) == BARRIER) 833 834 /* Predicate yielding nonzero iff X is a data for a jump table. */ 835 #define JUMP_TABLE_DATA_P(INSN) (GET_CODE (INSN) == JUMP_TABLE_DATA) 836 837 /* Predicate yielding nonzero iff RTX is a subreg. */ 838 #define SUBREG_P(RTX) (GET_CODE (RTX) == SUBREG) 839 840 /* Predicate yielding true iff RTX is a symbol ref. */ 841 #define SYMBOL_REF_P(RTX) (GET_CODE (RTX) == SYMBOL_REF) 842 843 template <> 844 template <> 845 inline bool 846 is_a_helper <rtx_insn *>::test (rtx rt) 847 { 848 return (INSN_P (rt) 849 || NOTE_P (rt) 850 || JUMP_TABLE_DATA_P (rt) 851 || BARRIER_P (rt) 852 || LABEL_P (rt)); 853 } 854 855 template <> 856 template <> 857 inline bool 858 is_a_helper <const rtx_insn *>::test (const_rtx rt) 859 { 860 return (INSN_P (rt) 861 || NOTE_P (rt) 862 || JUMP_TABLE_DATA_P (rt) 863 || BARRIER_P (rt) 864 || LABEL_P (rt)); 865 } 866 867 template <> 868 template <> 869 inline bool 870 is_a_helper <rtx_debug_insn *>::test (rtx rt) 871 { 872 return DEBUG_INSN_P (rt); 873 } 874 875 template <> 876 template <> 877 inline bool 878 is_a_helper <rtx_nonjump_insn *>::test (rtx rt) 879 { 880 return NONJUMP_INSN_P (rt); 881 } 882 883 template <> 884 template <> 885 inline bool 886 is_a_helper <rtx_jump_insn *>::test (rtx rt) 887 { 888 return JUMP_P (rt); 889 } 890 891 template <> 892 template <> 893 inline bool 894 is_a_helper <rtx_jump_insn *>::test (rtx_insn *insn) 895 { 896 return JUMP_P (insn); 897 } 898 899 template <> 900 template <> 901 inline bool 902 is_a_helper <rtx_call_insn *>::test (rtx rt) 903 { 904 return CALL_P (rt); 905 } 906 907 template <> 908 template <> 909 inline bool 910 is_a_helper <rtx_call_insn *>::test (rtx_insn *insn) 911 { 912 return CALL_P (insn); 913 } 914 915 template <> 916 template <> 917 inline bool 918 is_a_helper <rtx_jump_table_data *>::test (rtx rt) 919 { 920 return JUMP_TABLE_DATA_P (rt); 921 } 922 923 template <> 924 template <> 925 inline bool 926 is_a_helper <rtx_jump_table_data *>::test (rtx_insn *insn) 927 { 928 return JUMP_TABLE_DATA_P (insn); 929 } 930 931 template <> 932 template <> 933 inline bool 934 is_a_helper <rtx_barrier *>::test (rtx rt) 935 { 936 return BARRIER_P (rt); 937 } 938 939 template <> 940 template <> 941 inline bool 942 is_a_helper <rtx_code_label *>::test (rtx rt) 943 { 944 return LABEL_P (rt); 945 } 946 947 template <> 948 template <> 949 inline bool 950 is_a_helper <rtx_code_label *>::test (rtx_insn *insn) 951 { 952 return LABEL_P (insn); 953 } 954 955 template <> 956 template <> 957 inline bool 958 is_a_helper <rtx_note *>::test (rtx rt) 959 { 960 return NOTE_P (rt); 961 } 962 963 template <> 964 template <> 965 inline bool 966 is_a_helper <rtx_note *>::test (rtx_insn *insn) 967 { 968 return NOTE_P (insn); 969 } 970 971 /* Predicate yielding nonzero iff X is a return or simple_return. */ 972 #define ANY_RETURN_P(X) \ 973 (GET_CODE (X) == RETURN || GET_CODE (X) == SIMPLE_RETURN) 974 975 /* 1 if X is a unary operator. */ 976 977 #define UNARY_P(X) \ 978 (GET_RTX_CLASS (GET_CODE (X)) == RTX_UNARY) 979 980 /* 1 if X is a binary operator. */ 981 982 #define BINARY_P(X) \ 983 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_BINARY_MASK) == RTX_BINARY_RESULT) 984 985 /* 1 if X is an arithmetic operator. */ 986 987 #define ARITHMETIC_P(X) \ 988 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_ARITHMETIC_MASK) \ 989 == RTX_ARITHMETIC_RESULT) 990 991 /* 1 if X is an arithmetic operator. */ 992 993 #define COMMUTATIVE_ARITH_P(X) \ 994 (GET_RTX_CLASS (GET_CODE (X)) == RTX_COMM_ARITH) 995 996 /* 1 if X is a commutative arithmetic operator or a comparison operator. 997 These two are sometimes selected together because it is possible to 998 swap the two operands. */ 999 1000 #define SWAPPABLE_OPERANDS_P(X) \ 1001 ((1 << GET_RTX_CLASS (GET_CODE (X))) \ 1002 & ((1 << RTX_COMM_ARITH) | (1 << RTX_COMM_COMPARE) \ 1003 | (1 << RTX_COMPARE))) 1004 1005 /* 1 if X is a non-commutative operator. */ 1006 1007 #define NON_COMMUTATIVE_P(X) \ 1008 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \ 1009 == RTX_NON_COMMUTATIVE_RESULT) 1010 1011 /* 1 if X is a commutative operator on integers. */ 1012 1013 #define COMMUTATIVE_P(X) \ 1014 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \ 1015 == RTX_COMMUTATIVE_RESULT) 1016 1017 /* 1 if X is a relational operator. */ 1018 1019 #define COMPARISON_P(X) \ 1020 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMPARE_MASK) == RTX_COMPARE_RESULT) 1021 1022 /* 1 if X is a constant value that is an integer. */ 1023 1024 #define CONSTANT_P(X) \ 1025 (GET_RTX_CLASS (GET_CODE (X)) == RTX_CONST_OBJ) 1026 1027 /* 1 if X can be used to represent an object. */ 1028 #define OBJECT_P(X) \ 1029 ((GET_RTX_CLASS (GET_CODE (X)) & RTX_OBJ_MASK) == RTX_OBJ_RESULT) 1030 1031 /* General accessor macros for accessing the fields of an rtx. */ 1032 1033 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) 1034 /* The bit with a star outside the statement expr and an & inside is 1035 so that N can be evaluated only once. */ 1036 #define RTL_CHECK1(RTX, N, C1) __extension__ \ 1037 (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ 1038 const enum rtx_code _code = GET_CODE (_rtx); \ 1039 if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ 1040 rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ 1041 __FUNCTION__); \ 1042 if (GET_RTX_FORMAT (_code)[_n] != C1) \ 1043 rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \ 1044 __FUNCTION__); \ 1045 &_rtx->u.fld[_n]; })) 1046 1047 #define RTL_CHECK2(RTX, N, C1, C2) __extension__ \ 1048 (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ 1049 const enum rtx_code _code = GET_CODE (_rtx); \ 1050 if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ 1051 rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ 1052 __FUNCTION__); \ 1053 if (GET_RTX_FORMAT (_code)[_n] != C1 \ 1054 && GET_RTX_FORMAT (_code)[_n] != C2) \ 1055 rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \ 1056 __FUNCTION__); \ 1057 &_rtx->u.fld[_n]; })) 1058 1059 #define RTL_CHECKC1(RTX, N, C) __extension__ \ 1060 (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ 1061 if (GET_CODE (_rtx) != (C)) \ 1062 rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \ 1063 __FUNCTION__); \ 1064 &_rtx->u.fld[_n]; })) 1065 1066 #define RTL_CHECKC2(RTX, N, C1, C2) __extension__ \ 1067 (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ 1068 const enum rtx_code _code = GET_CODE (_rtx); \ 1069 if (_code != (C1) && _code != (C2)) \ 1070 rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__, \ 1071 __FUNCTION__); \ 1072 &_rtx->u.fld[_n]; })) 1073 1074 #define RTVEC_ELT(RTVEC, I) __extension__ \ 1075 (*({ __typeof (RTVEC) const _rtvec = (RTVEC); const int _i = (I); \ 1076 if (_i < 0 || _i >= GET_NUM_ELEM (_rtvec)) \ 1077 rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__, \ 1078 __FUNCTION__); \ 1079 &_rtvec->elem[_i]; })) 1080 1081 #define XWINT(RTX, N) __extension__ \ 1082 (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ 1083 const enum rtx_code _code = GET_CODE (_rtx); \ 1084 if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ 1085 rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ 1086 __FUNCTION__); \ 1087 if (GET_RTX_FORMAT (_code)[_n] != 'w') \ 1088 rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__, \ 1089 __FUNCTION__); \ 1090 &_rtx->u.hwint[_n]; })) 1091 1092 #define CWI_ELT(RTX, I) __extension__ \ 1093 (*({ __typeof (RTX) const _cwi = (RTX); \ 1094 int _max = CWI_GET_NUM_ELEM (_cwi); \ 1095 const int _i = (I); \ 1096 if (_i < 0 || _i >= _max) \ 1097 cwi_check_failed_bounds (_cwi, _i, __FILE__, __LINE__, \ 1098 __FUNCTION__); \ 1099 &_cwi->u.hwiv.elem[_i]; })) 1100 1101 #define XCWINT(RTX, N, C) __extension__ \ 1102 (*({ __typeof (RTX) const _rtx = (RTX); \ 1103 if (GET_CODE (_rtx) != (C)) \ 1104 rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \ 1105 __FUNCTION__); \ 1106 &_rtx->u.hwint[N]; })) 1107 1108 #define XCMWINT(RTX, N, C, M) __extension__ \ 1109 (*({ __typeof (RTX) const _rtx = (RTX); \ 1110 if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) != (M)) \ 1111 rtl_check_failed_code_mode (_rtx, (C), (M), false, __FILE__, \ 1112 __LINE__, __FUNCTION__); \ 1113 &_rtx->u.hwint[N]; })) 1114 1115 #define XCNMPRV(RTX, C, M) __extension__ \ 1116 ({ __typeof (RTX) const _rtx = (RTX); \ 1117 if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M)) \ 1118 rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__, \ 1119 __LINE__, __FUNCTION__); \ 1120 &_rtx->u.rv; }) 1121 1122 #define XCNMPFV(RTX, C, M) __extension__ \ 1123 ({ __typeof (RTX) const _rtx = (RTX); \ 1124 if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M)) \ 1125 rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__, \ 1126 __LINE__, __FUNCTION__); \ 1127 &_rtx->u.fv; }) 1128 1129 #define REG_CHECK(RTX) __extension__ \ 1130 ({ __typeof (RTX) const _rtx = (RTX); \ 1131 if (GET_CODE (_rtx) != REG) \ 1132 rtl_check_failed_code1 (_rtx, REG, __FILE__, __LINE__, \ 1133 __FUNCTION__); \ 1134 &_rtx->u.reg; }) 1135 1136 #define BLOCK_SYMBOL_CHECK(RTX) __extension__ \ 1137 ({ __typeof (RTX) const _symbol = (RTX); \ 1138 const unsigned int flags = SYMBOL_REF_FLAGS (_symbol); \ 1139 if ((flags & SYMBOL_FLAG_HAS_BLOCK_INFO) == 0) \ 1140 rtl_check_failed_block_symbol (__FILE__, __LINE__, \ 1141 __FUNCTION__); \ 1142 &_symbol->u.block_sym; }) 1143 1144 #define HWIVEC_CHECK(RTX,C) __extension__ \ 1145 ({ __typeof (RTX) const _symbol = (RTX); \ 1146 RTL_CHECKC1 (_symbol, 0, C); \ 1147 &_symbol->u.hwiv; }) 1148 1149 extern void rtl_check_failed_bounds (const_rtx, int, const char *, int, 1150 const char *) 1151 ATTRIBUTE_NORETURN; 1152 extern void rtl_check_failed_type1 (const_rtx, int, int, const char *, int, 1153 const char *) 1154 ATTRIBUTE_NORETURN; 1155 extern void rtl_check_failed_type2 (const_rtx, int, int, int, const char *, 1156 int, const char *) 1157 ATTRIBUTE_NORETURN; 1158 extern void rtl_check_failed_code1 (const_rtx, enum rtx_code, const char *, 1159 int, const char *) 1160 ATTRIBUTE_NORETURN; 1161 extern void rtl_check_failed_code2 (const_rtx, enum rtx_code, enum rtx_code, 1162 const char *, int, const char *) 1163 ATTRIBUTE_NORETURN; 1164 extern void rtl_check_failed_code_mode (const_rtx, enum rtx_code, machine_mode, 1165 bool, const char *, int, const char *) 1166 ATTRIBUTE_NORETURN; 1167 extern void rtl_check_failed_block_symbol (const char *, int, const char *) 1168 ATTRIBUTE_NORETURN; 1169 extern void cwi_check_failed_bounds (const_rtx, int, const char *, int, 1170 const char *) 1171 ATTRIBUTE_NORETURN; 1172 extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, 1173 const char *) 1174 ATTRIBUTE_NORETURN; 1175 1176 #else /* not ENABLE_RTL_CHECKING */ 1177 1178 #define RTL_CHECK1(RTX, N, C1) ((RTX)->u.fld[N]) 1179 #define RTL_CHECK2(RTX, N, C1, C2) ((RTX)->u.fld[N]) 1180 #define RTL_CHECKC1(RTX, N, C) ((RTX)->u.fld[N]) 1181 #define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->u.fld[N]) 1182 #define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[I]) 1183 #define XWINT(RTX, N) ((RTX)->u.hwint[N]) 1184 #define CWI_ELT(RTX, I) ((RTX)->u.hwiv.elem[I]) 1185 #define XCWINT(RTX, N, C) ((RTX)->u.hwint[N]) 1186 #define XCMWINT(RTX, N, C, M) ((RTX)->u.hwint[N]) 1187 #define XCNMWINT(RTX, N, C, M) ((RTX)->u.hwint[N]) 1188 #define XCNMPRV(RTX, C, M) (&(RTX)->u.rv) 1189 #define XCNMPFV(RTX, C, M) (&(RTX)->u.fv) 1190 #define REG_CHECK(RTX) (&(RTX)->u.reg) 1191 #define BLOCK_SYMBOL_CHECK(RTX) (&(RTX)->u.block_sym) 1192 #define HWIVEC_CHECK(RTX,C) (&(RTX)->u.hwiv) 1193 1194 #endif 1195 1196 /* General accessor macros for accessing the flags of an rtx. */ 1197 1198 /* Access an individual rtx flag, with no checking of any kind. */ 1199 #define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG) 1200 1201 #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007) 1202 #define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \ 1203 ({ __typeof (RTX) const _rtx = (RTX); \ 1204 if (GET_CODE (_rtx) != C1) \ 1205 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1206 __FUNCTION__); \ 1207 _rtx; }) 1208 1209 #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \ 1210 ({ __typeof (RTX) const _rtx = (RTX); \ 1211 if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2) \ 1212 rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ 1213 __FUNCTION__); \ 1214 _rtx; }) 1215 1216 #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \ 1217 ({ __typeof (RTX) const _rtx = (RTX); \ 1218 if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \ 1219 && GET_CODE (_rtx) != C3) \ 1220 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1221 __FUNCTION__); \ 1222 _rtx; }) 1223 1224 #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \ 1225 ({ __typeof (RTX) const _rtx = (RTX); \ 1226 if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \ 1227 && GET_CODE (_rtx) != C3 && GET_CODE(_rtx) != C4) \ 1228 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1229 __FUNCTION__); \ 1230 _rtx; }) 1231 1232 #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \ 1233 ({ __typeof (RTX) const _rtx = (RTX); \ 1234 if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ 1235 && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ 1236 && GET_CODE (_rtx) != C5) \ 1237 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1238 __FUNCTION__); \ 1239 _rtx; }) 1240 1241 #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \ 1242 __extension__ \ 1243 ({ __typeof (RTX) const _rtx = (RTX); \ 1244 if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ 1245 && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ 1246 && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6) \ 1247 rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ 1248 __FUNCTION__); \ 1249 _rtx; }) 1250 1251 #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \ 1252 __extension__ \ 1253 ({ __typeof (RTX) const _rtx = (RTX); \ 1254 if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ 1255 && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ 1256 && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6 \ 1257 && GET_CODE (_rtx) != C7) \ 1258 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1259 __FUNCTION__); \ 1260 _rtx; }) 1261 1262 #define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX) \ 1263 __extension__ \ 1264 ({ __typeof (RTX) const _rtx = (RTX); \ 1265 if (!INSN_CHAIN_CODE_P (GET_CODE (_rtx))) \ 1266 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ 1267 __FUNCTION__); \ 1268 _rtx; }) 1269 1270 extern void rtl_check_failed_flag (const char *, const_rtx, const char *, 1271 int, const char *) 1272 ATTRIBUTE_NORETURN 1273 ; 1274 1275 #else /* not ENABLE_RTL_FLAG_CHECKING */ 1276 1277 #define RTL_FLAG_CHECK1(NAME, RTX, C1) (RTX) 1278 #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) (RTX) 1279 #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) (RTX) 1280 #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) (RTX) 1281 #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) (RTX) 1282 #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) (RTX) 1283 #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) (RTX) 1284 #define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX) (RTX) 1285 #endif 1286 1287 #define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_int) 1288 #define XUINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_uint) 1289 #define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rt_str) 1290 #define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rt_rtx) 1291 #define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rt_rtvec) 1292 #define XMODE(RTX, N) (RTL_CHECK1 (RTX, N, 'M').rt_type) 1293 #define XTREE(RTX, N) (RTL_CHECK1 (RTX, N, 't').rt_tree) 1294 #define XBBDEF(RTX, N) (RTL_CHECK1 (RTX, N, 'B').rt_bb) 1295 #define XTMPL(RTX, N) (RTL_CHECK1 (RTX, N, 'T').rt_str) 1296 #define XCFI(RTX, N) (RTL_CHECK1 (RTX, N, 'C').rt_cfi) 1297 1298 #define XVECEXP(RTX, N, M) RTVEC_ELT (XVEC (RTX, N), M) 1299 #define XVECLEN(RTX, N) GET_NUM_ELEM (XVEC (RTX, N)) 1300 1301 /* These are like XINT, etc. except that they expect a '0' field instead 1302 of the normal type code. */ 1303 1304 #define X0INT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_int) 1305 #define X0UINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_uint) 1306 #define X0STR(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_str) 1307 #define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtx) 1308 #define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtvec) 1309 #define X0MODE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_type) 1310 #define X0TREE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_tree) 1311 #define X0BBDEF(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_bb) 1312 #define X0ADVFLAGS(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_addr_diff_vec_flags) 1313 #define X0CSELIB(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_cselib) 1314 #define X0MEMATTR(RTX, N) (RTL_CHECKC1 (RTX, N, MEM).rt_mem) 1315 #define X0CONSTANT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_constant) 1316 1317 /* Access a '0' field with any type. */ 1318 #define X0ANY(RTX, N) RTL_CHECK1 (RTX, N, '0') 1319 1320 #define XCINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_int) 1321 #define XCUINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_uint) 1322 #define XCSTR(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_str) 1323 #define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtx) 1324 #define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtvec) 1325 #define XCMODE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_type) 1326 #define XCTREE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_tree) 1327 #define XCBBDEF(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_bb) 1328 #define XCCFI(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_cfi) 1329 #define XCCSELIB(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_cselib) 1330 1331 #define XCVECEXP(RTX, N, M, C) RTVEC_ELT (XCVEC (RTX, N, C), M) 1332 #define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C)) 1333 1334 #define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rt_rtx) 1335 1336 1337 /* Methods of rtx_expr_list. */ 1338 1339 inline rtx_expr_list *rtx_expr_list::next () const 1340 { 1341 rtx tmp = XEXP (this, 1); 1342 return safe_as_a <rtx_expr_list *> (tmp); 1343 } 1344 1345 inline rtx rtx_expr_list::element () const 1346 { 1347 return XEXP (this, 0); 1348 } 1349 1350 /* Methods of rtx_insn_list. */ 1351 1352 inline rtx_insn_list *rtx_insn_list::next () const 1353 { 1354 rtx tmp = XEXP (this, 1); 1355 return safe_as_a <rtx_insn_list *> (tmp); 1356 } 1357 1358 inline rtx_insn *rtx_insn_list::insn () const 1359 { 1360 rtx tmp = XEXP (this, 0); 1361 return safe_as_a <rtx_insn *> (tmp); 1362 } 1363 1364 /* Methods of rtx_sequence. */ 1365 1366 inline int rtx_sequence::len () const 1367 { 1368 return XVECLEN (this, 0); 1369 } 1370 1371 inline rtx rtx_sequence::element (int index) const 1372 { 1373 return XVECEXP (this, 0, index); 1374 } 1375 1376 inline rtx_insn *rtx_sequence::insn (int index) const 1377 { 1378 return as_a <rtx_insn *> (XVECEXP (this, 0, index)); 1379 } 1380 1381 /* ACCESS MACROS for particular fields of insns. */ 1382 1383 /* Holds a unique number for each insn. 1384 These are not necessarily sequentially increasing. */ 1385 inline int INSN_UID (const_rtx insn) 1386 { 1387 return RTL_INSN_CHAIN_FLAG_CHECK ("INSN_UID", 1388 (insn))->u2.insn_uid; 1389 } 1390 inline int& INSN_UID (rtx insn) 1391 { 1392 return RTL_INSN_CHAIN_FLAG_CHECK ("INSN_UID", 1393 (insn))->u2.insn_uid; 1394 } 1395 1396 /* Chain insns together in sequence. */ 1397 1398 /* For now these are split in two: an rvalue form: 1399 PREV_INSN/NEXT_INSN 1400 and an lvalue form: 1401 SET_NEXT_INSN/SET_PREV_INSN. */ 1402 1403 inline rtx_insn *PREV_INSN (const rtx_insn *insn) 1404 { 1405 rtx prev = XEXP (insn, 0); 1406 return safe_as_a <rtx_insn *> (prev); 1407 } 1408 1409 inline rtx& SET_PREV_INSN (rtx_insn *insn) 1410 { 1411 return XEXP (insn, 0); 1412 } 1413 1414 inline rtx_insn *NEXT_INSN (const rtx_insn *insn) 1415 { 1416 rtx next = XEXP (insn, 1); 1417 return safe_as_a <rtx_insn *> (next); 1418 } 1419 1420 inline rtx& SET_NEXT_INSN (rtx_insn *insn) 1421 { 1422 return XEXP (insn, 1); 1423 } 1424 1425 inline basic_block BLOCK_FOR_INSN (const_rtx insn) 1426 { 1427 return XBBDEF (insn, 2); 1428 } 1429 1430 inline basic_block& BLOCK_FOR_INSN (rtx insn) 1431 { 1432 return XBBDEF (insn, 2); 1433 } 1434 1435 inline void set_block_for_insn (rtx_insn *insn, basic_block bb) 1436 { 1437 BLOCK_FOR_INSN (insn) = bb; 1438 } 1439 1440 /* The body of an insn. */ 1441 inline rtx PATTERN (const_rtx insn) 1442 { 1443 return XEXP (insn, 3); 1444 } 1445 1446 inline rtx& PATTERN (rtx insn) 1447 { 1448 return XEXP (insn, 3); 1449 } 1450 1451 inline unsigned int INSN_LOCATION (const rtx_insn *insn) 1452 { 1453 return XUINT (insn, 4); 1454 } 1455 1456 inline unsigned int& INSN_LOCATION (rtx_insn *insn) 1457 { 1458 return XUINT (insn, 4); 1459 } 1460 1461 inline bool INSN_HAS_LOCATION (const rtx_insn *insn) 1462 { 1463 return LOCATION_LOCUS (INSN_LOCATION (insn)) != UNKNOWN_LOCATION; 1464 } 1465 1466 /* LOCATION of an RTX if relevant. */ 1467 #define RTL_LOCATION(X) (INSN_P (X) ? \ 1468 INSN_LOCATION (as_a <rtx_insn *> (X)) \ 1469 : UNKNOWN_LOCATION) 1470 1471 /* Code number of instruction, from when it was recognized. 1472 -1 means this instruction has not been recognized yet. */ 1473 #define INSN_CODE(INSN) XINT (INSN, 5) 1474 1475 inline rtvec rtx_jump_table_data::get_labels () const 1476 { 1477 rtx pat = PATTERN (this); 1478 if (GET_CODE (pat) == ADDR_VEC) 1479 return XVEC (pat, 0); 1480 else 1481 return XVEC (pat, 1); /* presumably an ADDR_DIFF_VEC */ 1482 } 1483 1484 #define RTX_FRAME_RELATED_P(RTX) \ 1485 (RTL_FLAG_CHECK6 ("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \ 1486 CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related) 1487 1488 /* 1 if JUMP RTX is a crossing jump. */ 1489 #define CROSSING_JUMP_P(RTX) \ 1490 (RTL_FLAG_CHECK1 ("CROSSING_JUMP_P", (RTX), JUMP_INSN)->jump) 1491 1492 /* 1 if RTX is a call to a const function. Built from ECF_CONST and 1493 TREE_READONLY. */ 1494 #define RTL_CONST_CALL_P(RTX) \ 1495 (RTL_FLAG_CHECK1 ("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging) 1496 1497 /* 1 if RTX is a call to a pure function. Built from ECF_PURE and 1498 DECL_PURE_P. */ 1499 #define RTL_PURE_CALL_P(RTX) \ 1500 (RTL_FLAG_CHECK1 ("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val) 1501 1502 /* 1 if RTX is a call to a const or pure function. */ 1503 #define RTL_CONST_OR_PURE_CALL_P(RTX) \ 1504 (RTL_CONST_CALL_P (RTX) || RTL_PURE_CALL_P (RTX)) 1505 1506 /* 1 if RTX is a call to a looping const or pure function. Built from 1507 ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. */ 1508 #define RTL_LOOPING_CONST_OR_PURE_CALL_P(RTX) \ 1509 (RTL_FLAG_CHECK1 ("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call) 1510 1511 /* 1 if RTX is a call_insn for a sibling call. */ 1512 #define SIBLING_CALL_P(RTX) \ 1513 (RTL_FLAG_CHECK1 ("SIBLING_CALL_P", (RTX), CALL_INSN)->jump) 1514 1515 /* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */ 1516 #define INSN_ANNULLED_BRANCH_P(RTX) \ 1517 (RTL_FLAG_CHECK1 ("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging) 1518 1519 /* 1 if RTX is an insn in a delay slot and is from the target of the branch. 1520 If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be 1521 executed if the branch is taken. For annulled branches with this bit 1522 clear, the insn should be executed only if the branch is not taken. */ 1523 #define INSN_FROM_TARGET_P(RTX) \ 1524 (RTL_FLAG_CHECK3 ("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, \ 1525 CALL_INSN)->in_struct) 1526 1527 /* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening. 1528 See the comments for ADDR_DIFF_VEC in rtl.def. */ 1529 #define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS (RTX, 4) 1530 1531 /* In a VALUE, the value cselib has assigned to RTX. 1532 This is a "struct cselib_val", see cselib.h. */ 1533 #define CSELIB_VAL_PTR(RTX) X0CSELIB (RTX, 0) 1534 1535 /* Holds a list of notes on what this insn does to various REGs. 1536 It is a chain of EXPR_LIST rtx's, where the second operand is the 1537 chain pointer and the first operand is the REG being described. 1538 The mode field of the EXPR_LIST contains not a real machine mode 1539 but a value from enum reg_note. */ 1540 #define REG_NOTES(INSN) XEXP(INSN, 6) 1541 1542 /* In an ENTRY_VALUE this is the DECL_INCOMING_RTL of the argument in 1543 question. */ 1544 #define ENTRY_VALUE_EXP(RTX) (RTL_CHECKC1 (RTX, 0, ENTRY_VALUE).rt_rtx) 1545 1546 enum reg_note 1547 { 1548 #define DEF_REG_NOTE(NAME) NAME, 1549 #include "reg-notes.def" 1550 #undef DEF_REG_NOTE 1551 REG_NOTE_MAX 1552 }; 1553 1554 /* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */ 1555 #define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK)) 1556 #define PUT_REG_NOTE_KIND(LINK, KIND) \ 1557 PUT_MODE_RAW (LINK, (machine_mode) (KIND)) 1558 1559 /* Names for REG_NOTE's in EXPR_LIST insn's. */ 1560 1561 extern const char * const reg_note_name[]; 1562 #define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)]) 1563 1564 /* This field is only present on CALL_INSNs. It holds a chain of EXPR_LIST of 1565 USE and CLOBBER expressions. 1566 USE expressions list the registers filled with arguments that 1567 are passed to the function. 1568 CLOBBER expressions document the registers explicitly clobbered 1569 by this CALL_INSN. 1570 Pseudo registers can not be mentioned in this list. */ 1571 #define CALL_INSN_FUNCTION_USAGE(INSN) XEXP(INSN, 7) 1572 1573 /* The label-number of a code-label. The assembler label 1574 is made from `L' and the label-number printed in decimal. 1575 Label numbers are unique in a compilation. */ 1576 #define CODE_LABEL_NUMBER(INSN) XINT (INSN, 5) 1577 1578 /* In a NOTE that is a line number, this is a string for the file name that the 1579 line is in. We use the same field to record block numbers temporarily in 1580 NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes. (We avoid lots of casts 1581 between ints and pointers if we use a different macro for the block number.) 1582 */ 1583 1584 /* Opaque data. */ 1585 #define NOTE_DATA(INSN) RTL_CHECKC1 (INSN, 3, NOTE) 1586 #define NOTE_DELETED_LABEL_NAME(INSN) XCSTR (INSN, 3, NOTE) 1587 #define SET_INSN_DELETED(INSN) set_insn_deleted (INSN); 1588 #define NOTE_BLOCK(INSN) XCTREE (INSN, 3, NOTE) 1589 #define NOTE_EH_HANDLER(INSN) XCINT (INSN, 3, NOTE) 1590 #define NOTE_BASIC_BLOCK(INSN) XCBBDEF (INSN, 3, NOTE) 1591 #define NOTE_VAR_LOCATION(INSN) XCEXP (INSN, 3, NOTE) 1592 #define NOTE_CFI(INSN) XCCFI (INSN, 3, NOTE) 1593 #define NOTE_LABEL_NUMBER(INSN) XCINT (INSN, 3, NOTE) 1594 1595 /* In a NOTE that is a line number, this is the line number. 1596 Other kinds of NOTEs are identified by negative numbers here. */ 1597 #define NOTE_KIND(INSN) XCINT (INSN, 4, NOTE) 1598 1599 /* Nonzero if INSN is a note marking the beginning of a basic block. */ 1600 #define NOTE_INSN_BASIC_BLOCK_P(INSN) \ 1601 (NOTE_P (INSN) && NOTE_KIND (INSN) == NOTE_INSN_BASIC_BLOCK) 1602 1603 /* Variable declaration and the location of a variable. */ 1604 #define PAT_VAR_LOCATION_DECL(PAT) (XCTREE ((PAT), 0, VAR_LOCATION)) 1605 #define PAT_VAR_LOCATION_LOC(PAT) (XCEXP ((PAT), 1, VAR_LOCATION)) 1606 1607 /* Initialization status of the variable in the location. Status 1608 can be unknown, uninitialized or initialized. See enumeration 1609 type below. */ 1610 #define PAT_VAR_LOCATION_STATUS(PAT) \ 1611 (RTL_FLAG_CHECK1 ("PAT_VAR_LOCATION_STATUS", PAT, VAR_LOCATION) \ 1612 ->u2.var_location_status) 1613 1614 /* Accessors for a NOTE_INSN_VAR_LOCATION. */ 1615 #define NOTE_VAR_LOCATION_DECL(NOTE) \ 1616 PAT_VAR_LOCATION_DECL (NOTE_VAR_LOCATION (NOTE)) 1617 #define NOTE_VAR_LOCATION_LOC(NOTE) \ 1618 PAT_VAR_LOCATION_LOC (NOTE_VAR_LOCATION (NOTE)) 1619 #define NOTE_VAR_LOCATION_STATUS(NOTE) \ 1620 PAT_VAR_LOCATION_STATUS (NOTE_VAR_LOCATION (NOTE)) 1621 1622 /* The VAR_LOCATION rtx in a DEBUG_INSN. */ 1623 #define INSN_VAR_LOCATION(INSN) PATTERN (INSN) 1624 1625 /* Accessors for a tree-expanded var location debug insn. */ 1626 #define INSN_VAR_LOCATION_DECL(INSN) \ 1627 PAT_VAR_LOCATION_DECL (INSN_VAR_LOCATION (INSN)) 1628 #define INSN_VAR_LOCATION_LOC(INSN) \ 1629 PAT_VAR_LOCATION_LOC (INSN_VAR_LOCATION (INSN)) 1630 #define INSN_VAR_LOCATION_STATUS(INSN) \ 1631 PAT_VAR_LOCATION_STATUS (INSN_VAR_LOCATION (INSN)) 1632 1633 /* Expand to the RTL that denotes an unknown variable location in a 1634 DEBUG_INSN. */ 1635 #define gen_rtx_UNKNOWN_VAR_LOC() (gen_rtx_CLOBBER (VOIDmode, const0_rtx)) 1636 1637 /* Determine whether X is such an unknown location. */ 1638 #define VAR_LOC_UNKNOWN_P(X) \ 1639 (GET_CODE (X) == CLOBBER && XEXP ((X), 0) == const0_rtx) 1640 1641 /* 1 if RTX is emitted after a call, but it should take effect before 1642 the call returns. */ 1643 #define NOTE_DURING_CALL_P(RTX) \ 1644 (RTL_FLAG_CHECK1 ("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call) 1645 1646 /* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX. */ 1647 #define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR) 1648 1649 /* VAR_DECL/PARM_DECL DEBUG_IMPLICIT_PTR takes address of. */ 1650 #define DEBUG_IMPLICIT_PTR_DECL(RTX) XCTREE (RTX, 0, DEBUG_IMPLICIT_PTR) 1651 1652 /* PARM_DECL DEBUG_PARAMETER_REF references. */ 1653 #define DEBUG_PARAMETER_REF_DECL(RTX) XCTREE (RTX, 0, DEBUG_PARAMETER_REF) 1654 1655 /* Codes that appear in the NOTE_KIND field for kinds of notes 1656 that are not line numbers. These codes are all negative. 1657 1658 Notice that we do not try to use zero here for any of 1659 the special note codes because sometimes the source line 1660 actually can be zero! This happens (for example) when we 1661 are generating code for the per-translation-unit constructor 1662 and destructor routines for some C++ translation unit. */ 1663 1664 enum insn_note 1665 { 1666 #define DEF_INSN_NOTE(NAME) NAME, 1667 #include "insn-notes.def" 1668 #undef DEF_INSN_NOTE 1669 1670 NOTE_INSN_MAX 1671 }; 1672 1673 /* Names for NOTE insn's other than line numbers. */ 1674 1675 extern const char * const note_insn_name[NOTE_INSN_MAX]; 1676 #define GET_NOTE_INSN_NAME(NOTE_CODE) \ 1677 (note_insn_name[(NOTE_CODE)]) 1678 1679 /* The name of a label, in case it corresponds to an explicit label 1680 in the input source code. */ 1681 #define LABEL_NAME(RTX) XCSTR (RTX, 6, CODE_LABEL) 1682 1683 /* In jump.c, each label contains a count of the number 1684 of LABEL_REFs that point at it, so unused labels can be deleted. */ 1685 #define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL) 1686 1687 /* Labels carry a two-bit field composed of the ->jump and ->call 1688 bits. This field indicates whether the label is an alternate 1689 entry point, and if so, what kind. */ 1690 enum label_kind 1691 { 1692 LABEL_NORMAL = 0, /* ordinary label */ 1693 LABEL_STATIC_ENTRY, /* alternate entry point, not exported */ 1694 LABEL_GLOBAL_ENTRY, /* alternate entry point, exported */ 1695 LABEL_WEAK_ENTRY /* alternate entry point, exported as weak symbol */ 1696 }; 1697 1698 #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION > 2007) 1699 1700 /* Retrieve the kind of LABEL. */ 1701 #define LABEL_KIND(LABEL) __extension__ \ 1702 ({ __typeof (LABEL) const _label = (LABEL); \ 1703 if (! LABEL_P (_label)) \ 1704 rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \ 1705 __FUNCTION__); \ 1706 (enum label_kind) ((_label->jump << 1) | _label->call); }) 1707 1708 /* Set the kind of LABEL. */ 1709 #define SET_LABEL_KIND(LABEL, KIND) do { \ 1710 __typeof (LABEL) const _label = (LABEL); \ 1711 const unsigned int _kind = (KIND); \ 1712 if (! LABEL_P (_label)) \ 1713 rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \ 1714 __FUNCTION__); \ 1715 _label->jump = ((_kind >> 1) & 1); \ 1716 _label->call = (_kind & 1); \ 1717 } while (0) 1718 1719 #else 1720 1721 /* Retrieve the kind of LABEL. */ 1722 #define LABEL_KIND(LABEL) \ 1723 ((enum label_kind) (((LABEL)->jump << 1) | (LABEL)->call)) 1724 1725 /* Set the kind of LABEL. */ 1726 #define SET_LABEL_KIND(LABEL, KIND) do { \ 1727 rtx const _label = (LABEL); \ 1728 const unsigned int _kind = (KIND); \ 1729 _label->jump = ((_kind >> 1) & 1); \ 1730 _label->call = (_kind & 1); \ 1731 } while (0) 1732 1733 #endif /* rtl flag checking */ 1734 1735 #define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL) 1736 1737 /* In jump.c, each JUMP_INSN can point to a label that it can jump to, 1738 so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can 1739 be decremented and possibly the label can be deleted. */ 1740 #define JUMP_LABEL(INSN) XCEXP (INSN, 7, JUMP_INSN) 1741 1742 inline rtx_insn *JUMP_LABEL_AS_INSN (const rtx_insn *insn) 1743 { 1744 return safe_as_a <rtx_insn *> (JUMP_LABEL (insn)); 1745 } 1746 1747 /* Methods of rtx_jump_insn. */ 1748 1749 inline rtx rtx_jump_insn::jump_label () const 1750 { 1751 return JUMP_LABEL (this); 1752 } 1753 1754 inline rtx_code_label *rtx_jump_insn::jump_target () const 1755 { 1756 return safe_as_a <rtx_code_label *> (JUMP_LABEL (this)); 1757 } 1758 1759 inline void rtx_jump_insn::set_jump_target (rtx_code_label *target) 1760 { 1761 JUMP_LABEL (this) = target; 1762 } 1763 1764 /* Once basic blocks are found, each CODE_LABEL starts a chain that 1765 goes through all the LABEL_REFs that jump to that label. The chain 1766 eventually winds up at the CODE_LABEL: it is circular. */ 1767 #define LABEL_REFS(LABEL) XCEXP (LABEL, 3, CODE_LABEL) 1768 1769 /* Get the label that a LABEL_REF references. */ 1770 static inline rtx_insn * 1771 label_ref_label (const_rtx ref) 1772 { 1773 return as_a<rtx_insn *> (XCEXP (ref, 0, LABEL_REF)); 1774 } 1775 1776 /* Set the label that LABEL_REF ref refers to. */ 1777 1778 static inline void 1779 set_label_ref_label (rtx ref, rtx_insn *label) 1780 { 1781 XCEXP (ref, 0, LABEL_REF) = label; 1782 } 1783 1784 /* For a REG rtx, REGNO extracts the register number. REGNO can only 1785 be used on RHS. Use SET_REGNO to change the value. */ 1786 #define REGNO(RTX) (rhs_regno(RTX)) 1787 #define SET_REGNO(RTX, N) (df_ref_change_reg_with_loc (RTX, N)) 1788 1789 /* Return the number of consecutive registers in a REG. This is always 1790 1 for pseudo registers and is determined by HARD_REGNO_NREGS for 1791 hard registers. */ 1792 #define REG_NREGS(RTX) (REG_CHECK (RTX)->nregs) 1793 1794 /* ORIGINAL_REGNO holds the number the register originally had; for a 1795 pseudo register turned into a hard reg this will hold the old pseudo 1796 register number. */ 1797 #define ORIGINAL_REGNO(RTX) \ 1798 (RTL_FLAG_CHECK1 ("ORIGINAL_REGNO", (RTX), REG)->u2.original_regno) 1799 1800 /* Force the REGNO macro to only be used on the lhs. */ 1801 static inline unsigned int 1802 rhs_regno (const_rtx x) 1803 { 1804 return REG_CHECK (x)->regno; 1805 } 1806 1807 /* Return the final register in REG X plus one. */ 1808 static inline unsigned int 1809 END_REGNO (const_rtx x) 1810 { 1811 return REGNO (x) + REG_NREGS (x); 1812 } 1813 1814 /* Change the REGNO and REG_NREGS of REG X to the specified values, 1815 bypassing the df machinery. */ 1816 static inline void 1817 set_regno_raw (rtx x, unsigned int regno, unsigned int nregs) 1818 { 1819 reg_info *reg = REG_CHECK (x); 1820 reg->regno = regno; 1821 reg->nregs = nregs; 1822 } 1823 1824 /* 1 if RTX is a reg or parallel that is the current function's return 1825 value. */ 1826 #define REG_FUNCTION_VALUE_P(RTX) \ 1827 (RTL_FLAG_CHECK2 ("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val) 1828 1829 /* 1 if RTX is a reg that corresponds to a variable declared by the user. */ 1830 #define REG_USERVAR_P(RTX) \ 1831 (RTL_FLAG_CHECK1 ("REG_USERVAR_P", (RTX), REG)->volatil) 1832 1833 /* 1 if RTX is a reg that holds a pointer value. */ 1834 #define REG_POINTER(RTX) \ 1835 (RTL_FLAG_CHECK1 ("REG_POINTER", (RTX), REG)->frame_related) 1836 1837 /* 1 if RTX is a mem that holds a pointer value. */ 1838 #define MEM_POINTER(RTX) \ 1839 (RTL_FLAG_CHECK1 ("MEM_POINTER", (RTX), MEM)->frame_related) 1840 1841 /* 1 if the given register REG corresponds to a hard register. */ 1842 #define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG))) 1843 1844 /* 1 if the given register number REG_NO corresponds to a hard register. */ 1845 #define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER) 1846 1847 /* For a CONST_INT rtx, INTVAL extracts the integer. */ 1848 #define INTVAL(RTX) XCWINT (RTX, 0, CONST_INT) 1849 #define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX)) 1850 1851 /* For a CONST_WIDE_INT, CONST_WIDE_INT_NUNITS is the number of 1852 elements actually needed to represent the constant. 1853 CONST_WIDE_INT_ELT gets one of the elements. 0 is the least 1854 significant HOST_WIDE_INT. */ 1855 #define CONST_WIDE_INT_VEC(RTX) HWIVEC_CHECK (RTX, CONST_WIDE_INT) 1856 #define CONST_WIDE_INT_NUNITS(RTX) CWI_GET_NUM_ELEM (RTX) 1857 #define CONST_WIDE_INT_ELT(RTX, N) CWI_ELT (RTX, N) 1858 1859 /* For a CONST_DOUBLE: 1860 #if TARGET_SUPPORTS_WIDE_INT == 0 1861 For a VOIDmode, there are two integers CONST_DOUBLE_LOW is the 1862 low-order word and ..._HIGH the high-order. 1863 #endif 1864 For a float, there is a REAL_VALUE_TYPE structure, and 1865 CONST_DOUBLE_REAL_VALUE(r) is a pointer to it. */ 1866 #define CONST_DOUBLE_LOW(r) XCMWINT (r, 0, CONST_DOUBLE, VOIDmode) 1867 #define CONST_DOUBLE_HIGH(r) XCMWINT (r, 1, CONST_DOUBLE, VOIDmode) 1868 #define CONST_DOUBLE_REAL_VALUE(r) \ 1869 ((const struct real_value *) XCNMPRV (r, CONST_DOUBLE, VOIDmode)) 1870 1871 #define CONST_FIXED_VALUE(r) \ 1872 ((const struct fixed_value *) XCNMPFV (r, CONST_FIXED, VOIDmode)) 1873 #define CONST_FIXED_VALUE_HIGH(r) \ 1874 ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.high)) 1875 #define CONST_FIXED_VALUE_LOW(r) \ 1876 ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.low)) 1877 1878 /* For a CONST_VECTOR, return element #n. */ 1879 #define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR) 1880 1881 /* For a CONST_VECTOR, return the number of elements in a vector. */ 1882 #define CONST_VECTOR_NUNITS(RTX) XCVECLEN (RTX, 0, CONST_VECTOR) 1883 1884 /* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of. 1885 SUBREG_BYTE extracts the byte-number. */ 1886 1887 #define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG) 1888 #define SUBREG_BYTE(RTX) XCUINT (RTX, 1, SUBREG) 1889 1890 /* in rtlanal.c */ 1891 /* Return the right cost to give to an operation 1892 to make the cost of the corresponding register-to-register instruction 1893 N times that of a fast register-to-register instruction. */ 1894 #define COSTS_N_INSNS(N) ((N) * 4) 1895 1896 /* Maximum cost of an rtl expression. This value has the special meaning 1897 not to use an rtx with this cost under any circumstances. */ 1898 #define MAX_COST INT_MAX 1899 1900 /* Return true if CODE always has VOIDmode. */ 1901 1902 static inline bool 1903 always_void_p (enum rtx_code code) 1904 { 1905 return code == SET; 1906 } 1907 1908 /* A structure to hold all available cost information about an rtl 1909 expression. */ 1910 struct full_rtx_costs 1911 { 1912 int speed; 1913 int size; 1914 }; 1915 1916 /* Initialize a full_rtx_costs structure C to the maximum cost. */ 1917 static inline void 1918 init_costs_to_max (struct full_rtx_costs *c) 1919 { 1920 c->speed = MAX_COST; 1921 c->size = MAX_COST; 1922 } 1923 1924 /* Initialize a full_rtx_costs structure C to zero cost. */ 1925 static inline void 1926 init_costs_to_zero (struct full_rtx_costs *c) 1927 { 1928 c->speed = 0; 1929 c->size = 0; 1930 } 1931 1932 /* Compare two full_rtx_costs structures A and B, returning true 1933 if A < B when optimizing for speed. */ 1934 static inline bool 1935 costs_lt_p (struct full_rtx_costs *a, struct full_rtx_costs *b, 1936 bool speed) 1937 { 1938 if (speed) 1939 return (a->speed < b->speed 1940 || (a->speed == b->speed && a->size < b->size)); 1941 else 1942 return (a->size < b->size 1943 || (a->size == b->size && a->speed < b->speed)); 1944 } 1945 1946 /* Increase both members of the full_rtx_costs structure C by the 1947 cost of N insns. */ 1948 static inline void 1949 costs_add_n_insns (struct full_rtx_costs *c, int n) 1950 { 1951 c->speed += COSTS_N_INSNS (n); 1952 c->size += COSTS_N_INSNS (n); 1953 } 1954 1955 /* Describes the shape of a subreg: 1956 1957 inner_mode == the mode of the SUBREG_REG 1958 offset == the SUBREG_BYTE 1959 outer_mode == the mode of the SUBREG itself. */ 1960 struct subreg_shape { 1961 subreg_shape (machine_mode, unsigned int, machine_mode); 1962 bool operator == (const subreg_shape &) const; 1963 bool operator != (const subreg_shape &) const; 1964 unsigned int unique_id () const; 1965 1966 machine_mode inner_mode; 1967 unsigned int offset; 1968 machine_mode outer_mode; 1969 }; 1970 1971 inline 1972 subreg_shape::subreg_shape (machine_mode inner_mode_in, 1973 unsigned int offset_in, 1974 machine_mode outer_mode_in) 1975 : inner_mode (inner_mode_in), offset (offset_in), outer_mode (outer_mode_in) 1976 {} 1977 1978 inline bool 1979 subreg_shape::operator == (const subreg_shape &other) const 1980 { 1981 return (inner_mode == other.inner_mode 1982 && offset == other.offset 1983 && outer_mode == other.outer_mode); 1984 } 1985 1986 inline bool 1987 subreg_shape::operator != (const subreg_shape &other) const 1988 { 1989 return !operator == (other); 1990 } 1991 1992 /* Return an integer that uniquely identifies this shape. Structures 1993 like rtx_def assume that a mode can fit in an 8-bit bitfield and no 1994 current mode is anywhere near being 65536 bytes in size, so the 1995 id comfortably fits in an int. */ 1996 1997 inline unsigned int 1998 subreg_shape::unique_id () const 1999 { 2000 STATIC_ASSERT (MAX_MACHINE_MODE <= 256); 2001 return (int) inner_mode + ((int) outer_mode << 8) + (offset << 16); 2002 } 2003 2004 /* Return the shape of a SUBREG rtx. */ 2005 2006 static inline subreg_shape 2007 shape_of_subreg (const_rtx x) 2008 { 2009 return subreg_shape (GET_MODE (SUBREG_REG (x)), 2010 SUBREG_BYTE (x), GET_MODE (x)); 2011 } 2012 2013 /* Information about an address. This structure is supposed to be able 2014 to represent all supported target addresses. Please extend it if it 2015 is not yet general enough. */ 2016 struct address_info { 2017 /* The mode of the value being addressed, or VOIDmode if this is 2018 a load-address operation with no known address mode. */ 2019 machine_mode mode; 2020 2021 /* The address space. */ 2022 addr_space_t as; 2023 2024 /* True if this is an RTX_AUTOINC address. */ 2025 bool autoinc_p; 2026 2027 /* A pointer to the top-level address. */ 2028 rtx *outer; 2029 2030 /* A pointer to the inner address, after all address mutations 2031 have been stripped from the top-level address. It can be one 2032 of the following: 2033 2034 - A {PRE,POST}_{INC,DEC} of *BASE. SEGMENT, INDEX and DISP are null. 2035 2036 - A {PRE,POST}_MODIFY of *BASE. In this case either INDEX or DISP 2037 points to the step value, depending on whether the step is variable 2038 or constant respectively. SEGMENT is null. 2039 2040 - A plain sum of the form SEGMENT + BASE + INDEX + DISP, 2041 with null fields evaluating to 0. */ 2042 rtx *inner; 2043 2044 /* Components that make up *INNER. Each one may be null or nonnull. 2045 When nonnull, their meanings are as follows: 2046 2047 - *SEGMENT is the "segment" of memory to which the address refers. 2048 This value is entirely target-specific and is only called a "segment" 2049 because that's its most typical use. It contains exactly one UNSPEC, 2050 pointed to by SEGMENT_TERM. The contents of *SEGMENT do not need 2051 reloading. 2052 2053 - *BASE is a variable expression representing a base address. 2054 It contains exactly one REG, SUBREG or MEM, pointed to by BASE_TERM. 2055 2056 - *INDEX is a variable expression representing an index value. 2057 It may be a scaled expression, such as a MULT. It has exactly 2058 one REG, SUBREG or MEM, pointed to by INDEX_TERM. 2059 2060 - *DISP is a constant, possibly mutated. DISP_TERM points to the 2061 unmutated RTX_CONST_OBJ. */ 2062 rtx *segment; 2063 rtx *base; 2064 rtx *index; 2065 rtx *disp; 2066 2067 rtx *segment_term; 2068 rtx *base_term; 2069 rtx *index_term; 2070 rtx *disp_term; 2071 2072 /* In a {PRE,POST}_MODIFY address, this points to a second copy 2073 of BASE_TERM, otherwise it is null. */ 2074 rtx *base_term2; 2075 2076 /* ADDRESS if this structure describes an address operand, MEM if 2077 it describes a MEM address. */ 2078 enum rtx_code addr_outer_code; 2079 2080 /* If BASE is nonnull, this is the code of the rtx that contains it. */ 2081 enum rtx_code base_outer_code; 2082 }; 2083 2084 /* This is used to bundle an rtx and a mode together so that the pair 2085 can be used with the wi:: routines. If we ever put modes into rtx 2086 integer constants, this should go away and then just pass an rtx in. */ 2087 typedef std::pair <rtx, machine_mode> rtx_mode_t; 2088 2089 namespace wi 2090 { 2091 template <> 2092 struct int_traits <rtx_mode_t> 2093 { 2094 static const enum precision_type precision_type = VAR_PRECISION; 2095 static const bool host_dependent_precision = false; 2096 /* This ought to be true, except for the special case that BImode 2097 is canonicalized to STORE_FLAG_VALUE, which might be 1. */ 2098 static const bool is_sign_extended = false; 2099 static unsigned int get_precision (const rtx_mode_t &); 2100 static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int, 2101 const rtx_mode_t &); 2102 }; 2103 } 2104 2105 inline unsigned int 2106 wi::int_traits <rtx_mode_t>::get_precision (const rtx_mode_t &x) 2107 { 2108 gcc_checking_assert (x.second != BLKmode && x.second != VOIDmode); 2109 return GET_MODE_PRECISION (x.second); 2110 } 2111 2112 inline wi::storage_ref 2113 wi::int_traits <rtx_mode_t>::decompose (HOST_WIDE_INT *, 2114 unsigned int precision, 2115 const rtx_mode_t &x) 2116 { 2117 gcc_checking_assert (precision == get_precision (x)); 2118 switch (GET_CODE (x.first)) 2119 { 2120 case CONST_INT: 2121 if (precision < HOST_BITS_PER_WIDE_INT) 2122 /* Nonzero BImodes are stored as STORE_FLAG_VALUE, which on many 2123 targets is 1 rather than -1. */ 2124 gcc_checking_assert (INTVAL (x.first) 2125 == sext_hwi (INTVAL (x.first), precision) 2126 || (x.second == BImode && INTVAL (x.first) == 1)); 2127 2128 return wi::storage_ref (&INTVAL (x.first), 1, precision); 2129 2130 case CONST_WIDE_INT: 2131 return wi::storage_ref (&CONST_WIDE_INT_ELT (x.first, 0), 2132 CONST_WIDE_INT_NUNITS (x.first), precision); 2133 2134 #if TARGET_SUPPORTS_WIDE_INT == 0 2135 case CONST_DOUBLE: 2136 return wi::storage_ref (&CONST_DOUBLE_LOW (x.first), 2, precision); 2137 #endif 2138 2139 default: 2140 gcc_unreachable (); 2141 } 2142 } 2143 2144 namespace wi 2145 { 2146 hwi_with_prec shwi (HOST_WIDE_INT, machine_mode mode); 2147 wide_int min_value (machine_mode, signop); 2148 wide_int max_value (machine_mode, signop); 2149 } 2150 2151 inline wi::hwi_with_prec 2152 wi::shwi (HOST_WIDE_INT val, machine_mode mode) 2153 { 2154 return shwi (val, GET_MODE_PRECISION (mode)); 2155 } 2156 2157 /* Produce the smallest number that is represented in MODE. The precision 2158 is taken from MODE and the sign from SGN. */ 2159 inline wide_int 2160 wi::min_value (machine_mode mode, signop sgn) 2161 { 2162 return min_value (GET_MODE_PRECISION (mode), sgn); 2163 } 2164 2165 /* Produce the largest number that is represented in MODE. The precision 2166 is taken from MODE and the sign from SGN. */ 2167 inline wide_int 2168 wi::max_value (machine_mode mode, signop sgn) 2169 { 2170 return max_value (GET_MODE_PRECISION (mode), sgn); 2171 } 2172 2173 extern void init_rtlanal (void); 2174 extern int rtx_cost (rtx, machine_mode, enum rtx_code, int, bool); 2175 extern int address_cost (rtx, machine_mode, addr_space_t, bool); 2176 extern void get_full_rtx_cost (rtx, machine_mode, enum rtx_code, int, 2177 struct full_rtx_costs *); 2178 extern unsigned int subreg_lsb (const_rtx); 2179 extern unsigned int subreg_lsb_1 (machine_mode, machine_mode, 2180 unsigned int); 2181 extern unsigned int subreg_size_offset_from_lsb (unsigned int, unsigned int, 2182 unsigned int); 2183 2184 /* Return the subreg byte offset for a subreg whose outer mode is 2185 OUTER_MODE, whose inner mode is INNER_MODE, and where there are 2186 LSB_SHIFT *bits* between the lsb of the outer value and the lsb of 2187 the inner value. This is the inverse of subreg_lsb_1 (which converts 2188 byte offsets to bit shifts). */ 2189 2190 inline unsigned int 2191 subreg_offset_from_lsb (machine_mode outer_mode, 2192 machine_mode inner_mode, 2193 unsigned int lsb_shift) 2194 { 2195 return subreg_size_offset_from_lsb (GET_MODE_SIZE (outer_mode), 2196 GET_MODE_SIZE (inner_mode), lsb_shift); 2197 } 2198 2199 extern unsigned int subreg_regno_offset (unsigned int, machine_mode, 2200 unsigned int, machine_mode); 2201 extern bool subreg_offset_representable_p (unsigned int, machine_mode, 2202 unsigned int, machine_mode); 2203 extern unsigned int subreg_regno (const_rtx); 2204 extern int simplify_subreg_regno (unsigned int, machine_mode, 2205 unsigned int, machine_mode); 2206 extern unsigned int subreg_nregs (const_rtx); 2207 extern unsigned int subreg_nregs_with_regno (unsigned int, const_rtx); 2208 extern unsigned HOST_WIDE_INT nonzero_bits (const_rtx, machine_mode); 2209 extern unsigned int num_sign_bit_copies (const_rtx, machine_mode); 2210 extern bool constant_pool_constant_p (rtx); 2211 extern bool truncated_to_mode (machine_mode, const_rtx); 2212 extern int low_bitmask_len (machine_mode, unsigned HOST_WIDE_INT); 2213 extern void split_double (rtx, rtx *, rtx *); 2214 extern rtx *strip_address_mutations (rtx *, enum rtx_code * = 0); 2215 extern void decompose_address (struct address_info *, rtx *, 2216 machine_mode, addr_space_t, enum rtx_code); 2217 extern void decompose_lea_address (struct address_info *, rtx *); 2218 extern void decompose_mem_address (struct address_info *, rtx); 2219 extern void update_address (struct address_info *); 2220 extern HOST_WIDE_INT get_index_scale (const struct address_info *); 2221 extern enum rtx_code get_index_code (const struct address_info *); 2222 2223 /* 1 if RTX is a subreg containing a reg that is already known to be 2224 sign- or zero-extended from the mode of the subreg to the mode of 2225 the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the 2226 extension. 2227 2228 When used as a LHS, is means that this extension must be done 2229 when assigning to SUBREG_REG. */ 2230 2231 #define SUBREG_PROMOTED_VAR_P(RTX) \ 2232 (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct) 2233 2234 /* Valid for subregs which are SUBREG_PROMOTED_VAR_P(). In that case 2235 this gives the necessary extensions: 2236 0 - signed (SPR_SIGNED) 2237 1 - normal unsigned (SPR_UNSIGNED) 2238 2 - value is both sign and unsign extended for mode 2239 (SPR_SIGNED_AND_UNSIGNED). 2240 -1 - pointer unsigned, which most often can be handled like unsigned 2241 extension, except for generating instructions where we need to 2242 emit special code (ptr_extend insns) on some architectures 2243 (SPR_POINTER). */ 2244 2245 const int SRP_POINTER = -1; 2246 const int SRP_SIGNED = 0; 2247 const int SRP_UNSIGNED = 1; 2248 const int SRP_SIGNED_AND_UNSIGNED = 2; 2249 2250 /* Sets promoted mode for SUBREG_PROMOTED_VAR_P(). */ 2251 #define SUBREG_PROMOTED_SET(RTX, VAL) \ 2252 do { \ 2253 rtx const _rtx = RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SET", \ 2254 (RTX), SUBREG); \ 2255 switch (VAL) \ 2256 { \ 2257 case SRP_POINTER: \ 2258 _rtx->volatil = 0; \ 2259 _rtx->unchanging = 0; \ 2260 break; \ 2261 case SRP_SIGNED: \ 2262 _rtx->volatil = 0; \ 2263 _rtx->unchanging = 1; \ 2264 break; \ 2265 case SRP_UNSIGNED: \ 2266 _rtx->volatil = 1; \ 2267 _rtx->unchanging = 0; \ 2268 break; \ 2269 case SRP_SIGNED_AND_UNSIGNED: \ 2270 _rtx->volatil = 1; \ 2271 _rtx->unchanging = 1; \ 2272 break; \ 2273 } \ 2274 } while (0) 2275 2276 /* Gets the value stored in promoted mode for SUBREG_PROMOTED_VAR_P(), 2277 including SRP_SIGNED_AND_UNSIGNED if promoted for 2278 both signed and unsigned. */ 2279 #define SUBREG_PROMOTED_GET(RTX) \ 2280 (2 * (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_GET", (RTX), SUBREG)->volatil)\ 2281 + (RTX)->unchanging - 1) 2282 2283 /* Returns sign of promoted mode for SUBREG_PROMOTED_VAR_P(). */ 2284 #define SUBREG_PROMOTED_SIGN(RTX) \ 2285 ((RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SIGN", (RTX), SUBREG)->volatil) ? 1\ 2286 : (RTX)->unchanging - 1) 2287 2288 /* Predicate to check if RTX of SUBREG_PROMOTED_VAR_P() is promoted 2289 for SIGNED type. */ 2290 #define SUBREG_PROMOTED_SIGNED_P(RTX) \ 2291 (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SIGNED_P", (RTX), SUBREG)->unchanging) 2292 2293 /* Predicate to check if RTX of SUBREG_PROMOTED_VAR_P() is promoted 2294 for UNSIGNED type. */ 2295 #define SUBREG_PROMOTED_UNSIGNED_P(RTX) \ 2296 (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) 2297 2298 /* Checks if RTX of SUBREG_PROMOTED_VAR_P() is promoted for given SIGN. */ 2299 #define SUBREG_CHECK_PROMOTED_SIGN(RTX, SIGN) \ 2300 ((SIGN) == SRP_POINTER ? SUBREG_PROMOTED_GET (RTX) == SRP_POINTER \ 2301 : (SIGN) == SRP_SIGNED ? SUBREG_PROMOTED_SIGNED_P (RTX) \ 2302 : SUBREG_PROMOTED_UNSIGNED_P (RTX)) 2303 2304 /* True if the REG is the static chain register for some CALL_INSN. */ 2305 #define STATIC_CHAIN_REG_P(RTX) \ 2306 (RTL_FLAG_CHECK1 ("STATIC_CHAIN_REG_P", (RTX), REG)->jump) 2307 2308 /* True if the subreg was generated by LRA for reload insns. Such 2309 subregs are valid only during LRA. */ 2310 #define LRA_SUBREG_P(RTX) \ 2311 (RTL_FLAG_CHECK1 ("LRA_SUBREG_P", (RTX), SUBREG)->jump) 2312 2313 /* True if call is instrumented by Pointer Bounds Checker. */ 2314 #define CALL_EXPR_WITH_BOUNDS_P(RTX) \ 2315 (RTL_FLAG_CHECK1 ("CALL_EXPR_WITH_BOUNDS_P", (RTX), CALL)->jump) 2316 2317 /* Access various components of an ASM_OPERANDS rtx. */ 2318 2319 #define ASM_OPERANDS_TEMPLATE(RTX) XCSTR (RTX, 0, ASM_OPERANDS) 2320 #define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XCSTR (RTX, 1, ASM_OPERANDS) 2321 #define ASM_OPERANDS_OUTPUT_IDX(RTX) XCINT (RTX, 2, ASM_OPERANDS) 2322 #define ASM_OPERANDS_INPUT_VEC(RTX) XCVEC (RTX, 3, ASM_OPERANDS) 2323 #define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XCVEC (RTX, 4, ASM_OPERANDS) 2324 #define ASM_OPERANDS_INPUT(RTX, N) XCVECEXP (RTX, 3, N, ASM_OPERANDS) 2325 #define ASM_OPERANDS_INPUT_LENGTH(RTX) XCVECLEN (RTX, 3, ASM_OPERANDS) 2326 #define ASM_OPERANDS_INPUT_CONSTRAINT_EXP(RTX, N) \ 2327 XCVECEXP (RTX, 4, N, ASM_OPERANDS) 2328 #define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) \ 2329 XSTR (XCVECEXP (RTX, 4, N, ASM_OPERANDS), 0) 2330 #define ASM_OPERANDS_INPUT_MODE(RTX, N) \ 2331 GET_MODE (XCVECEXP (RTX, 4, N, ASM_OPERANDS)) 2332 #define ASM_OPERANDS_LABEL_VEC(RTX) XCVEC (RTX, 5, ASM_OPERANDS) 2333 #define ASM_OPERANDS_LABEL_LENGTH(RTX) XCVECLEN (RTX, 5, ASM_OPERANDS) 2334 #define ASM_OPERANDS_LABEL(RTX, N) XCVECEXP (RTX, 5, N, ASM_OPERANDS) 2335 #define ASM_OPERANDS_SOURCE_LOCATION(RTX) XCUINT (RTX, 6, ASM_OPERANDS) 2336 #define ASM_INPUT_SOURCE_LOCATION(RTX) XCUINT (RTX, 1, ASM_INPUT) 2337 2338 /* 1 if RTX is a mem that is statically allocated in read-only memory. */ 2339 #define MEM_READONLY_P(RTX) \ 2340 (RTL_FLAG_CHECK1 ("MEM_READONLY_P", (RTX), MEM)->unchanging) 2341 2342 /* 1 if RTX is a mem and we should keep the alias set for this mem 2343 unchanged when we access a component. Set to 1, or example, when we 2344 are already in a non-addressable component of an aggregate. */ 2345 #define MEM_KEEP_ALIAS_SET_P(RTX) \ 2346 (RTL_FLAG_CHECK1 ("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump) 2347 2348 /* 1 if RTX is a mem or asm_operand for a volatile reference. */ 2349 #define MEM_VOLATILE_P(RTX) \ 2350 (RTL_FLAG_CHECK3 ("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \ 2351 ASM_INPUT)->volatil) 2352 2353 /* 1 if RTX is a mem that cannot trap. */ 2354 #define MEM_NOTRAP_P(RTX) \ 2355 (RTL_FLAG_CHECK1 ("MEM_NOTRAP_P", (RTX), MEM)->call) 2356 2357 /* The memory attribute block. We provide access macros for each value 2358 in the block and provide defaults if none specified. */ 2359 #define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1) 2360 2361 /* The register attribute block. We provide access macros for each value 2362 in the block and provide defaults if none specified. */ 2363 #define REG_ATTRS(RTX) (REG_CHECK (RTX)->attrs) 2364 2365 #ifndef GENERATOR_FILE 2366 /* For a MEM rtx, the alias set. If 0, this MEM is not in any alias 2367 set, and may alias anything. Otherwise, the MEM can only alias 2368 MEMs in a conflicting alias set. This value is set in a 2369 language-dependent manner in the front-end, and should not be 2370 altered in the back-end. These set numbers are tested with 2371 alias_sets_conflict_p. */ 2372 #define MEM_ALIAS_SET(RTX) (get_mem_attrs (RTX)->alias) 2373 2374 /* For a MEM rtx, the decl it is known to refer to, if it is known to 2375 refer to part of a DECL. It may also be a COMPONENT_REF. */ 2376 #define MEM_EXPR(RTX) (get_mem_attrs (RTX)->expr) 2377 2378 /* For a MEM rtx, true if its MEM_OFFSET is known. */ 2379 #define MEM_OFFSET_KNOWN_P(RTX) (get_mem_attrs (RTX)->offset_known_p) 2380 2381 /* For a MEM rtx, the offset from the start of MEM_EXPR. */ 2382 #define MEM_OFFSET(RTX) (get_mem_attrs (RTX)->offset) 2383 2384 /* For a MEM rtx, the address space. */ 2385 #define MEM_ADDR_SPACE(RTX) (get_mem_attrs (RTX)->addrspace) 2386 2387 /* For a MEM rtx, true if its MEM_SIZE is known. */ 2388 #define MEM_SIZE_KNOWN_P(RTX) (get_mem_attrs (RTX)->size_known_p) 2389 2390 /* For a MEM rtx, the size in bytes of the MEM. */ 2391 #define MEM_SIZE(RTX) (get_mem_attrs (RTX)->size) 2392 2393 /* For a MEM rtx, the alignment in bits. We can use the alignment of the 2394 mode as a default when STRICT_ALIGNMENT, but not if not. */ 2395 #define MEM_ALIGN(RTX) (get_mem_attrs (RTX)->align) 2396 #else 2397 #define MEM_ADDR_SPACE(RTX) ADDR_SPACE_GENERIC 2398 #endif 2399 2400 /* For a REG rtx, the decl it is known to refer to, if it is known to 2401 refer to part of a DECL. */ 2402 #define REG_EXPR(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->decl) 2403 2404 /* For a REG rtx, the offset from the start of REG_EXPR, if known, as an 2405 HOST_WIDE_INT. */ 2406 #define REG_OFFSET(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->offset) 2407 2408 /* Copy the attributes that apply to memory locations from RHS to LHS. */ 2409 #define MEM_COPY_ATTRIBUTES(LHS, RHS) \ 2410 (MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS), \ 2411 MEM_NOTRAP_P (LHS) = MEM_NOTRAP_P (RHS), \ 2412 MEM_READONLY_P (LHS) = MEM_READONLY_P (RHS), \ 2413 MEM_KEEP_ALIAS_SET_P (LHS) = MEM_KEEP_ALIAS_SET_P (RHS), \ 2414 MEM_POINTER (LHS) = MEM_POINTER (RHS), \ 2415 MEM_ATTRS (LHS) = MEM_ATTRS (RHS)) 2416 2417 /* 1 if RTX is a label_ref for a nonlocal label. */ 2418 /* Likewise in an expr_list for a REG_LABEL_OPERAND or 2419 REG_LABEL_TARGET note. */ 2420 #define LABEL_REF_NONLOCAL_P(RTX) \ 2421 (RTL_FLAG_CHECK1 ("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil) 2422 2423 /* 1 if RTX is a code_label that should always be considered to be needed. */ 2424 #define LABEL_PRESERVE_P(RTX) \ 2425 (RTL_FLAG_CHECK2 ("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct) 2426 2427 /* During sched, 1 if RTX is an insn that must be scheduled together 2428 with the preceding insn. */ 2429 #define SCHED_GROUP_P(RTX) \ 2430 (RTL_FLAG_CHECK4 ("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \ 2431 JUMP_INSN, CALL_INSN)->in_struct) 2432 2433 /* For a SET rtx, SET_DEST is the place that is set 2434 and SET_SRC is the value it is set to. */ 2435 #define SET_DEST(RTX) XC2EXP (RTX, 0, SET, CLOBBER) 2436 #define SET_SRC(RTX) XCEXP (RTX, 1, SET) 2437 #define SET_IS_RETURN_P(RTX) \ 2438 (RTL_FLAG_CHECK1 ("SET_IS_RETURN_P", (RTX), SET)->jump) 2439 2440 /* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */ 2441 #define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF) 2442 #define TRAP_CODE(RTX) XCEXP (RTX, 1, TRAP_IF) 2443 2444 /* For a COND_EXEC rtx, COND_EXEC_TEST is the condition to base 2445 conditionally executing the code on, COND_EXEC_CODE is the code 2446 to execute if the condition is true. */ 2447 #define COND_EXEC_TEST(RTX) XCEXP (RTX, 0, COND_EXEC) 2448 #define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC) 2449 2450 /* 1 if RTX is a symbol_ref that addresses this function's rtl 2451 constants pool. */ 2452 #define CONSTANT_POOL_ADDRESS_P(RTX) \ 2453 (RTL_FLAG_CHECK1 ("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging) 2454 2455 /* 1 if RTX is a symbol_ref that addresses a value in the file's 2456 tree constant pool. This information is private to varasm.c. */ 2457 #define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \ 2458 (RTL_FLAG_CHECK1 ("TREE_CONSTANT_POOL_ADDRESS_P", \ 2459 (RTX), SYMBOL_REF)->frame_related) 2460 2461 /* Used if RTX is a symbol_ref, for machine-specific purposes. */ 2462 #define SYMBOL_REF_FLAG(RTX) \ 2463 (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil) 2464 2465 /* 1 if RTX is a symbol_ref that has been the library function in 2466 emit_library_call. */ 2467 #define SYMBOL_REF_USED(RTX) \ 2468 (RTL_FLAG_CHECK1 ("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used) 2469 2470 /* 1 if RTX is a symbol_ref for a weak symbol. */ 2471 #define SYMBOL_REF_WEAK(RTX) \ 2472 (RTL_FLAG_CHECK1 ("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val) 2473 2474 /* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or 2475 SYMBOL_REF_CONSTANT. */ 2476 #define SYMBOL_REF_DATA(RTX) X0ANY ((RTX), 1) 2477 2478 /* Set RTX's SYMBOL_REF_DECL to DECL. RTX must not be a constant 2479 pool symbol. */ 2480 #define SET_SYMBOL_REF_DECL(RTX, DECL) \ 2481 (gcc_assert (!CONSTANT_POOL_ADDRESS_P (RTX)), X0TREE ((RTX), 1) = (DECL)) 2482 2483 /* The tree (decl or constant) associated with the symbol, or null. */ 2484 #define SYMBOL_REF_DECL(RTX) \ 2485 (CONSTANT_POOL_ADDRESS_P (RTX) ? NULL : X0TREE ((RTX), 1)) 2486 2487 /* Set RTX's SYMBOL_REF_CONSTANT to C. RTX must be a constant pool symbol. */ 2488 #define SET_SYMBOL_REF_CONSTANT(RTX, C) \ 2489 (gcc_assert (CONSTANT_POOL_ADDRESS_P (RTX)), X0CONSTANT ((RTX), 1) = (C)) 2490 2491 /* The rtx constant pool entry for a symbol, or null. */ 2492 #define SYMBOL_REF_CONSTANT(RTX) \ 2493 (CONSTANT_POOL_ADDRESS_P (RTX) ? X0CONSTANT ((RTX), 1) : NULL) 2494 2495 /* A set of flags on a symbol_ref that are, in some respects, redundant with 2496 information derivable from the tree decl associated with this symbol. 2497 Except that we build a *lot* of SYMBOL_REFs that aren't associated with a 2498 decl. In some cases this is a bug. But beyond that, it's nice to cache 2499 this information to avoid recomputing it. Finally, this allows space for 2500 the target to store more than one bit of information, as with 2501 SYMBOL_REF_FLAG. */ 2502 #define SYMBOL_REF_FLAGS(RTX) \ 2503 (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAGS", (RTX), SYMBOL_REF) \ 2504 ->u2.symbol_ref_flags) 2505 2506 /* These flags are common enough to be defined for all targets. They 2507 are computed by the default version of targetm.encode_section_info. */ 2508 2509 /* Set if this symbol is a function. */ 2510 #define SYMBOL_FLAG_FUNCTION (1 << 0) 2511 #define SYMBOL_REF_FUNCTION_P(RTX) \ 2512 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_FUNCTION) != 0) 2513 /* Set if targetm.binds_local_p is true. */ 2514 #define SYMBOL_FLAG_LOCAL (1 << 1) 2515 #define SYMBOL_REF_LOCAL_P(RTX) \ 2516 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_LOCAL) != 0) 2517 /* Set if targetm.in_small_data_p is true. */ 2518 #define SYMBOL_FLAG_SMALL (1 << 2) 2519 #define SYMBOL_REF_SMALL_P(RTX) \ 2520 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_SMALL) != 0) 2521 /* The three-bit field at [5:3] is true for TLS variables; use 2522 SYMBOL_REF_TLS_MODEL to extract the field as an enum tls_model. */ 2523 #define SYMBOL_FLAG_TLS_SHIFT 3 2524 #define SYMBOL_REF_TLS_MODEL(RTX) \ 2525 ((enum tls_model) ((SYMBOL_REF_FLAGS (RTX) >> SYMBOL_FLAG_TLS_SHIFT) & 7)) 2526 /* Set if this symbol is not defined in this translation unit. */ 2527 #define SYMBOL_FLAG_EXTERNAL (1 << 6) 2528 #define SYMBOL_REF_EXTERNAL_P(RTX) \ 2529 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0) 2530 /* Set if this symbol has a block_symbol structure associated with it. */ 2531 #define SYMBOL_FLAG_HAS_BLOCK_INFO (1 << 7) 2532 #define SYMBOL_REF_HAS_BLOCK_INFO_P(RTX) \ 2533 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_HAS_BLOCK_INFO) != 0) 2534 /* Set if this symbol is a section anchor. SYMBOL_REF_ANCHOR_P implies 2535 SYMBOL_REF_HAS_BLOCK_INFO_P. */ 2536 #define SYMBOL_FLAG_ANCHOR (1 << 8) 2537 #define SYMBOL_REF_ANCHOR_P(RTX) \ 2538 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_ANCHOR) != 0) 2539 2540 /* Subsequent bits are available for the target to use. */ 2541 #define SYMBOL_FLAG_MACH_DEP_SHIFT 9 2542 #define SYMBOL_FLAG_MACH_DEP (1 << SYMBOL_FLAG_MACH_DEP_SHIFT) 2543 2544 /* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the object_block 2545 structure to which the symbol belongs, or NULL if it has not been 2546 assigned a block. */ 2547 #define SYMBOL_REF_BLOCK(RTX) (BLOCK_SYMBOL_CHECK (RTX)->block) 2548 2549 /* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the offset of RTX from 2550 the first object in SYMBOL_REF_BLOCK (RTX). The value is negative if 2551 RTX has not yet been assigned to a block, or it has not been given an 2552 offset within that block. */ 2553 #define SYMBOL_REF_BLOCK_OFFSET(RTX) (BLOCK_SYMBOL_CHECK (RTX)->offset) 2554 2555 /* True if RTX is flagged to be a scheduling barrier. */ 2556 #define PREFETCH_SCHEDULE_BARRIER_P(RTX) \ 2557 (RTL_FLAG_CHECK1 ("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil) 2558 2559 /* Indicate whether the machine has any sort of auto increment addressing. 2560 If not, we can avoid checking for REG_INC notes. */ 2561 2562 #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) \ 2563 || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) \ 2564 || defined (HAVE_PRE_MODIFY_DISP) || defined (HAVE_POST_MODIFY_DISP) \ 2565 || defined (HAVE_PRE_MODIFY_REG) || defined (HAVE_POST_MODIFY_REG)) 2566 #define AUTO_INC_DEC 1 2567 #else 2568 #define AUTO_INC_DEC 0 2569 #endif 2570 2571 /* Define a macro to look for REG_INC notes, 2572 but save time on machines where they never exist. */ 2573 2574 #if AUTO_INC_DEC 2575 #define FIND_REG_INC_NOTE(INSN, REG) \ 2576 ((REG) != NULL_RTX && REG_P ((REG)) \ 2577 ? find_regno_note ((INSN), REG_INC, REGNO (REG)) \ 2578 : find_reg_note ((INSN), REG_INC, (REG))) 2579 #else 2580 #define FIND_REG_INC_NOTE(INSN, REG) 0 2581 #endif 2582 2583 #ifndef HAVE_PRE_INCREMENT 2584 #define HAVE_PRE_INCREMENT 0 2585 #endif 2586 2587 #ifndef HAVE_PRE_DECREMENT 2588 #define HAVE_PRE_DECREMENT 0 2589 #endif 2590 2591 #ifndef HAVE_POST_INCREMENT 2592 #define HAVE_POST_INCREMENT 0 2593 #endif 2594 2595 #ifndef HAVE_POST_DECREMENT 2596 #define HAVE_POST_DECREMENT 0 2597 #endif 2598 2599 #ifndef HAVE_POST_MODIFY_DISP 2600 #define HAVE_POST_MODIFY_DISP 0 2601 #endif 2602 2603 #ifndef HAVE_POST_MODIFY_REG 2604 #define HAVE_POST_MODIFY_REG 0 2605 #endif 2606 2607 #ifndef HAVE_PRE_MODIFY_DISP 2608 #define HAVE_PRE_MODIFY_DISP 0 2609 #endif 2610 2611 #ifndef HAVE_PRE_MODIFY_REG 2612 #define HAVE_PRE_MODIFY_REG 0 2613 #endif 2614 2615 2616 /* Some architectures do not have complete pre/post increment/decrement 2617 instruction sets, or only move some modes efficiently. These macros 2618 allow us to tune autoincrement generation. */ 2619 2620 #ifndef USE_LOAD_POST_INCREMENT 2621 #define USE_LOAD_POST_INCREMENT(MODE) HAVE_POST_INCREMENT 2622 #endif 2623 2624 #ifndef USE_LOAD_POST_DECREMENT 2625 #define USE_LOAD_POST_DECREMENT(MODE) HAVE_POST_DECREMENT 2626 #endif 2627 2628 #ifndef USE_LOAD_PRE_INCREMENT 2629 #define USE_LOAD_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT 2630 #endif 2631 2632 #ifndef USE_LOAD_PRE_DECREMENT 2633 #define USE_LOAD_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT 2634 #endif 2635 2636 #ifndef USE_STORE_POST_INCREMENT 2637 #define USE_STORE_POST_INCREMENT(MODE) HAVE_POST_INCREMENT 2638 #endif 2639 2640 #ifndef USE_STORE_POST_DECREMENT 2641 #define USE_STORE_POST_DECREMENT(MODE) HAVE_POST_DECREMENT 2642 #endif 2643 2644 #ifndef USE_STORE_PRE_INCREMENT 2645 #define USE_STORE_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT 2646 #endif 2647 2648 #ifndef USE_STORE_PRE_DECREMENT 2649 #define USE_STORE_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT 2650 #endif 2651 2652 /* Nonzero when we are generating CONCATs. */ 2653 extern int generating_concat_p; 2654 2655 /* Nonzero when we are expanding trees to RTL. */ 2656 extern int currently_expanding_to_rtl; 2657 2658 /* Generally useful functions. */ 2659 2660 #ifndef GENERATOR_FILE 2661 /* Return the cost of SET X. SPEED_P is true if optimizing for speed 2662 rather than size. */ 2663 2664 static inline int 2665 set_rtx_cost (rtx x, bool speed_p) 2666 { 2667 return rtx_cost (x, VOIDmode, INSN, 4, speed_p); 2668 } 2669 2670 /* Like set_rtx_cost, but return both the speed and size costs in C. */ 2671 2672 static inline void 2673 get_full_set_rtx_cost (rtx x, struct full_rtx_costs *c) 2674 { 2675 get_full_rtx_cost (x, VOIDmode, INSN, 4, c); 2676 } 2677 2678 /* Return the cost of moving X into a register, relative to the cost 2679 of a register move. SPEED_P is true if optimizing for speed rather 2680 than size. */ 2681 2682 static inline int 2683 set_src_cost (rtx x, machine_mode mode, bool speed_p) 2684 { 2685 return rtx_cost (x, mode, SET, 1, speed_p); 2686 } 2687 2688 /* Like set_src_cost, but return both the speed and size costs in C. */ 2689 2690 static inline void 2691 get_full_set_src_cost (rtx x, machine_mode mode, struct full_rtx_costs *c) 2692 { 2693 get_full_rtx_cost (x, mode, SET, 1, c); 2694 } 2695 #endif 2696 2697 /* A convenience macro to validate the arguments of a zero_extract 2698 expression. It determines whether SIZE lies inclusively within 2699 [1, RANGE], POS lies inclusively within between [0, RANGE - 1] 2700 and the sum lies inclusively within [1, RANGE]. RANGE must be 2701 >= 1, but SIZE and POS may be negative. */ 2702 #define EXTRACT_ARGS_IN_RANGE(SIZE, POS, RANGE) \ 2703 (IN_RANGE ((POS), 0, (unsigned HOST_WIDE_INT) (RANGE) - 1) \ 2704 && IN_RANGE ((SIZE), 1, (unsigned HOST_WIDE_INT) (RANGE) \ 2705 - (unsigned HOST_WIDE_INT)(POS))) 2706 2707 /* In explow.c */ 2708 extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, machine_mode); 2709 extern rtx plus_constant (machine_mode, rtx, HOST_WIDE_INT, bool = false); 2710 2711 /* In rtl.c */ 2712 extern rtx rtx_alloc_stat (RTX_CODE MEM_STAT_DECL); 2713 #define rtx_alloc(c) rtx_alloc_stat (c MEM_STAT_INFO) 2714 extern rtx rtx_alloc_stat_v (RTX_CODE MEM_STAT_DECL, int); 2715 #define rtx_alloc_v(c, SZ) rtx_alloc_stat_v (c MEM_STAT_INFO, SZ) 2716 #define const_wide_int_alloc(NWORDS) \ 2717 rtx_alloc_v (CONST_WIDE_INT, \ 2718 (sizeof (struct hwivec_def) \ 2719 + ((NWORDS)-1) * sizeof (HOST_WIDE_INT))) \ 2720 2721 extern rtvec rtvec_alloc (int); 2722 extern rtvec shallow_copy_rtvec (rtvec); 2723 extern bool shared_const_p (const_rtx); 2724 extern rtx copy_rtx (rtx); 2725 extern enum rtx_code classify_insn (rtx); 2726 extern void dump_rtx_statistics (void); 2727 2728 /* In emit-rtl.c */ 2729 extern rtx copy_rtx_if_shared (rtx); 2730 2731 /* In rtl.c */ 2732 extern unsigned int rtx_size (const_rtx); 2733 extern rtx shallow_copy_rtx_stat (const_rtx MEM_STAT_DECL); 2734 #define shallow_copy_rtx(a) shallow_copy_rtx_stat (a MEM_STAT_INFO) 2735 extern int rtx_equal_p (const_rtx, const_rtx); 2736 extern bool rtvec_all_equal_p (const_rtvec); 2737 2738 /* Return true if X is a vector constant with a duplicated element value. */ 2739 2740 inline bool 2741 const_vec_duplicate_p (const_rtx x) 2742 { 2743 return GET_CODE (x) == CONST_VECTOR && rtvec_all_equal_p (XVEC (x, 0)); 2744 } 2745 2746 /* Return true if X is a vector constant with a duplicated element value. 2747 Store the duplicated element in *ELT if so. */ 2748 2749 template <typename T> 2750 inline bool 2751 const_vec_duplicate_p (T x, T *elt) 2752 { 2753 if (const_vec_duplicate_p (x)) 2754 { 2755 *elt = CONST_VECTOR_ELT (x, 0); 2756 return true; 2757 } 2758 return false; 2759 } 2760 2761 /* If X is a vector constant with a duplicated element value, return that 2762 element value, otherwise return X. */ 2763 2764 template <typename T> 2765 inline T 2766 unwrap_const_vec_duplicate (T x) 2767 { 2768 if (const_vec_duplicate_p (x)) 2769 x = CONST_VECTOR_ELT (x, 0); 2770 return x; 2771 } 2772 2773 /* In emit-rtl.c */ 2774 extern rtvec gen_rtvec_v (int, rtx *); 2775 extern rtvec gen_rtvec_v (int, rtx_insn **); 2776 extern rtx gen_reg_rtx (machine_mode); 2777 extern rtx gen_rtx_REG_offset (rtx, machine_mode, unsigned int, int); 2778 extern rtx gen_reg_rtx_offset (rtx, machine_mode, int); 2779 extern rtx gen_reg_rtx_and_attrs (rtx); 2780 extern rtx_code_label *gen_label_rtx (void); 2781 extern rtx gen_lowpart_common (machine_mode, rtx); 2782 2783 /* In cse.c */ 2784 extern rtx gen_lowpart_if_possible (machine_mode, rtx); 2785 2786 /* In emit-rtl.c */ 2787 extern rtx gen_highpart (machine_mode, rtx); 2788 extern rtx gen_highpart_mode (machine_mode, machine_mode, rtx); 2789 extern rtx operand_subword (rtx, unsigned int, int, machine_mode); 2790 2791 /* In emit-rtl.c */ 2792 extern rtx operand_subword_force (rtx, unsigned int, machine_mode); 2793 extern bool paradoxical_subreg_p (const_rtx); 2794 extern int subreg_lowpart_p (const_rtx); 2795 extern unsigned int subreg_size_lowpart_offset (unsigned int, unsigned int); 2796 2797 /* Return the SUBREG_BYTE for an OUTERMODE lowpart of an INNERMODE value. */ 2798 2799 inline unsigned int 2800 subreg_lowpart_offset (machine_mode outermode, machine_mode innermode) 2801 { 2802 return subreg_size_lowpart_offset (GET_MODE_SIZE (outermode), 2803 GET_MODE_SIZE (innermode)); 2804 } 2805 2806 extern unsigned int subreg_size_highpart_offset (unsigned int, unsigned int); 2807 2808 /* Return the SUBREG_BYTE for an OUTERMODE highpart of an INNERMODE value. */ 2809 2810 inline unsigned int 2811 subreg_highpart_offset (machine_mode outermode, machine_mode innermode) 2812 { 2813 return subreg_size_highpart_offset (GET_MODE_SIZE (outermode), 2814 GET_MODE_SIZE (innermode)); 2815 } 2816 2817 extern int byte_lowpart_offset (machine_mode, machine_mode); 2818 extern rtx make_safe_from (rtx, rtx); 2819 extern rtx convert_memory_address_addr_space_1 (machine_mode, rtx, 2820 addr_space_t, bool, bool); 2821 extern rtx convert_memory_address_addr_space (machine_mode, rtx, 2822 addr_space_t); 2823 #define convert_memory_address(to_mode,x) \ 2824 convert_memory_address_addr_space ((to_mode), (x), ADDR_SPACE_GENERIC) 2825 extern const char *get_insn_name (int); 2826 extern rtx_insn *get_last_insn_anywhere (void); 2827 extern rtx_insn *get_first_nonnote_insn (void); 2828 extern rtx_insn *get_last_nonnote_insn (void); 2829 extern void start_sequence (void); 2830 extern void push_to_sequence (rtx_insn *); 2831 extern void push_to_sequence2 (rtx_insn *, rtx_insn *); 2832 extern void end_sequence (void); 2833 #if TARGET_SUPPORTS_WIDE_INT == 0 2834 extern double_int rtx_to_double_int (const_rtx); 2835 #endif 2836 extern void cwi_output_hex (FILE *, const_rtx); 2837 #ifndef GENERATOR_FILE 2838 extern rtx immed_wide_int_const (const wide_int_ref &, machine_mode); 2839 #endif 2840 #if TARGET_SUPPORTS_WIDE_INT == 0 2841 extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT, 2842 machine_mode); 2843 #endif 2844 2845 /* In varasm.c */ 2846 extern rtx force_const_mem (machine_mode, rtx); 2847 2848 /* In varasm.c */ 2849 2850 struct function; 2851 extern rtx get_pool_constant (const_rtx); 2852 extern rtx get_pool_constant_mark (rtx, bool *); 2853 extern machine_mode get_pool_mode (const_rtx); 2854 extern rtx simplify_subtraction (rtx); 2855 extern void decide_function_section (tree); 2856 2857 /* In emit-rtl.c */ 2858 extern rtx_insn *emit_insn_before (rtx, rtx); 2859 extern rtx_insn *emit_insn_before_noloc (rtx, rtx_insn *, basic_block); 2860 extern rtx_insn *emit_insn_before_setloc (rtx, rtx_insn *, int); 2861 extern rtx_jump_insn *emit_jump_insn_before (rtx, rtx); 2862 extern rtx_jump_insn *emit_jump_insn_before_noloc (rtx, rtx_insn *); 2863 extern rtx_jump_insn *emit_jump_insn_before_setloc (rtx, rtx_insn *, int); 2864 extern rtx_insn *emit_call_insn_before (rtx, rtx_insn *); 2865 extern rtx_insn *emit_call_insn_before_noloc (rtx, rtx_insn *); 2866 extern rtx_insn *emit_call_insn_before_setloc (rtx, rtx_insn *, int); 2867 extern rtx_insn *emit_debug_insn_before (rtx, rtx_insn *); 2868 extern rtx_insn *emit_debug_insn_before_noloc (rtx, rtx); 2869 extern rtx_insn *emit_debug_insn_before_setloc (rtx, rtx, int); 2870 extern rtx_barrier *emit_barrier_before (rtx); 2871 extern rtx_code_label *emit_label_before (rtx, rtx_insn *); 2872 extern rtx_note *emit_note_before (enum insn_note, rtx_insn *); 2873 extern rtx_insn *emit_insn_after (rtx, rtx); 2874 extern rtx_insn *emit_insn_after_noloc (rtx, rtx, basic_block); 2875 extern rtx_insn *emit_insn_after_setloc (rtx, rtx, int); 2876 extern rtx_jump_insn *emit_jump_insn_after (rtx, rtx); 2877 extern rtx_jump_insn *emit_jump_insn_after_noloc (rtx, rtx); 2878 extern rtx_jump_insn *emit_jump_insn_after_setloc (rtx, rtx, int); 2879 extern rtx_insn *emit_call_insn_after (rtx, rtx); 2880 extern rtx_insn *emit_call_insn_after_noloc (rtx, rtx); 2881 extern rtx_insn *emit_call_insn_after_setloc (rtx, rtx, int); 2882 extern rtx_insn *emit_debug_insn_after (rtx, rtx); 2883 extern rtx_insn *emit_debug_insn_after_noloc (rtx, rtx); 2884 extern rtx_insn *emit_debug_insn_after_setloc (rtx, rtx, int); 2885 extern rtx_barrier *emit_barrier_after (rtx); 2886 extern rtx_insn *emit_label_after (rtx, rtx_insn *); 2887 extern rtx_note *emit_note_after (enum insn_note, rtx_insn *); 2888 extern rtx_insn *emit_insn (rtx); 2889 extern rtx_insn *emit_debug_insn (rtx); 2890 extern rtx_insn *emit_jump_insn (rtx); 2891 extern rtx_insn *emit_call_insn (rtx); 2892 extern rtx_code_label *emit_label (rtx); 2893 extern rtx_jump_table_data *emit_jump_table_data (rtx); 2894 extern rtx_barrier *emit_barrier (void); 2895 extern rtx_note *emit_note (enum insn_note); 2896 extern rtx_note *emit_note_copy (rtx_note *); 2897 extern rtx_insn *gen_clobber (rtx); 2898 extern rtx_insn *emit_clobber (rtx); 2899 extern rtx_insn *gen_use (rtx); 2900 extern rtx_insn *emit_use (rtx); 2901 extern rtx_insn *make_insn_raw (rtx); 2902 extern void add_function_usage_to (rtx, rtx); 2903 extern rtx_call_insn *last_call_insn (void); 2904 extern rtx_insn *previous_insn (rtx_insn *); 2905 extern rtx_insn *next_insn (rtx_insn *); 2906 extern rtx_insn *prev_nonnote_insn (rtx_insn *); 2907 extern rtx_insn *prev_nonnote_insn_bb (rtx_insn *); 2908 extern rtx_insn *next_nonnote_insn (rtx_insn *); 2909 extern rtx_insn *next_nonnote_insn_bb (rtx_insn *); 2910 extern rtx_insn *prev_nondebug_insn (rtx_insn *); 2911 extern rtx_insn *next_nondebug_insn (rtx_insn *); 2912 extern rtx_insn *prev_nonnote_nondebug_insn (rtx_insn *); 2913 extern rtx_insn *next_nonnote_nondebug_insn (rtx_insn *); 2914 extern rtx_insn *prev_real_insn (rtx_insn *); 2915 extern rtx_insn *next_real_insn (rtx); 2916 extern rtx_insn *prev_active_insn (rtx_insn *); 2917 extern rtx_insn *next_active_insn (rtx_insn *); 2918 extern int active_insn_p (const rtx_insn *); 2919 extern rtx_insn *next_cc0_user (rtx_insn *); 2920 extern rtx_insn *prev_cc0_setter (rtx_insn *); 2921 2922 /* In emit-rtl.c */ 2923 extern int insn_line (const rtx_insn *); 2924 extern const char * insn_file (const rtx_insn *); 2925 extern tree insn_scope (const rtx_insn *); 2926 extern expanded_location insn_location (const rtx_insn *); 2927 extern location_t prologue_location, epilogue_location; 2928 2929 /* In jump.c */ 2930 extern enum rtx_code reverse_condition (enum rtx_code); 2931 extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code); 2932 extern enum rtx_code swap_condition (enum rtx_code); 2933 extern enum rtx_code unsigned_condition (enum rtx_code); 2934 extern enum rtx_code signed_condition (enum rtx_code); 2935 extern void mark_jump_label (rtx, rtx_insn *, int); 2936 2937 /* In jump.c */ 2938 extern rtx_insn *delete_related_insns (rtx); 2939 2940 /* In recog.c */ 2941 extern rtx *find_constant_term_loc (rtx *); 2942 2943 /* In emit-rtl.c */ 2944 extern rtx_insn *try_split (rtx, rtx_insn *, int); 2945 extern int split_branch_probability; 2946 2947 /* In insn-recog.c (generated by genrecog). */ 2948 extern rtx_insn *split_insns (rtx, rtx_insn *); 2949 2950 /* In simplify-rtx.c */ 2951 extern rtx simplify_const_unary_operation (enum rtx_code, machine_mode, 2952 rtx, machine_mode); 2953 extern rtx simplify_unary_operation (enum rtx_code, machine_mode, rtx, 2954 machine_mode); 2955 extern rtx simplify_const_binary_operation (enum rtx_code, machine_mode, 2956 rtx, rtx); 2957 extern rtx simplify_binary_operation (enum rtx_code, machine_mode, rtx, 2958 rtx); 2959 extern rtx simplify_ternary_operation (enum rtx_code, machine_mode, 2960 machine_mode, rtx, rtx, rtx); 2961 extern rtx simplify_const_relational_operation (enum rtx_code, 2962 machine_mode, rtx, rtx); 2963 extern rtx simplify_relational_operation (enum rtx_code, machine_mode, 2964 machine_mode, rtx, rtx); 2965 extern rtx simplify_gen_binary (enum rtx_code, machine_mode, rtx, rtx); 2966 extern rtx simplify_gen_unary (enum rtx_code, machine_mode, rtx, 2967 machine_mode); 2968 extern rtx simplify_gen_ternary (enum rtx_code, machine_mode, 2969 machine_mode, rtx, rtx, rtx); 2970 extern rtx simplify_gen_relational (enum rtx_code, machine_mode, 2971 machine_mode, rtx, rtx); 2972 extern rtx simplify_subreg (machine_mode, rtx, machine_mode, 2973 unsigned int); 2974 extern rtx simplify_gen_subreg (machine_mode, rtx, machine_mode, 2975 unsigned int); 2976 extern rtx lowpart_subreg (machine_mode, rtx, machine_mode); 2977 extern rtx simplify_replace_fn_rtx (rtx, const_rtx, 2978 rtx (*fn) (rtx, const_rtx, void *), void *); 2979 extern rtx simplify_replace_rtx (rtx, const_rtx, rtx); 2980 extern rtx simplify_rtx (const_rtx); 2981 extern rtx avoid_constant_pool_reference (rtx); 2982 extern rtx delegitimize_mem_from_attrs (rtx); 2983 extern bool mode_signbit_p (machine_mode, const_rtx); 2984 extern bool val_signbit_p (machine_mode, unsigned HOST_WIDE_INT); 2985 extern bool val_signbit_known_set_p (machine_mode, 2986 unsigned HOST_WIDE_INT); 2987 extern bool val_signbit_known_clear_p (machine_mode, 2988 unsigned HOST_WIDE_INT); 2989 2990 /* In reginfo.c */ 2991 extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int, 2992 bool); 2993 extern const HARD_REG_SET &simplifiable_subregs (const subreg_shape &); 2994 2995 /* In emit-rtl.c */ 2996 extern rtx set_for_reg_notes (rtx); 2997 extern rtx set_unique_reg_note (rtx, enum reg_note, rtx); 2998 extern rtx set_dst_reg_note (rtx, enum reg_note, rtx, rtx); 2999 extern void set_insn_deleted (rtx); 3000 3001 /* Functions in rtlanal.c */ 3002 3003 extern rtx single_set_2 (const rtx_insn *, const_rtx); 3004 extern bool contains_symbol_ref_p (const_rtx); 3005 extern bool contains_symbolic_reference_p (const_rtx); 3006 3007 /* Handle the cheap and common cases inline for performance. */ 3008 3009 inline rtx single_set (const rtx_insn *insn) 3010 { 3011 if (!INSN_P (insn)) 3012 return NULL_RTX; 3013 3014 if (GET_CODE (PATTERN (insn)) == SET) 3015 return PATTERN (insn); 3016 3017 /* Defer to the more expensive case. */ 3018 return single_set_2 (insn, PATTERN (insn)); 3019 } 3020 3021 extern machine_mode get_address_mode (rtx mem); 3022 extern int rtx_addr_can_trap_p (const_rtx); 3023 extern bool nonzero_address_p (const_rtx); 3024 extern int rtx_unstable_p (const_rtx); 3025 extern bool rtx_varies_p (const_rtx, bool); 3026 extern bool rtx_addr_varies_p (const_rtx, bool); 3027 extern rtx get_call_rtx_from (rtx); 3028 extern HOST_WIDE_INT get_integer_term (const_rtx); 3029 extern rtx get_related_value (const_rtx); 3030 extern bool offset_within_block_p (const_rtx, HOST_WIDE_INT); 3031 extern void split_const (rtx, rtx *, rtx *); 3032 extern bool unsigned_reg_p (rtx); 3033 extern int reg_mentioned_p (const_rtx, const_rtx); 3034 extern int count_occurrences (const_rtx, const_rtx, int); 3035 extern int reg_referenced_p (const_rtx, const_rtx); 3036 extern int reg_used_between_p (const_rtx, const rtx_insn *, const rtx_insn *); 3037 extern int reg_set_between_p (const_rtx, const rtx_insn *, const rtx_insn *); 3038 extern int commutative_operand_precedence (rtx); 3039 extern bool swap_commutative_operands_p (rtx, rtx); 3040 extern int modified_between_p (const_rtx, const rtx_insn *, const rtx_insn *); 3041 extern int no_labels_between_p (const rtx_insn *, const rtx_insn *); 3042 extern int modified_in_p (const_rtx, const_rtx); 3043 extern int reg_set_p (const_rtx, const_rtx); 3044 extern int multiple_sets (const_rtx); 3045 extern int set_noop_p (const_rtx); 3046 extern int noop_move_p (const rtx_insn *); 3047 extern bool refers_to_regno_p (unsigned int, unsigned int, const_rtx, rtx *); 3048 extern int reg_overlap_mentioned_p (const_rtx, const_rtx); 3049 extern const_rtx set_of (const_rtx, const_rtx); 3050 extern void record_hard_reg_sets (rtx, const_rtx, void *); 3051 extern void record_hard_reg_uses (rtx *, void *); 3052 extern void find_all_hard_regs (const_rtx, HARD_REG_SET *); 3053 extern void find_all_hard_reg_sets (const rtx_insn *, HARD_REG_SET *, bool); 3054 extern void note_stores (const_rtx, void (*) (rtx, const_rtx, void *), void *); 3055 extern void note_uses (rtx *, void (*) (rtx *, void *), void *); 3056 extern int dead_or_set_p (const rtx_insn *, const_rtx); 3057 extern int dead_or_set_regno_p (const rtx_insn *, unsigned int); 3058 extern rtx find_reg_note (const_rtx, enum reg_note, const_rtx); 3059 extern rtx find_regno_note (const_rtx, enum reg_note, unsigned int); 3060 extern rtx find_reg_equal_equiv_note (const_rtx); 3061 extern rtx find_constant_src (const rtx_insn *); 3062 extern int find_reg_fusage (const_rtx, enum rtx_code, const_rtx); 3063 extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int); 3064 extern rtx alloc_reg_note (enum reg_note, rtx, rtx); 3065 extern void add_reg_note (rtx, enum reg_note, rtx); 3066 extern void add_int_reg_note (rtx_insn *, enum reg_note, int); 3067 extern void add_shallow_copy_of_reg_note (rtx_insn *, rtx); 3068 extern rtx duplicate_reg_note (rtx); 3069 extern void remove_note (rtx_insn *, const_rtx); 3070 extern bool remove_reg_equal_equiv_notes (rtx_insn *); 3071 extern void remove_reg_equal_equiv_notes_for_regno (unsigned int); 3072 extern int side_effects_p (const_rtx); 3073 extern int volatile_refs_p (const_rtx); 3074 extern int volatile_insn_p (const_rtx); 3075 extern int may_trap_p_1 (const_rtx, unsigned); 3076 extern int may_trap_p (const_rtx); 3077 extern int may_trap_or_fault_p (const_rtx); 3078 extern bool can_throw_internal (const_rtx); 3079 extern bool can_throw_external (const_rtx); 3080 extern bool insn_could_throw_p (const_rtx); 3081 extern bool insn_nothrow_p (const_rtx); 3082 extern bool can_nonlocal_goto (const rtx_insn *); 3083 extern void copy_reg_eh_region_note_forward (rtx, rtx_insn *, rtx); 3084 extern void copy_reg_eh_region_note_backward (rtx, rtx_insn *, rtx); 3085 extern int inequality_comparisons_p (const_rtx); 3086 extern rtx replace_rtx (rtx, rtx, rtx, bool = false); 3087 extern void replace_label (rtx *, rtx, rtx, bool); 3088 extern void replace_label_in_insn (rtx_insn *, rtx_insn *, rtx_insn *, bool); 3089 extern bool rtx_referenced_p (const_rtx, const_rtx); 3090 extern bool tablejump_p (const rtx_insn *, rtx_insn **, rtx_jump_table_data **); 3091 extern int computed_jump_p (const rtx_insn *); 3092 extern bool tls_referenced_p (const_rtx); 3093 extern bool contains_mem_rtx_p (rtx x); 3094 3095 /* Overload for refers_to_regno_p for checking a single register. */ 3096 inline bool 3097 refers_to_regno_p (unsigned int regnum, const_rtx x, rtx* loc = NULL) 3098 { 3099 return refers_to_regno_p (regnum, regnum + 1, x, loc); 3100 } 3101 3102 /* Callback for for_each_inc_dec, to process the autoinc operation OP 3103 within MEM that sets DEST to SRC + SRCOFF, or SRC if SRCOFF is 3104 NULL. The callback is passed the same opaque ARG passed to 3105 for_each_inc_dec. Return zero to continue looking for other 3106 autoinc operations or any other value to interrupt the traversal and 3107 return that value to the caller of for_each_inc_dec. */ 3108 typedef int (*for_each_inc_dec_fn) (rtx mem, rtx op, rtx dest, rtx src, 3109 rtx srcoff, void *arg); 3110 extern int for_each_inc_dec (rtx, for_each_inc_dec_fn, void *arg); 3111 3112 typedef int (*rtx_equal_p_callback_function) (const_rtx *, const_rtx *, 3113 rtx *, rtx *); 3114 extern int rtx_equal_p_cb (const_rtx, const_rtx, 3115 rtx_equal_p_callback_function); 3116 3117 typedef int (*hash_rtx_callback_function) (const_rtx, machine_mode, rtx *, 3118 machine_mode *); 3119 extern unsigned hash_rtx_cb (const_rtx, machine_mode, int *, int *, 3120 bool, hash_rtx_callback_function); 3121 3122 extern rtx regno_use_in (unsigned int, rtx); 3123 extern int auto_inc_p (const_rtx); 3124 extern bool in_insn_list_p (const rtx_insn_list *, const rtx_insn *); 3125 extern void remove_node_from_expr_list (const_rtx, rtx_expr_list **); 3126 extern void remove_node_from_insn_list (const rtx_insn *, rtx_insn_list **); 3127 extern int loc_mentioned_in_p (rtx *, const_rtx); 3128 extern rtx_insn *find_first_parameter_load (rtx_insn *, rtx_insn *); 3129 extern bool keep_with_call_p (const rtx_insn *); 3130 extern bool label_is_jump_target_p (const_rtx, const rtx_insn *); 3131 extern int insn_rtx_cost (rtx, bool); 3132 extern unsigned seq_cost (const rtx_insn *, bool); 3133 3134 /* Given an insn and condition, return a canonical description of 3135 the test being made. */ 3136 extern rtx canonicalize_condition (rtx_insn *, rtx, int, rtx_insn **, rtx, 3137 int, int); 3138 3139 /* Given a JUMP_INSN, return a canonical description of the test 3140 being made. */ 3141 extern rtx get_condition (rtx_insn *, rtx_insn **, int, int); 3142 3143 /* Information about a subreg of a hard register. */ 3144 struct subreg_info 3145 { 3146 /* Offset of first hard register involved in the subreg. */ 3147 int offset; 3148 /* Number of hard registers involved in the subreg. In the case of 3149 a paradoxical subreg, this is the number of registers that would 3150 be modified by writing to the subreg; some of them may be don't-care 3151 when reading from the subreg. */ 3152 int nregs; 3153 /* Whether this subreg can be represented as a hard reg with the new 3154 mode (by adding OFFSET to the original hard register). */ 3155 bool representable_p; 3156 }; 3157 3158 extern void subreg_get_info (unsigned int, machine_mode, 3159 unsigned int, machine_mode, 3160 struct subreg_info *); 3161 3162 /* lists.c */ 3163 3164 extern void free_EXPR_LIST_list (rtx_expr_list **); 3165 extern void free_INSN_LIST_list (rtx_insn_list **); 3166 extern void free_EXPR_LIST_node (rtx); 3167 extern void free_INSN_LIST_node (rtx); 3168 extern rtx_insn_list *alloc_INSN_LIST (rtx, rtx); 3169 extern rtx_insn_list *copy_INSN_LIST (rtx_insn_list *); 3170 extern rtx_insn_list *concat_INSN_LIST (rtx_insn_list *, rtx_insn_list *); 3171 extern rtx_expr_list *alloc_EXPR_LIST (int, rtx, rtx); 3172 extern void remove_free_INSN_LIST_elem (rtx_insn *, rtx_insn_list **); 3173 extern rtx remove_list_elem (rtx, rtx *); 3174 extern rtx_insn *remove_free_INSN_LIST_node (rtx_insn_list **); 3175 extern rtx remove_free_EXPR_LIST_node (rtx_expr_list **); 3176 3177 3178 /* reginfo.c */ 3179 3180 /* Resize reg info. */ 3181 extern bool resize_reg_info (void); 3182 /* Free up register info memory. */ 3183 extern void free_reg_info (void); 3184 extern void init_subregs_of_mode (void); 3185 extern void finish_subregs_of_mode (void); 3186 3187 /* recog.c */ 3188 extern rtx extract_asm_operands (rtx); 3189 extern int asm_noperands (const_rtx); 3190 extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **, 3191 machine_mode *, location_t *); 3192 extern void get_referenced_operands (const char *, bool *, unsigned int); 3193 3194 extern enum reg_class reg_preferred_class (int); 3195 extern enum reg_class reg_alternate_class (int); 3196 extern enum reg_class reg_allocno_class (int); 3197 extern void setup_reg_classes (int, enum reg_class, enum reg_class, 3198 enum reg_class); 3199 3200 extern void split_all_insns (void); 3201 extern unsigned int split_all_insns_noflow (void); 3202 3203 #define MAX_SAVED_CONST_INT 64 3204 extern GTY(()) rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1]; 3205 3206 #define const0_rtx (const_int_rtx[MAX_SAVED_CONST_INT]) 3207 #define const1_rtx (const_int_rtx[MAX_SAVED_CONST_INT+1]) 3208 #define const2_rtx (const_int_rtx[MAX_SAVED_CONST_INT+2]) 3209 #define constm1_rtx (const_int_rtx[MAX_SAVED_CONST_INT-1]) 3210 extern GTY(()) rtx const_true_rtx; 3211 3212 extern GTY(()) rtx const_tiny_rtx[4][(int) MAX_MACHINE_MODE]; 3213 3214 /* Returns a constant 0 rtx in mode MODE. Integer modes are treated the 3215 same as VOIDmode. */ 3216 3217 #define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)]) 3218 3219 /* Likewise, for the constants 1 and 2 and -1. */ 3220 3221 #define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)]) 3222 #define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)]) 3223 #define CONSTM1_RTX(MODE) (const_tiny_rtx[3][(int) (MODE)]) 3224 3225 extern GTY(()) rtx pc_rtx; 3226 extern GTY(()) rtx cc0_rtx; 3227 extern GTY(()) rtx ret_rtx; 3228 extern GTY(()) rtx simple_return_rtx; 3229 extern GTY(()) rtx_insn *invalid_insn_rtx; 3230 3231 /* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg 3232 is used to represent the frame pointer. This is because the 3233 hard frame pointer and the automatic variables are separated by an amount 3234 that cannot be determined until after register allocation. We can assume 3235 that in this case ELIMINABLE_REGS will be defined, one action of which 3236 will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */ 3237 #ifndef HARD_FRAME_POINTER_REGNUM 3238 #define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM 3239 #endif 3240 3241 #ifndef HARD_FRAME_POINTER_IS_FRAME_POINTER 3242 #define HARD_FRAME_POINTER_IS_FRAME_POINTER \ 3243 (HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM) 3244 #endif 3245 3246 #ifndef HARD_FRAME_POINTER_IS_ARG_POINTER 3247 #define HARD_FRAME_POINTER_IS_ARG_POINTER \ 3248 (HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM) 3249 #endif 3250 3251 /* Index labels for global_rtl. */ 3252 enum global_rtl_index 3253 { 3254 GR_STACK_POINTER, 3255 GR_FRAME_POINTER, 3256 /* For register elimination to work properly these hard_frame_pointer_rtx, 3257 frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to 3258 the same register. */ 3259 #if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM 3260 GR_ARG_POINTER = GR_FRAME_POINTER, 3261 #endif 3262 #if HARD_FRAME_POINTER_IS_FRAME_POINTER 3263 GR_HARD_FRAME_POINTER = GR_FRAME_POINTER, 3264 #else 3265 GR_HARD_FRAME_POINTER, 3266 #endif 3267 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM 3268 #if HARD_FRAME_POINTER_IS_ARG_POINTER 3269 GR_ARG_POINTER = GR_HARD_FRAME_POINTER, 3270 #else 3271 GR_ARG_POINTER, 3272 #endif 3273 #endif 3274 GR_VIRTUAL_INCOMING_ARGS, 3275 GR_VIRTUAL_STACK_ARGS, 3276 GR_VIRTUAL_STACK_DYNAMIC, 3277 GR_VIRTUAL_OUTGOING_ARGS, 3278 GR_VIRTUAL_CFA, 3279 GR_VIRTUAL_PREFERRED_STACK_BOUNDARY, 3280 3281 GR_MAX 3282 }; 3283 3284 /* Target-dependent globals. */ 3285 struct GTY(()) target_rtl { 3286 /* All references to the hard registers in global_rtl_index go through 3287 these unique rtl objects. On machines where the frame-pointer and 3288 arg-pointer are the same register, they use the same unique object. 3289 3290 After register allocation, other rtl objects which used to be pseudo-regs 3291 may be clobbered to refer to the frame-pointer register. 3292 But references that were originally to the frame-pointer can be 3293 distinguished from the others because they contain frame_pointer_rtx. 3294 3295 When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little 3296 tricky: until register elimination has taken place hard_frame_pointer_rtx 3297 should be used if it is being set, and frame_pointer_rtx otherwise. After 3298 register elimination hard_frame_pointer_rtx should always be used. 3299 On machines where the two registers are same (most) then these are the 3300 same. */ 3301 rtx x_global_rtl[GR_MAX]; 3302 3303 /* A unique representation of (REG:Pmode PIC_OFFSET_TABLE_REGNUM). */ 3304 rtx x_pic_offset_table_rtx; 3305 3306 /* A unique representation of (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM). 3307 This is used to implement __builtin_return_address for some machines; 3308 see for instance the MIPS port. */ 3309 rtx x_return_address_pointer_rtx; 3310 3311 /* Commonly used RTL for hard registers. These objects are not 3312 necessarily unique, so we allocate them separately from global_rtl. 3313 They are initialized once per compilation unit, then copied into 3314 regno_reg_rtx at the beginning of each function. */ 3315 rtx x_initial_regno_reg_rtx[FIRST_PSEUDO_REGISTER]; 3316 3317 /* A sample (mem:M stack_pointer_rtx) rtx for each mode M. */ 3318 rtx x_top_of_stack[MAX_MACHINE_MODE]; 3319 3320 /* Static hunks of RTL used by the aliasing code; these are treated 3321 as persistent to avoid unnecessary RTL allocations. */ 3322 rtx x_static_reg_base_value[FIRST_PSEUDO_REGISTER]; 3323 3324 /* The default memory attributes for each mode. */ 3325 struct mem_attrs *x_mode_mem_attrs[(int) MAX_MACHINE_MODE]; 3326 3327 /* Track if RTL has been initialized. */ 3328 bool target_specific_initialized; 3329 }; 3330 3331 extern GTY(()) struct target_rtl default_target_rtl; 3332 #if SWITCHABLE_TARGET 3333 extern struct target_rtl *this_target_rtl; 3334 #else 3335 #define this_target_rtl (&default_target_rtl) 3336 #endif 3337 3338 #define global_rtl \ 3339 (this_target_rtl->x_global_rtl) 3340 #define pic_offset_table_rtx \ 3341 (this_target_rtl->x_pic_offset_table_rtx) 3342 #define return_address_pointer_rtx \ 3343 (this_target_rtl->x_return_address_pointer_rtx) 3344 #define top_of_stack \ 3345 (this_target_rtl->x_top_of_stack) 3346 #define mode_mem_attrs \ 3347 (this_target_rtl->x_mode_mem_attrs) 3348 3349 /* All references to certain hard regs, except those created 3350 by allocating pseudo regs into them (when that's possible), 3351 go through these unique rtx objects. */ 3352 #define stack_pointer_rtx (global_rtl[GR_STACK_POINTER]) 3353 #define frame_pointer_rtx (global_rtl[GR_FRAME_POINTER]) 3354 #define hard_frame_pointer_rtx (global_rtl[GR_HARD_FRAME_POINTER]) 3355 #define arg_pointer_rtx (global_rtl[GR_ARG_POINTER]) 3356 3357 #ifndef GENERATOR_FILE 3358 /* Return the attributes of a MEM rtx. */ 3359 static inline const struct mem_attrs * 3360 get_mem_attrs (const_rtx x) 3361 { 3362 struct mem_attrs *attrs; 3363 3364 attrs = MEM_ATTRS (x); 3365 if (!attrs) 3366 attrs = mode_mem_attrs[(int) GET_MODE (x)]; 3367 return attrs; 3368 } 3369 #endif 3370 3371 /* Include the RTL generation functions. */ 3372 3373 #ifndef GENERATOR_FILE 3374 #include "genrtl.h" 3375 #undef gen_rtx_ASM_INPUT 3376 #define gen_rtx_ASM_INPUT(MODE, ARG0) \ 3377 gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), 0) 3378 #define gen_rtx_ASM_INPUT_loc(MODE, ARG0, LOC) \ 3379 gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), (LOC)) 3380 #endif 3381 3382 /* There are some RTL codes that require special attention; the 3383 generation functions included above do the raw handling. If you 3384 add to this list, modify special_rtx in gengenrtl.c as well. */ 3385 3386 extern rtx_expr_list *gen_rtx_EXPR_LIST (machine_mode, rtx, rtx); 3387 extern rtx_insn_list *gen_rtx_INSN_LIST (machine_mode, rtx, rtx); 3388 extern rtx_insn * 3389 gen_rtx_INSN (machine_mode mode, rtx_insn *prev_insn, rtx_insn *next_insn, 3390 basic_block bb, rtx pattern, int location, int code, 3391 rtx reg_notes); 3392 extern rtx gen_rtx_CONST_INT (machine_mode, HOST_WIDE_INT); 3393 extern rtx gen_rtx_CONST_VECTOR (machine_mode, rtvec); 3394 extern void set_mode_and_regno (rtx, machine_mode, unsigned int); 3395 extern rtx gen_raw_REG (machine_mode, unsigned int); 3396 extern rtx gen_rtx_REG (machine_mode, unsigned int); 3397 extern rtx gen_rtx_SUBREG (machine_mode, rtx, int); 3398 extern rtx gen_rtx_MEM (machine_mode, rtx); 3399 extern rtx gen_rtx_VAR_LOCATION (machine_mode, tree, rtx, 3400 enum var_init_status); 3401 3402 #ifdef GENERATOR_FILE 3403 #define PUT_MODE(RTX, MODE) PUT_MODE_RAW (RTX, MODE) 3404 #else 3405 static inline void 3406 PUT_MODE (rtx x, machine_mode mode) 3407 { 3408 if (REG_P (x)) 3409 set_mode_and_regno (x, mode, REGNO (x)); 3410 else 3411 PUT_MODE_RAW (x, mode); 3412 } 3413 #endif 3414 3415 #define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (N)) 3416 3417 /* Virtual registers are used during RTL generation to refer to locations into 3418 the stack frame when the actual location isn't known until RTL generation 3419 is complete. The routine instantiate_virtual_regs replaces these with 3420 the proper value, which is normally {frame,arg,stack}_pointer_rtx plus 3421 a constant. */ 3422 3423 #define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER) 3424 3425 /* This points to the first word of the incoming arguments passed on the stack, 3426 either by the caller or by the callee when pretending it was passed by the 3427 caller. */ 3428 3429 #define virtual_incoming_args_rtx (global_rtl[GR_VIRTUAL_INCOMING_ARGS]) 3430 3431 #define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER) 3432 3433 /* If FRAME_GROWS_DOWNWARD, this points to immediately above the first 3434 variable on the stack. Otherwise, it points to the first variable on 3435 the stack. */ 3436 3437 #define virtual_stack_vars_rtx (global_rtl[GR_VIRTUAL_STACK_ARGS]) 3438 3439 #define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1) 3440 3441 /* This points to the location of dynamically-allocated memory on the stack 3442 immediately after the stack pointer has been adjusted by the amount 3443 desired. */ 3444 3445 #define virtual_stack_dynamic_rtx (global_rtl[GR_VIRTUAL_STACK_DYNAMIC]) 3446 3447 #define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2) 3448 3449 /* This points to the location in the stack at which outgoing arguments should 3450 be written when the stack is pre-pushed (arguments pushed using push 3451 insns always use sp). */ 3452 3453 #define virtual_outgoing_args_rtx (global_rtl[GR_VIRTUAL_OUTGOING_ARGS]) 3454 3455 #define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3) 3456 3457 /* This points to the Canonical Frame Address of the function. This 3458 should correspond to the CFA produced by INCOMING_FRAME_SP_OFFSET, 3459 but is calculated relative to the arg pointer for simplicity; the 3460 frame pointer nor stack pointer are necessarily fixed relative to 3461 the CFA until after reload. */ 3462 3463 #define virtual_cfa_rtx (global_rtl[GR_VIRTUAL_CFA]) 3464 3465 #define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4) 3466 3467 #define LAST_VIRTUAL_POINTER_REGISTER ((FIRST_VIRTUAL_REGISTER) + 4) 3468 3469 /* This is replaced by crtl->preferred_stack_boundary / BITS_PER_UNIT 3470 when finalized. */ 3471 3472 #define virtual_preferred_stack_boundary_rtx \ 3473 (global_rtl[GR_VIRTUAL_PREFERRED_STACK_BOUNDARY]) 3474 3475 #define VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM \ 3476 ((FIRST_VIRTUAL_REGISTER) + 5) 3477 3478 #define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 5) 3479 3480 /* Nonzero if REGNUM is a pointer into the stack frame. */ 3481 #define REGNO_PTR_FRAME_P(REGNUM) \ 3482 ((REGNUM) == STACK_POINTER_REGNUM \ 3483 || (REGNUM) == FRAME_POINTER_REGNUM \ 3484 || (REGNUM) == HARD_FRAME_POINTER_REGNUM \ 3485 || (REGNUM) == ARG_POINTER_REGNUM \ 3486 || ((REGNUM) >= FIRST_VIRTUAL_REGISTER \ 3487 && (REGNUM) <= LAST_VIRTUAL_POINTER_REGISTER)) 3488 3489 /* REGNUM never really appearing in the INSN stream. */ 3490 #define INVALID_REGNUM (~(unsigned int) 0) 3491 3492 /* REGNUM for which no debug information can be generated. */ 3493 #define IGNORED_DWARF_REGNUM (INVALID_REGNUM - 1) 3494 3495 extern rtx output_constant_def (tree, int); 3496 extern rtx lookup_constant_def (tree); 3497 3498 /* Nonzero after end of reload pass. 3499 Set to 1 or 0 by reload1.c. */ 3500 3501 extern int reload_completed; 3502 3503 /* Nonzero after thread_prologue_and_epilogue_insns has run. */ 3504 extern int epilogue_completed; 3505 3506 /* Set to 1 while reload_as_needed is operating. 3507 Required by some machines to handle any generated moves differently. */ 3508 3509 extern int reload_in_progress; 3510 3511 /* Set to 1 while in lra. */ 3512 extern int lra_in_progress; 3513 3514 /* This macro indicates whether you may create a new 3515 pseudo-register. */ 3516 3517 #define can_create_pseudo_p() (!reload_in_progress && !reload_completed) 3518 3519 #ifdef STACK_REGS 3520 /* Nonzero after end of regstack pass. 3521 Set to 1 or 0 by reg-stack.c. */ 3522 extern int regstack_completed; 3523 #endif 3524 3525 /* If this is nonzero, we do not bother generating VOLATILE 3526 around volatile memory references, and we are willing to 3527 output indirect addresses. If cse is to follow, we reject 3528 indirect addresses so a useful potential cse is generated; 3529 if it is used only once, instruction combination will produce 3530 the same indirect address eventually. */ 3531 extern int cse_not_expected; 3532 3533 /* Translates rtx code to tree code, for those codes needed by 3534 real_arithmetic. The function returns an int because the caller may not 3535 know what `enum tree_code' means. */ 3536 3537 extern int rtx_to_tree_code (enum rtx_code); 3538 3539 /* In cse.c */ 3540 extern int delete_trivially_dead_insns (rtx_insn *, int); 3541 extern int exp_equiv_p (const_rtx, const_rtx, int, bool); 3542 extern unsigned hash_rtx (const_rtx x, machine_mode, int *, int *, bool); 3543 3544 /* In dse.c */ 3545 extern bool check_for_inc_dec (rtx_insn *insn); 3546 3547 /* In jump.c */ 3548 extern int comparison_dominates_p (enum rtx_code, enum rtx_code); 3549 extern bool jump_to_label_p (const rtx_insn *); 3550 extern int condjump_p (const rtx_insn *); 3551 extern int any_condjump_p (const rtx_insn *); 3552 extern int any_uncondjump_p (const rtx_insn *); 3553 extern rtx pc_set (const rtx_insn *); 3554 extern rtx condjump_label (const rtx_insn *); 3555 extern int simplejump_p (const rtx_insn *); 3556 extern int returnjump_p (const rtx_insn *); 3557 extern int eh_returnjump_p (rtx_insn *); 3558 extern int onlyjump_p (const rtx_insn *); 3559 extern int only_sets_cc0_p (const_rtx); 3560 extern int sets_cc0_p (const_rtx); 3561 extern int invert_jump_1 (rtx_jump_insn *, rtx); 3562 extern int invert_jump (rtx_jump_insn *, rtx, int); 3563 extern int rtx_renumbered_equal_p (const_rtx, const_rtx); 3564 extern int true_regnum (const_rtx); 3565 extern unsigned int reg_or_subregno (const_rtx); 3566 extern int redirect_jump_1 (rtx_insn *, rtx); 3567 extern void redirect_jump_2 (rtx_jump_insn *, rtx, rtx, int, int); 3568 extern int redirect_jump (rtx_jump_insn *, rtx, int); 3569 extern void rebuild_jump_labels (rtx_insn *); 3570 extern void rebuild_jump_labels_chain (rtx_insn *); 3571 extern rtx reversed_comparison (const_rtx, machine_mode); 3572 extern enum rtx_code reversed_comparison_code (const_rtx, const rtx_insn *); 3573 extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, const_rtx, 3574 const_rtx, const rtx_insn *); 3575 extern void delete_for_peephole (rtx_insn *, rtx_insn *); 3576 extern int condjump_in_parallel_p (const rtx_insn *); 3577 3578 /* In emit-rtl.c. */ 3579 extern int max_reg_num (void); 3580 extern int max_label_num (void); 3581 extern int get_first_label_num (void); 3582 extern void maybe_set_first_label_num (rtx_code_label *); 3583 extern void delete_insns_since (rtx_insn *); 3584 extern void mark_reg_pointer (rtx, int); 3585 extern void mark_user_reg (rtx); 3586 extern void reset_used_flags (rtx); 3587 extern void set_used_flags (rtx); 3588 extern void reorder_insns (rtx_insn *, rtx_insn *, rtx_insn *); 3589 extern void reorder_insns_nobb (rtx_insn *, rtx_insn *, rtx_insn *); 3590 extern int get_max_insn_count (void); 3591 extern int in_sequence_p (void); 3592 extern void init_emit (void); 3593 extern void init_emit_regs (void); 3594 extern void init_derived_machine_modes (void); 3595 extern void init_emit_once (void); 3596 extern void push_topmost_sequence (void); 3597 extern void pop_topmost_sequence (void); 3598 extern void set_new_first_and_last_insn (rtx_insn *, rtx_insn *); 3599 extern unsigned int unshare_all_rtl (void); 3600 extern void unshare_all_rtl_again (rtx_insn *); 3601 extern void unshare_all_rtl_in_chain (rtx_insn *); 3602 extern void verify_rtl_sharing (void); 3603 extern void add_insn (rtx_insn *); 3604 extern void add_insn_before (rtx, rtx, basic_block); 3605 extern void add_insn_after (rtx, rtx, basic_block); 3606 extern void remove_insn (rtx); 3607 extern rtx_insn *emit (rtx, bool = true); 3608 extern void emit_insn_at_entry (rtx); 3609 extern rtx gen_lowpart_SUBREG (machine_mode, rtx); 3610 extern rtx gen_const_mem (machine_mode, rtx); 3611 extern rtx gen_frame_mem (machine_mode, rtx); 3612 extern rtx gen_tmp_stack_mem (machine_mode, rtx); 3613 extern bool validate_subreg (machine_mode, machine_mode, 3614 const_rtx, unsigned int); 3615 3616 /* In combine.c */ 3617 extern unsigned int extended_count (const_rtx, machine_mode, int); 3618 extern rtx remove_death (unsigned int, rtx_insn *); 3619 extern void dump_combine_stats (FILE *); 3620 extern void dump_combine_total_stats (FILE *); 3621 extern rtx make_compound_operation (rtx, enum rtx_code); 3622 3623 /* In sched-rgn.c. */ 3624 extern void schedule_insns (void); 3625 3626 /* In sched-ebb.c. */ 3627 extern void schedule_ebbs (void); 3628 3629 /* In sel-sched-dump.c. */ 3630 extern void sel_sched_fix_param (const char *param, const char *val); 3631 3632 /* In print-rtl.c */ 3633 extern const char *print_rtx_head; 3634 extern void debug (const rtx_def &ref); 3635 extern void debug (const rtx_def *ptr); 3636 extern void debug_rtx (const_rtx); 3637 extern void debug_rtx_list (const rtx_insn *, int); 3638 extern void debug_rtx_range (const rtx_insn *, const rtx_insn *); 3639 extern const rtx_insn *debug_rtx_find (const rtx_insn *, int); 3640 extern void print_mem_expr (FILE *, const_tree); 3641 extern void print_rtl (FILE *, const_rtx); 3642 extern void print_simple_rtl (FILE *, const_rtx); 3643 extern int print_rtl_single (FILE *, const_rtx); 3644 extern int print_rtl_single_with_indent (FILE *, const_rtx, int); 3645 extern void print_inline_rtx (FILE *, const_rtx, int); 3646 3647 /* In stmt.c */ 3648 extern void expand_null_return (void); 3649 extern void expand_naked_return (void); 3650 extern void emit_jump (rtx); 3651 3652 /* In expr.c */ 3653 extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT, 3654 unsigned int, int); 3655 extern HOST_WIDE_INT find_args_size_adjust (rtx_insn *); 3656 extern int fixup_args_size_notes (rtx_insn *, rtx_insn *, int); 3657 3658 /* In expmed.c */ 3659 extern void init_expmed (void); 3660 extern void expand_inc (rtx, rtx); 3661 extern void expand_dec (rtx, rtx); 3662 3663 /* In lower-subreg.c */ 3664 extern void init_lower_subreg (void); 3665 3666 /* In gcse.c */ 3667 extern bool can_copy_p (machine_mode); 3668 extern bool can_assign_to_reg_without_clobbers_p (rtx, machine_mode); 3669 extern rtx_insn *prepare_copy_insn (rtx, rtx); 3670 3671 /* In cprop.c */ 3672 extern rtx fis_get_condition (rtx_insn *); 3673 3674 /* In ira.c */ 3675 extern HARD_REG_SET eliminable_regset; 3676 extern void mark_elimination (int, int); 3677 3678 /* In reginfo.c */ 3679 extern int reg_classes_intersect_p (reg_class_t, reg_class_t); 3680 extern int reg_class_subset_p (reg_class_t, reg_class_t); 3681 extern void globalize_reg (tree, int); 3682 extern void init_reg_modes_target (void); 3683 extern void init_regs (void); 3684 extern void reinit_regs (void); 3685 extern void init_fake_stack_mems (void); 3686 extern void save_register_info (void); 3687 extern void init_reg_sets (void); 3688 extern void regclass (rtx, int); 3689 extern void reg_scan (rtx_insn *, unsigned int); 3690 extern void fix_register (const char *, int, int); 3691 extern const HARD_REG_SET *valid_mode_changes_for_regno (unsigned int); 3692 3693 /* In reload1.c */ 3694 extern int function_invariant_p (const_rtx); 3695 3696 /* In calls.c */ 3697 enum libcall_type 3698 { 3699 LCT_NORMAL = 0, 3700 LCT_CONST = 1, 3701 LCT_PURE = 2, 3702 LCT_NORETURN = 3, 3703 LCT_THROW = 4, 3704 LCT_RETURNS_TWICE = 5 3705 }; 3706 3707 extern void emit_library_call (rtx, enum libcall_type, machine_mode, int, 3708 ...); 3709 extern rtx emit_library_call_value (rtx, rtx, enum libcall_type, 3710 machine_mode, int, ...); 3711 3712 /* In varasm.c */ 3713 extern void init_varasm_once (void); 3714 3715 extern rtx make_debug_expr_from_rtl (const_rtx); 3716 3717 /* In read-rtl.c */ 3718 #ifdef GENERATOR_FILE 3719 extern bool read_rtx (const char *, vec<rtx> *); 3720 #endif 3721 3722 /* In alias.c */ 3723 extern rtx canon_rtx (rtx); 3724 extern int true_dependence (const_rtx, machine_mode, const_rtx); 3725 extern rtx get_addr (rtx); 3726 extern int canon_true_dependence (const_rtx, machine_mode, rtx, 3727 const_rtx, rtx); 3728 extern int read_dependence (const_rtx, const_rtx); 3729 extern int anti_dependence (const_rtx, const_rtx); 3730 extern int canon_anti_dependence (const_rtx, bool, 3731 const_rtx, machine_mode, rtx); 3732 extern int output_dependence (const_rtx, const_rtx); 3733 extern int canon_output_dependence (const_rtx, bool, 3734 const_rtx, machine_mode, rtx); 3735 extern int may_alias_p (const_rtx, const_rtx); 3736 extern void init_alias_target (void); 3737 extern void init_alias_analysis (void); 3738 extern void end_alias_analysis (void); 3739 extern void vt_equate_reg_base_value (const_rtx, const_rtx); 3740 extern bool memory_modified_in_insn_p (const_rtx, const_rtx); 3741 extern bool may_be_sp_based_p (rtx); 3742 extern rtx gen_hard_reg_clobber (machine_mode, unsigned int); 3743 extern rtx get_reg_known_value (unsigned int); 3744 extern bool get_reg_known_equiv_p (unsigned int); 3745 extern rtx get_reg_base_value (unsigned int); 3746 3747 #ifdef STACK_REGS 3748 extern int stack_regs_mentioned (const_rtx insn); 3749 #endif 3750 3751 /* In toplev.c */ 3752 extern GTY(()) rtx stack_limit_rtx; 3753 3754 /* In var-tracking.c */ 3755 extern unsigned int variable_tracking_main (void); 3756 3757 /* In stor-layout.c. */ 3758 extern void get_mode_bounds (machine_mode, int, machine_mode, 3759 rtx *, rtx *); 3760 3761 /* In loop-iv.c */ 3762 extern rtx canon_condition (rtx); 3763 extern void simplify_using_condition (rtx, rtx *, bitmap); 3764 3765 /* In final.c */ 3766 extern unsigned int compute_alignments (void); 3767 extern void update_alignments (vec<rtx> &); 3768 extern int asm_str_count (const char *templ); 3769 3770 struct rtl_hooks 3771 { 3772 rtx (*gen_lowpart) (machine_mode, rtx); 3773 rtx (*gen_lowpart_no_emit) (machine_mode, rtx); 3774 rtx (*reg_nonzero_bits) (const_rtx, machine_mode, const_rtx, machine_mode, 3775 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT *); 3776 rtx (*reg_num_sign_bit_copies) (const_rtx, machine_mode, const_rtx, machine_mode, 3777 unsigned int, unsigned int *); 3778 bool (*reg_truncated_to_mode) (machine_mode, const_rtx); 3779 3780 /* Whenever you add entries here, make sure you adjust rtlhooks-def.h. */ 3781 }; 3782 3783 /* Each pass can provide its own. */ 3784 extern struct rtl_hooks rtl_hooks; 3785 3786 /* ... but then it has to restore these. */ 3787 extern const struct rtl_hooks general_rtl_hooks; 3788 3789 /* Keep this for the nonce. */ 3790 #define gen_lowpart rtl_hooks.gen_lowpart 3791 3792 extern void insn_locations_init (void); 3793 extern void insn_locations_finalize (void); 3794 extern void set_curr_insn_location (location_t); 3795 extern location_t curr_insn_location (void); 3796 3797 /* rtl-error.c */ 3798 extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *) 3799 ATTRIBUTE_NORETURN; 3800 extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *) 3801 ATTRIBUTE_NORETURN; 3802 3803 #define fatal_insn(msgid, insn) \ 3804 _fatal_insn (msgid, insn, __FILE__, __LINE__, __FUNCTION__) 3805 #define fatal_insn_not_found(insn) \ 3806 _fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__) 3807 3808 /* reginfo.c */ 3809 extern tree GTY(()) global_regs_decl[FIRST_PSEUDO_REGISTER]; 3810 3811 /* Information about the function that is propagated by the RTL backend. 3812 Available only for functions that has been already assembled. */ 3813 3814 struct GTY(()) cgraph_rtl_info { 3815 unsigned int preferred_incoming_stack_boundary; 3816 3817 /* Call unsaved hard registers really used by the corresponding 3818 function (including ones used by functions called by the 3819 function). */ 3820 HARD_REG_SET function_used_regs; 3821 /* Set if function_used_regs is valid. */ 3822 unsigned function_used_regs_valid: 1; 3823 }; 3824 3825 /* If loads from memories of mode MODE always sign or zero extend, 3826 return SIGN_EXTEND or ZERO_EXTEND as appropriate. Return UNKNOWN 3827 otherwise. */ 3828 3829 inline rtx_code 3830 load_extend_op (machine_mode mode) 3831 { 3832 if (SCALAR_INT_MODE_P (mode) 3833 && GET_MODE_PRECISION (mode) < BITS_PER_WORD) 3834 return LOAD_EXTEND_OP (mode); 3835 return UNKNOWN; 3836 } 3837 3838 /* Return true if X is an operation that always operates on the full 3839 registers for WORD_REGISTER_OPERATIONS architectures. */ 3840 3841 inline bool 3842 word_register_operation_p (const_rtx x) 3843 { 3844 switch (GET_CODE (x)) 3845 { 3846 case ROTATE: 3847 case ROTATERT: 3848 case SIGN_EXTRACT: 3849 case ZERO_EXTRACT: 3850 return false; 3851 3852 default: 3853 return true; 3854 } 3855 } 3856 3857 /* gtype-desc.c. */ 3858 extern void gt_ggc_mx (rtx &); 3859 extern void gt_pch_nx (rtx &); 3860 extern void gt_pch_nx (rtx &, gt_pointer_operator, void *); 3861 3862 #endif /* ! GCC_RTL_H */ 3863