|
0
|
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, 2008
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
9 GCC is free software; you can redistribute it and/or modify it under
|
|
|
10 the terms of the GNU General Public License as published by the Free
|
|
|
11 Software Foundation; either version 3, or (at your option) any later
|
|
|
12 version.
|
|
|
13
|
|
|
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
17 for more details.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License
|
|
|
20 along with GCC; see the file COPYING3. If not see
|
|
|
21 <http://www.gnu.org/licenses/>. */
|
|
|
22
|
|
|
23 #include "config.h"
|
|
|
24 #include "system.h"
|
|
|
25 #include "coretypes.h"
|
|
|
26 #include "tm.h"
|
|
|
27
|
|
|
28 #include "rtl.h"
|
|
|
29 #include "tree.h"
|
|
|
30 #include "tm_p.h"
|
|
|
31 #include "regs.h"
|
|
|
32 #include "flags.h"
|
|
|
33 #include "debug.h"
|
|
|
34 #include "insn-config.h"
|
|
|
35 #include "expr.h"
|
|
|
36 #include "output.h"
|
|
|
37 #include "recog.h"
|
|
|
38 #include "integrate.h"
|
|
|
39 #include "real.h"
|
|
|
40 #include "except.h"
|
|
|
41 #include "function.h"
|
|
|
42 #include "toplev.h"
|
|
|
43 #include "intl.h"
|
|
|
44 #include "params.h"
|
|
|
45 #include "ggc.h"
|
|
|
46 #include "target.h"
|
|
|
47 #include "langhooks.h"
|
|
|
48 #include "tree-pass.h"
|
|
|
49 #include "df.h"
|
|
|
50
|
|
|
51 /* Round to the next highest integer that meets the alignment. */
|
|
|
52 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
|
|
|
53
|
|
|
54
|
|
|
55 /* Private type used by {get/has}_hard_reg_initial_val. */
|
|
|
56 typedef struct initial_value_pair GTY(()) {
|
|
|
57 rtx hard_reg;
|
|
|
58 rtx pseudo;
|
|
|
59 } initial_value_pair;
|
|
|
60 typedef struct initial_value_struct GTY(()) {
|
|
|
61 int num_entries;
|
|
|
62 int max_entries;
|
|
|
63 initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
|
|
|
64 } initial_value_struct;
|
|
|
65
|
|
|
66 static void set_block_origin_self (tree);
|
|
|
67 static void set_block_abstract_flags (tree, int);
|
|
|
68
|
|
|
69
|
|
|
70 /* Return false if the function FNDECL cannot be inlined on account of its
|
|
|
71 attributes, true otherwise. */
|
|
|
72 bool
|
|
|
73 function_attribute_inlinable_p (const_tree fndecl)
|
|
|
74 {
|
|
|
75 if (targetm.attribute_table)
|
|
|
76 {
|
|
|
77 const_tree a;
|
|
|
78
|
|
|
79 for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
|
|
|
80 {
|
|
|
81 const_tree name = TREE_PURPOSE (a);
|
|
|
82 int i;
|
|
|
83
|
|
|
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);
|
|
|
87 }
|
|
|
88 }
|
|
|
89
|
|
|
90 return true;
|
|
|
91 }
|
|
|
92
|
|
|
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. */
|
|
|
102
|
|
|
103 static void
|
|
|
104 set_block_origin_self (tree stmt)
|
|
|
105 {
|
|
|
106 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
|
|
|
107 {
|
|
|
108 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
|
|
|
109
|
|
|
110 {
|
|
|
111 tree local_decl;
|
|
|
112
|
|
|
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. */
|
|
|
117 }
|
|
|
118
|
|
|
119 {
|
|
|
120 tree subblock;
|
|
|
121
|
|
|
122 for (subblock = BLOCK_SUBBLOCKS (stmt);
|
|
|
123 subblock != NULL_TREE;
|
|
|
124 subblock = BLOCK_CHAIN (subblock))
|
|
|
125 set_block_origin_self (subblock); /* Recurse. */
|
|
|
126 }
|
|
|
127 }
|
|
|
128 }
|
|
|
129
|
|
|
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. */
|
|
|
140
|
|
|
141 void
|
|
|
142 set_decl_origin_self (tree decl)
|
|
|
143 {
|
|
|
144 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
|
|
|
145 {
|
|
|
146 DECL_ABSTRACT_ORIGIN (decl) = decl;
|
|
|
147 if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
148 {
|
|
|
149 tree arg;
|
|
|
150
|
|
|
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));
|
|
|
156 }
|
|
|
157 }
|
|
|
158 }
|
|
|
159
|
|
|
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. */
|
|
|
164
|
|
|
165 static void
|
|
|
166 set_block_abstract_flags (tree stmt, int setting)
|
|
|
167 {
|
|
|
168 tree local_decl;
|
|
|
169 tree subblock;
|
|
|
170
|
|
|
171 BLOCK_ABSTRACT (stmt) = setting;
|
|
|
172
|
|
|
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);
|
|
|
177
|
|
|
178 for (subblock = BLOCK_SUBBLOCKS (stmt);
|
|
|
179 subblock != NULL_TREE;
|
|
|
180 subblock = BLOCK_CHAIN (subblock))
|
|
|
181 set_block_abstract_flags (subblock, setting);
|
|
|
182 }
|
|
|
183
|
|
|
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. */
|
|
|
189
|
|
|
190 void
|
|
|
191 set_decl_abstract_flags (tree decl, int setting)
|
|
|
192 {
|
|
|
193 DECL_ABSTRACT (decl) = setting;
|
|
|
194 if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
195 {
|
|
|
196 tree arg;
|
|
|
197
|
|
|
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);
|
|
|
203 }
|
|
|
204 }
|
|
|
205
|
|
|
206 /* Functions to keep track of the values hard regs had at the start of
|
|
|
207 the function. */
|
|
|
208
|
|
|
209 rtx
|
|
|
210 get_hard_reg_initial_reg (rtx reg)
|
|
|
211 {
|
|
|
212 struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
|
|
|
213 int i;
|
|
|
214
|
|
|
215 if (ivs == 0)
|
|
|
216 return NULL_RTX;
|
|
|
217
|
|
|
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;
|
|
|
221
|
|
|
222 return NULL_RTX;
|
|
|
223 }
|
|
|
224
|
|
|
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. */
|
|
|
227
|
|
|
228 rtx
|
|
|
229 get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
|
|
230 {
|
|
|
231 struct initial_value_struct *ivs;
|
|
|
232 rtx rv;
|
|
|
233
|
|
|
234 rv = has_hard_reg_initial_val (mode, regno);
|
|
|
235 if (rv)
|
|
|
236 return rv;
|
|
|
237
|
|
|
238 ivs = crtl->hard_reg_initial_vals;
|
|
|
239 if (ivs == 0)
|
|
|
240 {
|
|
|
241 ivs = GGC_NEW (initial_value_struct);
|
|
|
242 ivs->num_entries = 0;
|
|
|
243 ivs->max_entries = 5;
|
|
|
244 ivs->entries = GGC_NEWVEC (initial_value_pair, 5);
|
|
|
245 crtl->hard_reg_initial_vals = ivs;
|
|
|
246 }
|
|
|
247
|
|
|
248 if (ivs->num_entries >= ivs->max_entries)
|
|
|
249 {
|
|
|
250 ivs->max_entries += 5;
|
|
|
251 ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries,
|
|
|
252 ivs->max_entries);
|
|
|
253 }
|
|
|
254
|
|
|
255 ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
|
|
|
256 ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
|
|
|
257
|
|
|
258 return ivs->entries[ivs->num_entries++].pseudo;
|
|
|
259 }
|
|
|
260
|
|
|
261 /* See if get_hard_reg_initial_val has been used to create a pseudo
|
|
|
262 for the initial value of hard register REGNO in mode MODE. Return
|
|
|
263 the associated pseudo if so, otherwise return NULL. */
|
|
|
264
|
|
|
265 rtx
|
|
|
266 has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
|
|
267 {
|
|
|
268 struct initial_value_struct *ivs;
|
|
|
269 int i;
|
|
|
270
|
|
|
271 ivs = crtl->hard_reg_initial_vals;
|
|
|
272 if (ivs != 0)
|
|
|
273 for (i = 0; i < ivs->num_entries; i++)
|
|
|
274 if (GET_MODE (ivs->entries[i].hard_reg) == mode
|
|
|
275 && REGNO (ivs->entries[i].hard_reg) == regno)
|
|
|
276 return ivs->entries[i].pseudo;
|
|
|
277
|
|
|
278 return NULL_RTX;
|
|
|
279 }
|
|
|
280
|
|
|
281 unsigned int
|
|
|
282 emit_initial_value_sets (void)
|
|
|
283 {
|
|
|
284 struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
|
|
|
285 int i;
|
|
|
286 rtx seq;
|
|
|
287
|
|
|
288 if (ivs == 0)
|
|
|
289 return 0;
|
|
|
290
|
|
|
291 start_sequence ();
|
|
|
292 for (i = 0; i < ivs->num_entries; i++)
|
|
|
293 emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
|
|
|
294 seq = get_insns ();
|
|
|
295 end_sequence ();
|
|
|
296
|
|
|
297 emit_insn_at_entry (seq);
|
|
|
298 return 0;
|
|
|
299 }
|
|
|
300
|
|
|
301 struct rtl_opt_pass pass_initial_value_sets =
|
|
|
302 {
|
|
|
303 {
|
|
|
304 RTL_PASS,
|
|
|
305 "initvals", /* name */
|
|
|
306 NULL, /* gate */
|
|
|
307 emit_initial_value_sets, /* execute */
|
|
|
308 NULL, /* sub */
|
|
|
309 NULL, /* next */
|
|
|
310 0, /* static_pass_number */
|
|
|
311 0, /* tv_id */
|
|
|
312 0, /* properties_required */
|
|
|
313 0, /* properties_provided */
|
|
|
314 0, /* properties_destroyed */
|
|
|
315 0, /* todo_flags_start */
|
|
|
316 TODO_dump_func /* todo_flags_finish */
|
|
|
317 }
|
|
|
318 };
|
|
|
319
|
|
|
320 /* If the backend knows where to allocate pseudos for hard
|
|
|
321 register initial values, register these allocations now. */
|
|
|
322 void
|
|
|
323 allocate_initial_values (rtx *reg_equiv_memory_loc)
|
|
|
324 {
|
|
|
325 if (targetm.allocate_initial_value)
|
|
|
326 {
|
|
|
327 struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
|
|
|
328 int i;
|
|
|
329
|
|
|
330 if (ivs == 0)
|
|
|
331 return;
|
|
|
332
|
|
|
333 for (i = 0; i < ivs->num_entries; i++)
|
|
|
334 {
|
|
|
335 int regno = REGNO (ivs->entries[i].pseudo);
|
|
|
336 rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
|
|
|
337
|
|
|
338 if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
|
|
|
339 {
|
|
|
340 if (MEM_P (x))
|
|
|
341 reg_equiv_memory_loc[regno] = x;
|
|
|
342 else
|
|
|
343 {
|
|
|
344 basic_block bb;
|
|
|
345 int new_regno;
|
|
|
346
|
|
|
347 gcc_assert (REG_P (x));
|
|
|
348 new_regno = REGNO (x);
|
|
|
349 reg_renumber[regno] = new_regno;
|
|
|
350 /* Poke the regno right into regno_reg_rtx so that even
|
|
|
351 fixed regs are accepted. */
|
|
|
352 SET_REGNO (ivs->entries[i].pseudo, new_regno);
|
|
|
353 /* Update global register liveness information. */
|
|
|
354 FOR_EACH_BB (bb)
|
|
|
355 {
|
|
|
356 if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
|
|
|
357 SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
|
|
|
358 if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
|
|
|
359 SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
|
|
|
360 }
|
|
|
361 }
|
|
|
362 }
|
|
|
363 }
|
|
|
364 }
|
|
|
365 }
|
|
|
366
|
|
|
367 #include "gt-integrate.h"
|
