OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [cgraph.h] - Blame information for rev 20

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 12 jlechner
/* Callgraph handling code.
2
   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3
   Contributed by Jan Hubicka
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 2, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING.  If not, write to the Free
19
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20
02110-1301, USA.  */
21
 
22
#ifndef GCC_CGRAPH_H
23
#define GCC_CGRAPH_H
24
#include "tree.h"
25
#include "basic-block.h"
26
 
27
enum availability
28
{
29
  /* Not yet set by cgraph_function_body_availability.  */
30
  AVAIL_UNSET,
31
  /* Function body/variable initializer is unknown.  */
32
  AVAIL_NOT_AVAILABLE,
33
  /* Function body/variable initializer is known but might be replaced
34
     by a different one from other compilation unit and thus needs to
35
     be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
36
     arbitrary side effects on escaping variables and functions, while
37
     like AVAILABLE it might access static variables.  */
38
  AVAIL_OVERWRITABLE,
39
  /* Function body/variable initializer is known and will be used in final
40
     program.  */
41
  AVAIL_AVAILABLE,
42
  /* Function body/variable initializer is known and all it's uses are explicitly
43
     visible within current unit (ie it's address is never taken and it is not
44
     exported to other units).
45
     Currently used only for functions.  */
46
  AVAIL_LOCAL
47
};
48
 
49
/* Information about the function collected locally.
50
   Available after function is analyzed.  */
51
 
52
struct cgraph_local_info GTY(())
53
{
54
  /* Size of the function before inlining.  */
55
  int self_insns;
56
 
57
  /* Set when function function is visible in current compilation unit only
58
     and its address is never taken.  */
59
  bool local;
60
 
61
  /* Set when function is visible by other units.  */
62
  bool externally_visible;
63
 
64
  /* Set once it has been finalized so we consider it to be output.  */
65
  bool finalized;
66
 
67
  /* False when there something makes inlining impossible (such as va_arg).  */
68
  bool inlinable;
69
 
70
  /* True when function should be inlined independently on its size.  */
71
  bool disregard_inline_limits;
72
 
73
  /* True when the function has been originally extern inline, but it is
74
     redefined now.  */
75
  bool redefined_extern_inline;
76
 
77
  /* True if statics_read_for_function and
78
     statics_written_for_function contain valid data.  */
79
  bool for_functions_valid;
80
 
81
  /* True if the function is going to be emitted in some other translation
82
     unit, referenced from vtable.  */
83
  bool vtable_method;
84
};
85
 
86
/* Information about the function that needs to be computed globally
87
   once compilation is finished.  Available only with -funit-at-time.  */
88
 
89
struct cgraph_global_info GTY(())
90
{
91
  /* For inline clones this points to the function they will be inlined into.  */
92
  struct cgraph_node *inlined_to;
93
 
94
  /* Estimated size of the function after inlining.  */
95
  int insns;
96
 
97
  /* Estimated growth after inlining.  INT_MIN if not computed.  */
98
  int estimated_growth;
99
 
100
  /* Set iff the function has been inlined at least once.  */
101
  bool inlined;
102
};
103
 
104
/* Information about the function that is propagated by the RTL backend.
105
   Available only for functions that has been already assembled.  */
106
 
107
struct cgraph_rtl_info GTY(())
108
{
109
   int preferred_incoming_stack_boundary;
110
};
111
 
112
/* The cgraph data structure.
113
   Each function decl has assigned cgraph_node listing callees and callers.  */
114
 
115
struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous")))
116
{
117
  tree decl;
118
  struct cgraph_edge *callees;
119
  struct cgraph_edge *callers;
120
  struct cgraph_node *next;
121
  struct cgraph_node *previous;
122
  /* For nested functions points to function the node is nested in.  */
123
  struct cgraph_node *origin;
124
  /* Points to first nested function, if any.  */
125
  struct cgraph_node *nested;
126
  /* Pointer to the next function with same origin, if any.  */
127
  struct cgraph_node *next_nested;
128
  /* Pointer to the next function in cgraph_nodes_queue.  */
129
  struct cgraph_node *next_needed;
130
  /* Pointer to the next clone.  */
131
  struct cgraph_node *next_clone;
132
  struct cgraph_node *prev_clone;
133
  /* Pointer to a single unique cgraph node for this function.  If the
134
     function is to be output, this is the copy that will survive.  */
135
  struct cgraph_node *master_clone;
136
 
137
  PTR GTY ((skip)) aux;
138
 
139
  struct cgraph_local_info local;
140
  struct cgraph_global_info global;
141
  struct cgraph_rtl_info rtl;
142
 
143
  /* Expected number of executions: calculated in profile.c.  */
144
  gcov_type count;
145
  /* Unique id of the node.  */
146
  int uid;
147
  /* Set when function must be output - it is externally visible
148
     or its address is taken.  */
149
  bool needed;
150
  /* Set when function is reachable by call from other function
151
     that is either reachable or needed.  */
152
  bool reachable;
153
  /* Set once the function is lowered (ie it's CFG is built).  */
154
  bool lowered;
155
  /* Set once the function has been instantiated and its callee
156
     lists created.  */
157
  bool analyzed;
158
  /* Set when function is scheduled to be assembled.  */
159
  bool output;
160
  /* Set when function is visible by other units.  */
161
  bool externally_visible;
162
  /* Set for aliases once they got through assemble_alias.  */
163
  bool alias;
164
};
165
 
166
struct cgraph_edge GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller")))
167
{
168
  struct cgraph_node *caller;
169
  struct cgraph_node *callee;
170
  struct cgraph_edge *prev_caller;
171
  struct cgraph_edge *next_caller;
172
  struct cgraph_edge *prev_callee;
173
  struct cgraph_edge *next_callee;
174
  tree call_stmt;
175
  PTR GTY ((skip (""))) aux;
176
  /* When NULL, inline this call.  When non-NULL, points to the explanation
177
     why function was not inlined.  */
178
  const char *inline_failed;
179
  /* Expected number of executions: calculated in profile.c.  */
180
  gcov_type count;
181
  /* Depth of loop nest, 1 means no loop nest.  */
182
  int loop_nest;
183
};
184
 
185
/* The cgraph_varpool data structure.
186
   Each static variable decl has assigned cgraph_varpool_node.  */
187
 
188
struct cgraph_varpool_node GTY(())
189
{
190
  tree decl;
191
  /* Pointer to the next function in cgraph_varpool_nodes.  */
192
  struct cgraph_varpool_node *next;
193
  /* Pointer to the next function in cgraph_varpool_nodes_queue.  */
194
  struct cgraph_varpool_node *next_needed;
195
 
196
  /* Set when function must be output - it is externally visible
197
     or its address is taken.  */
198
  bool needed;
199
  /* Needed variables might become dead by optimization.  This flag
200
     forces the variable to be output even if it appears dead otherwise.  */
201
  bool force_output;
202
  /* Set once the variable has been instantiated and its callee
203
     lists created.  */
204
  bool analyzed;
205
  /* Set once it has been finalized so we consider it to be output.  */
206
  bool finalized;
207
  /* Set when variable is scheduled to be assembled.  */
208
  bool output;
209
  /* Set when function is visible by other units.  */
210
  bool externally_visible;
211
  /* Set for aliases once they got through assemble_alias.  */
212
  bool alias;
213
};
214
 
215
extern GTY(()) struct cgraph_node *cgraph_nodes;
216
extern GTY(()) int cgraph_n_nodes;
217
extern GTY(()) int cgraph_max_uid;
218
extern bool cgraph_global_info_ready;
219
extern bool cgraph_function_flags_ready;
220
extern GTY(()) struct cgraph_node *cgraph_nodes_queue;
221
 
222
extern GTY(()) struct cgraph_varpool_node *cgraph_varpool_first_unanalyzed_node;
223
extern GTY(()) struct cgraph_varpool_node *cgraph_varpool_nodes_queue;
224
 
225
/* In cgraph.c  */
226
void dump_cgraph (FILE *);
227
void dump_cgraph_node (FILE *, struct cgraph_node *);
228
void dump_varpool (FILE *);
229
void dump_cgraph_varpool_node (FILE *, struct cgraph_varpool_node *);
230
void cgraph_remove_edge (struct cgraph_edge *);
231
void cgraph_remove_node (struct cgraph_node *);
232
void cgraph_node_remove_callees (struct cgraph_node *node);
233
struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
234
                                        struct cgraph_node *,
235
                                        tree, gcov_type, int);
236
struct cgraph_node *cgraph_node (tree);
237
struct cgraph_node *cgraph_node_for_asm (tree asmname);
238
struct cgraph_edge *cgraph_edge (struct cgraph_node *, tree);
239
struct cgraph_local_info *cgraph_local_info (tree);
240
struct cgraph_global_info *cgraph_global_info (tree);
241
struct cgraph_rtl_info *cgraph_rtl_info (tree);
242
const char * cgraph_node_name (struct cgraph_node *);
243
struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
244
                                        struct cgraph_node *,
245
                                        tree, gcov_type, int, bool);
246
struct cgraph_node * cgraph_clone_node (struct cgraph_node *, gcov_type,
247
                                        int, bool);
248
 
249
struct cgraph_varpool_node *cgraph_varpool_node (tree);
250
struct cgraph_varpool_node *cgraph_varpool_node_for_asm (tree asmname);
251
void cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *);
252
void cgraph_varpool_finalize_decl (tree);
253
void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
254
 
255
bool cgraph_function_possibly_inlined_p (tree);
256
void cgraph_unnest_node (struct cgraph_node *);
257
void cgraph_varpool_enqueue_needed_node (struct cgraph_varpool_node *);
258
void cgraph_varpool_reset_queue (void);
259
bool decide_is_variable_needed (struct cgraph_varpool_node *, tree);
260
 
261
enum availability cgraph_function_body_availability (struct cgraph_node *);
262
enum availability cgraph_variable_initializer_availability (struct cgraph_varpool_node *);
263
bool cgraph_is_master_clone (struct cgraph_node *);
264
struct cgraph_node *cgraph_master_clone (struct cgraph_node *);
265
 
266
/* In cgraphunit.c  */
267
bool cgraph_assemble_pending_functions (void);
268
bool cgraph_varpool_assemble_pending_decls (void);
269
void cgraph_finalize_function (tree, bool);
270
void cgraph_lower_function (struct cgraph_node *);
271
void cgraph_finalize_compilation_unit (void);
272
void cgraph_optimize (void);
273
void cgraph_mark_needed_node (struct cgraph_node *);
274
void cgraph_mark_reachable_node (struct cgraph_node *);
275
bool cgraph_inline_p (struct cgraph_edge *, const char **reason);
276
bool cgraph_preserve_function_body_p (tree);
277
void verify_cgraph (void);
278
void verify_cgraph_node (struct cgraph_node *);
279
void cgraph_build_static_cdtor (char which, tree body, int priority);
280
void cgraph_reset_static_var_maps (void);
281
void init_cgraph (void);
282
struct cgraph_node *cgraph_function_versioning (struct cgraph_node *,
283
                                                varray_type, varray_type);
284
 
285
/* In ipa.c  */
286
bool cgraph_remove_unreachable_nodes (bool, FILE *);
287
int cgraph_postorder (struct cgraph_node **);
288
 
289
/* In ipa-inline.c  */
290
bool cgraph_decide_inlining_incrementally (struct cgraph_node *, bool);
291
void cgraph_clone_inlined_nodes (struct cgraph_edge *, bool, bool);
292
void cgraph_mark_inline_edge (struct cgraph_edge *, bool);
293
bool cgraph_default_inline_p (struct cgraph_node *, const char **);
294
#endif  /* GCC_CGRAPH_H  */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.