1 /* Procedure integration for GCC.
2 Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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"
51 /* Round to the next highest integer that meets the alignment. */
52 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
55 /* Private type used by {get/has}_hard_reg_initial_val. */
56 typedef struct initial_value_pair
GTY(()) {
60 typedef struct initial_value_struct
GTY(()) {
63 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
64 } initial_value_struct
;
66 static void set_block_origin_self (tree
);
67 static void set_block_abstract_flags (tree
, int);
70 /* Return false if the function FNDECL cannot be inlined on account of its
71 attributes, true otherwise. */
73 function_attribute_inlinable_p (tree fndecl
)
75 if (targetm
.attribute_table
)
79 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
81 tree name
= TREE_PURPOSE (a
);
84 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
85 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
86 return targetm
.function_attribute_inlinable_p (fndecl
);
93 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
94 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
95 that it points to the node itself, thus indicating that the node is its
96 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
97 the given node is NULL, recursively descend the decl/block tree which
98 it is the root of, and for each other ..._DECL or BLOCK node contained
99 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
100 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
101 values to point to themselves. */
104 set_block_origin_self (tree stmt
)
106 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
108 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
113 for (local_decl
= BLOCK_VARS (stmt
);
114 local_decl
!= NULL_TREE
;
115 local_decl
= TREE_CHAIN (local_decl
))
116 set_decl_origin_self (local_decl
); /* Potential recursion. */
122 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
123 subblock
!= NULL_TREE
;
124 subblock
= BLOCK_CHAIN (subblock
))
125 set_block_origin_self (subblock
); /* Recurse. */
130 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
131 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
132 node to so that it points to the node itself, thus indicating that the
133 node represents its own (abstract) origin. Additionally, if the
134 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
135 the decl/block tree of which the given node is the root of, and for
136 each other ..._DECL or BLOCK node contained therein whose
137 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
138 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
139 point to themselves. */
142 set_decl_origin_self (tree decl
)
144 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
146 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
147 if (TREE_CODE (decl
) == FUNCTION_DECL
)
151 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
152 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
153 if (DECL_INITIAL (decl
) != NULL_TREE
154 && DECL_INITIAL (decl
) != error_mark_node
)
155 set_block_origin_self (DECL_INITIAL (decl
));
160 /* Given a pointer to some BLOCK node, and a boolean value to set the
161 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
162 the given block, and for all local decls and all local sub-blocks
163 (recursively) which are contained therein. */
166 set_block_abstract_flags (tree stmt
, int setting
)
171 BLOCK_ABSTRACT (stmt
) = setting
;
173 for (local_decl
= BLOCK_VARS (stmt
);
174 local_decl
!= NULL_TREE
;
175 local_decl
= TREE_CHAIN (local_decl
))
176 set_decl_abstract_flags (local_decl
, setting
);
178 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
179 subblock
!= NULL_TREE
;
180 subblock
= BLOCK_CHAIN (subblock
))
181 set_block_abstract_flags (subblock
, setting
);
184 /* Given a pointer to some ..._DECL node, and a boolean value to set the
185 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
186 given decl, and (in the case where the decl is a FUNCTION_DECL) also
187 set the abstract flags for all of the parameters, local vars, local
188 blocks and sub-blocks (recursively) to the same setting. */
191 set_decl_abstract_flags (tree decl
, int setting
)
193 DECL_ABSTRACT (decl
) = setting
;
194 if (TREE_CODE (decl
) == FUNCTION_DECL
)
198 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
199 DECL_ABSTRACT (arg
) = setting
;
200 if (DECL_INITIAL (decl
) != NULL_TREE
201 && DECL_INITIAL (decl
) != error_mark_node
)
202 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
206 /* Functions to keep track of the values hard regs had at the start of
210 get_hard_reg_initial_reg (struct function
*fun
, rtx reg
)
212 struct initial_value_struct
*ivs
= fun
->hard_reg_initial_vals
;
218 for (i
= 0; i
< ivs
->num_entries
; i
++)
219 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
220 return ivs
->entries
[i
].hard_reg
;
225 /* Make sure that there's a pseudo register of mode MODE that stores the
226 initial value of hard register REGNO. Return an rtx for such a pseudo. */
229 get_hard_reg_initial_val (enum machine_mode mode
, unsigned int regno
)
231 struct initial_value_struct
*ivs
;
234 rv
= has_hard_reg_initial_val (mode
, regno
);
238 ivs
= cfun
->hard_reg_initial_vals
;
241 ivs
= ggc_alloc (sizeof (initial_value_struct
));
242 ivs
->num_entries
= 0;
243 ivs
->max_entries
= 5;
244 ivs
->entries
= ggc_alloc (5 * sizeof (initial_value_pair
));
245 cfun
->hard_reg_initial_vals
= ivs
;
248 if (ivs
->num_entries
>= ivs
->max_entries
)
250 ivs
->max_entries
+= 5;
251 ivs
->entries
= ggc_realloc (ivs
->entries
,
253 * sizeof (initial_value_pair
));
256 ivs
->entries
[ivs
->num_entries
].hard_reg
= gen_rtx_REG (mode
, regno
);
257 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (mode
);
259 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
262 /* See if get_hard_reg_initial_val has been used to create a pseudo
263 for the initial value of hard register REGNO in mode MODE. Return
264 the associated pseudo if so, otherwise return NULL. */
267 has_hard_reg_initial_val (enum machine_mode mode
, unsigned int regno
)
269 struct initial_value_struct
*ivs
;
272 ivs
= cfun
->hard_reg_initial_vals
;
274 for (i
= 0; i
< ivs
->num_entries
; i
++)
275 if (GET_MODE (ivs
->entries
[i
].hard_reg
) == mode
276 && REGNO (ivs
->entries
[i
].hard_reg
) == regno
)
277 return ivs
->entries
[i
].pseudo
;
283 emit_initial_value_sets (void)
285 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
293 for (i
= 0; i
< ivs
->num_entries
; i
++)
294 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
298 emit_insn_at_entry (seq
);
302 struct tree_opt_pass pass_initial_value_sets
=
304 "initvals", /* name */
306 emit_initial_value_sets
, /* execute */
309 0, /* static_pass_number */
311 0, /* properties_required */
312 0, /* properties_provided */
313 0, /* properties_destroyed */
314 0, /* todo_flags_start */
315 TODO_dump_func
, /* todo_flags_finish */
319 /* If the backend knows where to allocate pseudos for hard
320 register initial values, register these allocations now. */
322 allocate_initial_values (rtx
*reg_equiv_memory_loc
)
324 if (targetm
.allocate_initial_value
)
326 struct initial_value_struct
*ivs
= cfun
->hard_reg_initial_vals
;
332 for (i
= 0; i
< ivs
->num_entries
; i
++)
334 int regno
= REGNO (ivs
->entries
[i
].pseudo
);
335 rtx x
= targetm
.allocate_initial_value (ivs
->entries
[i
].hard_reg
);
337 if (x
&& REG_N_SETS (REGNO (ivs
->entries
[i
].pseudo
)) <= 1)
340 reg_equiv_memory_loc
[regno
] = x
;
346 gcc_assert (REG_P (x
));
347 new_regno
= REGNO (x
);
348 reg_renumber
[regno
] = new_regno
;
349 /* Poke the regno right into regno_reg_rtx so that even
350 fixed regs are accepted. */
351 SET_REGNO (ivs
->entries
[i
].pseudo
, new_regno
);
352 /* Update global register liveness information. */
355 if (REGNO_REG_SET_P(DF_LIVE_IN (bb
), regno
))
356 SET_REGNO_REG_SET (DF_LIVE_IN (bb
), new_regno
);
357 if (REGNO_REG_SET_P(DF_LIVE_OUT (bb
), regno
))
358 SET_REGNO_REG_SET (DF_LIVE_OUT (bb
), new_regno
);
366 #include "gt-integrate.h"