1 /* Procedure integration for GCC.
2 Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
34 #include "insn-config.h"
38 #include "integrate.h"
47 #include "langhooks.h"
49 /* Round to the next highest integer that meets the alignment. */
50 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
53 /* Private type used by {get/has}_func_hard_reg_initial_val. */
54 typedef struct initial_value_pair
GTY(()) {
58 typedef struct initial_value_struct
GTY(()) {
61 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
62 } initial_value_struct
;
64 static void subst_constants (rtx
*, rtx
, struct inline_remap
*, int);
65 static void set_block_origin_self (tree
);
66 static void set_block_abstract_flags (tree
, int);
67 static void mark_stores (rtx
, rtx
, void *);
69 /* Returns the Ith entry in the label_map contained in MAP. If the
70 Ith entry has not yet been set, return a fresh label. This function
71 performs a lazy initialization of label_map, thereby avoiding huge memory
72 explosions when the label_map gets very large. */
75 get_label_from_map (struct inline_remap
*map
, int i
)
77 rtx x
= map
->label_map
[i
];
80 x
= map
->label_map
[i
] = gen_label_rtx ();
85 /* Return false if the function FNDECL cannot be inlined on account of its
86 attributes, true otherwise. */
88 function_attribute_inlinable_p (tree fndecl
)
90 if (targetm
.attribute_table
)
94 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
96 tree name
= TREE_PURPOSE (a
);
99 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
100 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
101 return targetm
.function_attribute_inlinable_p (fndecl
);
108 /* Copy NODE (which must be a DECL, but not a PARM_DECL). The DECL
109 originally was in the FROM_FN, but now it will be in the
113 copy_decl_for_inlining (tree decl
, tree from_fn
, tree to_fn
)
117 /* Copy the declaration. */
118 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
123 /* See if the frontend wants to pass this by invisible reference. */
124 if (TREE_CODE (decl
) == PARM_DECL
125 && DECL_ARG_TYPE (decl
) != TREE_TYPE (decl
)
126 && POINTER_TYPE_P (DECL_ARG_TYPE (decl
))
127 && TREE_TYPE (DECL_ARG_TYPE (decl
)) == TREE_TYPE (decl
))
130 type
= DECL_ARG_TYPE (decl
);
133 type
= TREE_TYPE (decl
);
135 /* For a parameter, we must make an equivalent VAR_DECL, not a
137 copy
= build_decl (VAR_DECL
, DECL_NAME (decl
), type
);
140 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
141 TREE_READONLY (copy
) = TREE_READONLY (decl
);
142 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
146 TREE_ADDRESSABLE (copy
) = 0;
147 TREE_READONLY (copy
) = 1;
148 TREE_THIS_VOLATILE (copy
) = 0;
153 copy
= copy_node (decl
);
154 /* The COPY is not abstract; it will be generated in TO_FN. */
155 DECL_ABSTRACT (copy
) = 0;
156 lang_hooks
.dup_lang_specific_decl (copy
);
158 /* TREE_ADDRESSABLE isn't used to indicate that a label's
159 address has been taken; it's for internal bookkeeping in
160 expand_goto_internal. */
161 if (TREE_CODE (copy
) == LABEL_DECL
)
163 TREE_ADDRESSABLE (copy
) = 0;
164 DECL_TOO_LATE (copy
) = 0;
168 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
169 declaration inspired this copy. */
170 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
172 /* The new variable/label has no RTL, yet. */
173 if (!TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
174 SET_DECL_RTL (copy
, NULL_RTX
);
176 /* These args would always appear unused, if not for this. */
177 TREE_USED (copy
) = 1;
179 /* Set the context for the new declaration. */
180 if (!DECL_CONTEXT (decl
))
181 /* Globals stay global. */
183 else if (DECL_CONTEXT (decl
) != from_fn
)
184 /* Things that weren't in the scope of the function we're inlining
185 from aren't in the scope we're inlining to, either. */
187 else if (TREE_STATIC (decl
))
188 /* Function-scoped static variables should stay in the original
192 /* Ordinary automatic local variables are now in the scope of the
194 DECL_CONTEXT (copy
) = to_fn
;
199 /* Unfortunately, we need a global copy of const_equiv map for communication
200 with a function called from note_stores. Be *very* careful that this
201 is used properly in the presence of recursion. */
203 varray_type global_const_equiv_varray
;
205 /* Create a new copy of an rtx. Recursively copies the operands of the rtx,
206 except for those few rtx codes that are sharable.
208 We always return an rtx that is similar to that incoming rtx, with the
209 exception of possibly changing a REG to a SUBREG or vice versa. No
212 If FOR_LHS is nonzero, if means we are processing something that will
213 be the LHS of a SET. In that case, we copy RTX_UNCHANGING_P even if
214 inlining since we need to be conservative in how it is set for
217 Handle constants that need to be placed in the constant pool by
218 calling `force_const_mem'. */
221 copy_rtx_and_substitute (rtx orig
, struct inline_remap
*map
, int for_lhs
)
226 enum machine_mode mode
;
227 const char *format_ptr
;
233 code
= GET_CODE (orig
);
234 mode
= GET_MODE (orig
);
239 /* If the stack pointer register shows up, it must be part of
240 stack-adjustments (*not* because we eliminated the frame pointer!).
241 Small hard registers are returned as-is. Pseudo-registers
242 go through their `reg_map'. */
243 regno
= REGNO (orig
);
244 if (regno
<= LAST_VIRTUAL_REGISTER
)
246 /* Some hard registers are also mapped,
247 but others are not translated. */
248 if (map
->reg_map
[regno
] != 0)
249 return map
->reg_map
[regno
];
251 /* If this is the virtual frame pointer, make space in current
252 function's stack frame for the stack frame of the inline function.
254 Copy the address of this area into a pseudo. Map
255 virtual_stack_vars_rtx to this pseudo and set up a constant
256 equivalence for it to be the address. This will substitute the
257 address into insns where it can be substituted and use the new
258 pseudo where it can't. */
259 else if (regno
== VIRTUAL_STACK_VARS_REGNUM
)
263 = get_func_frame_size (DECL_STRUCT_FUNCTION (map
->fndecl
));
264 #ifdef FRAME_GROWS_DOWNWARD
266 = (DECL_STRUCT_FUNCTION (map
->fndecl
)->stack_alignment_needed
269 /* In this case, virtual_stack_vars_rtx points to one byte
270 higher than the top of the frame area. So make sure we
271 allocate a big enough chunk to keep the frame pointer
272 aligned like a real one. */
274 size
= CEIL_ROUND (size
, alignment
);
277 loc
= assign_stack_temp (BLKmode
, size
, 1);
279 #ifdef FRAME_GROWS_DOWNWARD
280 /* In this case, virtual_stack_vars_rtx points to one byte
281 higher than the top of the frame area. So compute the offset
282 to one byte higher than our substitute frame. */
283 loc
= plus_constant (loc
, size
);
285 map
->reg_map
[regno
] = temp
286 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
288 #ifdef STACK_BOUNDARY
289 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
292 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
296 emit_insn_after (seq
, map
->insns_at_start
);
299 else if (regno
== VIRTUAL_INCOMING_ARGS_REGNUM
)
301 /* Do the same for a block to contain any arguments referenced
304 int size
= DECL_STRUCT_FUNCTION (map
->fndecl
)->args_size
;
307 loc
= assign_stack_temp (BLKmode
, size
, 1);
309 /* When arguments grow downward, the virtual incoming
310 args pointer points to the top of the argument block,
311 so the remapped location better do the same. */
312 #ifdef ARGS_GROW_DOWNWARD
313 loc
= plus_constant (loc
, size
);
315 map
->reg_map
[regno
] = temp
316 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
318 #ifdef STACK_BOUNDARY
319 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
322 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
326 emit_insn_after (seq
, map
->insns_at_start
);
329 else if (REG_FUNCTION_VALUE_P (orig
))
331 if (rtx_equal_function_value_matters
)
332 /* This is an ignored return value. We must not
333 leave it in with REG_FUNCTION_VALUE_P set, since
334 that would confuse subsequent inlining of the
335 current function into a later function. */
336 return gen_rtx_REG (GET_MODE (orig
), regno
);
338 /* Must be unrolling loops or replicating code if we
339 reach here, so return the register unchanged. */
347 if (map
->reg_map
[regno
] == NULL
)
349 map
->reg_map
[regno
] = gen_reg_rtx (mode
);
350 REG_USERVAR_P (map
->reg_map
[regno
]) = REG_USERVAR_P (orig
);
351 REG_LOOP_TEST_P (map
->reg_map
[regno
]) = REG_LOOP_TEST_P (orig
);
352 RTX_UNCHANGING_P (map
->reg_map
[regno
]) = RTX_UNCHANGING_P (orig
);
353 /* A reg with REG_FUNCTION_VALUE_P true will never reach here. */
355 if (REG_POINTER (map
->x_regno_reg_rtx
[regno
]))
356 mark_reg_pointer (map
->reg_map
[regno
],
357 map
->regno_pointer_align
[regno
]);
359 return map
->reg_map
[regno
];
362 copy
= copy_rtx_and_substitute (SUBREG_REG (orig
), map
, for_lhs
);
363 return simplify_gen_subreg (GET_MODE (orig
), copy
,
364 GET_MODE (SUBREG_REG (orig
)),
369 /* USE and CLOBBER are ordinary, but we convert (use (subreg foo))
370 to (use foo) if the original insn didn't have a subreg.
371 Removing the subreg distorts the VAX movstrhi pattern
372 by changing the mode of an operand. */
373 copy
= copy_rtx_and_substitute (XEXP (orig
, 0), map
, code
== CLOBBER
);
374 if (GET_CODE (copy
) == SUBREG
&& GET_CODE (XEXP (orig
, 0)) != SUBREG
)
375 copy
= SUBREG_REG (copy
);
376 return gen_rtx_fmt_e (code
, VOIDmode
, copy
);
378 /* We need to handle "deleted" labels that appear in the DECL_RTL
381 if (NOTE_LINE_NUMBER (orig
) != NOTE_INSN_DELETED_LABEL
)
386 LABEL_PRESERVE_P (get_label_from_map (map
, CODE_LABEL_NUMBER (orig
)))
387 = LABEL_PRESERVE_P (orig
);
388 return get_label_from_map (map
, CODE_LABEL_NUMBER (orig
));
394 LABEL_REF_NONLOCAL_P (orig
) ? XEXP (orig
, 0)
395 : get_label_from_map (map
, CODE_LABEL_NUMBER (XEXP (orig
, 0))));
397 LABEL_OUTSIDE_LOOP_P (copy
) = LABEL_OUTSIDE_LOOP_P (orig
);
399 /* The fact that this label was previously nonlocal does not mean
400 it still is, so we must check if it is within the range of
401 this function's labels. */
402 LABEL_REF_NONLOCAL_P (copy
)
403 = (LABEL_REF_NONLOCAL_P (orig
)
404 && ! (CODE_LABEL_NUMBER (XEXP (copy
, 0)) >= get_first_label_num ()
405 && CODE_LABEL_NUMBER (XEXP (copy
, 0)) < max_label_num ()));
416 /* Symbols which represent the address of a label stored in the constant
417 pool must be modified to point to a constant pool entry for the
418 remapped label. Otherwise, symbols are returned unchanged. */
419 if (CONSTANT_POOL_ADDRESS_P (orig
))
421 struct function
*f
= cfun
;
422 rtx constant
= get_pool_constant_for_function (f
, orig
);
423 if (GET_CODE (constant
) == LABEL_REF
)
424 return XEXP (force_const_mem
426 copy_rtx_and_substitute (constant
, map
, for_lhs
)),
432 /* We have to make a new copy of this CONST_DOUBLE because don't want
433 to use the old value of CONST_DOUBLE_MEM. Also, this may be a
434 duplicate of a CONST_DOUBLE we have already seen. */
435 if (GET_MODE_CLASS (GET_MODE (orig
)) == MODE_FLOAT
)
439 REAL_VALUE_FROM_CONST_DOUBLE (d
, orig
);
440 return CONST_DOUBLE_FROM_REAL_VALUE (d
, GET_MODE (orig
));
443 return immed_double_const (CONST_DOUBLE_LOW (orig
),
444 CONST_DOUBLE_HIGH (orig
), VOIDmode
);
450 /* If a single asm insn contains multiple output operands then
451 it contains multiple ASM_OPERANDS rtx's that share the input
452 and constraint vecs. We must make sure that the copied insn
453 continues to share it. */
454 if (map
->orig_asm_operands_vector
== ASM_OPERANDS_INPUT_VEC (orig
))
456 copy
= rtx_alloc (ASM_OPERANDS
);
457 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
458 PUT_MODE (copy
, GET_MODE (orig
));
459 ASM_OPERANDS_TEMPLATE (copy
) = ASM_OPERANDS_TEMPLATE (orig
);
460 ASM_OPERANDS_OUTPUT_CONSTRAINT (copy
)
461 = ASM_OPERANDS_OUTPUT_CONSTRAINT (orig
);
462 ASM_OPERANDS_OUTPUT_IDX (copy
) = ASM_OPERANDS_OUTPUT_IDX (orig
);
463 ASM_OPERANDS_INPUT_VEC (copy
) = map
->copy_asm_operands_vector
;
464 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
)
465 = map
->copy_asm_constraints_vector
;
466 #ifdef USE_MAPPED_LOCATION
467 ASM_OPERANDS_SOURCE_LOCATION (copy
)
468 = ASM_OPERANDS_SOURCE_LOCATION (orig
);
470 ASM_OPERANDS_SOURCE_FILE (copy
) = ASM_OPERANDS_SOURCE_FILE (orig
);
471 ASM_OPERANDS_SOURCE_LINE (copy
) = ASM_OPERANDS_SOURCE_LINE (orig
);
478 /* This is given special treatment because the first
479 operand of a CALL is a (MEM ...) which may get
480 forced into a register for cse. This is undesirable
481 if function-address cse isn't wanted or if we won't do cse. */
482 #ifndef NO_FUNCTION_CSE
483 if (! (optimize
&& ! flag_no_function_cse
))
487 = gen_rtx_MEM (GET_MODE (XEXP (orig
, 0)),
488 copy_rtx_and_substitute (XEXP (XEXP (orig
, 0), 0),
491 MEM_COPY_ATTRIBUTES (copy
, XEXP (orig
, 0));
494 gen_rtx_CALL (GET_MODE (orig
), copy
,
495 copy_rtx_and_substitute (XEXP (orig
, 1), map
, 0));
500 /* Must be ifdefed out for loop unrolling to work. */
501 /* ??? Is this for the old or the new unroller? */
507 /* If this is setting fp or ap, it means that we have a nonlocal goto.
508 Adjust the setting by the offset of the area we made.
509 If the nonlocal goto is into the current function,
510 this will result in unnecessarily bad code, but should work. */
511 if (SET_DEST (orig
) == virtual_stack_vars_rtx
512 || SET_DEST (orig
) == virtual_incoming_args_rtx
)
514 /* In case a translation hasn't occurred already, make one now. */
517 HOST_WIDE_INT loc_offset
;
519 copy_rtx_and_substitute (SET_DEST (orig
), map
, for_lhs
);
520 equiv_reg
= map
->reg_map
[REGNO (SET_DEST (orig
))];
521 equiv_loc
= VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
522 REGNO (equiv_reg
)).rtx
;
524 = REG_P (equiv_loc
) ? 0 : INTVAL (XEXP (equiv_loc
, 1));
526 return gen_rtx_SET (VOIDmode
, SET_DEST (orig
),
529 (copy_rtx_and_substitute (SET_SRC (orig
),
535 return gen_rtx_SET (VOIDmode
,
536 copy_rtx_and_substitute (SET_DEST (orig
), map
, 1),
537 copy_rtx_and_substitute (SET_SRC (orig
), map
, 0));
541 copy
= gen_rtx_MEM (mode
, copy_rtx_and_substitute (XEXP (orig
, 0),
543 MEM_COPY_ATTRIBUTES (copy
, orig
);
550 copy
= rtx_alloc (code
);
551 PUT_MODE (copy
, mode
);
552 RTX_FLAG (copy
, in_struct
) = RTX_FLAG (orig
, in_struct
);
553 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
554 RTX_FLAG (copy
, unchanging
) = RTX_FLAG (orig
, unchanging
);
556 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
558 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
560 switch (*format_ptr
++)
563 X0ANY (copy
, i
) = X0ANY (orig
, i
);
568 = copy_rtx_and_substitute (XEXP (orig
, i
), map
, for_lhs
);
572 /* Change any references to old-insns to point to the
573 corresponding copied insns. */
574 XEXP (copy
, i
) = map
->insn_map
[INSN_UID (XEXP (orig
, i
))];
578 XVEC (copy
, i
) = XVEC (orig
, i
);
579 if (XVEC (orig
, i
) != NULL
&& XVECLEN (orig
, i
) != 0)
581 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
582 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
584 = copy_rtx_and_substitute (XVECEXP (orig
, i
, j
),
590 XWINT (copy
, i
) = XWINT (orig
, i
);
594 XINT (copy
, i
) = XINT (orig
, i
);
598 XSTR (copy
, i
) = XSTR (orig
, i
);
602 XTREE (copy
, i
) = XTREE (orig
, i
);
610 if (code
== ASM_OPERANDS
&& map
->orig_asm_operands_vector
== 0)
612 map
->orig_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (orig
);
613 map
->copy_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (copy
);
614 map
->copy_asm_constraints_vector
615 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
);
621 /* Substitute known constant values into INSN, if that is valid. */
624 try_constants (rtx insn
, struct inline_remap
*map
)
630 /* First try just updating addresses, then other things. This is
631 important when we have something like the store of a constant
632 into memory and we can update the memory address but the machine
633 does not support a constant source. */
634 subst_constants (&PATTERN (insn
), insn
, map
, 1);
635 apply_change_group ();
636 subst_constants (&PATTERN (insn
), insn
, map
, 0);
637 apply_change_group ();
639 /* Enforce consistency between the addresses in the regular insn flow
640 and the ones in CALL_INSN_FUNCTION_USAGE lists, if any. */
641 if (GET_CODE (insn
) == CALL_INSN
&& CALL_INSN_FUNCTION_USAGE (insn
))
643 subst_constants (&CALL_INSN_FUNCTION_USAGE (insn
), insn
, map
, 1);
644 apply_change_group ();
647 /* Show we don't know the value of anything stored or clobbered. */
648 note_stores (PATTERN (insn
), mark_stores
, NULL
);
649 map
->last_pc_value
= 0;
651 map
->last_cc0_value
= 0;
654 /* Set up any constant equivalences made in this insn. */
655 for (i
= 0; i
< map
->num_sets
; i
++)
657 if (REG_P (map
->equiv_sets
[i
].dest
))
659 int regno
= REGNO (map
->equiv_sets
[i
].dest
);
661 MAYBE_EXTEND_CONST_EQUIV_VARRAY (map
, regno
);
662 if (VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
).rtx
== 0
663 /* Following clause is a hack to make case work where GNU C++
664 reassigns a variable to make cse work right. */
665 || ! rtx_equal_p (VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
667 map
->equiv_sets
[i
].equiv
))
668 SET_CONST_EQUIV_DATA (map
, map
->equiv_sets
[i
].dest
,
669 map
->equiv_sets
[i
].equiv
, map
->const_age
);
671 else if (map
->equiv_sets
[i
].dest
== pc_rtx
)
672 map
->last_pc_value
= map
->equiv_sets
[i
].equiv
;
674 else if (map
->equiv_sets
[i
].dest
== cc0_rtx
)
675 map
->last_cc0_value
= map
->equiv_sets
[i
].equiv
;
680 /* Substitute known constants for pseudo regs in the contents of LOC,
681 which are part of INSN.
682 If INSN is zero, the substitution should always be done (this is used to
684 These changes are taken out by try_constants if the result is not valid.
686 Note that we are more concerned with determining when the result of a SET
687 is a constant, for further propagation, than actually inserting constants
688 into insns; cse will do the latter task better.
690 This function is also used to adjust address of items previously addressed
691 via the virtual stack variable or virtual incoming arguments registers.
693 If MEMONLY is nonzero, only make changes inside a MEM. */
696 subst_constants (rtx
*loc
, rtx insn
, struct inline_remap
*map
, int memonly
)
701 const char *format_ptr
;
702 int num_changes
= num_validated_changes ();
704 enum machine_mode op0_mode
= MAX_MACHINE_MODE
;
723 validate_change (insn
, loc
, map
->last_cc0_value
, 1);
729 /* The only thing we can do with a USE or CLOBBER is possibly do
730 some substitutions in a MEM within it. */
731 if (MEM_P (XEXP (x
, 0)))
732 subst_constants (&XEXP (XEXP (x
, 0), 0), insn
, map
, 0);
736 /* Substitute for parms and known constants. Don't replace
737 hard regs used as user variables with constants. */
740 int regno
= REGNO (x
);
741 struct const_equiv_data
*p
;
743 if (! (regno
< FIRST_PSEUDO_REGISTER
&& REG_USERVAR_P (x
))
744 && (size_t) regno
< VARRAY_SIZE (map
->const_equiv_varray
)
745 && (p
= &VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
),
747 && p
->age
>= map
->const_age
)
748 validate_change (insn
, loc
, p
->rtx
, 1);
753 /* SUBREG applied to something other than a reg
754 should be treated as ordinary, since that must
755 be a special hack and we don't know how to treat it specially.
756 Consider for example mulsidi3 in m68k.md.
757 Ordinary SUBREG of a REG needs this special treatment. */
758 if (! memonly
&& REG_P (SUBREG_REG (x
)))
760 rtx inner
= SUBREG_REG (x
);
763 /* We can't call subst_constants on &SUBREG_REG (x) because any
764 constant or SUBREG wouldn't be valid inside our SUBEG. Instead,
765 see what is inside, try to form the new SUBREG and see if that is
766 valid. We handle two cases: extracting a full word in an
767 integral mode and extracting the low part. */
768 subst_constants (&inner
, NULL_RTX
, map
, 0);
769 new = simplify_gen_subreg (GET_MODE (x
), inner
,
770 GET_MODE (SUBREG_REG (x
)),
774 validate_change (insn
, loc
, new, 1);
776 cancel_changes (num_changes
);
783 subst_constants (&XEXP (x
, 0), insn
, map
, 0);
785 /* If a memory address got spoiled, change it back. */
786 if (! memonly
&& insn
!= 0 && num_validated_changes () != num_changes
787 && ! memory_address_p (GET_MODE (x
), XEXP (x
, 0)))
788 cancel_changes (num_changes
);
793 /* Substitute constants in our source, and in any arguments to a
794 complex (e..g, ZERO_EXTRACT) destination, but not in the destination
796 rtx
*dest_loc
= &SET_DEST (x
);
797 rtx dest
= *dest_loc
;
799 enum machine_mode compare_mode
= VOIDmode
;
801 /* If SET_SRC is a COMPARE which subst_constants would turn into
802 COMPARE of 2 VOIDmode constants, note the mode in which comparison
804 if (GET_CODE (SET_SRC (x
)) == COMPARE
)
807 if (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
810 compare_mode
= GET_MODE (XEXP (src
, 0));
811 if (compare_mode
== VOIDmode
)
812 compare_mode
= GET_MODE (XEXP (src
, 1));
816 subst_constants (&SET_SRC (x
), insn
, map
, memonly
);
819 while (GET_CODE (*dest_loc
) == ZERO_EXTRACT
820 || GET_CODE (*dest_loc
) == SUBREG
821 || GET_CODE (*dest_loc
) == STRICT_LOW_PART
)
823 if (GET_CODE (*dest_loc
) == ZERO_EXTRACT
)
825 subst_constants (&XEXP (*dest_loc
, 1), insn
, map
, memonly
);
826 subst_constants (&XEXP (*dest_loc
, 2), insn
, map
, memonly
);
828 dest_loc
= &XEXP (*dest_loc
, 0);
831 /* Do substitute in the address of a destination in memory. */
832 if (MEM_P (*dest_loc
))
833 subst_constants (&XEXP (*dest_loc
, 0), insn
, map
, 0);
835 /* Check for the case of DEST a SUBREG, both it and the underlying
836 register are less than one word, and the SUBREG has the wider mode.
837 In the case, we are really setting the underlying register to the
838 source converted to the mode of DEST. So indicate that. */
839 if (GET_CODE (dest
) == SUBREG
840 && GET_MODE_SIZE (GET_MODE (dest
)) <= UNITS_PER_WORD
841 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
))) <= UNITS_PER_WORD
842 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
843 <= GET_MODE_SIZE (GET_MODE (dest
)))
844 && (tem
= gen_lowpart_if_possible (GET_MODE (SUBREG_REG (dest
)),
846 src
= tem
, dest
= SUBREG_REG (dest
);
848 /* If storing a recognizable value save it for later recording. */
849 if ((map
->num_sets
< MAX_RECOG_OPERANDS
)
852 && (REGNO (src
) == VIRTUAL_INCOMING_ARGS_REGNUM
853 || REGNO (src
) == VIRTUAL_STACK_VARS_REGNUM
))
854 || (GET_CODE (src
) == PLUS
855 && REG_P (XEXP (src
, 0))
856 && (REGNO (XEXP (src
, 0)) == VIRTUAL_INCOMING_ARGS_REGNUM
857 || REGNO (XEXP (src
, 0)) == VIRTUAL_STACK_VARS_REGNUM
)
858 && CONSTANT_P (XEXP (src
, 1)))
859 || GET_CODE (src
) == COMPARE
862 && (src
== pc_rtx
|| GET_CODE (src
) == RETURN
863 || GET_CODE (src
) == LABEL_REF
))))
865 /* Normally, this copy won't do anything. But, if SRC is a COMPARE
866 it will cause us to save the COMPARE with any constants
867 substituted, which is what we want for later. */
868 rtx src_copy
= copy_rtx (src
);
869 map
->equiv_sets
[map
->num_sets
].equiv
= src_copy
;
870 map
->equiv_sets
[map
->num_sets
++].dest
= dest
;
871 if (compare_mode
!= VOIDmode
872 && GET_CODE (src
) == COMPARE
873 && (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
875 && GET_MODE (XEXP (src
, 0)) == VOIDmode
876 && GET_MODE (XEXP (src
, 1)) == VOIDmode
)
878 map
->compare_src
= src_copy
;
879 map
->compare_mode
= compare_mode
;
889 format_ptr
= GET_RTX_FORMAT (code
);
891 /* If the first operand is an expression, save its mode for later. */
892 if (*format_ptr
== 'e')
893 op0_mode
= GET_MODE (XEXP (x
, 0));
895 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
897 switch (*format_ptr
++)
904 subst_constants (&XEXP (x
, i
), insn
, map
, memonly
);
917 if (XVEC (x
, i
) != NULL
&& XVECLEN (x
, i
) != 0)
918 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
919 subst_constants (&XVECEXP (x
, i
, j
), insn
, map
, memonly
);
928 /* If this is a commutative operation, move a constant to the second
929 operand unless the second operand is already a CONST_INT. */
931 && (GET_RTX_CLASS (code
) == RTX_COMM_ARITH
932 || GET_RTX_CLASS (code
) == RTX_COMM_COMPARE
)
933 && CONSTANT_P (XEXP (x
, 0)) && GET_CODE (XEXP (x
, 1)) != CONST_INT
)
935 rtx tem
= XEXP (x
, 0);
936 validate_change (insn
, &XEXP (x
, 0), XEXP (x
, 1), 1);
937 validate_change (insn
, &XEXP (x
, 1), tem
, 1);
940 /* Simplify the expression in case we put in some constants. */
942 switch (GET_RTX_CLASS (code
))
945 if (op0_mode
== MAX_MACHINE_MODE
)
947 new = simplify_unary_operation (code
, GET_MODE (x
),
948 XEXP (x
, 0), op0_mode
);
952 case RTX_COMM_COMPARE
:
954 enum machine_mode op_mode
= GET_MODE (XEXP (x
, 0));
956 if (op_mode
== VOIDmode
)
957 op_mode
= GET_MODE (XEXP (x
, 1));
959 new = simplify_relational_operation (code
, GET_MODE (x
), op_mode
,
960 XEXP (x
, 0), XEXP (x
, 1));
966 new = simplify_binary_operation (code
, GET_MODE (x
),
967 XEXP (x
, 0), XEXP (x
, 1));
970 case RTX_BITFIELD_OPS
:
972 if (op0_mode
== MAX_MACHINE_MODE
)
975 if (code
== IF_THEN_ELSE
)
977 rtx op0
= XEXP (x
, 0);
979 if (COMPARISON_P (op0
)
980 && GET_MODE (op0
) == VOIDmode
981 && ! side_effects_p (op0
)
982 && XEXP (op0
, 0) == map
->compare_src
983 && GET_MODE (XEXP (op0
, 1)) == VOIDmode
)
985 /* We have compare of two VOIDmode constants for which
986 we recorded the comparison mode. */
988 simplify_gen_relational (GET_CODE (op0
), GET_MODE (op0
),
989 map
->compare_mode
, XEXP (op0
, 0),
992 if (GET_CODE (tem
) != CONST_INT
)
993 new = simplify_ternary_operation (code
, GET_MODE (x
),
994 op0_mode
, tem
, XEXP (x
, 1),
996 else if (tem
== const0_rtx
)
1003 new = simplify_ternary_operation (code
, GET_MODE (x
), op0_mode
,
1004 XEXP (x
, 0), XEXP (x
, 1),
1013 validate_change (insn
, loc
, new, 1);
1016 /* Show that register modified no longer contain known constants. We are
1017 called from note_stores with parts of the new insn. */
1020 mark_stores (rtx dest
, rtx x ATTRIBUTE_UNUSED
, void *data ATTRIBUTE_UNUSED
)
1023 enum machine_mode mode
= VOIDmode
;
1025 /* DEST is always the innermost thing set, except in the case of
1026 SUBREGs of hard registers. */
1029 regno
= REGNO (dest
), mode
= GET_MODE (dest
);
1030 else if (GET_CODE (dest
) == SUBREG
&& REG_P (SUBREG_REG (dest
)))
1032 regno
= REGNO (SUBREG_REG (dest
));
1033 if (regno
< FIRST_PSEUDO_REGISTER
)
1034 regno
+= subreg_regno_offset (REGNO (SUBREG_REG (dest
)),
1035 GET_MODE (SUBREG_REG (dest
)),
1038 mode
= GET_MODE (SUBREG_REG (dest
));
1043 unsigned int uregno
= regno
;
1044 unsigned int last_reg
= (uregno
>= FIRST_PSEUDO_REGISTER
? uregno
1045 : uregno
+ hard_regno_nregs
[uregno
][mode
] - 1);
1048 /* Ignore virtual stack var or virtual arg register since those
1049 are handled separately. */
1050 if (uregno
!= VIRTUAL_INCOMING_ARGS_REGNUM
1051 && uregno
!= VIRTUAL_STACK_VARS_REGNUM
)
1052 for (i
= uregno
; i
<= last_reg
; i
++)
1053 if ((size_t) i
< VARRAY_SIZE (global_const_equiv_varray
))
1054 VARRAY_CONST_EQUIV (global_const_equiv_varray
, i
).rtx
= 0;
1058 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
1059 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
1060 that it points to the node itself, thus indicating that the node is its
1061 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
1062 the given node is NULL, recursively descend the decl/block tree which
1063 it is the root of, and for each other ..._DECL or BLOCK node contained
1064 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
1065 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
1066 values to point to themselves. */
1069 set_block_origin_self (tree stmt
)
1071 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
1073 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
1078 for (local_decl
= BLOCK_VARS (stmt
);
1079 local_decl
!= NULL_TREE
;
1080 local_decl
= TREE_CHAIN (local_decl
))
1081 set_decl_origin_self (local_decl
); /* Potential recursion. */
1087 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
1088 subblock
!= NULL_TREE
;
1089 subblock
= BLOCK_CHAIN (subblock
))
1090 set_block_origin_self (subblock
); /* Recurse. */
1095 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
1096 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
1097 node to so that it points to the node itself, thus indicating that the
1098 node represents its own (abstract) origin. Additionally, if the
1099 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
1100 the decl/block tree of which the given node is the root of, and for
1101 each other ..._DECL or BLOCK node contained therein whose
1102 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
1103 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
1104 point to themselves. */
1107 set_decl_origin_self (tree decl
)
1109 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
1111 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
1112 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1116 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1117 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
1118 if (DECL_INITIAL (decl
) != NULL_TREE
1119 && DECL_INITIAL (decl
) != error_mark_node
)
1120 set_block_origin_self (DECL_INITIAL (decl
));
1125 /* Given a pointer to some BLOCK node, and a boolean value to set the
1126 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
1127 the given block, and for all local decls and all local sub-blocks
1128 (recursively) which are contained therein. */
1131 set_block_abstract_flags (tree stmt
, int setting
)
1136 BLOCK_ABSTRACT (stmt
) = setting
;
1138 for (local_decl
= BLOCK_VARS (stmt
);
1139 local_decl
!= NULL_TREE
;
1140 local_decl
= TREE_CHAIN (local_decl
))
1141 set_decl_abstract_flags (local_decl
, setting
);
1143 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
1144 subblock
!= NULL_TREE
;
1145 subblock
= BLOCK_CHAIN (subblock
))
1146 set_block_abstract_flags (subblock
, setting
);
1149 /* Given a pointer to some ..._DECL node, and a boolean value to set the
1150 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
1151 given decl, and (in the case where the decl is a FUNCTION_DECL) also
1152 set the abstract flags for all of the parameters, local vars, local
1153 blocks and sub-blocks (recursively) to the same setting. */
1156 set_decl_abstract_flags (tree decl
, int setting
)
1158 DECL_ABSTRACT (decl
) = setting
;
1159 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1163 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1164 DECL_ABSTRACT (arg
) = setting
;
1165 if (DECL_INITIAL (decl
) != NULL_TREE
1166 && DECL_INITIAL (decl
) != error_mark_node
)
1167 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
1171 /* Functions to keep track of the values hard regs had at the start of
1175 get_hard_reg_initial_reg (struct function
*fun
, rtx reg
)
1177 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1183 for (i
= 0; i
< ivs
->num_entries
; i
++)
1184 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
1185 return ivs
->entries
[i
].hard_reg
;
1191 has_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
1193 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1199 for (i
= 0; i
< ivs
->num_entries
; i
++)
1200 if (rtx_equal_p (ivs
->entries
[i
].hard_reg
, reg
))
1201 return ivs
->entries
[i
].pseudo
;
1207 get_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
1209 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1210 rtx rv
= has_func_hard_reg_initial_val (fun
, reg
);
1217 fun
->hard_reg_initial_vals
= ggc_alloc (sizeof (initial_value_struct
));
1218 ivs
= fun
->hard_reg_initial_vals
;
1219 ivs
->num_entries
= 0;
1220 ivs
->max_entries
= 5;
1221 ivs
->entries
= ggc_alloc (5 * sizeof (initial_value_pair
));
1224 if (ivs
->num_entries
>= ivs
->max_entries
)
1226 ivs
->max_entries
+= 5;
1227 ivs
->entries
= ggc_realloc (ivs
->entries
,
1229 * sizeof (initial_value_pair
));
1232 ivs
->entries
[ivs
->num_entries
].hard_reg
= reg
;
1233 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (GET_MODE (reg
));
1235 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
1239 get_hard_reg_initial_val (enum machine_mode mode
, int regno
)
1241 return get_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
1245 has_hard_reg_initial_val (enum machine_mode mode
, int regno
)
1247 return has_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
1251 emit_initial_value_sets (void)
1253 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
1261 for (i
= 0; i
< ivs
->num_entries
; i
++)
1262 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
1266 emit_insn_after (seq
, entry_of_function ());
1269 /* If the backend knows where to allocate pseudos for hard
1270 register initial values, register these allocations now. */
1272 allocate_initial_values (rtx
*reg_equiv_memory_loc ATTRIBUTE_UNUSED
)
1274 #ifdef ALLOCATE_INITIAL_VALUE
1275 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
1281 for (i
= 0; i
< ivs
->num_entries
; i
++)
1283 int regno
= REGNO (ivs
->entries
[i
].pseudo
);
1284 rtx x
= ALLOCATE_INITIAL_VALUE (ivs
->entries
[i
].hard_reg
);
1286 if (x
== NULL_RTX
|| REG_N_SETS (REGNO (ivs
->entries
[i
].pseudo
)) > 1)
1289 reg_equiv_memory_loc
[regno
] = x
;
1292 reg_renumber
[regno
] = REGNO (x
);
1293 /* Poke the regno right into regno_reg_rtx
1294 so that even fixed regs are accepted. */
1295 REGNO (ivs
->entries
[i
].pseudo
) = REGNO (x
);
1302 #include "gt-integrate.h"