1 /* Procedure integration for GCC.
2 Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
34 #include "insn-config.h"
38 #include "integrate.h"
47 #include "langhooks.h"
48 #include "tree-pass.h"
50 /* Round to the next highest integer that meets the alignment. */
51 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
54 /* Private type used by {get/has}_hard_reg_initial_val. */
55 typedef struct initial_value_pair
GTY(()) {
59 typedef struct initial_value_struct
GTY(()) {
62 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
63 } initial_value_struct
;
65 static void set_block_origin_self (tree
);
66 static void set_block_abstract_flags (tree
, int);
69 /* Return false if the function FNDECL cannot be inlined on account of its
70 attributes, true otherwise. */
72 function_attribute_inlinable_p (tree fndecl
)
74 if (targetm
.attribute_table
)
78 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
80 tree name
= TREE_PURPOSE (a
);
83 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
84 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
85 return targetm
.function_attribute_inlinable_p (fndecl
);
92 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
93 but now it will be in the TO_FN. */
96 copy_decl_for_inlining (tree decl
, tree from_fn
, tree to_fn
)
100 /* Copy the declaration. */
101 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
103 tree type
= TREE_TYPE (decl
);
105 /* For a parameter or result, we must make an equivalent VAR_DECL, not a
107 copy
= build_decl (VAR_DECL
, DECL_NAME (decl
), type
);
108 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
109 TREE_READONLY (copy
) = TREE_READONLY (decl
);
110 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
111 DECL_COMPLEX_GIMPLE_REG_P (copy
) = DECL_COMPLEX_GIMPLE_REG_P (decl
);
115 copy
= copy_node (decl
);
116 /* The COPY is not abstract; it will be generated in TO_FN. */
117 DECL_ABSTRACT (copy
) = 0;
118 lang_hooks
.dup_lang_specific_decl (copy
);
120 /* TREE_ADDRESSABLE isn't used to indicate that a label's
121 address has been taken; it's for internal bookkeeping in
122 expand_goto_internal. */
123 if (TREE_CODE (copy
) == LABEL_DECL
)
125 TREE_ADDRESSABLE (copy
) = 0;
126 LABEL_DECL_UID (copy
) = -1;
130 /* Don't generate debug information for the copy if we wouldn't have
131 generated it for the copy either. */
132 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
133 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
135 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
136 declaration inspired this copy. */
137 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
139 /* The new variable/label has no RTL, yet. */
140 if (!TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
141 SET_DECL_RTL (copy
, NULL_RTX
);
143 /* These args would always appear unused, if not for this. */
144 TREE_USED (copy
) = 1;
146 /* Set the context for the new declaration. */
147 if (!DECL_CONTEXT (decl
))
148 /* Globals stay global. */
150 else if (DECL_CONTEXT (decl
) != from_fn
)
151 /* Things that weren't in the scope of the function we're inlining
152 from aren't in the scope we're inlining to, either. */
154 else if (TREE_STATIC (decl
))
155 /* Function-scoped static variables should stay in the original
159 /* Ordinary automatic local variables are now in the scope of the
161 DECL_CONTEXT (copy
) = to_fn
;
167 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
168 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
169 that it points to the node itself, thus indicating that the node is its
170 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
171 the given node is NULL, recursively descend the decl/block tree which
172 it is the root of, and for each other ..._DECL or BLOCK node contained
173 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
174 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
175 values to point to themselves. */
178 set_block_origin_self (tree stmt
)
180 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
182 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
187 for (local_decl
= BLOCK_VARS (stmt
);
188 local_decl
!= NULL_TREE
;
189 local_decl
= TREE_CHAIN (local_decl
))
190 set_decl_origin_self (local_decl
); /* Potential recursion. */
196 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
197 subblock
!= NULL_TREE
;
198 subblock
= BLOCK_CHAIN (subblock
))
199 set_block_origin_self (subblock
); /* Recurse. */
204 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
205 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
206 node to so that it points to the node itself, thus indicating that the
207 node represents its own (abstract) origin. Additionally, if the
208 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
209 the decl/block tree of which the given node is the root of, and for
210 each other ..._DECL or BLOCK node contained therein whose
211 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
212 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
213 point to themselves. */
216 set_decl_origin_self (tree decl
)
218 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
220 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
221 if (TREE_CODE (decl
) == FUNCTION_DECL
)
225 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
226 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
227 if (DECL_INITIAL (decl
) != NULL_TREE
228 && DECL_INITIAL (decl
) != error_mark_node
)
229 set_block_origin_self (DECL_INITIAL (decl
));
234 /* Given a pointer to some BLOCK node, and a boolean value to set the
235 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
236 the given block, and for all local decls and all local sub-blocks
237 (recursively) which are contained therein. */
240 set_block_abstract_flags (tree stmt
, int setting
)
245 BLOCK_ABSTRACT (stmt
) = setting
;
247 for (local_decl
= BLOCK_VARS (stmt
);
248 local_decl
!= NULL_TREE
;
249 local_decl
= TREE_CHAIN (local_decl
))
250 set_decl_abstract_flags (local_decl
, setting
);
252 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
253 subblock
!= NULL_TREE
;
254 subblock
= BLOCK_CHAIN (subblock
))
255 set_block_abstract_flags (subblock
, setting
);
258 /* Given a pointer to some ..._DECL node, and a boolean value to set the
259 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
260 given decl, and (in the case where the decl is a FUNCTION_DECL) also
261 set the abstract flags for all of the parameters, local vars, local
262 blocks and sub-blocks (recursively) to the same setting. */
265 set_decl_abstract_flags (tree decl
, int setting
)
267 DECL_ABSTRACT (decl
) = setting
;
268 if (TREE_CODE (decl
) == FUNCTION_DECL
)
272 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
273 DECL_ABSTRACT (arg
) = setting
;
274 if (DECL_INITIAL (decl
) != NULL_TREE
275 && DECL_INITIAL (decl
) != error_mark_node
)
276 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
280 /* Functions to keep track of the values hard regs had at the start of
284 get_hard_reg_initial_reg (struct function
*fun
, rtx reg
)
286 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
292 for (i
= 0; i
< ivs
->num_entries
; i
++)
293 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
294 return ivs
->entries
[i
].hard_reg
;
299 /* Make sure that there's a pseudo register of mode MODE that stores the
300 initial value of hard register REGNO. Return an rtx for such a pseudo. */
303 get_hard_reg_initial_val (enum machine_mode mode
, unsigned int regno
)
305 struct initial_value_struct
*ivs
;
308 rv
= has_hard_reg_initial_val (mode
, regno
);
312 ivs
= cfun
->hard_reg_initial_vals
;
315 ivs
= ggc_alloc (sizeof (initial_value_struct
));
316 ivs
->num_entries
= 0;
317 ivs
->max_entries
= 5;
318 ivs
->entries
= ggc_alloc (5 * sizeof (initial_value_pair
));
319 cfun
->hard_reg_initial_vals
= ivs
;
322 if (ivs
->num_entries
>= ivs
->max_entries
)
324 ivs
->max_entries
+= 5;
325 ivs
->entries
= ggc_realloc (ivs
->entries
,
327 * sizeof (initial_value_pair
));
330 ivs
->entries
[ivs
->num_entries
].hard_reg
= gen_rtx_REG (mode
, regno
);
331 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (mode
);
333 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
336 /* See if get_hard_reg_initial_val has been used to create a pseudo
337 for the initial value of hard register REGNO in mode MODE. Return
338 the associated pseudo if so, otherwise return NULL. */
341 has_hard_reg_initial_val (enum machine_mode mode
, unsigned int regno
)
343 struct initial_value_struct
*ivs
;
346 ivs
= cfun
->hard_reg_initial_vals
;
348 for (i
= 0; i
< ivs
->num_entries
; i
++)
349 if (GET_MODE (ivs
->entries
[i
].hard_reg
) == mode
350 && REGNO (ivs
->entries
[i
].hard_reg
) == regno
)
351 return ivs
->entries
[i
].pseudo
;
357 emit_initial_value_sets (void)
359 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
367 for (i
= 0; i
< ivs
->num_entries
; i
++)
368 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
372 emit_insn_after (seq
, entry_of_function ());
375 struct tree_opt_pass pass_initial_value_sets
=
379 emit_initial_value_sets
, /* execute */
382 0, /* static_pass_number */
384 0, /* properties_required */
385 0, /* properties_provided */
386 0, /* properties_destroyed */
387 0, /* todo_flags_start */
388 0, /* todo_flags_finish */
392 /* If the backend knows where to allocate pseudos for hard
393 register initial values, register these allocations now. */
395 allocate_initial_values (rtx
*reg_equiv_memory_loc ATTRIBUTE_UNUSED
)
397 if (targetm
.allocate_initial_value
)
399 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
405 for (i
= 0; i
< ivs
->num_entries
; i
++)
407 int regno
= REGNO (ivs
->entries
[i
].pseudo
);
408 rtx x
= targetm
.allocate_initial_value (ivs
->entries
[i
].hard_reg
);
410 if (x
&& REG_N_SETS (REGNO (ivs
->entries
[i
].pseudo
)) <= 1)
413 reg_equiv_memory_loc
[regno
] = x
;
419 gcc_assert (REG_P (x
));
420 new_regno
= REGNO (x
);
421 reg_renumber
[regno
] = new_regno
;
422 /* Poke the regno right into regno_reg_rtx so that even
423 fixed regs are accepted. */
424 REGNO (ivs
->entries
[i
].pseudo
) = new_regno
;
425 /* Update global register liveness information. */
428 struct rtl_bb_info
*info
= bb
->il
.rtl
;
430 if (REGNO_REG_SET_P(info
->global_live_at_start
, regno
))
431 SET_REGNO_REG_SET (info
->global_live_at_start
,
433 if (REGNO_REG_SET_P(info
->global_live_at_end
, regno
))
434 SET_REGNO_REG_SET (info
->global_live_at_end
,
443 #include "gt-integrate.h"