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). The DECL originally was in the FROM_FN,
109 but now it will be in the TO_FN. */
112 copy_decl_for_inlining (tree decl
, tree from_fn
, tree to_fn
)
116 /* Copy the declaration. */
117 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
122 /* See if the frontend wants to pass this by invisible reference. */
123 if (TREE_CODE (decl
) == PARM_DECL
124 && DECL_ARG_TYPE (decl
) != TREE_TYPE (decl
)
125 && POINTER_TYPE_P (DECL_ARG_TYPE (decl
))
126 && TREE_TYPE (DECL_ARG_TYPE (decl
)) == TREE_TYPE (decl
))
129 type
= DECL_ARG_TYPE (decl
);
132 type
= TREE_TYPE (decl
);
134 /* For a parameter or result, we must make an equivalent VAR_DECL, not a
136 copy
= build_decl (VAR_DECL
, DECL_NAME (decl
), type
);
139 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
140 TREE_READONLY (copy
) = TREE_READONLY (decl
);
141 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
145 TREE_ADDRESSABLE (copy
) = 0;
146 TREE_READONLY (copy
) = 1;
147 TREE_THIS_VOLATILE (copy
) = 0;
152 copy
= copy_node (decl
);
153 /* The COPY is not abstract; it will be generated in TO_FN. */
154 DECL_ABSTRACT (copy
) = 0;
155 lang_hooks
.dup_lang_specific_decl (copy
);
157 /* TREE_ADDRESSABLE isn't used to indicate that a label's
158 address has been taken; it's for internal bookkeeping in
159 expand_goto_internal. */
160 if (TREE_CODE (copy
) == LABEL_DECL
)
162 TREE_ADDRESSABLE (copy
) = 0;
166 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
167 declaration inspired this copy. */
168 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
170 /* The new variable/label has no RTL, yet. */
171 if (!TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
172 SET_DECL_RTL (copy
, NULL_RTX
);
174 /* These args would always appear unused, if not for this. */
175 TREE_USED (copy
) = 1;
177 /* Set the context for the new declaration. */
178 if (!DECL_CONTEXT (decl
))
179 /* Globals stay global. */
181 else if (DECL_CONTEXT (decl
) != from_fn
)
182 /* Things that weren't in the scope of the function we're inlining
183 from aren't in the scope we're inlining to, either. */
185 else if (TREE_STATIC (decl
))
186 /* Function-scoped static variables should stay in the original
190 /* Ordinary automatic local variables are now in the scope of the
192 DECL_CONTEXT (copy
) = to_fn
;
197 /* Unfortunately, we need a global copy of const_equiv map for communication
198 with a function called from note_stores. Be *very* careful that this
199 is used properly in the presence of recursion. */
201 varray_type global_const_equiv_varray
;
203 /* Create a new copy of an rtx. Recursively copies the operands of the rtx,
204 except for those few rtx codes that are sharable.
206 We always return an rtx that is similar to that incoming rtx, with the
207 exception of possibly changing a REG to a SUBREG or vice versa. No
210 If FOR_LHS is nonzero, if means we are processing something that will
211 be the LHS of a SET. In that case, we copy RTX_UNCHANGING_P even if
212 inlining since we need to be conservative in how it is set for
215 Handle constants that need to be placed in the constant pool by
216 calling `force_const_mem'. */
219 copy_rtx_and_substitute (rtx orig
, struct inline_remap
*map
, int for_lhs
)
224 enum machine_mode mode
;
225 const char *format_ptr
;
231 code
= GET_CODE (orig
);
232 mode
= GET_MODE (orig
);
237 /* If the stack pointer register shows up, it must be part of
238 stack-adjustments (*not* because we eliminated the frame pointer!).
239 Small hard registers are returned as-is. Pseudo-registers
240 go through their `reg_map'. */
241 regno
= REGNO (orig
);
242 if (regno
<= LAST_VIRTUAL_REGISTER
)
244 /* Some hard registers are also mapped,
245 but others are not translated. */
246 if (map
->reg_map
[regno
] != 0)
247 return map
->reg_map
[regno
];
249 /* If this is the virtual frame pointer, make space in current
250 function's stack frame for the stack frame of the inline function.
252 Copy the address of this area into a pseudo. Map
253 virtual_stack_vars_rtx to this pseudo and set up a constant
254 equivalence for it to be the address. This will substitute the
255 address into insns where it can be substituted and use the new
256 pseudo where it can't. */
257 else if (regno
== VIRTUAL_STACK_VARS_REGNUM
)
261 = get_func_frame_size (DECL_STRUCT_FUNCTION (map
->fndecl
));
262 #ifdef FRAME_GROWS_DOWNWARD
264 = (DECL_STRUCT_FUNCTION (map
->fndecl
)->stack_alignment_needed
267 /* In this case, virtual_stack_vars_rtx points to one byte
268 higher than the top of the frame area. So make sure we
269 allocate a big enough chunk to keep the frame pointer
270 aligned like a real one. */
272 size
= CEIL_ROUND (size
, alignment
);
275 loc
= assign_stack_temp (BLKmode
, size
, 1);
277 #ifdef FRAME_GROWS_DOWNWARD
278 /* In this case, virtual_stack_vars_rtx points to one byte
279 higher than the top of the frame area. So compute the offset
280 to one byte higher than our substitute frame. */
281 loc
= plus_constant (loc
, size
);
283 map
->reg_map
[regno
] = temp
284 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
286 #ifdef STACK_BOUNDARY
287 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
290 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
294 emit_insn_after (seq
, map
->insns_at_start
);
297 else if (regno
== VIRTUAL_INCOMING_ARGS_REGNUM
)
299 /* Do the same for a block to contain any arguments referenced
302 int size
= DECL_STRUCT_FUNCTION (map
->fndecl
)->args_size
;
305 loc
= assign_stack_temp (BLKmode
, size
, 1);
307 /* When arguments grow downward, the virtual incoming
308 args pointer points to the top of the argument block,
309 so the remapped location better do the same. */
310 #ifdef ARGS_GROW_DOWNWARD
311 loc
= plus_constant (loc
, size
);
313 map
->reg_map
[regno
] = temp
314 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
316 #ifdef STACK_BOUNDARY
317 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
320 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
324 emit_insn_after (seq
, map
->insns_at_start
);
327 else if (REG_FUNCTION_VALUE_P (orig
))
329 if (rtx_equal_function_value_matters
)
330 /* This is an ignored return value. We must not
331 leave it in with REG_FUNCTION_VALUE_P set, since
332 that would confuse subsequent inlining of the
333 current function into a later function. */
334 return gen_rtx_REG (GET_MODE (orig
), regno
);
336 /* Must be unrolling loops or replicating code if we
337 reach here, so return the register unchanged. */
345 if (map
->reg_map
[regno
] == NULL
)
347 map
->reg_map
[regno
] = gen_reg_rtx (mode
);
348 REG_USERVAR_P (map
->reg_map
[regno
]) = REG_USERVAR_P (orig
);
349 REG_LOOP_TEST_P (map
->reg_map
[regno
]) = REG_LOOP_TEST_P (orig
);
350 RTX_UNCHANGING_P (map
->reg_map
[regno
]) = RTX_UNCHANGING_P (orig
);
351 /* A reg with REG_FUNCTION_VALUE_P true will never reach here. */
353 if (REG_POINTER (map
->x_regno_reg_rtx
[regno
]))
354 mark_reg_pointer (map
->reg_map
[regno
],
355 map
->regno_pointer_align
[regno
]);
357 return map
->reg_map
[regno
];
360 copy
= copy_rtx_and_substitute (SUBREG_REG (orig
), map
, for_lhs
);
361 return simplify_gen_subreg (GET_MODE (orig
), copy
,
362 GET_MODE (SUBREG_REG (orig
)),
367 /* USE and CLOBBER are ordinary, but we convert (use (subreg foo))
368 to (use foo) if the original insn didn't have a subreg.
369 Removing the subreg distorts the VAX movmemhi pattern
370 by changing the mode of an operand. */
371 copy
= copy_rtx_and_substitute (XEXP (orig
, 0), map
, code
== CLOBBER
);
372 if (GET_CODE (copy
) == SUBREG
&& GET_CODE (XEXP (orig
, 0)) != SUBREG
)
373 copy
= SUBREG_REG (copy
);
374 return gen_rtx_fmt_e (code
, VOIDmode
, copy
);
376 /* We need to handle "deleted" labels that appear in the DECL_RTL
379 if (NOTE_LINE_NUMBER (orig
) != NOTE_INSN_DELETED_LABEL
)
384 LABEL_PRESERVE_P (get_label_from_map (map
, CODE_LABEL_NUMBER (orig
)))
385 = LABEL_PRESERVE_P (orig
);
386 return get_label_from_map (map
, CODE_LABEL_NUMBER (orig
));
392 LABEL_REF_NONLOCAL_P (orig
) ? XEXP (orig
, 0)
393 : get_label_from_map (map
, CODE_LABEL_NUMBER (XEXP (orig
, 0))));
395 LABEL_OUTSIDE_LOOP_P (copy
) = LABEL_OUTSIDE_LOOP_P (orig
);
397 /* The fact that this label was previously nonlocal does not mean
398 it still is, so we must check if it is within the range of
399 this function's labels. */
400 LABEL_REF_NONLOCAL_P (copy
)
401 = (LABEL_REF_NONLOCAL_P (orig
)
402 && ! (CODE_LABEL_NUMBER (XEXP (copy
, 0)) >= get_first_label_num ()
403 && CODE_LABEL_NUMBER (XEXP (copy
, 0)) < max_label_num ()));
414 /* Symbols which represent the address of a label stored in the constant
415 pool must be modified to point to a constant pool entry for the
416 remapped label. Otherwise, symbols are returned unchanged. */
417 if (CONSTANT_POOL_ADDRESS_P (orig
))
419 struct function
*f
= cfun
;
420 rtx constant
= get_pool_constant_for_function (f
, orig
);
421 if (GET_CODE (constant
) == LABEL_REF
)
422 return XEXP (force_const_mem
424 copy_rtx_and_substitute (constant
, map
, for_lhs
)),
430 /* We have to make a new copy of this CONST_DOUBLE because don't want
431 to use the old value of CONST_DOUBLE_MEM. Also, this may be a
432 duplicate of a CONST_DOUBLE we have already seen. */
433 if (GET_MODE_CLASS (GET_MODE (orig
)) == MODE_FLOAT
)
437 REAL_VALUE_FROM_CONST_DOUBLE (d
, orig
);
438 return CONST_DOUBLE_FROM_REAL_VALUE (d
, GET_MODE (orig
));
441 return immed_double_const (CONST_DOUBLE_LOW (orig
),
442 CONST_DOUBLE_HIGH (orig
), VOIDmode
);
448 /* If a single asm insn contains multiple output operands then
449 it contains multiple ASM_OPERANDS rtx's that share the input
450 and constraint vecs. We must make sure that the copied insn
451 continues to share it. */
452 if (map
->orig_asm_operands_vector
== ASM_OPERANDS_INPUT_VEC (orig
))
454 copy
= rtx_alloc (ASM_OPERANDS
);
455 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
456 PUT_MODE (copy
, GET_MODE (orig
));
457 ASM_OPERANDS_TEMPLATE (copy
) = ASM_OPERANDS_TEMPLATE (orig
);
458 ASM_OPERANDS_OUTPUT_CONSTRAINT (copy
)
459 = ASM_OPERANDS_OUTPUT_CONSTRAINT (orig
);
460 ASM_OPERANDS_OUTPUT_IDX (copy
) = ASM_OPERANDS_OUTPUT_IDX (orig
);
461 ASM_OPERANDS_INPUT_VEC (copy
) = map
->copy_asm_operands_vector
;
462 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
)
463 = map
->copy_asm_constraints_vector
;
464 #ifdef USE_MAPPED_LOCATION
465 ASM_OPERANDS_SOURCE_LOCATION (copy
)
466 = ASM_OPERANDS_SOURCE_LOCATION (orig
);
468 ASM_OPERANDS_SOURCE_FILE (copy
) = ASM_OPERANDS_SOURCE_FILE (orig
);
469 ASM_OPERANDS_SOURCE_LINE (copy
) = ASM_OPERANDS_SOURCE_LINE (orig
);
476 /* This is given special treatment because the first
477 operand of a CALL is a (MEM ...) which may get
478 forced into a register for cse. This is undesirable
479 if function-address cse isn't wanted or if we won't do cse. */
480 #ifndef NO_FUNCTION_CSE
481 if (! (optimize
&& ! flag_no_function_cse
))
485 = gen_rtx_MEM (GET_MODE (XEXP (orig
, 0)),
486 copy_rtx_and_substitute (XEXP (XEXP (orig
, 0), 0),
489 MEM_COPY_ATTRIBUTES (copy
, XEXP (orig
, 0));
492 gen_rtx_CALL (GET_MODE (orig
), copy
,
493 copy_rtx_and_substitute (XEXP (orig
, 1), map
, 0));
498 /* Must be ifdefed out for loop unrolling to work. */
499 /* ??? Is this for the old or the new unroller? */
505 /* If this is setting fp or ap, it means that we have a nonlocal goto.
506 Adjust the setting by the offset of the area we made.
507 If the nonlocal goto is into the current function,
508 this will result in unnecessarily bad code, but should work. */
509 if (SET_DEST (orig
) == virtual_stack_vars_rtx
510 || SET_DEST (orig
) == virtual_incoming_args_rtx
)
512 /* In case a translation hasn't occurred already, make one now. */
515 HOST_WIDE_INT loc_offset
;
517 copy_rtx_and_substitute (SET_DEST (orig
), map
, for_lhs
);
518 equiv_reg
= map
->reg_map
[REGNO (SET_DEST (orig
))];
519 equiv_loc
= VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
520 REGNO (equiv_reg
)).rtx
;
522 = REG_P (equiv_loc
) ? 0 : INTVAL (XEXP (equiv_loc
, 1));
524 return gen_rtx_SET (VOIDmode
, SET_DEST (orig
),
527 (copy_rtx_and_substitute (SET_SRC (orig
),
533 return gen_rtx_SET (VOIDmode
,
534 copy_rtx_and_substitute (SET_DEST (orig
), map
, 1),
535 copy_rtx_and_substitute (SET_SRC (orig
), map
, 0));
539 copy
= gen_rtx_MEM (mode
, copy_rtx_and_substitute (XEXP (orig
, 0),
541 MEM_COPY_ATTRIBUTES (copy
, orig
);
548 copy
= rtx_alloc (code
);
549 PUT_MODE (copy
, mode
);
550 RTX_FLAG (copy
, in_struct
) = RTX_FLAG (orig
, in_struct
);
551 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
552 RTX_FLAG (copy
, unchanging
) = RTX_FLAG (orig
, unchanging
);
554 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
556 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
558 switch (*format_ptr
++)
561 X0ANY (copy
, i
) = X0ANY (orig
, i
);
566 = copy_rtx_and_substitute (XEXP (orig
, i
), map
, for_lhs
);
570 /* Change any references to old-insns to point to the
571 corresponding copied insns. */
572 XEXP (copy
, i
) = map
->insn_map
[INSN_UID (XEXP (orig
, i
))];
576 XVEC (copy
, i
) = XVEC (orig
, i
);
577 if (XVEC (orig
, i
) != NULL
&& XVECLEN (orig
, i
) != 0)
579 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
580 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
582 = copy_rtx_and_substitute (XVECEXP (orig
, i
, j
),
588 XWINT (copy
, i
) = XWINT (orig
, i
);
592 XINT (copy
, i
) = XINT (orig
, i
);
596 XSTR (copy
, i
) = XSTR (orig
, i
);
600 XTREE (copy
, i
) = XTREE (orig
, i
);
608 if (code
== ASM_OPERANDS
&& map
->orig_asm_operands_vector
== 0)
610 map
->orig_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (orig
);
611 map
->copy_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (copy
);
612 map
->copy_asm_constraints_vector
613 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
);
619 /* Substitute known constant values into INSN, if that is valid. */
622 try_constants (rtx insn
, struct inline_remap
*map
)
628 /* First try just updating addresses, then other things. This is
629 important when we have something like the store of a constant
630 into memory and we can update the memory address but the machine
631 does not support a constant source. */
632 subst_constants (&PATTERN (insn
), insn
, map
, 1);
633 apply_change_group ();
634 subst_constants (&PATTERN (insn
), insn
, map
, 0);
635 apply_change_group ();
637 /* Enforce consistency between the addresses in the regular insn flow
638 and the ones in CALL_INSN_FUNCTION_USAGE lists, if any. */
639 if (CALL_P (insn
) && CALL_INSN_FUNCTION_USAGE (insn
))
641 subst_constants (&CALL_INSN_FUNCTION_USAGE (insn
), insn
, map
, 1);
642 apply_change_group ();
645 /* Show we don't know the value of anything stored or clobbered. */
646 note_stores (PATTERN (insn
), mark_stores
, NULL
);
647 map
->last_pc_value
= 0;
649 map
->last_cc0_value
= 0;
652 /* Set up any constant equivalences made in this insn. */
653 for (i
= 0; i
< map
->num_sets
; i
++)
655 if (REG_P (map
->equiv_sets
[i
].dest
))
657 int regno
= REGNO (map
->equiv_sets
[i
].dest
);
659 MAYBE_EXTEND_CONST_EQUIV_VARRAY (map
, regno
);
660 if (VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
).rtx
== 0
661 /* Following clause is a hack to make case work where GNU C++
662 reassigns a variable to make cse work right. */
663 || ! rtx_equal_p (VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
665 map
->equiv_sets
[i
].equiv
))
666 SET_CONST_EQUIV_DATA (map
, map
->equiv_sets
[i
].dest
,
667 map
->equiv_sets
[i
].equiv
, map
->const_age
);
669 else if (map
->equiv_sets
[i
].dest
== pc_rtx
)
670 map
->last_pc_value
= map
->equiv_sets
[i
].equiv
;
672 else if (map
->equiv_sets
[i
].dest
== cc0_rtx
)
673 map
->last_cc0_value
= map
->equiv_sets
[i
].equiv
;
678 /* Substitute known constants for pseudo regs in the contents of LOC,
679 which are part of INSN.
680 If INSN is zero, the substitution should always be done (this is used to
682 These changes are taken out by try_constants if the result is not valid.
684 Note that we are more concerned with determining when the result of a SET
685 is a constant, for further propagation, than actually inserting constants
686 into insns; cse will do the latter task better.
688 This function is also used to adjust address of items previously addressed
689 via the virtual stack variable or virtual incoming arguments registers.
691 If MEMONLY is nonzero, only make changes inside a MEM. */
694 subst_constants (rtx
*loc
, rtx insn
, struct inline_remap
*map
, int memonly
)
699 const char *format_ptr
;
700 int num_changes
= num_validated_changes ();
702 enum machine_mode op0_mode
= MAX_MACHINE_MODE
;
721 validate_change (insn
, loc
, map
->last_cc0_value
, 1);
727 /* The only thing we can do with a USE or CLOBBER is possibly do
728 some substitutions in a MEM within it. */
729 if (MEM_P (XEXP (x
, 0)))
730 subst_constants (&XEXP (XEXP (x
, 0), 0), insn
, map
, 0);
734 /* Substitute for parms and known constants. Don't replace
735 hard regs used as user variables with constants. */
738 int regno
= REGNO (x
);
739 struct const_equiv_data
*p
;
741 if (! (regno
< FIRST_PSEUDO_REGISTER
&& REG_USERVAR_P (x
))
742 && (size_t) regno
< VARRAY_SIZE (map
->const_equiv_varray
)
743 && (p
= &VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
),
745 && p
->age
>= map
->const_age
)
746 validate_change (insn
, loc
, p
->rtx
, 1);
751 /* SUBREG applied to something other than a reg
752 should be treated as ordinary, since that must
753 be a special hack and we don't know how to treat it specially.
754 Consider for example mulsidi3 in m68k.md.
755 Ordinary SUBREG of a REG needs this special treatment. */
756 if (! memonly
&& REG_P (SUBREG_REG (x
)))
758 rtx inner
= SUBREG_REG (x
);
761 /* We can't call subst_constants on &SUBREG_REG (x) because any
762 constant or SUBREG wouldn't be valid inside our SUBEG. Instead,
763 see what is inside, try to form the new SUBREG and see if that is
764 valid. We handle two cases: extracting a full word in an
765 integral mode and extracting the low part. */
766 subst_constants (&inner
, NULL_RTX
, map
, 0);
767 new = simplify_gen_subreg (GET_MODE (x
), inner
,
768 GET_MODE (SUBREG_REG (x
)),
772 validate_change (insn
, loc
, new, 1);
774 cancel_changes (num_changes
);
781 subst_constants (&XEXP (x
, 0), insn
, map
, 0);
783 /* If a memory address got spoiled, change it back. */
784 if (! memonly
&& insn
!= 0 && num_validated_changes () != num_changes
785 && ! memory_address_p (GET_MODE (x
), XEXP (x
, 0)))
786 cancel_changes (num_changes
);
791 /* Substitute constants in our source, and in any arguments to a
792 complex (e..g, ZERO_EXTRACT) destination, but not in the destination
794 rtx
*dest_loc
= &SET_DEST (x
);
795 rtx dest
= *dest_loc
;
797 enum machine_mode compare_mode
= VOIDmode
;
799 /* If SET_SRC is a COMPARE which subst_constants would turn into
800 COMPARE of 2 VOIDmode constants, note the mode in which comparison
802 if (GET_CODE (SET_SRC (x
)) == COMPARE
)
805 if (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
808 compare_mode
= GET_MODE (XEXP (src
, 0));
809 if (compare_mode
== VOIDmode
)
810 compare_mode
= GET_MODE (XEXP (src
, 1));
814 subst_constants (&SET_SRC (x
), insn
, map
, memonly
);
817 while (GET_CODE (*dest_loc
) == ZERO_EXTRACT
818 || GET_CODE (*dest_loc
) == SUBREG
819 || GET_CODE (*dest_loc
) == STRICT_LOW_PART
)
821 if (GET_CODE (*dest_loc
) == ZERO_EXTRACT
)
823 subst_constants (&XEXP (*dest_loc
, 1), insn
, map
, memonly
);
824 subst_constants (&XEXP (*dest_loc
, 2), insn
, map
, memonly
);
826 dest_loc
= &XEXP (*dest_loc
, 0);
829 /* Do substitute in the address of a destination in memory. */
830 if (MEM_P (*dest_loc
))
831 subst_constants (&XEXP (*dest_loc
, 0), insn
, map
, 0);
833 /* Check for the case of DEST a SUBREG, both it and the underlying
834 register are less than one word, and the SUBREG has the wider mode.
835 In the case, we are really setting the underlying register to the
836 source converted to the mode of DEST. So indicate that. */
837 if (GET_CODE (dest
) == SUBREG
838 && GET_MODE_SIZE (GET_MODE (dest
)) <= UNITS_PER_WORD
839 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
))) <= UNITS_PER_WORD
840 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
841 <= GET_MODE_SIZE (GET_MODE (dest
)))
842 && (tem
= gen_lowpart_if_possible (GET_MODE (SUBREG_REG (dest
)),
844 src
= tem
, dest
= SUBREG_REG (dest
);
846 /* If storing a recognizable value save it for later recording. */
847 if ((map
->num_sets
< MAX_RECOG_OPERANDS
)
850 && (REGNO (src
) == VIRTUAL_INCOMING_ARGS_REGNUM
851 || REGNO (src
) == VIRTUAL_STACK_VARS_REGNUM
))
852 || (GET_CODE (src
) == PLUS
853 && REG_P (XEXP (src
, 0))
854 && (REGNO (XEXP (src
, 0)) == VIRTUAL_INCOMING_ARGS_REGNUM
855 || REGNO (XEXP (src
, 0)) == VIRTUAL_STACK_VARS_REGNUM
)
856 && CONSTANT_P (XEXP (src
, 1)))
857 || GET_CODE (src
) == COMPARE
860 && (src
== pc_rtx
|| GET_CODE (src
) == RETURN
861 || GET_CODE (src
) == LABEL_REF
))))
863 /* Normally, this copy won't do anything. But, if SRC is a COMPARE
864 it will cause us to save the COMPARE with any constants
865 substituted, which is what we want for later. */
866 rtx src_copy
= copy_rtx (src
);
867 map
->equiv_sets
[map
->num_sets
].equiv
= src_copy
;
868 map
->equiv_sets
[map
->num_sets
++].dest
= dest
;
869 if (compare_mode
!= VOIDmode
870 && GET_CODE (src
) == COMPARE
871 && (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
873 && GET_MODE (XEXP (src
, 0)) == VOIDmode
874 && GET_MODE (XEXP (src
, 1)) == VOIDmode
)
876 map
->compare_src
= src_copy
;
877 map
->compare_mode
= compare_mode
;
887 format_ptr
= GET_RTX_FORMAT (code
);
889 /* If the first operand is an expression, save its mode for later. */
890 if (*format_ptr
== 'e')
891 op0_mode
= GET_MODE (XEXP (x
, 0));
893 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
895 switch (*format_ptr
++)
902 subst_constants (&XEXP (x
, i
), insn
, map
, memonly
);
915 if (XVEC (x
, i
) != NULL
&& XVECLEN (x
, i
) != 0)
916 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
917 subst_constants (&XVECEXP (x
, i
, j
), insn
, map
, memonly
);
926 /* If this is a commutative operation, move a constant to the second
927 operand unless the second operand is already a CONST_INT. */
929 && (GET_RTX_CLASS (code
) == RTX_COMM_ARITH
930 || GET_RTX_CLASS (code
) == RTX_COMM_COMPARE
)
931 && CONSTANT_P (XEXP (x
, 0)) && GET_CODE (XEXP (x
, 1)) != CONST_INT
)
933 rtx tem
= XEXP (x
, 0);
934 validate_change (insn
, &XEXP (x
, 0), XEXP (x
, 1), 1);
935 validate_change (insn
, &XEXP (x
, 1), tem
, 1);
938 /* Simplify the expression in case we put in some constants. */
940 switch (GET_RTX_CLASS (code
))
943 if (op0_mode
== MAX_MACHINE_MODE
)
945 new = simplify_unary_operation (code
, GET_MODE (x
),
946 XEXP (x
, 0), op0_mode
);
950 case RTX_COMM_COMPARE
:
952 enum machine_mode op_mode
= GET_MODE (XEXP (x
, 0));
954 if (op_mode
== VOIDmode
)
955 op_mode
= GET_MODE (XEXP (x
, 1));
957 new = simplify_relational_operation (code
, GET_MODE (x
), op_mode
,
958 XEXP (x
, 0), XEXP (x
, 1));
964 new = simplify_binary_operation (code
, GET_MODE (x
),
965 XEXP (x
, 0), XEXP (x
, 1));
968 case RTX_BITFIELD_OPS
:
970 if (op0_mode
== MAX_MACHINE_MODE
)
973 if (code
== IF_THEN_ELSE
)
975 rtx op0
= XEXP (x
, 0);
977 if (COMPARISON_P (op0
)
978 && GET_MODE (op0
) == VOIDmode
979 && ! side_effects_p (op0
)
980 && XEXP (op0
, 0) == map
->compare_src
981 && GET_MODE (XEXP (op0
, 1)) == VOIDmode
)
983 /* We have compare of two VOIDmode constants for which
984 we recorded the comparison mode. */
986 simplify_gen_relational (GET_CODE (op0
), GET_MODE (op0
),
987 map
->compare_mode
, XEXP (op0
, 0),
990 if (GET_CODE (tem
) != CONST_INT
)
991 new = simplify_ternary_operation (code
, GET_MODE (x
),
992 op0_mode
, tem
, XEXP (x
, 1),
994 else if (tem
== const0_rtx
)
1001 new = simplify_ternary_operation (code
, GET_MODE (x
), op0_mode
,
1002 XEXP (x
, 0), XEXP (x
, 1),
1011 validate_change (insn
, loc
, new, 1);
1014 /* Show that register modified no longer contain known constants. We are
1015 called from note_stores with parts of the new insn. */
1018 mark_stores (rtx dest
, rtx x ATTRIBUTE_UNUSED
, void *data ATTRIBUTE_UNUSED
)
1021 enum machine_mode mode
= VOIDmode
;
1023 /* DEST is always the innermost thing set, except in the case of
1024 SUBREGs of hard registers. */
1027 regno
= REGNO (dest
), mode
= GET_MODE (dest
);
1028 else if (GET_CODE (dest
) == SUBREG
&& REG_P (SUBREG_REG (dest
)))
1030 regno
= REGNO (SUBREG_REG (dest
));
1031 if (regno
< FIRST_PSEUDO_REGISTER
)
1032 regno
+= subreg_regno_offset (REGNO (SUBREG_REG (dest
)),
1033 GET_MODE (SUBREG_REG (dest
)),
1036 mode
= GET_MODE (SUBREG_REG (dest
));
1041 unsigned int uregno
= regno
;
1042 unsigned int last_reg
= (uregno
>= FIRST_PSEUDO_REGISTER
? uregno
1043 : uregno
+ hard_regno_nregs
[uregno
][mode
] - 1);
1046 /* Ignore virtual stack var or virtual arg register since those
1047 are handled separately. */
1048 if (uregno
!= VIRTUAL_INCOMING_ARGS_REGNUM
1049 && uregno
!= VIRTUAL_STACK_VARS_REGNUM
)
1050 for (i
= uregno
; i
<= last_reg
; i
++)
1051 if ((size_t) i
< VARRAY_SIZE (global_const_equiv_varray
))
1052 VARRAY_CONST_EQUIV (global_const_equiv_varray
, i
).rtx
= 0;
1056 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
1057 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
1058 that it points to the node itself, thus indicating that the node is its
1059 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
1060 the given node is NULL, recursively descend the decl/block tree which
1061 it is the root of, and for each other ..._DECL or BLOCK node contained
1062 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
1063 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
1064 values to point to themselves. */
1067 set_block_origin_self (tree stmt
)
1069 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
1071 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
1076 for (local_decl
= BLOCK_VARS (stmt
);
1077 local_decl
!= NULL_TREE
;
1078 local_decl
= TREE_CHAIN (local_decl
))
1079 set_decl_origin_self (local_decl
); /* Potential recursion. */
1085 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
1086 subblock
!= NULL_TREE
;
1087 subblock
= BLOCK_CHAIN (subblock
))
1088 set_block_origin_self (subblock
); /* Recurse. */
1093 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
1094 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
1095 node to so that it points to the node itself, thus indicating that the
1096 node represents its own (abstract) origin. Additionally, if the
1097 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
1098 the decl/block tree of which the given node is the root of, and for
1099 each other ..._DECL or BLOCK node contained therein whose
1100 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
1101 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
1102 point to themselves. */
1105 set_decl_origin_self (tree decl
)
1107 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
1109 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
1110 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1114 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1115 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
1116 if (DECL_INITIAL (decl
) != NULL_TREE
1117 && DECL_INITIAL (decl
) != error_mark_node
)
1118 set_block_origin_self (DECL_INITIAL (decl
));
1123 /* Given a pointer to some BLOCK node, and a boolean value to set the
1124 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
1125 the given block, and for all local decls and all local sub-blocks
1126 (recursively) which are contained therein. */
1129 set_block_abstract_flags (tree stmt
, int setting
)
1134 BLOCK_ABSTRACT (stmt
) = setting
;
1136 for (local_decl
= BLOCK_VARS (stmt
);
1137 local_decl
!= NULL_TREE
;
1138 local_decl
= TREE_CHAIN (local_decl
))
1139 set_decl_abstract_flags (local_decl
, setting
);
1141 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
1142 subblock
!= NULL_TREE
;
1143 subblock
= BLOCK_CHAIN (subblock
))
1144 set_block_abstract_flags (subblock
, setting
);
1147 /* Given a pointer to some ..._DECL node, and a boolean value to set the
1148 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
1149 given decl, and (in the case where the decl is a FUNCTION_DECL) also
1150 set the abstract flags for all of the parameters, local vars, local
1151 blocks and sub-blocks (recursively) to the same setting. */
1154 set_decl_abstract_flags (tree decl
, int setting
)
1156 DECL_ABSTRACT (decl
) = setting
;
1157 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1161 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1162 DECL_ABSTRACT (arg
) = setting
;
1163 if (DECL_INITIAL (decl
) != NULL_TREE
1164 && DECL_INITIAL (decl
) != error_mark_node
)
1165 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
1169 /* Functions to keep track of the values hard regs had at the start of
1173 get_hard_reg_initial_reg (struct function
*fun
, rtx reg
)
1175 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1181 for (i
= 0; i
< ivs
->num_entries
; i
++)
1182 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
1183 return ivs
->entries
[i
].hard_reg
;
1189 has_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
1191 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1197 for (i
= 0; i
< ivs
->num_entries
; i
++)
1198 if (rtx_equal_p (ivs
->entries
[i
].hard_reg
, reg
))
1199 return ivs
->entries
[i
].pseudo
;
1205 get_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
1207 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
1208 rtx rv
= has_func_hard_reg_initial_val (fun
, reg
);
1215 fun
->hard_reg_initial_vals
= ggc_alloc (sizeof (initial_value_struct
));
1216 ivs
= fun
->hard_reg_initial_vals
;
1217 ivs
->num_entries
= 0;
1218 ivs
->max_entries
= 5;
1219 ivs
->entries
= ggc_alloc (5 * sizeof (initial_value_pair
));
1222 if (ivs
->num_entries
>= ivs
->max_entries
)
1224 ivs
->max_entries
+= 5;
1225 ivs
->entries
= ggc_realloc (ivs
->entries
,
1227 * sizeof (initial_value_pair
));
1230 ivs
->entries
[ivs
->num_entries
].hard_reg
= reg
;
1231 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (GET_MODE (reg
));
1233 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
1237 get_hard_reg_initial_val (enum machine_mode mode
, int regno
)
1239 return get_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
1243 has_hard_reg_initial_val (enum machine_mode mode
, int regno
)
1245 return has_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
1249 emit_initial_value_sets (void)
1251 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
1259 for (i
= 0; i
< ivs
->num_entries
; i
++)
1260 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
1264 emit_insn_after (seq
, entry_of_function ());
1267 /* If the backend knows where to allocate pseudos for hard
1268 register initial values, register these allocations now. */
1270 allocate_initial_values (rtx
*reg_equiv_memory_loc ATTRIBUTE_UNUSED
)
1272 #ifdef ALLOCATE_INITIAL_VALUE
1273 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
1279 for (i
= 0; i
< ivs
->num_entries
; i
++)
1281 int regno
= REGNO (ivs
->entries
[i
].pseudo
);
1282 rtx x
= ALLOCATE_INITIAL_VALUE (ivs
->entries
[i
].hard_reg
);
1284 if (x
== NULL_RTX
|| REG_N_SETS (REGNO (ivs
->entries
[i
].pseudo
)) > 1)
1287 reg_equiv_memory_loc
[regno
] = x
;
1290 reg_renumber
[regno
] = REGNO (x
);
1291 /* Poke the regno right into regno_reg_rtx
1292 so that even fixed regs are accepted. */
1293 REGNO (ivs
->entries
[i
].pseudo
) = REGNO (x
);
1300 #include "gt-integrate.h"