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