OSDN Git Service

2005-07-08 Daniel Berlin <dberlin@dberlin.org>
[pf3gnuchains/gcc-fork.git] / gcc / integrate.c
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)
5
6 This file is part of GCC.
7
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
11 version.
12
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
16 for more details.
17
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
21 02110-1301, USA.  */
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
50 /* Round to the next highest integer that meets the alignment.  */
51 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
52 \f
53
54 /* Private type used by {get/has}_hard_reg_initial_val.  */
55 typedef struct initial_value_pair GTY(()) {
56   rtx hard_reg;
57   rtx pseudo;
58 } initial_value_pair;
59 typedef struct initial_value_struct GTY(()) {
60   int num_entries;
61   int max_entries;
62   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
63 } initial_value_struct;
64
65 static void set_block_origin_self (tree);
66 static void set_block_abstract_flags (tree, int);
67 \f
68
69 /* Return false if the function FNDECL cannot be inlined on account of its
70    attributes, true otherwise.  */
71 bool
72 function_attribute_inlinable_p (tree fndecl)
73 {
74   if (targetm.attribute_table)
75     {
76       tree a;
77
78       for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
79         {
80           tree name = TREE_PURPOSE (a);
81           int i;
82
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);
86         }
87     }
88
89   return true;
90 }
91 \f
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.  */
94
95 tree
96 copy_decl_for_inlining (tree decl, tree from_fn, tree to_fn)
97 {
98   tree copy;
99
100   /* Copy the declaration.  */
101   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
102     {
103       tree type = TREE_TYPE (decl);
104
105       /* For a parameter or result, we must make an equivalent VAR_DECL, not a
106          new PARM_DECL.  */
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);
112     }
113   else
114     {
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);
119
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)
124         {
125           TREE_ADDRESSABLE (copy) = 0;
126           LABEL_DECL_UID (copy) = -1;
127         }
128     }
129
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);
134
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);
138
139   /* The new variable/label has no RTL, yet.  */
140   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL) 
141       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
142     SET_DECL_RTL (copy, NULL_RTX);
143
144   /* These args would always appear unused, if not for this.  */
145   TREE_USED (copy) = 1;
146
147   /* Set the context for the new declaration.  */
148   if (!DECL_CONTEXT (decl))
149     /* Globals stay global.  */
150     ;
151   else if (DECL_CONTEXT (decl) != from_fn)
152     /* Things that weren't in the scope of the function we're inlining
153        from aren't in the scope we're inlining to, either.  */
154     ;
155   else if (TREE_STATIC (decl))
156     /* Function-scoped static variables should stay in the original
157        function.  */
158     ;
159   else
160     /* Ordinary automatic local variables are now in the scope of the
161        new function.  */
162     DECL_CONTEXT (copy) = to_fn;
163
164   return copy;
165 }
166
167 \f
168 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
169    given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
170    that it points to the node itself, thus indicating that the node is its
171    own (abstract) origin.  Additionally, if the BLOCK_ABSTRACT_ORIGIN for
172    the given node is NULL, recursively descend the decl/block tree which
173    it is the root of, and for each other ..._DECL or BLOCK node contained
174    therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
175    still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
176    values to point to themselves.  */
177
178 static void
179 set_block_origin_self (tree stmt)
180 {
181   if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
182     {
183       BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
184
185       {
186         tree local_decl;
187
188         for (local_decl = BLOCK_VARS (stmt);
189              local_decl != NULL_TREE;
190              local_decl = TREE_CHAIN (local_decl))
191           set_decl_origin_self (local_decl);    /* Potential recursion.  */
192       }
193
194       {
195         tree subblock;
196
197         for (subblock = BLOCK_SUBBLOCKS (stmt);
198              subblock != NULL_TREE;
199              subblock = BLOCK_CHAIN (subblock))
200           set_block_origin_self (subblock);     /* Recurse.  */
201       }
202     }
203 }
204
205 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
206    the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
207    node to so that it points to the node itself, thus indicating that the
208    node represents its own (abstract) origin.  Additionally, if the
209    DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
210    the decl/block tree of which the given node is the root of, and for
211    each other ..._DECL or BLOCK node contained therein whose
212    DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
213    set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
214    point to themselves.  */
215
216 void
217 set_decl_origin_self (tree decl)
218 {
219   if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
220     {
221       DECL_ABSTRACT_ORIGIN (decl) = decl;
222       if (TREE_CODE (decl) == FUNCTION_DECL)
223         {
224           tree arg;
225
226           for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
227             DECL_ABSTRACT_ORIGIN (arg) = arg;
228           if (DECL_INITIAL (decl) != NULL_TREE
229               && DECL_INITIAL (decl) != error_mark_node)
230             set_block_origin_self (DECL_INITIAL (decl));
231         }
232     }
233 }
234 \f
235 /* Given a pointer to some BLOCK node, and a boolean value to set the
236    "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
237    the given block, and for all local decls and all local sub-blocks
238    (recursively) which are contained therein.  */
239
240 static void
241 set_block_abstract_flags (tree stmt, int setting)
242 {
243   tree local_decl;
244   tree subblock;
245
246   BLOCK_ABSTRACT (stmt) = setting;
247
248   for (local_decl = BLOCK_VARS (stmt);
249        local_decl != NULL_TREE;
250        local_decl = TREE_CHAIN (local_decl))
251     set_decl_abstract_flags (local_decl, setting);
252
253   for (subblock = BLOCK_SUBBLOCKS (stmt);
254        subblock != NULL_TREE;
255        subblock = BLOCK_CHAIN (subblock))
256     set_block_abstract_flags (subblock, setting);
257 }
258
259 /* Given a pointer to some ..._DECL node, and a boolean value to set the
260    "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
261    given decl, and (in the case where the decl is a FUNCTION_DECL) also
262    set the abstract flags for all of the parameters, local vars, local
263    blocks and sub-blocks (recursively) to the same setting.  */
264
265 void
266 set_decl_abstract_flags (tree decl, int setting)
267 {
268   DECL_ABSTRACT (decl) = setting;
269   if (TREE_CODE (decl) == FUNCTION_DECL)
270     {
271       tree arg;
272
273       for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
274         DECL_ABSTRACT (arg) = setting;
275       if (DECL_INITIAL (decl) != NULL_TREE
276           && DECL_INITIAL (decl) != error_mark_node)
277         set_block_abstract_flags (DECL_INITIAL (decl), setting);
278     }
279 }
280 \f
281 /* Functions to keep track of the values hard regs had at the start of
282    the function.  */
283
284 rtx
285 get_hard_reg_initial_reg (struct function *fun, rtx reg)
286 {
287   struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
288   int i;
289
290   if (ivs == 0)
291     return NULL_RTX;
292
293   for (i = 0; i < ivs->num_entries; i++)
294     if (rtx_equal_p (ivs->entries[i].pseudo, reg))
295       return ivs->entries[i].hard_reg;
296
297   return NULL_RTX;
298 }
299
300 /* Make sure that there's a pseudo register of mode MODE that stores the
301    initial value of hard register REGNO.  Return an rtx for such a pseudo.  */
302
303 rtx
304 get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
305 {
306   struct initial_value_struct *ivs;
307   rtx rv;
308
309   rv = has_hard_reg_initial_val (mode, regno);
310   if (rv)
311     return rv;
312
313   ivs = cfun->hard_reg_initial_vals;
314   if (ivs == 0)
315     {
316       ivs = ggc_alloc (sizeof (initial_value_struct));
317       ivs->num_entries = 0;
318       ivs->max_entries = 5;
319       ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair));
320       cfun->hard_reg_initial_vals = ivs;
321     }
322
323   if (ivs->num_entries >= ivs->max_entries)
324     {
325       ivs->max_entries += 5;
326       ivs->entries = ggc_realloc (ivs->entries,
327                                   ivs->max_entries
328                                   * sizeof (initial_value_pair));
329     }
330
331   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
332   ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
333
334   return ivs->entries[ivs->num_entries++].pseudo;
335 }
336
337 /* See if get_hard_reg_initial_val has been used to create a pseudo
338    for the initial value of hard register REGNO in mode MODE.  Return
339    the associated pseudo if so, otherwise return NULL.  */
340
341 rtx
342 has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
343 {
344   struct initial_value_struct *ivs;
345   int i;
346
347   ivs = cfun->hard_reg_initial_vals;
348   if (ivs != 0)
349     for (i = 0; i < ivs->num_entries; i++)
350       if (GET_MODE (ivs->entries[i].hard_reg) == mode
351           && REGNO (ivs->entries[i].hard_reg) == regno)
352         return ivs->entries[i].pseudo;
353
354   return NULL_RTX;
355 }
356
357 void
358 emit_initial_value_sets (void)
359 {
360   struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
361   int i;
362   rtx seq;
363
364   if (ivs == 0)
365     return;
366
367   start_sequence ();
368   for (i = 0; i < ivs->num_entries; i++)
369     emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
370   seq = get_insns ();
371   end_sequence ();
372
373   emit_insn_after (seq, entry_of_function ());
374 }
375
376 struct tree_opt_pass pass_initial_value_sets =
377 {
378   NULL,                                 /* name */
379   NULL,                                 /* gate */
380   emit_initial_value_sets,              /* execute */
381   NULL,                                 /* sub */
382   NULL,                                 /* next */
383   0,                                    /* static_pass_number */
384   0,                                    /* tv_id */
385   0,                                    /* properties_required */
386   0,                                    /* properties_provided */
387   0,                                    /* properties_destroyed */
388   0,                                    /* todo_flags_start */
389   0,                                    /* todo_flags_finish */
390   0                                     /* letter */
391 };
392
393 /* If the backend knows where to allocate pseudos for hard
394    register initial values, register these allocations now.  */
395 void
396 allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
397 {
398   if (targetm.allocate_initial_value)
399     {
400       struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
401       int i;
402
403       if (ivs == 0)
404         return;
405
406       for (i = 0; i < ivs->num_entries; i++)
407         {
408           int regno = REGNO (ivs->entries[i].pseudo);
409           rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
410   
411           if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
412             {
413               if (MEM_P (x))
414                 reg_equiv_memory_loc[regno] = x;
415               else
416                 {
417                   basic_block bb;
418                   int new_regno;
419
420                   gcc_assert (REG_P (x));
421                   new_regno = REGNO (x);
422                   reg_renumber[regno] = new_regno;
423                   /* Poke the regno right into regno_reg_rtx so that even
424                      fixed regs are accepted.  */
425                   REGNO (ivs->entries[i].pseudo) = new_regno;
426                   /* Update global register liveness information.  */
427                   FOR_EACH_BB (bb)
428                     {
429                       struct rtl_bb_info *info = bb->il.rtl;
430
431                       if (REGNO_REG_SET_P(info->global_live_at_start, regno))
432                         SET_REGNO_REG_SET (info->global_live_at_start,
433                                            new_regno);
434                       if (REGNO_REG_SET_P(info->global_live_at_end, regno))
435                         SET_REGNO_REG_SET (info->global_live_at_end,
436                                            new_regno);
437                     }
438                 }
439             }
440         }
441     }
442 }
443
444 #include "gt-integrate.h"