1 /* Procedure integration for GCC.
2 Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003 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"
48 #include "langhooks.h"
50 /* Similar, but round to the next highest integer that meets the
52 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
54 /* Default max number of insns a function can have and still be inline.
55 This is overridden on RISC machines. */
56 #ifndef INTEGRATE_THRESHOLD
57 /* Inlining small functions might save more space then not inlining at
58 all. Assume 1 instruction for the call and 1.5 insns per argument. */
59 #define INTEGRATE_THRESHOLD(DECL) \
61 ? (1 + (3 * list_length (DECL_ARGUMENTS (DECL))) / 2) \
62 : (8 * (8 + list_length (DECL_ARGUMENTS (DECL)))))
66 /* Private type used by {get/has}_func_hard_reg_initial_val. */
67 typedef struct initial_value_pair
GTY(()) {
71 typedef struct initial_value_struct
GTY(()) {
74 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
75 } initial_value_struct
;
77 static void setup_initial_hard_reg_value_integration (struct function
*,
78 struct inline_remap
*);
80 static rtvec
initialize_for_inline (tree
);
81 static void note_modified_parmregs (rtx
, rtx
, void *);
82 static void integrate_parm_decls (tree
, struct inline_remap
*, rtvec
);
83 static tree
integrate_decl_tree (tree
, struct inline_remap
*);
84 static void subst_constants (rtx
*, rtx
, struct inline_remap
*, int);
85 static void set_block_origin_self (tree
);
86 static void set_block_abstract_flags (tree
, int);
87 static void process_reg_param (struct inline_remap
*, rtx
, rtx
);
88 static void mark_stores (rtx
, rtx
, void *);
89 static void save_parm_insns (rtx
, rtx
);
90 static void copy_insn_list (rtx
, struct inline_remap
*, rtx
);
91 static void copy_insn_notes (rtx
, struct inline_remap
*, int);
92 static int compare_blocks (const void *, const void *);
93 static int find_block (const void *, const void *);
95 /* Used by copy_rtx_and_substitute; this indicates whether the function is
96 called for the purpose of inlining or some other purpose (i.e. loop
97 unrolling). This affects how constant pool references are handled.
98 This variable contains the FUNCTION_DECL for the inlined function. */
99 static struct function
*inlining
= 0;
101 /* Returns the Ith entry in the label_map contained in MAP. If the
102 Ith entry has not yet been set, return a fresh label. This function
103 performs a lazy initialization of label_map, thereby avoiding huge memory
104 explosions when the label_map gets very large. */
107 get_label_from_map (struct inline_remap
*map
, int i
)
109 rtx x
= map
->label_map
[i
];
112 x
= map
->label_map
[i
] = gen_label_rtx ();
117 /* Return false if the function FNDECL cannot be inlined on account of its
118 attributes, true otherwise. */
120 function_attribute_inlinable_p (tree fndecl
)
122 if (targetm
.attribute_table
)
126 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
128 tree name
= TREE_PURPOSE (a
);
131 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
132 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
133 return (*targetm
.function_attribute_inlinable_p
) (fndecl
);
140 /* Zero if the current function (whose FUNCTION_DECL is FNDECL)
141 is safe and reasonable to integrate into other functions.
142 Nonzero means value is a warning msgid with a single %s
143 for the function's name. */
146 function_cannot_inline_p (tree fndecl
)
149 tree last
= tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
151 /* For functions marked as inline increase the maximum size to
152 MAX_INLINE_INSNS_RTL (--param max-inline-insn-rtl=<n>). For
153 regular functions use the limit given by INTEGRATE_THRESHOLD.
154 Note that the RTL inliner is not used by the languages that use
155 the tree inliner (C, C++). */
157 int max_insns
= (DECL_INLINE (fndecl
))
158 ? (MAX_INLINE_INSNS_RTL
159 + 8 * list_length (DECL_ARGUMENTS (fndecl
)))
160 : INTEGRATE_THRESHOLD (fndecl
);
165 if (DECL_UNINLINABLE (fndecl
))
166 return N_("function cannot be inline");
168 /* No inlines with varargs. */
169 if (last
&& TREE_VALUE (last
) != void_type_node
)
170 return N_("varargs function cannot be inline");
172 if (current_function_calls_alloca
)
173 return N_("function using alloca cannot be inline");
175 if (current_function_calls_longjmp
)
176 return N_("function using longjmp cannot be inline");
178 if (current_function_calls_setjmp
)
179 return N_("function using setjmp cannot be inline");
181 if (current_function_calls_eh_return
)
182 return N_("function uses __builtin_eh_return");
184 if (current_function_contains_functions
)
185 return N_("function with nested functions cannot be inline");
189 N_("function with label addresses used in initializers cannot inline");
191 if (current_function_cannot_inline
)
192 return current_function_cannot_inline
;
194 /* If its not even close, don't even look. */
195 if (get_max_uid () > 3 * max_insns
)
196 return N_("function too large to be inline");
199 /* Don't inline functions which do not specify a function prototype and
200 have BLKmode argument or take the address of a parameter. */
201 for (parms
= DECL_ARGUMENTS (fndecl
); parms
; parms
= TREE_CHAIN (parms
))
203 if (TYPE_MODE (TREE_TYPE (parms
)) == BLKmode
)
204 TREE_ADDRESSABLE (parms
) = 1;
205 if (last
== NULL_TREE
&& TREE_ADDRESSABLE (parms
))
206 return N_("no prototype, and parameter address used; cannot be inline");
210 /* We can't inline functions that return structures
211 the old-fashioned PCC way, copying into a static block. */
212 if (current_function_returns_pcc_struct
)
213 return N_("inline functions not supported for this return value type");
215 /* We can't inline functions that return structures of varying size. */
216 if (TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
217 && int_size_in_bytes (TREE_TYPE (TREE_TYPE (fndecl
))) < 0)
218 return N_("function with varying-size return value cannot be inline");
220 /* Cannot inline a function with a varying size argument or one that
221 receives a transparent union. */
222 for (parms
= DECL_ARGUMENTS (fndecl
); parms
; parms
= TREE_CHAIN (parms
))
224 if (int_size_in_bytes (TREE_TYPE (parms
)) < 0)
225 return N_("function with varying-size parameter cannot be inline");
226 else if (TREE_CODE (TREE_TYPE (parms
)) == UNION_TYPE
227 && TYPE_TRANSPARENT_UNION (TREE_TYPE (parms
)))
228 return N_("function with transparent unit parameter cannot be inline");
231 if (get_max_uid () > max_insns
)
233 for (ninsns
= 0, insn
= get_first_nonparm_insn ();
234 insn
&& ninsns
< max_insns
;
235 insn
= NEXT_INSN (insn
))
239 if (ninsns
>= max_insns
)
240 return N_("function too large to be inline");
243 /* We will not inline a function which uses computed goto. The addresses of
244 its local labels, which may be tucked into global storage, are of course
245 not constant across instantiations, which causes unexpected behavior. */
246 if (current_function_has_computed_jump
)
247 return N_("function with computed jump cannot inline");
249 /* We cannot inline a nested function that jumps to a nonlocal label. */
250 if (current_function_has_nonlocal_goto
)
251 return N_("function with nonlocal goto cannot be inline");
253 /* We can't inline functions that return a PARALLEL rtx. */
254 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
256 rtx result
= DECL_RTL (DECL_RESULT (fndecl
));
257 if (GET_CODE (result
) == PARALLEL
)
258 return N_("inline functions not supported for this return value type");
261 /* If the function has a target specific attribute attached to it,
262 then we assume that we should not inline it. This can be overridden
263 by the target if it defines TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P. */
264 if (!function_attribute_inlinable_p (fndecl
))
265 return N_("function with target specific attribute(s) cannot be inlined");
270 /* Map pseudo reg number into the PARM_DECL for the parm living in the reg.
271 Zero for a reg that isn't a parm's home.
272 Only reg numbers less than max_parm_reg are mapped here. */
273 static tree
*parmdecl_map
;
275 /* In save_for_inline, nonzero if past the parm-initialization insns. */
276 static int in_nonparm_insns
;
278 /* Subroutine for `save_for_inline'. Performs initialization
279 needed to save FNDECL's insns and info for future inline expansion. */
282 initialize_for_inline (tree fndecl
)
288 /* Clear out PARMDECL_MAP. It was allocated in the caller's frame. */
289 memset (parmdecl_map
, 0, max_parm_reg
* sizeof (tree
));
290 arg_vector
= rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl
)));
292 for (parms
= DECL_ARGUMENTS (fndecl
), i
= 0;
294 parms
= TREE_CHAIN (parms
), i
++)
296 rtx p
= DECL_RTL (parms
);
298 /* If we have (mem (addressof (mem ...))), use the inner MEM since
299 otherwise the copy_rtx call below will not unshare the MEM since
300 it shares ADDRESSOF. */
301 if (GET_CODE (p
) == MEM
&& GET_CODE (XEXP (p
, 0)) == ADDRESSOF
302 && GET_CODE (XEXP (XEXP (p
, 0), 0)) == MEM
)
303 p
= XEXP (XEXP (p
, 0), 0);
305 RTVEC_ELT (arg_vector
, i
) = p
;
307 if (GET_CODE (p
) == REG
)
308 parmdecl_map
[REGNO (p
)] = parms
;
309 else if (GET_CODE (p
) == CONCAT
)
311 rtx preal
= gen_realpart (GET_MODE (XEXP (p
, 0)), p
);
312 rtx pimag
= gen_imagpart (GET_MODE (preal
), p
);
314 if (GET_CODE (preal
) == REG
)
315 parmdecl_map
[REGNO (preal
)] = parms
;
316 if (GET_CODE (pimag
) == REG
)
317 parmdecl_map
[REGNO (pimag
)] = parms
;
320 /* This flag is cleared later
321 if the function ever modifies the value of the parm. */
322 TREE_READONLY (parms
) = 1;
328 /* Copy NODE (which must be a DECL, but not a PARM_DECL). The DECL
329 originally was in the FROM_FN, but now it will be in the
333 copy_decl_for_inlining (tree decl
, tree from_fn
, tree to_fn
)
337 /* Copy the declaration. */
338 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
343 /* See if the frontend wants to pass this by invisible reference. */
344 if (TREE_CODE (decl
) == PARM_DECL
345 && DECL_ARG_TYPE (decl
) != TREE_TYPE (decl
)
346 && POINTER_TYPE_P (DECL_ARG_TYPE (decl
))
347 && TREE_TYPE (DECL_ARG_TYPE (decl
)) == TREE_TYPE (decl
))
350 type
= DECL_ARG_TYPE (decl
);
353 type
= TREE_TYPE (decl
);
355 /* For a parameter, we must make an equivalent VAR_DECL, not a
357 copy
= build_decl (VAR_DECL
, DECL_NAME (decl
), type
);
360 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
361 TREE_READONLY (copy
) = TREE_READONLY (decl
);
362 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
366 TREE_ADDRESSABLE (copy
) = 0;
367 TREE_READONLY (copy
) = 1;
368 TREE_THIS_VOLATILE (copy
) = 0;
373 copy
= copy_node (decl
);
374 /* The COPY is not abstract; it will be generated in TO_FN. */
375 DECL_ABSTRACT (copy
) = 0;
376 (*lang_hooks
.dup_lang_specific_decl
) (copy
);
378 /* TREE_ADDRESSABLE isn't used to indicate that a label's
379 address has been taken; it's for internal bookkeeping in
380 expand_goto_internal. */
381 if (TREE_CODE (copy
) == LABEL_DECL
)
382 TREE_ADDRESSABLE (copy
) = 0;
385 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
386 declaration inspired this copy. */
387 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
389 /* The new variable/label has no RTL, yet. */
390 if (!TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
391 SET_DECL_RTL (copy
, NULL_RTX
);
393 /* These args would always appear unused, if not for this. */
394 TREE_USED (copy
) = 1;
396 /* Set the context for the new declaration. */
397 if (!DECL_CONTEXT (decl
))
398 /* Globals stay global. */
400 else if (DECL_CONTEXT (decl
) != from_fn
)
401 /* Things that weren't in the scope of the function we're inlining
402 from aren't in the scope we're inlining to, either. */
404 else if (TREE_STATIC (decl
))
405 /* Function-scoped static variables should stay in the original
409 /* Ordinary automatic local variables are now in the scope of the
411 DECL_CONTEXT (copy
) = to_fn
;
416 /* Make the insns and PARM_DECLs of the current function permanent
417 and record other information in DECL_SAVED_INSNS to allow inlining
418 of this function in subsequent calls.
420 This routine need not copy any insns because we are not going
421 to immediately compile the insns in the insn chain. There
422 are two cases when we would compile the insns for FNDECL:
423 (1) when FNDECL is expanded inline, and (2) when FNDECL needs to
424 be output at the end of other compilation, because somebody took
425 its address. In the first case, the insns of FNDECL are copied
426 as it is expanded inline, so FNDECL's saved insns are not
427 modified. In the second case, FNDECL is used for the last time,
428 so modifying the rtl is not a problem.
430 We don't have to worry about FNDECL being inline expanded by
431 other functions which are written at the end of compilation
432 because flag_no_inline is turned on when we begin writing
433 functions at the end of compilation. */
436 save_for_inline (tree fndecl
)
440 rtx first_nonparm_insn
;
442 /* Set up PARMDECL_MAP which maps pseudo-reg number to its PARM_DECL.
443 Later we set TREE_READONLY to 0 if the parm is modified inside the fn.
444 Also set up ARG_VECTOR, which holds the unmodified DECL_RTX values
445 for the parms, prior to elimination of virtual registers.
446 These values are needed for substituting parms properly. */
447 if (! flag_no_inline
)
448 parmdecl_map
= xmalloc (max_parm_reg
* sizeof (tree
));
450 /* Make and emit a return-label if we have not already done so. */
452 if (return_label
== 0)
454 return_label
= gen_label_rtx ();
455 emit_label (return_label
);
458 if (! flag_no_inline
)
459 argvec
= initialize_for_inline (fndecl
);
463 /* Delete basic block notes created by early run of find_basic_block.
464 The notes would be later used by find_basic_blocks to reuse the memory
465 for basic_block structures on already freed obstack. */
466 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
467 if (GET_CODE (insn
) == NOTE
&& NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BASIC_BLOCK
)
468 delete_related_insns (insn
);
470 /* If there are insns that copy parms from the stack into pseudo registers,
471 those insns are not copied. `expand_inline_function' must
472 emit the correct code to handle such things. */
475 if (GET_CODE (insn
) != NOTE
)
478 if (! flag_no_inline
)
480 /* Get the insn which signals the end of parameter setup code. */
481 first_nonparm_insn
= get_first_nonparm_insn ();
483 /* Now just scan the chain of insns to see what happens to our
484 PARM_DECLs. If a PARM_DECL is used but never modified, we
485 can substitute its rtl directly when expanding inline (and
486 perform constant folding when its incoming value is
487 constant). Otherwise, we have to copy its value into a new
488 register and track the new register's life. */
489 in_nonparm_insns
= 0;
490 save_parm_insns (insn
, first_nonparm_insn
);
492 cfun
->inl_max_label_num
= max_label_num ();
493 cfun
->inl_last_parm_insn
= cfun
->x_last_parm_insn
;
494 cfun
->original_arg_vector
= argvec
;
496 cfun
->original_decl_initial
= DECL_INITIAL (fndecl
);
497 cfun
->no_debugging_symbols
= (write_symbols
== NO_DEBUG
);
498 cfun
->saved_for_inline
= 1;
501 if (! flag_no_inline
)
505 /* Scan the chain of insns to see what happens to our PARM_DECLs. If a
506 PARM_DECL is used but never modified, we can substitute its rtl directly
507 when expanding inline (and perform constant folding when its incoming
508 value is constant). Otherwise, we have to copy its value into a new
509 register and track the new register's life. */
512 save_parm_insns (rtx insn
, rtx first_nonparm_insn
)
514 if (insn
== NULL_RTX
)
517 for (insn
= NEXT_INSN (insn
); insn
; insn
= NEXT_INSN (insn
))
519 if (insn
== first_nonparm_insn
)
520 in_nonparm_insns
= 1;
524 /* Record what interesting things happen to our parameters. */
525 note_stores (PATTERN (insn
), note_modified_parmregs
, NULL
);
527 /* If this is a CALL_PLACEHOLDER insn then we need to look into the
528 three attached sequences: normal call, sibling call and tail
530 if (GET_CODE (insn
) == CALL_INSN
531 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
535 for (i
= 0; i
< 3; i
++)
536 save_parm_insns (XEXP (PATTERN (insn
), i
),
543 /* Note whether a parameter is modified or not. */
546 note_modified_parmregs (rtx reg
, rtx x ATTRIBUTE_UNUSED
, void *data ATTRIBUTE_UNUSED
)
548 if (GET_CODE (reg
) == REG
&& in_nonparm_insns
549 && REGNO (reg
) < max_parm_reg
550 && REGNO (reg
) >= FIRST_PSEUDO_REGISTER
551 && parmdecl_map
[REGNO (reg
)] != 0)
552 TREE_READONLY (parmdecl_map
[REGNO (reg
)]) = 0;
555 /* Unfortunately, we need a global copy of const_equiv map for communication
556 with a function called from note_stores. Be *very* careful that this
557 is used properly in the presence of recursion. */
559 varray_type global_const_equiv_varray
;
561 #define FIXED_BASE_PLUS_P(X) \
562 (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
563 && GET_CODE (XEXP (X, 0)) == REG \
564 && REGNO (XEXP (X, 0)) >= FIRST_VIRTUAL_REGISTER \
565 && REGNO (XEXP (X, 0)) <= LAST_VIRTUAL_REGISTER)
567 /* Called to set up a mapping for the case where a parameter is in a
568 register. If it is read-only and our argument is a constant, set up the
569 constant equivalence.
571 If LOC is REG_USERVAR_P, the usual case, COPY must also have that flag set
574 Also, don't allow hard registers here; they might not be valid when
575 substituted into insns. */
577 process_reg_param (struct inline_remap
*map
, rtx loc
, rtx copy
)
579 if ((GET_CODE (copy
) != REG
&& GET_CODE (copy
) != SUBREG
)
580 || (GET_CODE (copy
) == REG
&& REG_USERVAR_P (loc
)
581 && ! REG_USERVAR_P (copy
))
582 || (GET_CODE (copy
) == REG
583 && REGNO (copy
) < FIRST_PSEUDO_REGISTER
))
585 rtx temp
= copy_to_mode_reg (GET_MODE (loc
), copy
);
586 REG_USERVAR_P (temp
) = REG_USERVAR_P (loc
);
587 if (CONSTANT_P (copy
) || FIXED_BASE_PLUS_P (copy
))
588 SET_CONST_EQUIV_DATA (map
, temp
, copy
, CONST_AGE_PARM
);
591 map
->reg_map
[REGNO (loc
)] = copy
;
594 /* Compare two BLOCKs for qsort. The key we sort on is the
595 BLOCK_ABSTRACT_ORIGIN of the blocks. We cannot just subtract the
596 two pointers, because it may overflow sizeof(int). */
599 compare_blocks (const void *v1
, const void *v2
)
601 tree b1
= *((const tree
*) v1
);
602 tree b2
= *((const tree
*) v2
);
603 char *p1
= (char *) BLOCK_ABSTRACT_ORIGIN (b1
);
604 char *p2
= (char *) BLOCK_ABSTRACT_ORIGIN (b2
);
608 return p1
< p2
? -1 : 1;
611 /* Compare two BLOCKs for bsearch. The first pointer corresponds to
612 an original block; the second to a remapped equivalent. */
615 find_block (const void *v1
, const void *v2
)
617 const union tree_node
*b1
= (const union tree_node
*) v1
;
618 tree b2
= *((const tree
*) v2
);
619 char *p1
= (char *) b1
;
620 char *p2
= (char *) BLOCK_ABSTRACT_ORIGIN (b2
);
624 return p1
< p2
? -1 : 1;
627 /* Integrate the procedure defined by FNDECL. Note that this function
628 may wind up calling itself. Since the static variables are not
629 reentrant, we do not assign them until after the possibility
630 of recursion is eliminated.
632 If IGNORE is nonzero, do not produce a value.
633 Otherwise store the value in TARGET if it is nonzero and that is convenient.
636 (rtx)-1 if we could not substitute the function
637 0 if we substituted it and it does not produce a value
638 else an rtx for where the value is stored. */
641 expand_inline_function (tree fndecl
, tree parms
, rtx target
, int ignore
,
642 tree type
, rtx structure_value_addr
)
644 struct function
*inlining_previous
;
645 struct function
*inl_f
= DECL_SAVED_INSNS (fndecl
);
646 tree formal
, actual
, block
;
647 rtx parm_insns
= inl_f
->emit
->x_first_insn
;
648 rtx insns
= (inl_f
->inl_last_parm_insn
649 ? NEXT_INSN (inl_f
->inl_last_parm_insn
)
655 int min_labelno
= inl_f
->emit
->x_first_label_num
;
656 int max_labelno
= inl_f
->inl_max_label_num
;
661 struct inline_remap
*map
= 0;
662 rtvec arg_vector
= inl_f
->original_arg_vector
;
663 rtx static_chain_value
= 0;
665 int eh_region_offset
;
667 /* The pointer used to track the true location of the memory used
668 for MAP->LABEL_MAP. */
669 rtx
*real_label_map
= 0;
671 /* Allow for equivalences of the pseudos we make for virtual fp and ap. */
672 max_regno
= inl_f
->emit
->x_reg_rtx_no
+ 3;
673 if (max_regno
< FIRST_PSEUDO_REGISTER
)
676 /* Pull out the decl for the function definition; fndecl may be a
677 local declaration, which would break DECL_ABSTRACT_ORIGIN. */
678 fndecl
= inl_f
->decl
;
680 nargs
= list_length (DECL_ARGUMENTS (fndecl
));
682 if (cfun
->preferred_stack_boundary
< inl_f
->preferred_stack_boundary
)
683 cfun
->preferred_stack_boundary
= inl_f
->preferred_stack_boundary
;
685 /* Check that the parms type match and that sufficient arguments were
686 passed. Since the appropriate conversions or default promotions have
687 already been applied, the machine modes should match exactly. */
689 for (formal
= DECL_ARGUMENTS (fndecl
), actual
= parms
;
691 formal
= TREE_CHAIN (formal
), actual
= TREE_CHAIN (actual
))
694 enum machine_mode mode
;
697 return (rtx
) (size_t) -1;
699 arg
= TREE_VALUE (actual
);
700 mode
= TYPE_MODE (DECL_ARG_TYPE (formal
));
702 if (arg
== error_mark_node
703 || mode
!= TYPE_MODE (TREE_TYPE (arg
))
704 /* If they are block mode, the types should match exactly.
705 They don't match exactly if TREE_TYPE (FORMAL) == ERROR_MARK_NODE,
706 which could happen if the parameter has incomplete type. */
708 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg
))
709 != TYPE_MAIN_VARIANT (TREE_TYPE (formal
)))))
710 return (rtx
) (size_t) -1;
713 /* If there is a TARGET which is a readonly BLKmode MEM and DECL_RESULT
714 is also a mem, we are going to lose the readonly on the stores, so don't
716 if (target
!= 0 && GET_CODE (target
) == MEM
&& GET_MODE (target
) == BLKmode
717 && RTX_UNCHANGING_P (target
) && DECL_RTL_SET_P (DECL_RESULT (fndecl
))
718 && GET_CODE (DECL_RTL (DECL_RESULT (fndecl
))) == MEM
)
719 return (rtx
) (size_t) -1;
721 /* Extra arguments are valid, but will be ignored below, so we must
722 evaluate them here for side-effects. */
723 for (; actual
; actual
= TREE_CHAIN (actual
))
724 expand_expr (TREE_VALUE (actual
), const0_rtx
,
725 TYPE_MODE (TREE_TYPE (TREE_VALUE (actual
))), 0);
727 /* Expand the function arguments. Do this first so that any
728 new registers get created before we allocate the maps. */
730 arg_vals
= xmalloc (nargs
* sizeof (rtx
));
731 arg_trees
= xmalloc (nargs
* sizeof (tree
));
733 for (formal
= DECL_ARGUMENTS (fndecl
), actual
= parms
, i
= 0;
735 formal
= TREE_CHAIN (formal
), actual
= TREE_CHAIN (actual
), i
++)
737 /* Actual parameter, converted to the type of the argument within the
739 tree arg
= convert (TREE_TYPE (formal
), TREE_VALUE (actual
));
740 /* Mode of the variable used within the function. */
741 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (formal
));
745 loc
= RTVEC_ELT (arg_vector
, i
);
747 /* If this is an object passed by invisible reference, we copy the
748 object into a stack slot and save its address. If this will go
749 into memory, we do nothing now. Otherwise, we just expand the
751 if (GET_CODE (loc
) == MEM
&& GET_CODE (XEXP (loc
, 0)) == REG
752 && REGNO (XEXP (loc
, 0)) > LAST_VIRTUAL_REGISTER
)
754 rtx stack_slot
= assign_temp (TREE_TYPE (arg
), 1, 1, 1);
756 store_expr (arg
, stack_slot
, 0);
757 arg_vals
[i
] = XEXP (stack_slot
, 0);
760 else if (GET_CODE (loc
) != MEM
)
762 if (GET_MODE (loc
) != TYPE_MODE (TREE_TYPE (arg
)))
764 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (formal
));
765 enum machine_mode pmode
= TYPE_MODE (TREE_TYPE (formal
));
767 pmode
= promote_mode (TREE_TYPE (formal
), pmode
,
770 if (GET_MODE (loc
) != pmode
)
773 /* The mode if LOC and ARG can differ if LOC was a variable
774 that had its mode promoted. */
775 arg_vals
[i
] = convert_modes (pmode
,
776 TYPE_MODE (TREE_TYPE (arg
)),
777 expand_expr (arg
, NULL_RTX
, mode
,
782 arg_vals
[i
] = expand_expr (arg
, NULL_RTX
, mode
, EXPAND_SUM
);
787 /* If the formal type was const but the actual was not, we might
788 end up here with an rtx wrongly tagged unchanging in the caller's
789 context. Fix that. */
791 && (GET_CODE (arg_vals
[i
]) == REG
|| GET_CODE (arg_vals
[i
]) == MEM
)
792 && ! TREE_READONLY (TREE_VALUE (actual
)))
793 RTX_UNCHANGING_P (arg_vals
[i
]) = 0;
796 && (! TREE_READONLY (formal
)
797 /* If the parameter is not read-only, copy our argument through
798 a register. Also, we cannot use ARG_VALS[I] if it overlaps
799 TARGET in any way. In the inline function, they will likely
800 be two different pseudos, and `safe_from_p' will make all
801 sorts of smart assumptions about their not conflicting.
802 But if ARG_VALS[I] overlaps TARGET, these assumptions are
803 wrong, so put ARG_VALS[I] into a fresh register.
804 Don't worry about invisible references, since their stack
805 temps will never overlap the target. */
808 && (GET_CODE (arg_vals
[i
]) == REG
809 || GET_CODE (arg_vals
[i
]) == SUBREG
810 || GET_CODE (arg_vals
[i
]) == MEM
)
811 && reg_overlap_mentioned_p (arg_vals
[i
], target
))
812 /* ??? We must always copy a SUBREG into a REG, because it might
813 get substituted into an address, and not all ports correctly
814 handle SUBREGs in addresses. */
815 || (GET_CODE (arg_vals
[i
]) == SUBREG
)))
816 arg_vals
[i
] = copy_to_mode_reg (GET_MODE (loc
), arg_vals
[i
]);
818 if (arg_vals
[i
] != 0 && GET_CODE (arg_vals
[i
]) == REG
819 && POINTER_TYPE_P (TREE_TYPE (formal
)))
820 mark_reg_pointer (arg_vals
[i
],
821 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (formal
))));
824 /* Allocate the structures we use to remap things. */
826 map
= xcalloc (1, sizeof (struct inline_remap
));
827 map
->fndecl
= fndecl
;
829 VARRAY_TREE_INIT (map
->block_map
, 10, "block_map");
830 map
->reg_map
= xcalloc (max_regno
, sizeof (rtx
));
832 /* We used to use alloca here, but the size of what it would try to
833 allocate would occasionally cause it to exceed the stack limit and
834 cause unpredictable core dumps. */
835 real_label_map
= xmalloc ((max_labelno
) * sizeof (rtx
));
836 map
->label_map
= real_label_map
;
837 map
->local_return_label
= NULL_RTX
;
839 inl_max_uid
= (inl_f
->emit
->x_cur_insn_uid
+ 1);
840 map
->insn_map
= xcalloc (inl_max_uid
, sizeof (rtx
));
842 map
->max_insnno
= inl_max_uid
;
844 map
->integrating
= 1;
845 map
->compare_src
= NULL_RTX
;
846 map
->compare_mode
= VOIDmode
;
848 /* const_equiv_varray maps pseudos in our routine to constants, so
849 it needs to be large enough for all our pseudos. This is the
850 number we are currently using plus the number in the called
851 routine, plus 15 for each arg, five to compute the virtual frame
852 pointer, and five for the return value. This should be enough
853 for most cases. We do not reference entries outside the range of
856 ??? These numbers are quite arbitrary and were obtained by
857 experimentation. At some point, we should try to allocate the
858 table after all the parameters are set up so we can more accurately
859 estimate the number of pseudos we will need. */
861 VARRAY_CONST_EQUIV_INIT (map
->const_equiv_varray
,
863 + (max_regno
- FIRST_PSEUDO_REGISTER
)
866 "expand_inline_function");
869 /* Record the current insn in case we have to set up pointers to frame
870 and argument memory blocks. If there are no insns yet, add a dummy
871 insn that can be used as an insertion point. */
872 map
->insns_at_start
= get_last_insn ();
873 if (map
->insns_at_start
== 0)
874 map
->insns_at_start
= emit_note (NOTE_INSN_DELETED
);
876 map
->regno_pointer_align
= inl_f
->emit
->regno_pointer_align
;
877 map
->x_regno_reg_rtx
= inl_f
->emit
->x_regno_reg_rtx
;
879 /* Update the outgoing argument size to allow for those in the inlined
881 if (inl_f
->outgoing_args_size
> current_function_outgoing_args_size
)
882 current_function_outgoing_args_size
= inl_f
->outgoing_args_size
;
884 /* If the inline function needs to make PIC references, that means
885 that this function's PIC offset table must be used. */
886 if (inl_f
->uses_pic_offset_table
)
887 current_function_uses_pic_offset_table
= 1;
889 /* If this function needs a context, set it up. */
890 if (inl_f
->needs_context
)
891 static_chain_value
= lookup_static_chain (fndecl
);
893 /* If the inlined function calls __builtin_constant_p, then we'll
894 need to call purge_builtin_constant_p on this function. */
895 if (inl_f
->calls_constant_p
)
896 current_function_calls_constant_p
= 1;
898 if (GET_CODE (parm_insns
) == NOTE
899 && NOTE_LINE_NUMBER (parm_insns
) > 0)
901 rtx note
= emit_note_copy (parm_insns
);
904 RTX_INTEGRATED_P (note
) = 1;
907 /* Process each argument. For each, set up things so that the function's
908 reference to the argument will refer to the argument being passed.
909 We only replace REG with REG here. Any simplifications are done
912 We make two passes: In the first, we deal with parameters that will
913 be placed into registers, since we need to ensure that the allocated
914 register number fits in const_equiv_map. Then we store all non-register
915 parameters into their memory location. */
917 /* Don't try to free temp stack slots here, because we may put one of the
918 parameters into a temp stack slot. */
920 for (i
= 0; i
< nargs
; i
++)
922 rtx copy
= arg_vals
[i
];
924 loc
= RTVEC_ELT (arg_vector
, i
);
926 /* There are three cases, each handled separately. */
927 if (GET_CODE (loc
) == MEM
&& GET_CODE (XEXP (loc
, 0)) == REG
928 && REGNO (XEXP (loc
, 0)) > LAST_VIRTUAL_REGISTER
)
930 /* This must be an object passed by invisible reference (it could
931 also be a variable-sized object, but we forbid inlining functions
932 with variable-sized arguments). COPY is the address of the
933 actual value (this computation will cause it to be copied). We
934 map that address for the register, noting the actual address as
935 an equivalent in case it can be substituted into the insns. */
937 if (GET_CODE (copy
) != REG
)
939 temp
= copy_addr_to_reg (copy
);
940 if (CONSTANT_P (copy
) || FIXED_BASE_PLUS_P (copy
))
941 SET_CONST_EQUIV_DATA (map
, temp
, copy
, CONST_AGE_PARM
);
944 map
->reg_map
[REGNO (XEXP (loc
, 0))] = copy
;
946 else if (GET_CODE (loc
) == MEM
)
948 /* This is the case of a parameter that lives in memory. It
949 will live in the block we allocate in the called routine's
950 frame that simulates the incoming argument area. Do nothing
951 with the parameter now; we will call store_expr later. In
952 this case, however, we must ensure that the virtual stack and
953 incoming arg rtx values are expanded now so that we can be
954 sure we have enough slots in the const equiv map since the
955 store_expr call can easily blow the size estimate. */
956 if (DECL_SAVED_INSNS (fndecl
)->args_size
!= 0)
957 copy_rtx_and_substitute (virtual_incoming_args_rtx
, map
, 0);
959 else if (GET_CODE (loc
) == REG
)
960 process_reg_param (map
, loc
, copy
);
961 else if (GET_CODE (loc
) == CONCAT
)
963 rtx locreal
= gen_realpart (GET_MODE (XEXP (loc
, 0)), loc
);
964 rtx locimag
= gen_imagpart (GET_MODE (XEXP (loc
, 0)), loc
);
965 rtx copyreal
= gen_realpart (GET_MODE (locreal
), copy
);
966 rtx copyimag
= gen_imagpart (GET_MODE (locimag
), copy
);
968 process_reg_param (map
, locreal
, copyreal
);
969 process_reg_param (map
, locimag
, copyimag
);
975 /* Tell copy_rtx_and_substitute to handle constant pool SYMBOL_REFs
976 specially. This function can be called recursively, so we need to
977 save the previous value. */
978 inlining_previous
= inlining
;
981 /* Now do the parameters that will be placed in memory. */
983 for (formal
= DECL_ARGUMENTS (fndecl
), i
= 0;
984 formal
; formal
= TREE_CHAIN (formal
), i
++)
986 loc
= RTVEC_ELT (arg_vector
, i
);
988 if (GET_CODE (loc
) == MEM
989 /* Exclude case handled above. */
990 && ! (GET_CODE (XEXP (loc
, 0)) == REG
991 && REGNO (XEXP (loc
, 0)) > LAST_VIRTUAL_REGISTER
))
993 rtx note
= emit_line_note (DECL_SOURCE_LOCATION (formal
));
996 RTX_INTEGRATED_P (note
) = 1;
998 /* Compute the address in the area we reserved and store the
1000 temp
= copy_rtx_and_substitute (loc
, map
, 1);
1001 subst_constants (&temp
, NULL_RTX
, map
, 1);
1002 apply_change_group ();
1003 if (! memory_address_p (GET_MODE (temp
), XEXP (temp
, 0)))
1004 temp
= change_address (temp
, VOIDmode
, XEXP (temp
, 0));
1005 store_expr (arg_trees
[i
], temp
, 0);
1009 /* Deal with the places that the function puts its result.
1010 We are driven by what is placed into DECL_RESULT.
1012 Initially, we assume that we don't have anything special handling for
1013 REG_FUNCTION_RETURN_VALUE_P. */
1015 map
->inline_target
= 0;
1016 loc
= (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
1017 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
1019 if (TYPE_MODE (type
) == VOIDmode
)
1020 /* There is no return value to worry about. */
1022 else if (GET_CODE (loc
) == MEM
)
1024 if (GET_CODE (XEXP (loc
, 0)) == ADDRESSOF
)
1026 temp
= copy_rtx_and_substitute (loc
, map
, 1);
1027 subst_constants (&temp
, NULL_RTX
, map
, 1);
1028 apply_change_group ();
1033 if (! structure_value_addr
1034 || ! aggregate_value_p (DECL_RESULT (fndecl
), fndecl
))
1037 /* Pass the function the address in which to return a structure
1038 value. Note that a constructor can cause someone to call us
1039 with STRUCTURE_VALUE_ADDR, but the initialization takes place
1040 via the first parameter, rather than the struct return address.
1042 We have two cases: If the address is a simple register
1043 indirect, use the mapping mechanism to point that register to
1044 our structure return address. Otherwise, store the structure
1045 return value into the place that it will be referenced from. */
1047 if (GET_CODE (XEXP (loc
, 0)) == REG
)
1049 temp
= force_operand (structure_value_addr
, NULL_RTX
);
1050 temp
= force_reg (Pmode
, temp
);
1051 /* A virtual register might be invalid in an insn, because
1052 it can cause trouble in reload. Since we don't have access
1053 to the expanders at map translation time, make sure we have
1054 a proper register now.
1055 If a virtual register is actually valid, cse or combine
1056 can put it into the mapped insns. */
1057 if (REGNO (temp
) >= FIRST_VIRTUAL_REGISTER
1058 && REGNO (temp
) <= LAST_VIRTUAL_REGISTER
)
1059 temp
= copy_to_mode_reg (Pmode
, temp
);
1060 map
->reg_map
[REGNO (XEXP (loc
, 0))] = temp
;
1062 if (CONSTANT_P (structure_value_addr
)
1063 || GET_CODE (structure_value_addr
) == ADDRESSOF
1064 || (GET_CODE (structure_value_addr
) == PLUS
1065 && (XEXP (structure_value_addr
, 0)
1066 == virtual_stack_vars_rtx
)
1067 && (GET_CODE (XEXP (structure_value_addr
, 1))
1070 SET_CONST_EQUIV_DATA (map
, temp
, structure_value_addr
,
1076 temp
= copy_rtx_and_substitute (loc
, map
, 1);
1077 subst_constants (&temp
, NULL_RTX
, map
, 0);
1078 apply_change_group ();
1079 emit_move_insn (temp
, structure_value_addr
);
1084 /* We will ignore the result value, so don't look at its structure.
1085 Note that preparations for an aggregate return value
1086 do need to be made (above) even if it will be ignored. */
1088 else if (GET_CODE (loc
) == REG
)
1090 /* The function returns an object in a register and we use the return
1091 value. Set up our target for remapping. */
1093 /* Machine mode function was declared to return. */
1094 enum machine_mode departing_mode
= TYPE_MODE (type
);
1095 /* (Possibly wider) machine mode it actually computes
1096 (for the sake of callers that fail to declare it right).
1097 We have to use the mode of the result's RTL, rather than
1098 its type, since expand_function_start may have promoted it. */
1099 enum machine_mode arriving_mode
1100 = GET_MODE (DECL_RTL (DECL_RESULT (fndecl
)));
1103 /* Don't use MEMs as direct targets because on some machines
1104 substituting a MEM for a REG makes invalid insns.
1105 Let the combiner substitute the MEM if that is valid. */
1106 if (target
== 0 || GET_CODE (target
) != REG
1107 || GET_MODE (target
) != departing_mode
)
1109 /* Don't make BLKmode registers. If this looks like
1110 a BLKmode object being returned in a register, get
1111 the mode from that, otherwise abort. */
1112 if (departing_mode
== BLKmode
)
1114 if (REG
== GET_CODE (DECL_RTL (DECL_RESULT (fndecl
))))
1116 departing_mode
= GET_MODE (DECL_RTL (DECL_RESULT (fndecl
)));
1117 arriving_mode
= departing_mode
;
1123 target
= gen_reg_rtx (departing_mode
);
1126 /* If function's value was promoted before return,
1127 avoid machine mode mismatch when we substitute INLINE_TARGET.
1128 But TARGET is what we will return to the caller. */
1129 if (arriving_mode
!= departing_mode
)
1131 /* Avoid creating a paradoxical subreg wider than
1132 BITS_PER_WORD, since that is illegal. */
1133 if (GET_MODE_BITSIZE (arriving_mode
) > BITS_PER_WORD
)
1135 if (!TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (departing_mode
),
1136 GET_MODE_BITSIZE (arriving_mode
)))
1137 /* Maybe could be handled by using convert_move () ? */
1139 reg_to_map
= gen_reg_rtx (arriving_mode
);
1140 target
= gen_lowpart (departing_mode
, reg_to_map
);
1143 reg_to_map
= gen_rtx_SUBREG (arriving_mode
, target
, 0);
1146 reg_to_map
= target
;
1148 /* Usually, the result value is the machine's return register.
1149 Sometimes it may be a pseudo. Handle both cases. */
1150 if (REG_FUNCTION_VALUE_P (loc
))
1151 map
->inline_target
= reg_to_map
;
1153 map
->reg_map
[REGNO (loc
)] = reg_to_map
;
1155 else if (GET_CODE (loc
) == CONCAT
)
1157 enum machine_mode departing_mode
= TYPE_MODE (type
);
1158 enum machine_mode arriving_mode
1159 = GET_MODE (DECL_RTL (DECL_RESULT (fndecl
)));
1161 if (departing_mode
!= arriving_mode
)
1163 if (GET_CODE (XEXP (loc
, 0)) != REG
1164 || GET_CODE (XEXP (loc
, 1)) != REG
)
1167 /* Don't use MEMs as direct targets because on some machines
1168 substituting a MEM for a REG makes invalid insns.
1169 Let the combiner substitute the MEM if that is valid. */
1170 if (target
== 0 || GET_CODE (target
) != REG
1171 || GET_MODE (target
) != departing_mode
)
1172 target
= gen_reg_rtx (departing_mode
);
1174 if (GET_CODE (target
) != CONCAT
)
1177 map
->reg_map
[REGNO (XEXP (loc
, 0))] = XEXP (target
, 0);
1178 map
->reg_map
[REGNO (XEXP (loc
, 1))] = XEXP (target
, 1);
1183 /* Remap the exception handler data pointer from one to the other. */
1184 temp
= get_exception_pointer (inl_f
);
1186 map
->reg_map
[REGNO (temp
)] = get_exception_pointer (cfun
);
1188 /* Initialize label_map. get_label_from_map will actually make
1190 memset (&map
->label_map
[min_labelno
], 0,
1191 (max_labelno
- min_labelno
) * sizeof (rtx
));
1193 /* Make copies of the decls of the symbols in the inline function, so that
1194 the copies of the variables get declared in the current function. Set
1195 up things so that lookup_static_chain knows that to interpret registers
1196 in SAVE_EXPRs for TYPE_SIZEs as local. */
1197 inline_function_decl
= fndecl
;
1198 integrate_parm_decls (DECL_ARGUMENTS (fndecl
), map
, arg_vector
);
1199 block
= integrate_decl_tree (inl_f
->original_decl_initial
, map
);
1200 BLOCK_ABSTRACT_ORIGIN (block
) = DECL_ORIGIN (fndecl
);
1201 inline_function_decl
= 0;
1203 /* Make a fresh binding contour that we can easily remove. Do this after
1204 expanding our arguments so cleanups are properly scoped. */
1205 expand_start_bindings_and_block (0, block
);
1207 /* Sort the block-map so that it will be easy to find remapped
1209 qsort (&VARRAY_TREE (map
->block_map
, 0),
1210 map
->block_map
->elements_used
,
1214 /* Perform postincrements before actually calling the function. */
1217 /* Clean up stack so that variables might have smaller offsets. */
1218 do_pending_stack_adjust ();
1220 /* Save a copy of the location of const_equiv_varray for
1221 mark_stores, called via note_stores. */
1222 global_const_equiv_varray
= map
->const_equiv_varray
;
1224 /* If the called function does an alloca, save and restore the
1225 stack pointer around the call. This saves stack space, but
1226 also is required if this inline is being done between two
1228 if (inl_f
->calls_alloca
)
1229 emit_stack_save (SAVE_BLOCK
, &stack_save
, NULL_RTX
);
1231 /* Map pseudos used for initial hard reg values. */
1232 setup_initial_hard_reg_value_integration (inl_f
, map
);
1234 /* Now copy the insns one by one. */
1235 copy_insn_list (insns
, map
, static_chain_value
);
1237 /* Duplicate the EH regions. This will create an offset from the
1238 region numbers in the function we're inlining to the region
1239 numbers in the calling function. This must wait until after
1240 copy_insn_list, as we need the insn map to be complete. */
1241 eh_region_offset
= duplicate_eh_regions (inl_f
, map
);
1243 /* Now copy the REG_NOTES for those insns. */
1244 copy_insn_notes (insns
, map
, eh_region_offset
);
1246 /* If the insn sequence required one, emit the return label. */
1247 if (map
->local_return_label
)
1248 emit_label (map
->local_return_label
);
1250 /* Restore the stack pointer if we saved it above. */
1251 if (inl_f
->calls_alloca
)
1252 emit_stack_restore (SAVE_BLOCK
, stack_save
, NULL_RTX
);
1254 if (! cfun
->x_whole_function_mode_p
)
1255 /* In statement-at-a-time mode, we just tell the front-end to add
1256 this block to the list of blocks at this binding level. We
1257 can't do it the way it's done for function-at-a-time mode the
1258 superblocks have not been created yet. */
1259 (*lang_hooks
.decls
.insert_block
) (block
);
1263 = BLOCK_CHAIN (DECL_INITIAL (current_function_decl
));
1264 BLOCK_CHAIN (DECL_INITIAL (current_function_decl
)) = block
;
1267 /* End the scope containing the copied formal parameter variables
1268 and copied LABEL_DECLs. We pass NULL_TREE for the variables list
1269 here so that expand_end_bindings will not check for unused
1270 variables. That's already been checked for when the inlined
1271 function was defined. */
1272 expand_end_bindings (NULL_TREE
, 1, 1);
1274 /* Must mark the line number note after inlined functions as a repeat, so
1275 that the test coverage code can avoid counting the call twice. This
1276 just tells the code to ignore the immediately following line note, since
1277 there already exists a copy of this note before the expanded inline call.
1278 This line number note is still needed for debugging though, so we can't
1280 if (flag_test_coverage
)
1281 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER
);
1283 emit_line_note (input_location
);
1285 /* If the function returns a BLKmode object in a register, copy it
1286 out of the temp register into a BLKmode memory object. */
1288 && TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl
))) == BLKmode
1289 && ! aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
))
1290 target
= copy_blkmode_from_reg (0, target
, TREE_TYPE (TREE_TYPE (fndecl
)));
1292 if (structure_value_addr
)
1294 target
= gen_rtx_MEM (TYPE_MODE (type
),
1295 memory_address (TYPE_MODE (type
),
1296 structure_value_addr
));
1297 set_mem_attributes (target
, type
, 1);
1300 /* Make sure we free the things we explicitly allocated with xmalloc. */
1302 free (real_label_map
);
1303 VARRAY_FREE (map
->const_equiv_varray
);
1304 free (map
->reg_map
);
1305 free (map
->insn_map
);
1310 inlining
= inlining_previous
;
1315 /* Make copies of each insn in the given list using the mapping
1316 computed in expand_inline_function. This function may call itself for
1317 insns containing sequences.
1319 Copying is done in two passes, first the insns and then their REG_NOTES.
1321 If static_chain_value is nonzero, it represents the context-pointer
1322 register for the function. */
1325 copy_insn_list (rtx insns
, struct inline_remap
*map
, rtx static_chain_value
)
1333 rtx static_chain_mem
= 0;
1335 /* Copy the insns one by one. Do this in two passes, first the insns and
1336 then their REG_NOTES. */
1338 /* This loop is very similar to the loop in copy_loop_body in unroll.c. */
1340 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
1342 rtx copy
, pattern
, set
;
1344 map
->orig_asm_operands_vector
= 0;
1346 switch (GET_CODE (insn
))
1349 pattern
= PATTERN (insn
);
1350 set
= single_set (insn
);
1352 if (GET_CODE (pattern
) == USE
1353 && GET_CODE (XEXP (pattern
, 0)) == REG
1354 && REG_FUNCTION_VALUE_P (XEXP (pattern
, 0)))
1355 /* The (USE (REG n)) at return from the function should
1356 be ignored since we are changing (REG n) into
1360 /* Ignore setting a function value that we don't want to use. */
1361 if (map
->inline_target
== 0
1363 && GET_CODE (SET_DEST (set
)) == REG
1364 && REG_FUNCTION_VALUE_P (SET_DEST (set
)))
1366 if (volatile_refs_p (SET_SRC (set
)))
1370 /* If we must not delete the source,
1371 load it into a new temporary. */
1372 copy
= emit_insn (copy_rtx_and_substitute (pattern
, map
, 0));
1374 new_set
= single_set (copy
);
1379 = gen_reg_rtx (GET_MODE (SET_DEST (new_set
)));
1381 /* If the source and destination are the same and it
1382 has a note on it, keep the insn. */
1383 else if (rtx_equal_p (SET_DEST (set
), SET_SRC (set
))
1384 && REG_NOTES (insn
) != 0)
1385 copy
= emit_insn (copy_rtx_and_substitute (pattern
, map
, 0));
1390 /* Similarly if an ignored return value is clobbered. */
1391 else if (map
->inline_target
== 0
1392 && GET_CODE (pattern
) == CLOBBER
1393 && GET_CODE (XEXP (pattern
, 0)) == REG
1394 && REG_FUNCTION_VALUE_P (XEXP (pattern
, 0)))
1397 /* Look for the address of the static chain slot. The
1398 rtx_equal_p comparisons against the
1399 static_chain_incoming_rtx below may fail if the static
1400 chain is in memory and the address specified is not
1401 "legitimate". This happens on Xtensa where the static
1402 chain is at a negative offset from argp and where only
1403 positive offsets are legitimate. When the RTL is
1404 generated, the address is "legitimized" by copying it
1405 into a register, causing the rtx_equal_p comparisons to
1406 fail. This workaround looks for code that sets a
1407 register to the address of the static chain. Subsequent
1408 memory references via that register can then be
1409 identified as static chain references. We assume that
1410 the register is only assigned once, and that the static
1411 chain address is only live in one register at a time. */
1413 else if (static_chain_value
!= 0
1415 && GET_CODE (static_chain_incoming_rtx
) == MEM
1416 && GET_CODE (SET_DEST (set
)) == REG
1417 && rtx_equal_p (SET_SRC (set
),
1418 XEXP (static_chain_incoming_rtx
, 0)))
1421 gen_rtx_MEM (GET_MODE (static_chain_incoming_rtx
),
1424 /* emit the instruction in case it is used for something
1425 other than setting the static chain; if it's not used,
1426 it can always be removed as dead code */
1427 copy
= emit_insn (copy_rtx_and_substitute (pattern
, map
, 0));
1430 /* If this is setting the static chain rtx, omit it. */
1431 else if (static_chain_value
!= 0
1433 && (rtx_equal_p (SET_DEST (set
),
1434 static_chain_incoming_rtx
)
1435 || (static_chain_mem
1436 && rtx_equal_p (SET_DEST (set
), static_chain_mem
))))
1439 /* If this is setting the static chain pseudo, set it from
1440 the value we want to give it instead. */
1441 else if (static_chain_value
!= 0
1443 && (rtx_equal_p (SET_SRC (set
),
1444 static_chain_incoming_rtx
)
1445 || (static_chain_mem
1446 && rtx_equal_p (SET_SRC (set
), static_chain_mem
))))
1448 rtx newdest
= copy_rtx_and_substitute (SET_DEST (set
), map
, 1);
1450 copy
= emit_move_insn (newdest
, static_chain_value
);
1451 if (GET_CODE (static_chain_incoming_rtx
) != MEM
)
1452 static_chain_value
= 0;
1455 /* If this is setting the virtual stack vars register, this must
1456 be the code at the handler for a builtin longjmp. The value
1457 saved in the setjmp buffer will be the address of the frame
1458 we've made for this inlined instance within our frame. But we
1459 know the offset of that value so we can use it to reconstruct
1460 our virtual stack vars register from that value. If we are
1461 copying it from the stack pointer, leave it unchanged. */
1463 && rtx_equal_p (SET_DEST (set
), virtual_stack_vars_rtx
))
1465 HOST_WIDE_INT offset
;
1466 temp
= map
->reg_map
[REGNO (SET_DEST (set
))];
1467 temp
= VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
1470 if (rtx_equal_p (temp
, virtual_stack_vars_rtx
))
1472 else if (GET_CODE (temp
) == PLUS
1473 && rtx_equal_p (XEXP (temp
, 0), virtual_stack_vars_rtx
)
1474 && GET_CODE (XEXP (temp
, 1)) == CONST_INT
)
1475 offset
= INTVAL (XEXP (temp
, 1));
1479 if (rtx_equal_p (SET_SRC (set
), stack_pointer_rtx
))
1480 temp
= SET_SRC (set
);
1482 temp
= force_operand (plus_constant (SET_SRC (set
),
1486 copy
= emit_move_insn (virtual_stack_vars_rtx
, temp
);
1490 copy
= emit_insn (copy_rtx_and_substitute (pattern
, map
, 0));
1491 /* REG_NOTES will be copied later. */
1494 /* If this insn is setting CC0, it may need to look at
1495 the insn that uses CC0 to see what type of insn it is.
1496 In that case, the call to recog via validate_change will
1497 fail. So don't substitute constants here. Instead,
1498 do it when we emit the following insn.
1500 For example, see the pyr.md file. That machine has signed and
1501 unsigned compares. The compare patterns must check the
1502 following branch insn to see which what kind of compare to
1505 If the previous insn set CC0, substitute constants on it as
1507 if (sets_cc0_p (PATTERN (copy
)) != 0)
1512 try_constants (cc0_insn
, map
);
1514 try_constants (copy
, map
);
1517 try_constants (copy
, map
);
1519 INSN_LOCATOR (copy
) = INSN_LOCATOR (insn
);
1523 if (map
->integrating
&& returnjump_p (insn
))
1525 if (map
->local_return_label
== 0)
1526 map
->local_return_label
= gen_label_rtx ();
1527 pattern
= gen_jump (map
->local_return_label
);
1530 pattern
= copy_rtx_and_substitute (PATTERN (insn
), map
, 0);
1532 copy
= emit_jump_insn (pattern
);
1536 try_constants (cc0_insn
, map
);
1539 try_constants (copy
, map
);
1540 INSN_LOCATOR (copy
) = INSN_LOCATOR (insn
);
1542 /* If this used to be a conditional jump insn but whose branch
1543 direction is now know, we must do something special. */
1544 if (any_condjump_p (insn
) && onlyjump_p (insn
) && map
->last_pc_value
)
1547 /* If the previous insn set cc0 for us, delete it. */
1548 if (only_sets_cc0_p (PREV_INSN (copy
)))
1549 delete_related_insns (PREV_INSN (copy
));
1552 /* If this is now a no-op, delete it. */
1553 if (map
->last_pc_value
== pc_rtx
)
1555 delete_related_insns (copy
);
1559 /* Otherwise, this is unconditional jump so we must put a
1560 BARRIER after it. We could do some dead code elimination
1561 here, but jump.c will do it just as well. */
1567 /* If this is a CALL_PLACEHOLDER insn then we need to copy the
1568 three attached sequences: normal call, sibling call and tail
1570 if (GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
1575 for (i
= 0; i
< 3; i
++)
1579 sequence
[i
] = NULL_RTX
;
1580 seq
= XEXP (PATTERN (insn
), i
);
1584 copy_insn_list (seq
, map
, static_chain_value
);
1585 sequence
[i
] = get_insns ();
1590 /* Find the new tail recursion label.
1591 It will already be substituted into sequence[2]. */
1592 tail_label
= copy_rtx_and_substitute (XEXP (PATTERN (insn
), 3),
1595 copy
= emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode
,
1603 pattern
= copy_rtx_and_substitute (PATTERN (insn
), map
, 0);
1604 copy
= emit_call_insn (pattern
);
1606 SIBLING_CALL_P (copy
) = SIBLING_CALL_P (insn
);
1607 CONST_OR_PURE_CALL_P (copy
) = CONST_OR_PURE_CALL_P (insn
);
1608 INSN_LOCATOR (copy
) = INSN_LOCATOR (insn
);
1610 /* Because the USAGE information potentially contains objects other
1611 than hard registers, we need to copy it. */
1613 CALL_INSN_FUNCTION_USAGE (copy
)
1614 = copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn
),
1619 try_constants (cc0_insn
, map
);
1622 try_constants (copy
, map
);
1624 /* Be lazy and assume CALL_INSNs clobber all hard registers. */
1625 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1626 VARRAY_CONST_EQUIV (map
->const_equiv_varray
, i
).rtx
= 0;
1630 copy
= emit_label (get_label_from_map (map
,
1631 CODE_LABEL_NUMBER (insn
)));
1632 LABEL_NAME (copy
) = LABEL_NAME (insn
);
1637 copy
= emit_barrier ();
1641 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
)
1643 copy
= emit_label (get_label_from_map (map
,
1644 CODE_LABEL_NUMBER (insn
)));
1645 LABEL_NAME (copy
) = NOTE_SOURCE_FILE (insn
);
1650 /* NOTE_INSN_FUNCTION_END and NOTE_INSN_FUNCTION_BEG are
1651 discarded because it is important to have only one of
1652 each in the current function.
1654 NOTE_INSN_DELETED notes aren't useful. */
1656 if (NOTE_LINE_NUMBER (insn
) != NOTE_INSN_FUNCTION_END
1657 && NOTE_LINE_NUMBER (insn
) != NOTE_INSN_FUNCTION_BEG
1658 && NOTE_LINE_NUMBER (insn
) != NOTE_INSN_DELETED
)
1660 copy
= emit_note_copy (insn
);
1662 /*Copied a line note, but line numbering is off*/;
1663 else if ((NOTE_LINE_NUMBER (copy
) == NOTE_INSN_BLOCK_BEG
1664 || NOTE_LINE_NUMBER (copy
) == NOTE_INSN_BLOCK_END
)
1665 && NOTE_BLOCK (insn
))
1667 tree
*mapped_block_p
;
1670 = (tree
*) bsearch (NOTE_BLOCK (insn
),
1671 &VARRAY_TREE (map
->block_map
, 0),
1672 map
->block_map
->elements_used
,
1676 if (!mapped_block_p
)
1679 NOTE_BLOCK (copy
) = *mapped_block_p
;
1681 else if (NOTE_LINE_NUMBER (copy
) == NOTE_INSN_EXPECTED_VALUE
)
1682 NOTE_EXPECTED_VALUE (copy
)
1683 = copy_rtx_and_substitute (NOTE_EXPECTED_VALUE (insn
),
1695 RTX_INTEGRATED_P (copy
) = 1;
1697 map
->insn_map
[INSN_UID (insn
)] = copy
;
1701 /* Copy the REG_NOTES. Increment const_age, so that only constants
1702 from parameters can be substituted in. These are the only ones
1703 that are valid across the entire function. */
1706 copy_insn_notes (rtx insns
, struct inline_remap
*map
, int eh_region_offset
)
1711 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
1713 if (! INSN_P (insn
))
1716 new_insn
= map
->insn_map
[INSN_UID (insn
)];
1720 if (REG_NOTES (insn
))
1722 rtx next
, note
= copy_rtx_and_substitute (REG_NOTES (insn
), map
, 0);
1724 /* We must also do subst_constants, in case one of our parameters
1725 has const type and constant value. */
1726 subst_constants (¬e
, NULL_RTX
, map
, 0);
1727 apply_change_group ();
1728 REG_NOTES (new_insn
) = note
;
1730 /* Delete any REG_LABEL notes from the chain. Remap any
1731 REG_EH_REGION notes. */
1732 for (; note
; note
= next
)
1734 next
= XEXP (note
, 1);
1735 if (REG_NOTE_KIND (note
) == REG_LABEL
)
1736 remove_note (new_insn
, note
);
1737 else if (REG_NOTE_KIND (note
) == REG_EH_REGION
1738 && INTVAL (XEXP (note
, 0)) > 0)
1739 XEXP (note
, 0) = GEN_INT (INTVAL (XEXP (note
, 0))
1740 + eh_region_offset
);
1744 if (GET_CODE (insn
) == CALL_INSN
1745 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
1748 for (i
= 0; i
< 3; i
++)
1749 copy_insn_notes (XEXP (PATTERN (insn
), i
), map
, eh_region_offset
);
1752 if (GET_CODE (insn
) == JUMP_INSN
1753 && GET_CODE (PATTERN (insn
)) == RESX
)
1754 XINT (PATTERN (new_insn
), 0) += eh_region_offset
;
1758 /* Given a chain of PARM_DECLs, ARGS, copy each decl into a VAR_DECL,
1759 push all of those decls and give each one the corresponding home. */
1762 integrate_parm_decls (tree args
, struct inline_remap
*map
, rtvec arg_vector
)
1767 for (tail
= args
, i
= 0; tail
; tail
= TREE_CHAIN (tail
), i
++)
1769 tree decl
= copy_decl_for_inlining (tail
, map
->fndecl
,
1770 current_function_decl
);
1772 = copy_rtx_and_substitute (RTVEC_ELT (arg_vector
, i
), map
, 1);
1774 /* We really should be setting DECL_INCOMING_RTL to something reasonable
1775 here, but that's going to require some more work. */
1776 /* DECL_INCOMING_RTL (decl) = ?; */
1777 /* Fully instantiate the address with the equivalent form so that the
1778 debugging information contains the actual register, instead of the
1779 virtual register. Do this by not passing an insn to
1781 subst_constants (&new_decl_rtl
, NULL_RTX
, map
, 1);
1782 apply_change_group ();
1783 SET_DECL_RTL (decl
, new_decl_rtl
);
1787 /* Given a BLOCK node LET, push decls and levels so as to construct in the
1788 current function a tree of contexts isomorphic to the one that is given.
1790 MAP, if nonzero, is a pointer to an inline_remap map which indicates how
1791 registers used in the DECL_RTL field should be remapped. If it is zero,
1792 no mapping is necessary. */
1795 integrate_decl_tree (tree let
, struct inline_remap
*map
)
1801 new_block
= make_node (BLOCK
);
1802 VARRAY_PUSH_TREE (map
->block_map
, new_block
);
1803 next
= &BLOCK_VARS (new_block
);
1805 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1809 d
= copy_decl_for_inlining (t
, map
->fndecl
, current_function_decl
);
1811 if (DECL_RTL_SET_P (t
))
1815 SET_DECL_RTL (d
, copy_rtx_and_substitute (DECL_RTL (t
), map
, 1));
1817 /* Fully instantiate the address with the equivalent form so that the
1818 debugging information contains the actual register, instead of the
1819 virtual register. Do this by not passing an insn to
1822 subst_constants (&r
, NULL_RTX
, map
, 1);
1823 SET_DECL_RTL (d
, r
);
1825 apply_change_group ();
1828 /* Add this declaration to the list of variables in the new
1831 next
= &TREE_CHAIN (d
);
1834 next
= &BLOCK_SUBBLOCKS (new_block
);
1835 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= BLOCK_CHAIN (t
))
1837 *next
= integrate_decl_tree (t
, map
);
1838 BLOCK_SUPERCONTEXT (*next
) = new_block
;
1839 next
= &BLOCK_CHAIN (*next
);
1842 TREE_USED (new_block
) = TREE_USED (let
);
1843 BLOCK_ABSTRACT_ORIGIN (new_block
) = let
;
1848 /* Create a new copy of an rtx. Recursively copies the operands of the rtx,
1849 except for those few rtx codes that are sharable.
1851 We always return an rtx that is similar to that incoming rtx, with the
1852 exception of possibly changing a REG to a SUBREG or vice versa. No
1853 rtl is ever emitted.
1855 If FOR_LHS is nonzero, if means we are processing something that will
1856 be the LHS of a SET. In that case, we copy RTX_UNCHANGING_P even if
1857 inlining since we need to be conservative in how it is set for
1860 Handle constants that need to be placed in the constant pool by
1861 calling `force_const_mem'. */
1864 copy_rtx_and_substitute (rtx orig
, struct inline_remap
*map
, int for_lhs
)
1869 enum machine_mode mode
;
1870 const char *format_ptr
;
1876 code
= GET_CODE (orig
);
1877 mode
= GET_MODE (orig
);
1882 /* If the stack pointer register shows up, it must be part of
1883 stack-adjustments (*not* because we eliminated the frame pointer!).
1884 Small hard registers are returned as-is. Pseudo-registers
1885 go through their `reg_map'. */
1886 regno
= REGNO (orig
);
1887 if (regno
<= LAST_VIRTUAL_REGISTER
1888 || (map
->integrating
1889 && DECL_SAVED_INSNS (map
->fndecl
)->internal_arg_pointer
== orig
))
1891 /* Some hard registers are also mapped,
1892 but others are not translated. */
1893 if (map
->reg_map
[regno
] != 0)
1894 return map
->reg_map
[regno
];
1896 /* If this is the virtual frame pointer, make space in current
1897 function's stack frame for the stack frame of the inline function.
1899 Copy the address of this area into a pseudo. Map
1900 virtual_stack_vars_rtx to this pseudo and set up a constant
1901 equivalence for it to be the address. This will substitute the
1902 address into insns where it can be substituted and use the new
1903 pseudo where it can't. */
1904 else if (regno
== VIRTUAL_STACK_VARS_REGNUM
)
1907 int size
= get_func_frame_size (DECL_SAVED_INSNS (map
->fndecl
));
1908 #ifdef FRAME_GROWS_DOWNWARD
1910 = (DECL_SAVED_INSNS (map
->fndecl
)->stack_alignment_needed
1913 /* In this case, virtual_stack_vars_rtx points to one byte
1914 higher than the top of the frame area. So make sure we
1915 allocate a big enough chunk to keep the frame pointer
1916 aligned like a real one. */
1918 size
= CEIL_ROUND (size
, alignment
);
1921 loc
= assign_stack_temp (BLKmode
, size
, 1);
1922 loc
= XEXP (loc
, 0);
1923 #ifdef FRAME_GROWS_DOWNWARD
1924 /* In this case, virtual_stack_vars_rtx points to one byte
1925 higher than the top of the frame area. So compute the offset
1926 to one byte higher than our substitute frame. */
1927 loc
= plus_constant (loc
, size
);
1929 map
->reg_map
[regno
] = temp
1930 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
1932 #ifdef STACK_BOUNDARY
1933 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
1936 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
1940 emit_insn_after (seq
, map
->insns_at_start
);
1943 else if (regno
== VIRTUAL_INCOMING_ARGS_REGNUM
1944 || (map
->integrating
1945 && (DECL_SAVED_INSNS (map
->fndecl
)->internal_arg_pointer
1948 /* Do the same for a block to contain any arguments referenced
1951 int size
= DECL_SAVED_INSNS (map
->fndecl
)->args_size
;
1954 loc
= assign_stack_temp (BLKmode
, size
, 1);
1955 loc
= XEXP (loc
, 0);
1956 /* When arguments grow downward, the virtual incoming
1957 args pointer points to the top of the argument block,
1958 so the remapped location better do the same. */
1959 #ifdef ARGS_GROW_DOWNWARD
1960 loc
= plus_constant (loc
, size
);
1962 map
->reg_map
[regno
] = temp
1963 = force_reg (Pmode
, force_operand (loc
, NULL_RTX
));
1965 #ifdef STACK_BOUNDARY
1966 mark_reg_pointer (map
->reg_map
[regno
], STACK_BOUNDARY
);
1969 SET_CONST_EQUIV_DATA (map
, temp
, loc
, CONST_AGE_PARM
);
1973 emit_insn_after (seq
, map
->insns_at_start
);
1976 else if (REG_FUNCTION_VALUE_P (orig
))
1978 /* This is a reference to the function return value. If
1979 the function doesn't have a return value, error. If the
1980 mode doesn't agree, and it ain't BLKmode, make a SUBREG. */
1981 if (map
->inline_target
== 0)
1983 if (rtx_equal_function_value_matters
)
1984 /* This is an ignored return value. We must not
1985 leave it in with REG_FUNCTION_VALUE_P set, since
1986 that would confuse subsequent inlining of the
1987 current function into a later function. */
1988 return gen_rtx_REG (GET_MODE (orig
), regno
);
1990 /* Must be unrolling loops or replicating code if we
1991 reach here, so return the register unchanged. */
1994 else if (GET_MODE (map
->inline_target
) != BLKmode
1995 && mode
!= GET_MODE (map
->inline_target
))
1996 return gen_lowpart (mode
, map
->inline_target
);
1998 return map
->inline_target
;
2000 #if defined (LEAF_REGISTERS) && defined (LEAF_REG_REMAP)
2001 /* If leaf_renumber_regs_insn() might remap this register to
2002 some other number, make sure we don't share it with the
2003 inlined function, otherwise delayed optimization of the
2004 inlined function may change it in place, breaking our
2005 reference to it. We may still shared it within the
2006 function, so create an entry for this register in the
2008 if (map
->integrating
&& regno
< FIRST_PSEUDO_REGISTER
2009 && LEAF_REGISTERS
[regno
] && LEAF_REG_REMAP (regno
) != regno
)
2011 if (!map
->leaf_reg_map
[regno
][mode
])
2012 map
->leaf_reg_map
[regno
][mode
] = gen_rtx_REG (mode
, regno
);
2013 return map
->leaf_reg_map
[regno
][mode
];
2021 if (map
->reg_map
[regno
] == NULL
)
2023 map
->reg_map
[regno
] = gen_reg_rtx (mode
);
2024 REG_USERVAR_P (map
->reg_map
[regno
]) = REG_USERVAR_P (orig
);
2025 REG_LOOP_TEST_P (map
->reg_map
[regno
]) = REG_LOOP_TEST_P (orig
);
2026 RTX_UNCHANGING_P (map
->reg_map
[regno
]) = RTX_UNCHANGING_P (orig
);
2027 /* A reg with REG_FUNCTION_VALUE_P true will never reach here. */
2029 if (REG_POINTER (map
->x_regno_reg_rtx
[regno
]))
2030 mark_reg_pointer (map
->reg_map
[regno
],
2031 map
->regno_pointer_align
[regno
]);
2033 return map
->reg_map
[regno
];
2036 copy
= copy_rtx_and_substitute (SUBREG_REG (orig
), map
, for_lhs
);
2037 return simplify_gen_subreg (GET_MODE (orig
), copy
,
2038 GET_MODE (SUBREG_REG (orig
)),
2039 SUBREG_BYTE (orig
));
2042 copy
= gen_rtx_ADDRESSOF (mode
,
2043 copy_rtx_and_substitute (XEXP (orig
, 0),
2045 0, ADDRESSOF_DECL (orig
));
2046 regno
= ADDRESSOF_REGNO (orig
);
2047 if (map
->reg_map
[regno
])
2048 regno
= REGNO (map
->reg_map
[regno
]);
2049 else if (regno
> LAST_VIRTUAL_REGISTER
)
2051 temp
= XEXP (orig
, 0);
2052 map
->reg_map
[regno
] = gen_reg_rtx (GET_MODE (temp
));
2053 REG_USERVAR_P (map
->reg_map
[regno
]) = REG_USERVAR_P (temp
);
2054 REG_LOOP_TEST_P (map
->reg_map
[regno
]) = REG_LOOP_TEST_P (temp
);
2055 RTX_UNCHANGING_P (map
->reg_map
[regno
]) = RTX_UNCHANGING_P (temp
);
2056 /* A reg with REG_FUNCTION_VALUE_P true will never reach here. */
2058 /* Objects may initially be represented as registers, but
2059 but turned into a MEM if their address is taken by
2060 put_var_into_stack. Therefore, the register table may have
2061 entries which are MEMs.
2063 We briefly tried to clear such entries, but that ended up
2064 cascading into many changes due to the optimizers not being
2065 prepared for empty entries in the register table. So we've
2066 decided to allow the MEMs in the register table for now. */
2067 if (REG_P (map
->x_regno_reg_rtx
[regno
])
2068 && REG_POINTER (map
->x_regno_reg_rtx
[regno
]))
2069 mark_reg_pointer (map
->reg_map
[regno
],
2070 map
->regno_pointer_align
[regno
]);
2071 regno
= REGNO (map
->reg_map
[regno
]);
2073 ADDRESSOF_REGNO (copy
) = regno
;
2078 /* USE and CLOBBER are ordinary, but we convert (use (subreg foo))
2079 to (use foo) if the original insn didn't have a subreg.
2080 Removing the subreg distorts the VAX movstrhi pattern
2081 by changing the mode of an operand. */
2082 copy
= copy_rtx_and_substitute (XEXP (orig
, 0), map
, code
== CLOBBER
);
2083 if (GET_CODE (copy
) == SUBREG
&& GET_CODE (XEXP (orig
, 0)) != SUBREG
)
2084 copy
= SUBREG_REG (copy
);
2085 return gen_rtx_fmt_e (code
, VOIDmode
, copy
);
2087 /* We need to handle "deleted" labels that appear in the DECL_RTL
2090 if (NOTE_LINE_NUMBER (orig
) != NOTE_INSN_DELETED_LABEL
)
2095 LABEL_PRESERVE_P (get_label_from_map (map
, CODE_LABEL_NUMBER (orig
)))
2096 = LABEL_PRESERVE_P (orig
);
2097 return get_label_from_map (map
, CODE_LABEL_NUMBER (orig
));
2103 LABEL_REF_NONLOCAL_P (orig
) ? XEXP (orig
, 0)
2104 : get_label_from_map (map
, CODE_LABEL_NUMBER (XEXP (orig
, 0))));
2106 LABEL_OUTSIDE_LOOP_P (copy
) = LABEL_OUTSIDE_LOOP_P (orig
);
2108 /* The fact that this label was previously nonlocal does not mean
2109 it still is, so we must check if it is within the range of
2110 this function's labels. */
2111 LABEL_REF_NONLOCAL_P (copy
)
2112 = (LABEL_REF_NONLOCAL_P (orig
)
2113 && ! (CODE_LABEL_NUMBER (XEXP (copy
, 0)) >= get_first_label_num ()
2114 && CODE_LABEL_NUMBER (XEXP (copy
, 0)) < max_label_num ()));
2116 /* If we have made a nonlocal label local, it means that this
2117 inlined call will be referring to our nonlocal goto handler.
2118 So make sure we create one for this block; we normally would
2119 not since this is not otherwise considered a "call". */
2120 if (LABEL_REF_NONLOCAL_P (orig
) && ! LABEL_REF_NONLOCAL_P (copy
))
2121 function_call_count
++;
2132 /* Symbols which represent the address of a label stored in the constant
2133 pool must be modified to point to a constant pool entry for the
2134 remapped label. Otherwise, symbols are returned unchanged. */
2135 if (CONSTANT_POOL_ADDRESS_P (orig
))
2137 struct function
*f
= inlining
? inlining
: cfun
;
2138 rtx constant
= get_pool_constant_for_function (f
, orig
);
2139 enum machine_mode const_mode
= get_pool_mode_for_function (f
, orig
);
2142 rtx temp
= force_const_mem (const_mode
,
2143 copy_rtx_and_substitute (constant
,
2147 /* Legitimizing the address here is incorrect.
2149 Since we had a SYMBOL_REF before, we can assume it is valid
2150 to have one in this position in the insn.
2152 Also, change_address may create new registers. These
2153 registers will not have valid reg_map entries. This can
2154 cause try_constants() to fail because assumes that all
2155 registers in the rtx have valid reg_map entries, and it may
2156 end up replacing one of these new registers with junk. */
2158 if (! memory_address_p (GET_MODE (temp
), XEXP (temp
, 0)))
2159 temp
= change_address (temp
, GET_MODE (temp
), XEXP (temp
, 0));
2162 temp
= XEXP (temp
, 0);
2163 temp
= convert_memory_address (GET_MODE (orig
), temp
);
2166 else if (GET_CODE (constant
) == LABEL_REF
)
2167 return XEXP (force_const_mem
2169 copy_rtx_and_substitute (constant
, map
, for_lhs
)),
2172 else if (TREE_CONSTANT_POOL_ADDRESS_P (orig
) && inlining
)
2173 notice_rtl_inlining_of_deferred_constant ();
2178 /* We have to make a new copy of this CONST_DOUBLE because don't want
2179 to use the old value of CONST_DOUBLE_MEM. Also, this may be a
2180 duplicate of a CONST_DOUBLE we have already seen. */
2181 if (GET_MODE_CLASS (GET_MODE (orig
)) == MODE_FLOAT
)
2185 REAL_VALUE_FROM_CONST_DOUBLE (d
, orig
);
2186 return CONST_DOUBLE_FROM_REAL_VALUE (d
, GET_MODE (orig
));
2189 return immed_double_const (CONST_DOUBLE_LOW (orig
),
2190 CONST_DOUBLE_HIGH (orig
), VOIDmode
);
2193 /* Make new constant pool entry for a constant
2194 that was in the pool of the inline function. */
2195 if (RTX_INTEGRATED_P (orig
))
2200 /* If a single asm insn contains multiple output operands then
2201 it contains multiple ASM_OPERANDS rtx's that share the input
2202 and constraint vecs. We must make sure that the copied insn
2203 continues to share it. */
2204 if (map
->orig_asm_operands_vector
== ASM_OPERANDS_INPUT_VEC (orig
))
2206 copy
= rtx_alloc (ASM_OPERANDS
);
2207 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
2208 PUT_MODE (copy
, GET_MODE (orig
));
2209 ASM_OPERANDS_TEMPLATE (copy
) = ASM_OPERANDS_TEMPLATE (orig
);
2210 ASM_OPERANDS_OUTPUT_CONSTRAINT (copy
)
2211 = ASM_OPERANDS_OUTPUT_CONSTRAINT (orig
);
2212 ASM_OPERANDS_OUTPUT_IDX (copy
) = ASM_OPERANDS_OUTPUT_IDX (orig
);
2213 ASM_OPERANDS_INPUT_VEC (copy
) = map
->copy_asm_operands_vector
;
2214 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
)
2215 = map
->copy_asm_constraints_vector
;
2216 ASM_OPERANDS_SOURCE_FILE (copy
) = ASM_OPERANDS_SOURCE_FILE (orig
);
2217 ASM_OPERANDS_SOURCE_LINE (copy
) = ASM_OPERANDS_SOURCE_LINE (orig
);
2223 /* This is given special treatment because the first
2224 operand of a CALL is a (MEM ...) which may get
2225 forced into a register for cse. This is undesirable
2226 if function-address cse isn't wanted or if we won't do cse. */
2227 #ifndef NO_FUNCTION_CSE
2228 if (! (optimize
&& ! flag_no_function_cse
))
2232 = gen_rtx_MEM (GET_MODE (XEXP (orig
, 0)),
2233 copy_rtx_and_substitute (XEXP (XEXP (orig
, 0), 0),
2236 MEM_COPY_ATTRIBUTES (copy
, XEXP (orig
, 0));
2239 gen_rtx_CALL (GET_MODE (orig
), copy
,
2240 copy_rtx_and_substitute (XEXP (orig
, 1), map
, 0));
2245 /* Must be ifdefed out for loop unrolling to work. */
2251 /* If this is setting fp or ap, it means that we have a nonlocal goto.
2252 Adjust the setting by the offset of the area we made.
2253 If the nonlocal goto is into the current function,
2254 this will result in unnecessarily bad code, but should work. */
2255 if (SET_DEST (orig
) == virtual_stack_vars_rtx
2256 || SET_DEST (orig
) == virtual_incoming_args_rtx
)
2258 /* In case a translation hasn't occurred already, make one now. */
2261 HOST_WIDE_INT loc_offset
;
2263 copy_rtx_and_substitute (SET_DEST (orig
), map
, for_lhs
);
2264 equiv_reg
= map
->reg_map
[REGNO (SET_DEST (orig
))];
2265 equiv_loc
= VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
2266 REGNO (equiv_reg
)).rtx
;
2268 = GET_CODE (equiv_loc
) == REG
? 0 : INTVAL (XEXP (equiv_loc
, 1));
2270 return gen_rtx_SET (VOIDmode
, SET_DEST (orig
),
2273 (copy_rtx_and_substitute (SET_SRC (orig
),
2279 return gen_rtx_SET (VOIDmode
,
2280 copy_rtx_and_substitute (SET_DEST (orig
), map
, 1),
2281 copy_rtx_and_substitute (SET_SRC (orig
), map
, 0));
2286 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
2287 && CONSTANT_POOL_ADDRESS_P (XEXP (orig
, 0)))
2289 enum machine_mode const_mode
2290 = get_pool_mode_for_function (inlining
, XEXP (orig
, 0));
2292 = get_pool_constant_for_function (inlining
, XEXP (orig
, 0));
2294 constant
= copy_rtx_and_substitute (constant
, map
, 0);
2296 /* If this was an address of a constant pool entry that itself
2297 had to be placed in the constant pool, it might not be a
2298 valid address. So the recursive call might have turned it
2299 into a register. In that case, it isn't a constant any
2300 more, so return it. This has the potential of changing a
2301 MEM into a REG, but we'll assume that it safe. */
2302 if (! CONSTANT_P (constant
))
2305 return validize_mem (force_const_mem (const_mode
, constant
));
2308 copy
= gen_rtx_MEM (mode
, copy_rtx_and_substitute (XEXP (orig
, 0),
2310 MEM_COPY_ATTRIBUTES (copy
, orig
);
2312 /* If inlining and this is not for the LHS, turn off RTX_UNCHANGING_P
2313 since this may be an indirect reference to a parameter and the
2314 actual may not be readonly. */
2315 if (inlining
&& !for_lhs
)
2316 RTX_UNCHANGING_P (copy
) = 0;
2318 /* If inlining, squish aliasing data that references the subroutine's
2319 parameter list, since that's no longer applicable. */
2320 if (inlining
&& MEM_EXPR (copy
)
2321 && TREE_CODE (MEM_EXPR (copy
)) == INDIRECT_REF
2322 && TREE_CODE (TREE_OPERAND (MEM_EXPR (copy
), 0)) == PARM_DECL
)
2323 set_mem_expr (copy
, NULL_TREE
);
2331 copy
= rtx_alloc (code
);
2332 PUT_MODE (copy
, mode
);
2333 RTX_FLAG (copy
, in_struct
) = RTX_FLAG (orig
, in_struct
);
2334 RTX_FLAG (copy
, volatil
) = RTX_FLAG (orig
, volatil
);
2335 RTX_FLAG (copy
, unchanging
) = RTX_FLAG (orig
, unchanging
);
2337 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
2339 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
2341 switch (*format_ptr
++)
2344 X0ANY (copy
, i
) = X0ANY (orig
, i
);
2349 = copy_rtx_and_substitute (XEXP (orig
, i
), map
, for_lhs
);
2353 /* Change any references to old-insns to point to the
2354 corresponding copied insns. */
2355 XEXP (copy
, i
) = map
->insn_map
[INSN_UID (XEXP (orig
, i
))];
2359 XVEC (copy
, i
) = XVEC (orig
, i
);
2360 if (XVEC (orig
, i
) != NULL
&& XVECLEN (orig
, i
) != 0)
2362 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
2363 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
2364 XVECEXP (copy
, i
, j
)
2365 = copy_rtx_and_substitute (XVECEXP (orig
, i
, j
),
2371 XWINT (copy
, i
) = XWINT (orig
, i
);
2375 XINT (copy
, i
) = XINT (orig
, i
);
2379 XSTR (copy
, i
) = XSTR (orig
, i
);
2383 XTREE (copy
, i
) = XTREE (orig
, i
);
2391 if (code
== ASM_OPERANDS
&& map
->orig_asm_operands_vector
== 0)
2393 map
->orig_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (orig
);
2394 map
->copy_asm_operands_vector
= ASM_OPERANDS_INPUT_VEC (copy
);
2395 map
->copy_asm_constraints_vector
2396 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy
);
2402 /* Substitute known constant values into INSN, if that is valid. */
2405 try_constants (rtx insn
, struct inline_remap
*map
)
2411 /* First try just updating addresses, then other things. This is
2412 important when we have something like the store of a constant
2413 into memory and we can update the memory address but the machine
2414 does not support a constant source. */
2415 subst_constants (&PATTERN (insn
), insn
, map
, 1);
2416 apply_change_group ();
2417 subst_constants (&PATTERN (insn
), insn
, map
, 0);
2418 apply_change_group ();
2420 /* Enforce consistency between the addresses in the regular insn flow
2421 and the ones in CALL_INSN_FUNCTION_USAGE lists, if any. */
2422 if (GET_CODE (insn
) == CALL_INSN
&& CALL_INSN_FUNCTION_USAGE (insn
))
2424 subst_constants (&CALL_INSN_FUNCTION_USAGE (insn
), insn
, map
, 1);
2425 apply_change_group ();
2428 /* Show we don't know the value of anything stored or clobbered. */
2429 note_stores (PATTERN (insn
), mark_stores
, NULL
);
2430 map
->last_pc_value
= 0;
2432 map
->last_cc0_value
= 0;
2435 /* Set up any constant equivalences made in this insn. */
2436 for (i
= 0; i
< map
->num_sets
; i
++)
2438 if (GET_CODE (map
->equiv_sets
[i
].dest
) == REG
)
2440 int regno
= REGNO (map
->equiv_sets
[i
].dest
);
2442 MAYBE_EXTEND_CONST_EQUIV_VARRAY (map
, regno
);
2443 if (VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
).rtx
== 0
2444 /* Following clause is a hack to make case work where GNU C++
2445 reassigns a variable to make cse work right. */
2446 || ! rtx_equal_p (VARRAY_CONST_EQUIV (map
->const_equiv_varray
,
2448 map
->equiv_sets
[i
].equiv
))
2449 SET_CONST_EQUIV_DATA (map
, map
->equiv_sets
[i
].dest
,
2450 map
->equiv_sets
[i
].equiv
, map
->const_age
);
2452 else if (map
->equiv_sets
[i
].dest
== pc_rtx
)
2453 map
->last_pc_value
= map
->equiv_sets
[i
].equiv
;
2455 else if (map
->equiv_sets
[i
].dest
== cc0_rtx
)
2456 map
->last_cc0_value
= map
->equiv_sets
[i
].equiv
;
2461 /* Substitute known constants for pseudo regs in the contents of LOC,
2462 which are part of INSN.
2463 If INSN is zero, the substitution should always be done (this is used to
2465 These changes are taken out by try_constants if the result is not valid.
2467 Note that we are more concerned with determining when the result of a SET
2468 is a constant, for further propagation, than actually inserting constants
2469 into insns; cse will do the latter task better.
2471 This function is also used to adjust address of items previously addressed
2472 via the virtual stack variable or virtual incoming arguments registers.
2474 If MEMONLY is nonzero, only make changes inside a MEM. */
2477 subst_constants (rtx
*loc
, rtx insn
, struct inline_remap
*map
, int memonly
)
2482 const char *format_ptr
;
2483 int num_changes
= num_validated_changes ();
2485 enum machine_mode op0_mode
= MAX_MACHINE_MODE
;
2487 code
= GET_CODE (x
);
2504 validate_change (insn
, loc
, map
->last_cc0_value
, 1);
2510 /* The only thing we can do with a USE or CLOBBER is possibly do
2511 some substitutions in a MEM within it. */
2512 if (GET_CODE (XEXP (x
, 0)) == MEM
)
2513 subst_constants (&XEXP (XEXP (x
, 0), 0), insn
, map
, 0);
2517 /* Substitute for parms and known constants. Don't replace
2518 hard regs used as user variables with constants. */
2521 int regno
= REGNO (x
);
2522 struct const_equiv_data
*p
;
2524 if (! (regno
< FIRST_PSEUDO_REGISTER
&& REG_USERVAR_P (x
))
2525 && (size_t) regno
< VARRAY_SIZE (map
->const_equiv_varray
)
2526 && (p
= &VARRAY_CONST_EQUIV (map
->const_equiv_varray
, regno
),
2528 && p
->age
>= map
->const_age
)
2529 validate_change (insn
, loc
, p
->rtx
, 1);
2534 /* SUBREG applied to something other than a reg
2535 should be treated as ordinary, since that must
2536 be a special hack and we don't know how to treat it specially.
2537 Consider for example mulsidi3 in m68k.md.
2538 Ordinary SUBREG of a REG needs this special treatment. */
2539 if (! memonly
&& GET_CODE (SUBREG_REG (x
)) == REG
)
2541 rtx inner
= SUBREG_REG (x
);
2544 /* We can't call subst_constants on &SUBREG_REG (x) because any
2545 constant or SUBREG wouldn't be valid inside our SUBEG. Instead,
2546 see what is inside, try to form the new SUBREG and see if that is
2547 valid. We handle two cases: extracting a full word in an
2548 integral mode and extracting the low part. */
2549 subst_constants (&inner
, NULL_RTX
, map
, 0);
2550 new = simplify_gen_subreg (GET_MODE (x
), inner
,
2551 GET_MODE (SUBREG_REG (x
)),
2555 validate_change (insn
, loc
, new, 1);
2557 cancel_changes (num_changes
);
2564 subst_constants (&XEXP (x
, 0), insn
, map
, 0);
2566 /* If a memory address got spoiled, change it back. */
2567 if (! memonly
&& insn
!= 0 && num_validated_changes () != num_changes
2568 && ! memory_address_p (GET_MODE (x
), XEXP (x
, 0)))
2569 cancel_changes (num_changes
);
2574 /* Substitute constants in our source, and in any arguments to a
2575 complex (e..g, ZERO_EXTRACT) destination, but not in the destination
2577 rtx
*dest_loc
= &SET_DEST (x
);
2578 rtx dest
= *dest_loc
;
2580 enum machine_mode compare_mode
= VOIDmode
;
2582 /* If SET_SRC is a COMPARE which subst_constants would turn into
2583 COMPARE of 2 VOIDmode constants, note the mode in which comparison
2585 if (GET_CODE (SET_SRC (x
)) == COMPARE
)
2588 if (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
2591 compare_mode
= GET_MODE (XEXP (src
, 0));
2592 if (compare_mode
== VOIDmode
)
2593 compare_mode
= GET_MODE (XEXP (src
, 1));
2597 subst_constants (&SET_SRC (x
), insn
, map
, memonly
);
2600 while (GET_CODE (*dest_loc
) == ZERO_EXTRACT
2601 || GET_CODE (*dest_loc
) == SUBREG
2602 || GET_CODE (*dest_loc
) == STRICT_LOW_PART
)
2604 if (GET_CODE (*dest_loc
) == ZERO_EXTRACT
)
2606 subst_constants (&XEXP (*dest_loc
, 1), insn
, map
, memonly
);
2607 subst_constants (&XEXP (*dest_loc
, 2), insn
, map
, memonly
);
2609 dest_loc
= &XEXP (*dest_loc
, 0);
2612 /* Do substitute in the address of a destination in memory. */
2613 if (GET_CODE (*dest_loc
) == MEM
)
2614 subst_constants (&XEXP (*dest_loc
, 0), insn
, map
, 0);
2616 /* Check for the case of DEST a SUBREG, both it and the underlying
2617 register are less than one word, and the SUBREG has the wider mode.
2618 In the case, we are really setting the underlying register to the
2619 source converted to the mode of DEST. So indicate that. */
2620 if (GET_CODE (dest
) == SUBREG
2621 && GET_MODE_SIZE (GET_MODE (dest
)) <= UNITS_PER_WORD
2622 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
))) <= UNITS_PER_WORD
2623 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
2624 <= GET_MODE_SIZE (GET_MODE (dest
)))
2625 && (tem
= gen_lowpart_if_possible (GET_MODE (SUBREG_REG (dest
)),
2627 src
= tem
, dest
= SUBREG_REG (dest
);
2629 /* If storing a recognizable value save it for later recording. */
2630 if ((map
->num_sets
< MAX_RECOG_OPERANDS
)
2631 && (CONSTANT_P (src
)
2632 || (GET_CODE (src
) == REG
2633 && (REGNO (src
) == VIRTUAL_INCOMING_ARGS_REGNUM
2634 || REGNO (src
) == VIRTUAL_STACK_VARS_REGNUM
))
2635 || (GET_CODE (src
) == PLUS
2636 && GET_CODE (XEXP (src
, 0)) == REG
2637 && (REGNO (XEXP (src
, 0)) == VIRTUAL_INCOMING_ARGS_REGNUM
2638 || REGNO (XEXP (src
, 0)) == VIRTUAL_STACK_VARS_REGNUM
)
2639 && CONSTANT_P (XEXP (src
, 1)))
2640 || GET_CODE (src
) == COMPARE
2643 && (src
== pc_rtx
|| GET_CODE (src
) == RETURN
2644 || GET_CODE (src
) == LABEL_REF
))))
2646 /* Normally, this copy won't do anything. But, if SRC is a COMPARE
2647 it will cause us to save the COMPARE with any constants
2648 substituted, which is what we want for later. */
2649 rtx src_copy
= copy_rtx (src
);
2650 map
->equiv_sets
[map
->num_sets
].equiv
= src_copy
;
2651 map
->equiv_sets
[map
->num_sets
++].dest
= dest
;
2652 if (compare_mode
!= VOIDmode
2653 && GET_CODE (src
) == COMPARE
2654 && (GET_MODE_CLASS (GET_MODE (src
)) == MODE_CC
2656 && GET_MODE (XEXP (src
, 0)) == VOIDmode
2657 && GET_MODE (XEXP (src
, 1)) == VOIDmode
)
2659 map
->compare_src
= src_copy
;
2660 map
->compare_mode
= compare_mode
;
2670 format_ptr
= GET_RTX_FORMAT (code
);
2672 /* If the first operand is an expression, save its mode for later. */
2673 if (*format_ptr
== 'e')
2674 op0_mode
= GET_MODE (XEXP (x
, 0));
2676 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
2678 switch (*format_ptr
++)
2685 subst_constants (&XEXP (x
, i
), insn
, map
, memonly
);
2698 if (XVEC (x
, i
) != NULL
&& XVECLEN (x
, i
) != 0)
2699 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2700 subst_constants (&XVECEXP (x
, i
, j
), insn
, map
, memonly
);
2709 /* If this is a commutative operation, move a constant to the second
2710 operand unless the second operand is already a CONST_INT. */
2712 && (GET_RTX_CLASS (code
) == 'c' || code
== NE
|| code
== EQ
)
2713 && CONSTANT_P (XEXP (x
, 0)) && GET_CODE (XEXP (x
, 1)) != CONST_INT
)
2715 rtx tem
= XEXP (x
, 0);
2716 validate_change (insn
, &XEXP (x
, 0), XEXP (x
, 1), 1);
2717 validate_change (insn
, &XEXP (x
, 1), tem
, 1);
2720 /* Simplify the expression in case we put in some constants. */
2722 switch (GET_RTX_CLASS (code
))
2725 if (op0_mode
== MAX_MACHINE_MODE
)
2727 new = simplify_unary_operation (code
, GET_MODE (x
),
2728 XEXP (x
, 0), op0_mode
);
2733 enum machine_mode op_mode
= GET_MODE (XEXP (x
, 0));
2735 if (op_mode
== VOIDmode
)
2736 op_mode
= GET_MODE (XEXP (x
, 1));
2737 new = simplify_relational_operation (code
, op_mode
,
2738 XEXP (x
, 0), XEXP (x
, 1));
2739 #ifdef FLOAT_STORE_FLAG_VALUE
2740 if (new != 0 && GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
2742 enum machine_mode mode
= GET_MODE (x
);
2743 if (new == const0_rtx
)
2744 new = CONST0_RTX (mode
);
2747 REAL_VALUE_TYPE val
;
2749 /* Avoid automatic aggregate initialization. */
2750 val
= FLOAT_STORE_FLAG_VALUE (mode
);
2751 new = CONST_DOUBLE_FROM_REAL_VALUE (val
, mode
);
2760 new = simplify_binary_operation (code
, GET_MODE (x
),
2761 XEXP (x
, 0), XEXP (x
, 1));
2766 if (op0_mode
== MAX_MACHINE_MODE
)
2769 if (code
== IF_THEN_ELSE
)
2771 rtx op0
= XEXP (x
, 0);
2773 if (GET_RTX_CLASS (GET_CODE (op0
)) == '<'
2774 && GET_MODE (op0
) == VOIDmode
2775 && ! side_effects_p (op0
)
2776 && XEXP (op0
, 0) == map
->compare_src
2777 && GET_MODE (XEXP (op0
, 1)) == VOIDmode
)
2779 /* We have compare of two VOIDmode constants for which
2780 we recorded the comparison mode. */
2782 simplify_relational_operation (GET_CODE (op0
),
2787 if (temp
== const0_rtx
)
2789 else if (temp
== const1_rtx
)
2794 new = simplify_ternary_operation (code
, GET_MODE (x
), op0_mode
,
2795 XEXP (x
, 0), XEXP (x
, 1),
2801 validate_change (insn
, loc
, new, 1);
2804 /* Show that register modified no longer contain known constants. We are
2805 called from note_stores with parts of the new insn. */
2808 mark_stores (rtx dest
, rtx x ATTRIBUTE_UNUSED
, void *data ATTRIBUTE_UNUSED
)
2811 enum machine_mode mode
= VOIDmode
;
2813 /* DEST is always the innermost thing set, except in the case of
2814 SUBREGs of hard registers. */
2816 if (GET_CODE (dest
) == REG
)
2817 regno
= REGNO (dest
), mode
= GET_MODE (dest
);
2818 else if (GET_CODE (dest
) == SUBREG
&& GET_CODE (SUBREG_REG (dest
)) == REG
)
2820 regno
= REGNO (SUBREG_REG (dest
));
2821 if (regno
< FIRST_PSEUDO_REGISTER
)
2822 regno
+= subreg_regno_offset (REGNO (SUBREG_REG (dest
)),
2823 GET_MODE (SUBREG_REG (dest
)),
2826 mode
= GET_MODE (SUBREG_REG (dest
));
2831 unsigned int uregno
= regno
;
2832 unsigned int last_reg
= (uregno
>= FIRST_PSEUDO_REGISTER
? uregno
2833 : uregno
+ HARD_REGNO_NREGS (uregno
, mode
) - 1);
2836 /* Ignore virtual stack var or virtual arg register since those
2837 are handled separately. */
2838 if (uregno
!= VIRTUAL_INCOMING_ARGS_REGNUM
2839 && uregno
!= VIRTUAL_STACK_VARS_REGNUM
)
2840 for (i
= uregno
; i
<= last_reg
; i
++)
2841 if ((size_t) i
< VARRAY_SIZE (global_const_equiv_varray
))
2842 VARRAY_CONST_EQUIV (global_const_equiv_varray
, i
).rtx
= 0;
2846 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
2847 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
2848 that it points to the node itself, thus indicating that the node is its
2849 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
2850 the given node is NULL, recursively descend the decl/block tree which
2851 it is the root of, and for each other ..._DECL or BLOCK node contained
2852 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
2853 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
2854 values to point to themselves. */
2857 set_block_origin_self (tree stmt
)
2859 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
2861 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
2866 for (local_decl
= BLOCK_VARS (stmt
);
2867 local_decl
!= NULL_TREE
;
2868 local_decl
= TREE_CHAIN (local_decl
))
2869 set_decl_origin_self (local_decl
); /* Potential recursion. */
2875 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
2876 subblock
!= NULL_TREE
;
2877 subblock
= BLOCK_CHAIN (subblock
))
2878 set_block_origin_self (subblock
); /* Recurse. */
2883 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
2884 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
2885 node to so that it points to the node itself, thus indicating that the
2886 node represents its own (abstract) origin. Additionally, if the
2887 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
2888 the decl/block tree of which the given node is the root of, and for
2889 each other ..._DECL or BLOCK node contained therein whose
2890 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
2891 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
2892 point to themselves. */
2895 set_decl_origin_self (tree decl
)
2897 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
2899 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
2900 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2904 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
2905 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
2906 if (DECL_INITIAL (decl
) != NULL_TREE
2907 && DECL_INITIAL (decl
) != error_mark_node
)
2908 set_block_origin_self (DECL_INITIAL (decl
));
2913 /* Given a pointer to some BLOCK node, and a boolean value to set the
2914 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
2915 the given block, and for all local decls and all local sub-blocks
2916 (recursively) which are contained therein. */
2919 set_block_abstract_flags (tree stmt
, int setting
)
2924 BLOCK_ABSTRACT (stmt
) = setting
;
2926 for (local_decl
= BLOCK_VARS (stmt
);
2927 local_decl
!= NULL_TREE
;
2928 local_decl
= TREE_CHAIN (local_decl
))
2929 set_decl_abstract_flags (local_decl
, setting
);
2931 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
2932 subblock
!= NULL_TREE
;
2933 subblock
= BLOCK_CHAIN (subblock
))
2934 set_block_abstract_flags (subblock
, setting
);
2937 /* Given a pointer to some ..._DECL node, and a boolean value to set the
2938 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
2939 given decl, and (in the case where the decl is a FUNCTION_DECL) also
2940 set the abstract flags for all of the parameters, local vars, local
2941 blocks and sub-blocks (recursively) to the same setting. */
2944 set_decl_abstract_flags (tree decl
, int setting
)
2946 DECL_ABSTRACT (decl
) = setting
;
2947 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2951 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
2952 DECL_ABSTRACT (arg
) = setting
;
2953 if (DECL_INITIAL (decl
) != NULL_TREE
2954 && DECL_INITIAL (decl
) != error_mark_node
)
2955 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
2959 /* Output the assembly language code for the function FNDECL
2960 from its DECL_SAVED_INSNS. Used for inline functions that are output
2961 at end of compilation instead of where they came in the source. */
2963 static GTY(()) struct function
*old_cfun
;
2966 output_inline_function (tree fndecl
)
2968 enum debug_info_type old_write_symbols
= write_symbols
;
2969 const struct gcc_debug_hooks
*const old_debug_hooks
= debug_hooks
;
2970 struct function
*f
= DECL_SAVED_INSNS (fndecl
);
2974 current_function_decl
= fndecl
;
2976 set_new_last_label_num (f
->inl_max_label_num
);
2978 /* We're not deferring this any longer. */
2979 DECL_DEFER_OUTPUT (fndecl
) = 0;
2981 /* If requested, suppress debugging information. */
2982 if (f
->no_debugging_symbols
)
2984 write_symbols
= NO_DEBUG
;
2985 debug_hooks
= &do_nothing_debug_hooks
;
2988 /* Make sure warnings emitted by the optimizers (e.g. control reaches
2989 end of non-void function) is not wildly incorrect. */
2990 input_location
= DECL_SOURCE_LOCATION (fndecl
);
2992 /* Compile this function all the way down to assembly code. As a
2993 side effect this destroys the saved RTL representation, but
2994 that's okay, because we don't need to inline this anymore. */
2995 rest_of_compilation (fndecl
);
2996 DECL_INLINE (fndecl
) = 0;
2999 current_function_decl
= old_cfun
? old_cfun
->decl
: 0;
3000 write_symbols
= old_write_symbols
;
3001 debug_hooks
= old_debug_hooks
;
3005 /* Functions to keep track of the values hard regs had at the start of
3009 get_hard_reg_initial_reg (struct function
*fun
, rtx reg
)
3011 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
3017 for (i
= 0; i
< ivs
->num_entries
; i
++)
3018 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
3019 return ivs
->entries
[i
].hard_reg
;
3025 has_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
3027 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
3033 for (i
= 0; i
< ivs
->num_entries
; i
++)
3034 if (rtx_equal_p (ivs
->entries
[i
].hard_reg
, reg
))
3035 return ivs
->entries
[i
].pseudo
;
3041 get_func_hard_reg_initial_val (struct function
*fun
, rtx reg
)
3043 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
3044 rtx rv
= has_func_hard_reg_initial_val (fun
, reg
);
3051 fun
->hard_reg_initial_vals
= ggc_alloc (sizeof (initial_value_struct
));
3052 ivs
= fun
->hard_reg_initial_vals
;
3053 ivs
->num_entries
= 0;
3054 ivs
->max_entries
= 5;
3055 ivs
->entries
= ggc_alloc (5 * sizeof (initial_value_pair
));
3058 if (ivs
->num_entries
>= ivs
->max_entries
)
3060 ivs
->max_entries
+= 5;
3061 ivs
->entries
= ggc_realloc (ivs
->entries
,
3063 * sizeof (initial_value_pair
));
3066 ivs
->entries
[ivs
->num_entries
].hard_reg
= reg
;
3067 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (GET_MODE (reg
));
3069 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
3073 get_hard_reg_initial_val (enum machine_mode mode
, int regno
)
3075 return get_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
3079 has_hard_reg_initial_val (enum machine_mode mode
, int regno
)
3081 return has_func_hard_reg_initial_val (cfun
, gen_rtx_REG (mode
, regno
));
3085 setup_initial_hard_reg_value_integration (struct function
*inl_f
, struct inline_remap
*remap
)
3087 struct initial_value_struct
*ivs
= inl_f
->hard_reg_initial_vals
;
3093 for (i
= 0; i
< ivs
->num_entries
; i
++)
3094 remap
->reg_map
[REGNO (ivs
->entries
[i
].pseudo
)]
3095 = get_func_hard_reg_initial_val (cfun
, ivs
->entries
[i
].hard_reg
);
3100 emit_initial_value_sets (void)
3102 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
3110 for (i
= 0; i
< ivs
->num_entries
; i
++)
3111 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
3115 emit_insn_after (seq
, get_insns ());
3118 /* If the backend knows where to allocate pseudos for hard
3119 register initial values, register these allocations now. */
3121 allocate_initial_values (rtx
*reg_equiv_memory_loc ATTRIBUTE_UNUSED
)
3123 #ifdef ALLOCATE_INITIAL_VALUE
3124 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
3130 for (i
= 0; i
< ivs
->num_entries
; i
++)
3132 int regno
= REGNO (ivs
->entries
[i
].pseudo
);
3133 rtx x
= ALLOCATE_INITIAL_VALUE (ivs
->entries
[i
].hard_reg
);
3135 if (x
== NULL_RTX
|| REG_N_SETS (REGNO (ivs
->entries
[i
].pseudo
)) > 1)
3137 else if (GET_CODE (x
) == MEM
)
3138 reg_equiv_memory_loc
[regno
] = x
;
3139 else if (GET_CODE (x
) == REG
)
3141 reg_renumber
[regno
] = REGNO (x
);
3142 /* Poke the regno right into regno_reg_rtx
3143 so that even fixed regs are accepted. */
3144 REGNO (ivs
->entries
[i
].pseudo
) = REGNO (x
);
3151 #include "gt-integrate.h"