]>
Commit | Line | Data |
---|---|---|
518dc859 | 1 | /* Interprocedural analyses. |
23a5b65a | 2 | Copyright (C) 2005-2014 Free Software Foundation, Inc. |
518dc859 RL |
3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it under | |
7 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 8 | Software Foundation; either version 3, or (at your option) any later |
518dc859 RL |
9 | version. |
10 | ||
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
518dc859 RL |
19 | |
20 | #ifndef IPA_PROP_H | |
21 | #define IPA_PROP_H | |
22 | ||
771578a0 | 23 | #include "vec.h" |
3e293154 | 24 | #include "cgraph.h" |
310bc633 | 25 | #include "alloc-pool.h" |
518dc859 RL |
26 | |
27 | /* The following definitions and interfaces are used by | |
133f9369 MJ |
28 | interprocedural analyses or parameters. */ |
29 | ||
4502fe8d MJ |
30 | #define IPA_UNDESCRIBED_USE -1 |
31 | ||
133f9369 | 32 | /* ipa-prop.c stuff (ipa-cp, indirect inlining): */ |
518dc859 | 33 | |
be95e2b9 | 34 | /* A jump function for a callsite represents the values passed as actual |
310bc633 MJ |
35 | arguments of the callsite. They were originally proposed in a paper called |
36 | "Interprocedural Constant Propagation", by David Callahan, Keith D Cooper, | |
37 | Ken Kennedy, Linda Torczon in Comp86, pg 152-161. There are three main | |
38 | types of values : | |
685b0d13 MJ |
39 | |
40 | Pass-through - the caller's formal parameter is passed as an actual | |
41 | argument, possibly one simple operation performed on it. | |
42 | Constant - a constant (is_gimple_ip_invariant)is passed as an actual | |
43 | argument. | |
44 | Unknown - neither of the above. | |
45 | ||
b258210c MJ |
46 | IPA_JF_ANCESTOR is a special pass-through jump function, which means that |
47 | the result is an address of a part of the object pointed to by the formal | |
48 | parameter to which the function refers. It is mainly intended to represent | |
49 | getting addresses of of ancestor fields in C++ | |
50 | (e.g. &this_1(D)->D.1766.D.1756). Note that if the original pointer is | |
51 | NULL, ancestor jump function must behave like a simple pass-through. | |
52 | ||
53 | Other pass-through functions can either simply pass on an unchanged formal | |
54 | parameter or can apply one simple binary operation to it (such jump | |
55 | functions are called polynomial). | |
56 | ||
57 | IPA_JF_KNOWN_TYPE is a special type of an "unknown" function that applies | |
58 | only to pointer parameters. It means that even though we cannot prove that | |
59 | the passed value is an interprocedural constant, we still know the exact | |
60 | type of the containing object which may be valuable for devirtualization. | |
61 | ||
62 | Jump functions are computed in ipa-prop.c by function | |
63 | update_call_notes_after_inlining. Some information can be lost and jump | |
64 | functions degraded accordingly when inlining, see | |
65 | update_call_notes_after_inlining in the same file. */ | |
685b0d13 | 66 | |
518dc859 RL |
67 | enum jump_func_type |
68 | { | |
133f9369 | 69 | IPA_JF_UNKNOWN = 0, /* newly allocated and zeroed jump functions default */ |
c7573249 | 70 | IPA_JF_KNOWN_TYPE, /* represented by field known_type */ |
b258210c | 71 | IPA_JF_CONST, /* represented by field costant */ |
b258210c MJ |
72 | IPA_JF_PASS_THROUGH, /* represented by field pass_through */ |
73 | IPA_JF_ANCESTOR /* represented by field ancestor */ | |
518dc859 RL |
74 | }; |
75 | ||
c7573249 MJ |
76 | /* Structure holding data required to describe a known type jump function. */ |
77 | struct GTY(()) ipa_known_type_data | |
78 | { | |
79 | /* Offset of the component of the base_type being described. */ | |
80 | HOST_WIDE_INT offset; | |
81 | /* Type of the whole object. */ | |
82 | tree base_type; | |
83 | /* Type of the component of the object that is being described. */ | |
84 | tree component_type; | |
85 | }; | |
86 | ||
4502fe8d MJ |
87 | struct ipa_cst_ref_desc; |
88 | ||
89 | /* Structure holding data required to describe a constant jump function. */ | |
90 | struct GTY(()) ipa_constant_data | |
91 | { | |
92 | /* THe value of the constant. */ | |
93 | tree value; | |
94 | /* Pointer to the structure that describes the reference. */ | |
95 | struct ipa_cst_ref_desc GTY((skip)) *rdesc; | |
96 | }; | |
97 | ||
685b0d13 MJ |
98 | /* Structure holding data required to describe a pass-through jump function. */ |
99 | ||
fb3f88cc | 100 | struct GTY(()) ipa_pass_through_data |
685b0d13 MJ |
101 | { |
102 | /* If an operation is to be performed on the original parameter, this is the | |
103 | second (constant) operand. */ | |
104 | tree operand; | |
105 | /* Number of the caller's formal parameter being passed. */ | |
106 | int formal_id; | |
107 | /* Operation that is performed on the argument before it is passed on. | |
108 | NOP_EXPR means no operation. Otherwise oper must be a simple binary | |
109 | arithmetic operation where the caller's parameter is the first operand and | |
110 | operand field from this structure is the second one. */ | |
111 | enum tree_code operation; | |
8b7773a4 MJ |
112 | /* When the passed value is a pointer, it is set to true only when we are |
113 | certain that no write to the object it points to has occurred since the | |
114 | caller functions started execution, except for changes noted in the | |
115 | aggregate part of the jump function (see description of | |
116 | ipa_agg_jump_function). The flag is used only when the operation is | |
117 | NOP_EXPR. */ | |
b8f6e610 MJ |
118 | unsigned agg_preserved : 1; |
119 | ||
120 | /* When set to true, we guarantee that, if there is a C++ object pointed to | |
121 | by this object, it does not undergo dynamic type change in the course of | |
122 | functions decribed by this jump function. */ | |
123 | unsigned type_preserved : 1; | |
685b0d13 MJ |
124 | }; |
125 | ||
b258210c MJ |
126 | /* Structure holding data required to describe an ancestor pass-through |
127 | jump function. */ | |
685b0d13 | 128 | |
fb3f88cc | 129 | struct GTY(()) ipa_ancestor_jf_data |
685b0d13 MJ |
130 | { |
131 | /* Offset of the field representing the ancestor. */ | |
132 | HOST_WIDE_INT offset; | |
0a2550e7 JH |
133 | /* Type of the result. |
134 | When TYPE_PRESERVED is false, TYPE is NULL, since it is only | |
135 | relevant for the devirtualization machinery. */ | |
685b0d13 MJ |
136 | tree type; |
137 | /* Number of the caller's formal parameter being passed. */ | |
138 | int formal_id; | |
8b7773a4 | 139 | /* Flag with the same meaning like agg_preserve in ipa_pass_through_data. */ |
b8f6e610 MJ |
140 | unsigned agg_preserved : 1; |
141 | /* When set to true, we guarantee that, if there is a C++ object pointed to | |
142 | by this object, it does not undergo dynamic type change in the course of | |
143 | functions decribed by this jump function. */ | |
144 | unsigned type_preserved : 1; | |
685b0d13 MJ |
145 | }; |
146 | ||
8b7773a4 MJ |
147 | /* An element in an aggegate part of a jump function describing a known value |
148 | at a given offset. When it is part of a pass-through jump function with | |
149 | agg_preserved set or an ancestor jump function with agg_preserved set, all | |
150 | unlisted positions are assumed to be preserved but the value can be a type | |
151 | node, which means that the particular piece (starting at offset and having | |
152 | the size of the type) is clobbered with an unknown value. When | |
153 | agg_preserved is false or the type of the containing jump function is | |
154 | different, all unlisted parts are assumed to be unknown and all values must | |
688010ba | 155 | fulfill is_gimple_ip_invariant. */ |
8b7773a4 | 156 | |
84562394 | 157 | struct GTY(()) ipa_agg_jf_item |
8b7773a4 MJ |
158 | { |
159 | /* The offset at which the known value is located within the aggregate. */ | |
160 | HOST_WIDE_INT offset; | |
161 | ||
162 | /* The known constant or type if this is a clobber. */ | |
163 | tree value; | |
84562394 | 164 | }; |
8b7773a4 | 165 | |
8b7773a4 MJ |
166 | |
167 | /* Aggregate jump function - i.e. description of contents of aggregates passed | |
168 | either by reference or value. */ | |
169 | ||
170 | struct GTY(()) ipa_agg_jump_function | |
3e293154 | 171 | { |
8b7773a4 | 172 | /* Description of the individual items. */ |
84562394 | 173 | vec<ipa_agg_jf_item, va_gc> *items; |
8b7773a4 MJ |
174 | /* True if the data was passed by reference (as opposed to by value). */ |
175 | bool by_ref; | |
3e293154 MJ |
176 | }; |
177 | ||
8b7773a4 | 178 | typedef struct ipa_agg_jump_function *ipa_agg_jump_function_p; |
8b7773a4 | 179 | |
be95e2b9 MJ |
180 | /* A jump function for a callsite represents the values passed as actual |
181 | arguments of the callsite. See enum jump_func_type for the various | |
518dc859 | 182 | types of jump functions supported. */ |
84562394 | 183 | struct GTY (()) ipa_jump_func |
518dc859 | 184 | { |
8b7773a4 MJ |
185 | /* Aggregate contants description. See struct ipa_agg_jump_function and its |
186 | description. */ | |
187 | struct ipa_agg_jump_function agg; | |
188 | ||
518dc859 | 189 | enum jump_func_type type; |
fb3f88cc JH |
190 | /* Represents a value of a jump function. pass_through is used only in jump |
191 | function context. constant represents the actual constant in constant jump | |
192 | functions and member_cst holds constant c++ member functions. */ | |
193 | union jump_func_value | |
194 | { | |
c7573249 | 195 | struct ipa_known_type_data GTY ((tag ("IPA_JF_KNOWN_TYPE"))) known_type; |
4502fe8d | 196 | struct ipa_constant_data GTY ((tag ("IPA_JF_CONST"))) constant; |
fb3f88cc JH |
197 | struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through; |
198 | struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor; | |
fb3f88cc | 199 | } GTY ((desc ("%1.type"))) value; |
84562394 | 200 | }; |
606d9a09 | 201 | |
518dc859 | 202 | |
688010ba | 203 | /* Return the offset of the component that is described by a known type jump |
7b872d9e MJ |
204 | function JFUNC. */ |
205 | ||
206 | static inline HOST_WIDE_INT | |
207 | ipa_get_jf_known_type_offset (struct ipa_jump_func *jfunc) | |
208 | { | |
209 | gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE); | |
210 | return jfunc->value.known_type.offset; | |
211 | } | |
212 | ||
213 | /* Return the base type of a known type jump function JFUNC. */ | |
214 | ||
215 | static inline tree | |
216 | ipa_get_jf_known_type_base_type (struct ipa_jump_func *jfunc) | |
217 | { | |
218 | gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE); | |
219 | return jfunc->value.known_type.base_type; | |
220 | } | |
221 | ||
222 | /* Return the component type of a known type jump function JFUNC. */ | |
223 | ||
224 | static inline tree | |
225 | ipa_get_jf_known_type_component_type (struct ipa_jump_func *jfunc) | |
226 | { | |
227 | gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE); | |
228 | return jfunc->value.known_type.component_type; | |
229 | } | |
230 | ||
231 | /* Return the constant stored in a constant jump functin JFUNC. */ | |
232 | ||
233 | static inline tree | |
234 | ipa_get_jf_constant (struct ipa_jump_func *jfunc) | |
235 | { | |
236 | gcc_checking_assert (jfunc->type == IPA_JF_CONST); | |
4502fe8d MJ |
237 | return jfunc->value.constant.value; |
238 | } | |
239 | ||
240 | static inline struct ipa_cst_ref_desc * | |
241 | ipa_get_jf_constant_rdesc (struct ipa_jump_func *jfunc) | |
242 | { | |
243 | gcc_checking_assert (jfunc->type == IPA_JF_CONST); | |
244 | return jfunc->value.constant.rdesc; | |
7b872d9e MJ |
245 | } |
246 | ||
247 | /* Return the operand of a pass through jmp function JFUNC. */ | |
248 | ||
249 | static inline tree | |
250 | ipa_get_jf_pass_through_operand (struct ipa_jump_func *jfunc) | |
251 | { | |
252 | gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH); | |
253 | return jfunc->value.pass_through.operand; | |
254 | } | |
255 | ||
256 | /* Return the number of the caller's formal parameter that a pass through jump | |
257 | function JFUNC refers to. */ | |
258 | ||
259 | static inline int | |
260 | ipa_get_jf_pass_through_formal_id (struct ipa_jump_func *jfunc) | |
261 | { | |
262 | gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH); | |
263 | return jfunc->value.pass_through.formal_id; | |
264 | } | |
265 | ||
266 | /* Return operation of a pass through jump function JFUNC. */ | |
267 | ||
268 | static inline enum tree_code | |
269 | ipa_get_jf_pass_through_operation (struct ipa_jump_func *jfunc) | |
270 | { | |
271 | gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH); | |
272 | return jfunc->value.pass_through.operation; | |
273 | } | |
274 | ||
b8f6e610 | 275 | /* Return the agg_preserved flag of a pass through jump function JFUNC. */ |
8b7773a4 MJ |
276 | |
277 | static inline bool | |
278 | ipa_get_jf_pass_through_agg_preserved (struct ipa_jump_func *jfunc) | |
279 | { | |
280 | gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH); | |
281 | return jfunc->value.pass_through.agg_preserved; | |
282 | } | |
283 | ||
b8f6e610 MJ |
284 | /* Return the type_preserved flag of a pass through jump function JFUNC. */ |
285 | ||
286 | static inline bool | |
287 | ipa_get_jf_pass_through_type_preserved (struct ipa_jump_func *jfunc) | |
288 | { | |
289 | gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH); | |
290 | return jfunc->value.pass_through.type_preserved; | |
291 | } | |
292 | ||
7b872d9e MJ |
293 | /* Return the offset of an ancestor jump function JFUNC. */ |
294 | ||
295 | static inline HOST_WIDE_INT | |
296 | ipa_get_jf_ancestor_offset (struct ipa_jump_func *jfunc) | |
297 | { | |
298 | gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR); | |
299 | return jfunc->value.ancestor.offset; | |
300 | } | |
301 | ||
302 | /* Return the result type of an ancestor jump function JFUNC. */ | |
303 | ||
304 | static inline tree | |
305 | ipa_get_jf_ancestor_type (struct ipa_jump_func *jfunc) | |
306 | { | |
307 | gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR); | |
308 | return jfunc->value.ancestor.type; | |
309 | } | |
310 | ||
311 | /* Return the number of the caller's formal parameter that an ancestor jump | |
312 | function JFUNC refers to. */ | |
313 | ||
314 | static inline int | |
315 | ipa_get_jf_ancestor_formal_id (struct ipa_jump_func *jfunc) | |
316 | { | |
317 | gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR); | |
318 | return jfunc->value.ancestor.formal_id; | |
319 | } | |
320 | ||
b8f6e610 | 321 | /* Return the agg_preserved flag of an ancestor jump function JFUNC. */ |
7b872d9e | 322 | |
8b7773a4 MJ |
323 | static inline bool |
324 | ipa_get_jf_ancestor_agg_preserved (struct ipa_jump_func *jfunc) | |
7b872d9e | 325 | { |
8b7773a4 MJ |
326 | gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR); |
327 | return jfunc->value.ancestor.agg_preserved; | |
7b872d9e MJ |
328 | } |
329 | ||
b8f6e610 MJ |
330 | /* Return the type_preserved flag of an ancestor jump function JFUNC. */ |
331 | ||
332 | static inline bool | |
333 | ipa_get_jf_ancestor_type_preserved (struct ipa_jump_func *jfunc) | |
334 | { | |
335 | gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR); | |
336 | return jfunc->value.ancestor.type_preserved; | |
337 | } | |
338 | ||
310bc633 | 339 | /* Summary describing a single formal parameter. */ |
b258210c | 340 | |
f8e2a1ed MJ |
341 | struct ipa_param_descriptor |
342 | { | |
f8e2a1ed MJ |
343 | /* PARAM_DECL of this parameter. */ |
344 | tree decl; | |
4502fe8d MJ |
345 | /* If all uses of the parameter are described by ipa-prop structures, this |
346 | says how many there are. If any use could not be described by means of | |
347 | ipa-prop structures, this is IPA_UNDESCRIBED_USE. */ | |
348 | int controlled_uses; | |
0e8853ee | 349 | unsigned int move_cost : 31; |
339f49ec JH |
350 | /* The parameter is used. */ |
351 | unsigned used : 1; | |
f8e2a1ed MJ |
352 | }; |
353 | ||
310bc633 MJ |
354 | struct ipcp_lattice; |
355 | ||
dcd416e3 MJ |
356 | /* ipa_node_params stores information related to formal parameters of functions |
357 | and some other information for interprocedural passes that operate on | |
358 | parameters (such as ipa-cp). */ | |
310bc633 | 359 | |
dcd416e3 | 360 | struct ipa_node_params |
518dc859 | 361 | { |
310bc633 MJ |
362 | /* Information about individual formal parameters that are gathered when |
363 | summaries are generated. */ | |
84562394 | 364 | vec<ipa_param_descriptor> descriptors; |
310bc633 MJ |
365 | /* Pointer to an array of structures describing individual formal |
366 | parameters. */ | |
2c9561b5 | 367 | struct ipcp_param_lattices *lattices; |
310bc633 MJ |
368 | /* Only for versioned nodes this field would not be NULL, |
369 | it points to the node that IPA cp cloned from. */ | |
370 | struct cgraph_node *ipcp_orig_node; | |
371 | /* If this node is an ipa-cp clone, these are the known values that describe | |
372 | what it has been specialized for. */ | |
9771b263 | 373 | vec<tree> known_vals; |
448f65db NF |
374 | /* Whether the param uses analysis has already been performed. */ |
375 | unsigned uses_analysis_done : 1; | |
310bc633 | 376 | /* Whether the function is enqueued in ipa-cp propagation stack. */ |
448f65db | 377 | unsigned node_enqueued : 1; |
310bc633 MJ |
378 | /* Whether we should create a specialized version based on values that are |
379 | known to be constant in all contexts. */ | |
eb20b778 MJ |
380 | unsigned do_clone_for_all_contexts : 1; |
381 | /* Set if this is an IPA-CP clone for all contexts. */ | |
382 | unsigned is_all_contexts_clone : 1; | |
310bc633 MJ |
383 | /* Node has been completely replaced by clones and will be removed after |
384 | ipa-cp is finished. */ | |
385 | unsigned node_dead : 1; | |
518dc859 RL |
386 | }; |
387 | ||
dcd416e3 MJ |
388 | /* ipa_node_params access functions. Please use these to access fields that |
389 | are or will be shared among various passes. */ | |
390 | ||
dcd416e3 | 391 | /* Return the number of formal parameters. */ |
be95e2b9 | 392 | |
dcd416e3 MJ |
393 | static inline int |
394 | ipa_get_param_count (struct ipa_node_params *info) | |
395 | { | |
9771b263 | 396 | return info->descriptors.length (); |
dcd416e3 MJ |
397 | } |
398 | ||
f8e2a1ed MJ |
399 | /* Return the declaration of Ith formal parameter of the function corresponding |
400 | to INFO. Note there is no setter function as this array is built just once | |
401 | using ipa_initialize_node_params. */ | |
be95e2b9 | 402 | |
dcd416e3 | 403 | static inline tree |
f8e2a1ed | 404 | ipa_get_param (struct ipa_node_params *info, int i) |
dcd416e3 | 405 | { |
0e8853ee | 406 | gcc_checking_assert (!flag_wpa); |
9771b263 | 407 | return info->descriptors[i].decl; |
339f49ec JH |
408 | } |
409 | ||
0e8853ee JH |
410 | /* Return the move cost of Ith formal parameter of the function corresponding |
411 | to INFO. */ | |
412 | ||
413 | static inline int | |
414 | ipa_get_param_move_cost (struct ipa_node_params *info, int i) | |
415 | { | |
416 | return info->descriptors[i].move_cost; | |
417 | } | |
418 | ||
310bc633 MJ |
419 | /* Set the used flag corresponding to the Ith formal parameter of the function |
420 | associated with INFO to VAL. */ | |
3949c4a7 | 421 | |
310bc633 MJ |
422 | static inline void |
423 | ipa_set_param_used (struct ipa_node_params *info, int i, bool val) | |
3949c4a7 | 424 | { |
9771b263 | 425 | info->descriptors[i].used = val; |
3949c4a7 MJ |
426 | } |
427 | ||
4502fe8d MJ |
428 | /* Return how many uses described by ipa-prop a parameter has or |
429 | IPA_UNDESCRIBED_USE if there is a use that is not described by these | |
430 | structures. */ | |
431 | static inline int | |
432 | ipa_get_controlled_uses (struct ipa_node_params *info, int i) | |
433 | { | |
434 | return info->descriptors[i].controlled_uses; | |
435 | } | |
436 | ||
437 | /* Set the controlled counter of a given parameter. */ | |
438 | ||
439 | static inline void | |
440 | ipa_set_controlled_uses (struct ipa_node_params *info, int i, int val) | |
441 | { | |
442 | info->descriptors[i].controlled_uses = val; | |
443 | } | |
444 | ||
310bc633 MJ |
445 | /* Return the used flag corresponding to the Ith formal parameter of the |
446 | function associated with INFO. */ | |
3949c4a7 MJ |
447 | |
448 | static inline bool | |
310bc633 | 449 | ipa_is_param_used (struct ipa_node_params *info, int i) |
3949c4a7 | 450 | { |
9771b263 | 451 | return info->descriptors[i].used; |
3949c4a7 MJ |
452 | } |
453 | ||
2c9561b5 MJ |
454 | /* Information about replacements done in aggregates for a given node (each |
455 | node has its linked list). */ | |
456 | struct GTY(()) ipa_agg_replacement_value | |
457 | { | |
458 | /* Next item in the linked list. */ | |
459 | struct ipa_agg_replacement_value *next; | |
460 | /* Offset within the aggregate. */ | |
461 | HOST_WIDE_INT offset; | |
462 | /* The constant value. */ | |
463 | tree value; | |
464 | /* The paramter index. */ | |
465 | int index; | |
7b920a9a MJ |
466 | /* Whether the value was passed by reference. */ |
467 | bool by_ref; | |
2c9561b5 MJ |
468 | }; |
469 | ||
470 | typedef struct ipa_agg_replacement_value *ipa_agg_replacement_value_p; | |
2c9561b5 MJ |
471 | |
472 | void ipa_set_node_agg_value_chain (struct cgraph_node *node, | |
473 | struct ipa_agg_replacement_value *aggvals); | |
474 | ||
93c594a3 MJ |
475 | /* ipa_edge_args stores information related to a callsite and particularly its |
476 | arguments. It can be accessed by the IPA_EDGE_REF macro. */ | |
84562394 | 477 | struct GTY(()) ipa_edge_args |
518dc859 | 478 | { |
606d9a09 | 479 | /* Vector of the callsite's jump function of each parameter. */ |
84562394 OE |
480 | vec<ipa_jump_func, va_gc> *jump_functions; |
481 | }; | |
518dc859 | 482 | |
dcd416e3 MJ |
483 | /* ipa_edge_args access functions. Please use these to access fields that |
484 | are or will be shared among various passes. */ | |
485 | ||
dcd416e3 | 486 | /* Return the number of actual arguments. */ |
be95e2b9 | 487 | |
dcd416e3 MJ |
488 | static inline int |
489 | ipa_get_cs_argument_count (struct ipa_edge_args *args) | |
490 | { | |
9771b263 | 491 | return vec_safe_length (args->jump_functions); |
dcd416e3 MJ |
492 | } |
493 | ||
494 | /* Returns a pointer to the jump function for the ith argument. Please note | |
495 | there is no setter function as jump functions are all set up in | |
496 | ipa_compute_jump_functions. */ | |
be95e2b9 | 497 | |
dcd416e3 MJ |
498 | static inline struct ipa_jump_func * |
499 | ipa_get_ith_jump_func (struct ipa_edge_args *args, int i) | |
500 | { | |
9771b263 | 501 | return &(*args->jump_functions)[i]; |
dcd416e3 MJ |
502 | } |
503 | ||
be95e2b9 | 504 | /* Types of vectors holding the infos. */ |
771578a0 MJ |
505 | |
506 | /* Vector where the parameter infos are actually stored. */ | |
84562394 | 507 | extern vec<ipa_node_params> ipa_node_params_vector; |
2c9561b5 | 508 | /* Vector of known aggregate values in cloned nodes. */ |
9771b263 | 509 | extern GTY(()) vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements; |
771578a0 | 510 | /* Vector where the parameter infos are actually stored. */ |
84562394 | 511 | extern GTY(()) vec<ipa_edge_args, va_gc> *ipa_edge_args_vector; |
771578a0 MJ |
512 | |
513 | /* Return the associated parameter/argument info corresponding to the given | |
514 | node/edge. */ | |
9771b263 DN |
515 | #define IPA_NODE_REF(NODE) (&ipa_node_params_vector[(NODE)->uid]) |
516 | #define IPA_EDGE_REF(EDGE) (&(*ipa_edge_args_vector)[(EDGE)->uid]) | |
771578a0 MJ |
517 | /* This macro checks validity of index returned by |
518 | ipa_get_param_decl_index function. */ | |
519 | #define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1) | |
520 | ||
521 | /* Creating and freeing ipa_node_params and ipa_edge_args. */ | |
522 | void ipa_create_all_node_params (void); | |
523 | void ipa_create_all_edge_args (void); | |
524 | void ipa_free_edge_args_substructures (struct ipa_edge_args *); | |
525 | void ipa_free_node_params_substructures (struct ipa_node_params *); | |
526 | void ipa_free_all_node_params (void); | |
527 | void ipa_free_all_edge_args (void); | |
e33c6cd6 MJ |
528 | void ipa_free_all_structures_after_ipa_cp (void); |
529 | void ipa_free_all_structures_after_iinln (void); | |
771578a0 MJ |
530 | void ipa_register_cgraph_hooks (void); |
531 | ||
532 | /* This function ensures the array of node param infos is big enough to | |
be95e2b9 MJ |
533 | accommodate a structure for all nodes and reallocates it if not. */ |
534 | ||
771578a0 MJ |
535 | static inline void |
536 | ipa_check_create_node_params (void) | |
537 | { | |
9771b263 DN |
538 | if (!ipa_node_params_vector.exists ()) |
539 | ipa_node_params_vector.create (cgraph_max_uid); | |
771578a0 | 540 | |
9771b263 DN |
541 | if (ipa_node_params_vector.length () <= (unsigned) cgraph_max_uid) |
542 | ipa_node_params_vector.safe_grow_cleared (cgraph_max_uid + 1); | |
771578a0 MJ |
543 | } |
544 | ||
be95e2b9 MJ |
545 | /* This function ensures the array of edge arguments infos is big enough to |
546 | accommodate a structure for all edges and reallocates it if not. */ | |
547 | ||
771578a0 MJ |
548 | static inline void |
549 | ipa_check_create_edge_args (void) | |
550 | { | |
9771b263 DN |
551 | if (vec_safe_length (ipa_edge_args_vector) <= (unsigned) cgraph_edge_max_uid) |
552 | vec_safe_grow_cleared (ipa_edge_args_vector, cgraph_edge_max_uid + 1); | |
771578a0 MJ |
553 | } |
554 | ||
be95e2b9 | 555 | /* Returns true if the array of edge infos is large enough to accommodate an |
0eae6bab MJ |
556 | info for EDGE. The main purpose of this function is that debug dumping |
557 | function can check info availability without causing reallocations. */ | |
be95e2b9 | 558 | |
0eae6bab MJ |
559 | static inline bool |
560 | ipa_edge_args_info_available_for_edge_p (struct cgraph_edge *edge) | |
561 | { | |
9771b263 | 562 | return ((unsigned) edge->uid < vec_safe_length (ipa_edge_args_vector)); |
0eae6bab MJ |
563 | } |
564 | ||
2c9561b5 MJ |
565 | /* Return the aggregate replacements for NODE, if there are any. */ |
566 | ||
567 | static inline struct ipa_agg_replacement_value * | |
568 | ipa_get_agg_replacements_for_node (struct cgraph_node *node) | |
569 | { | |
9771b263 | 570 | if ((unsigned) node->uid >= vec_safe_length (ipa_node_agg_replacements)) |
2c9561b5 | 571 | return NULL; |
9771b263 | 572 | return (*ipa_node_agg_replacements)[node->uid]; |
2c9561b5 MJ |
573 | } |
574 | ||
f8e2a1ed MJ |
575 | /* Function formal parameters related computations. */ |
576 | void ipa_initialize_node_params (struct cgraph_node *node); | |
f8e2a1ed | 577 | bool ipa_propagate_indirect_call_infos (struct cgraph_edge *cs, |
9771b263 | 578 | vec<cgraph_edge_p> *new_edges); |
518dc859 | 579 | |
3949c4a7 | 580 | /* Indirect edge and binfo processing. */ |
d2d668fb | 581 | tree ipa_get_indirect_edge_target (struct cgraph_edge *ie, |
9771b263 DN |
582 | vec<tree> , |
583 | vec<tree> , | |
584 | vec<ipa_agg_jump_function_p> ); | |
81fa35bd | 585 | struct cgraph_edge *ipa_make_edge_direct_to_target (struct cgraph_edge *, tree); |
e248d83f MJ |
586 | tree ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *); |
587 | tree ipa_intraprocedural_devirtualization (gimple); | |
3949c4a7 | 588 | |
310bc633 MJ |
589 | /* Functions related to both. */ |
590 | void ipa_analyze_node (struct cgraph_node *); | |
3949c4a7 | 591 | |
8b7773a4 MJ |
592 | /* Aggregate jump function related functions. */ |
593 | tree ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *, HOST_WIDE_INT, | |
594 | bool); | |
595 | bool ipa_load_from_parm_agg (struct ipa_node_params *, gimple, tree, int *, | |
596 | HOST_WIDE_INT *, bool *); | |
597 | ||
518dc859 | 598 | /* Debugging interface. */ |
ca30a539 JH |
599 | void ipa_print_node_params (FILE *, struct cgraph_node *node); |
600 | void ipa_print_all_params (FILE *); | |
3e293154 MJ |
601 | void ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node); |
602 | void ipa_print_all_jump_functions (FILE * f); | |
310bc633 MJ |
603 | void ipcp_verify_propagated_values (void); |
604 | ||
605 | extern alloc_pool ipcp_values_pool; | |
606 | extern alloc_pool ipcp_sources_pool; | |
2c9561b5 | 607 | extern alloc_pool ipcp_agg_lattice_pool; |
518dc859 | 608 | |
31519c38 AH |
609 | /* Operation to be performed for the parameter in ipa_parm_adjustment |
610 | below. */ | |
611 | enum ipa_parm_op { | |
612 | IPA_PARM_OP_NONE, | |
613 | ||
614 | /* This describes a brand new parameter. | |
615 | ||
616 | The field `type' should be set to the new type, `arg_prefix' | |
617 | should be set to the string prefix for the new DECL_NAME, and | |
618 | `new_decl' will ultimately hold the newly created argument. */ | |
619 | IPA_PARM_OP_NEW, | |
620 | ||
621 | /* This new parameter is an unmodified parameter at index base_index. */ | |
622 | IPA_PARM_OP_COPY, | |
623 | ||
624 | /* This adjustment describes a parameter that is about to be removed | |
625 | completely. Most users will probably need to book keep those so that they | |
626 | don't leave behinfd any non default def ssa names belonging to them. */ | |
627 | IPA_PARM_OP_REMOVE | |
628 | }; | |
629 | ||
3f84bf08 MJ |
630 | /* Structure to describe transformations of formal parameters and actual |
631 | arguments. Each instance describes one new parameter and they are meant to | |
632 | be stored in a vector. Additionally, most users will probably want to store | |
633 | adjustments about parameters that are being removed altogether so that SSA | |
634 | names belonging to them can be replaced by SSA names of an artificial | |
635 | variable. */ | |
636 | struct ipa_parm_adjustment | |
637 | { | |
638 | /* The original PARM_DECL itself, helpful for processing of the body of the | |
639 | function itself. Intended for traversing function bodies. | |
640 | ipa_modify_formal_parameters, ipa_modify_call_arguments and | |
641 | ipa_combine_adjustments ignore this and use base_index. | |
642 | ipa_modify_formal_parameters actually sets this. */ | |
643 | tree base; | |
644 | ||
645 | /* Type of the new parameter. However, if by_ref is true, the real type will | |
646 | be a pointer to this type. */ | |
647 | tree type; | |
648 | ||
82d49829 MJ |
649 | /* Alias refrerence type to be used in MEM_REFs when adjusting caller |
650 | arguments. */ | |
651 | tree alias_ptr_type; | |
652 | ||
31519c38 AH |
653 | /* The new declaration when creating/replacing a parameter. Created |
654 | by ipa_modify_formal_parameters, useful for functions modifying | |
655 | the body accordingly. For brand new arguments, this is the newly | |
656 | created argument. */ | |
657 | tree new_decl; | |
3f84bf08 MJ |
658 | |
659 | /* New declaration of a substitute variable that we may use to replace all | |
660 | non-default-def ssa names when a parm decl is going away. */ | |
661 | tree new_ssa_base; | |
662 | ||
663 | /* If non-NULL and the original parameter is to be removed (copy_param below | |
664 | is NULL), this is going to be its nonlocalized vars value. */ | |
665 | tree nonlocal_value; | |
666 | ||
31519c38 AH |
667 | /* This holds the prefix to be used for the new DECL_NAME. */ |
668 | const char *arg_prefix; | |
669 | ||
3f84bf08 MJ |
670 | /* Offset into the original parameter (for the cases when the new parameter |
671 | is a component of an original one). */ | |
672 | HOST_WIDE_INT offset; | |
673 | ||
31519c38 | 674 | /* Zero based index of the original parameter this one is based on. */ |
3f84bf08 MJ |
675 | int base_index; |
676 | ||
31519c38 AH |
677 | /* Whether this parameter is a new parameter, a copy of an old one, |
678 | or one about to be removed. */ | |
679 | enum ipa_parm_op op; | |
3f84bf08 MJ |
680 | |
681 | /* The parameter is to be passed by reference. */ | |
682 | unsigned by_ref : 1; | |
683 | }; | |
684 | ||
84562394 | 685 | typedef vec<ipa_parm_adjustment> ipa_parm_adjustment_vec; |
3f84bf08 | 686 | |
9771b263 | 687 | vec<tree> ipa_get_vector_of_formal_parms (tree fndecl); |
31519c38 AH |
688 | vec<tree> ipa_get_vector_of_formal_parm_types (tree fntype); |
689 | void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec); | |
3f84bf08 MJ |
690 | void ipa_modify_call_arguments (struct cgraph_edge *, gimple, |
691 | ipa_parm_adjustment_vec); | |
692 | ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec, | |
693 | ipa_parm_adjustment_vec); | |
694 | void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree); | |
2c9561b5 MJ |
695 | void ipa_dump_agg_replacement_values (FILE *f, |
696 | struct ipa_agg_replacement_value *av); | |
f27c1867 | 697 | void ipa_prop_write_jump_functions (void); |
fb3f88cc | 698 | void ipa_prop_read_jump_functions (void); |
2c9561b5 MJ |
699 | void ipa_prop_write_all_agg_replacement (void); |
700 | void ipa_prop_read_all_agg_replacement (void); | |
fb3f88cc | 701 | void ipa_update_after_lto_read (void); |
632b4f8e | 702 | int ipa_get_param_decl_index (struct ipa_node_params *, tree); |
d2d668fb MK |
703 | tree ipa_value_from_jfunc (struct ipa_node_params *info, |
704 | struct ipa_jump_func *jfunc); | |
2c9561b5 | 705 | unsigned int ipcp_transform_function (struct cgraph_node *node); |
0e8853ee | 706 | void ipa_dump_param (FILE *, struct ipa_node_params *info, int i); |
31519c38 AH |
707 | bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec); |
708 | ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *, | |
709 | ipa_parm_adjustment_vec, | |
710 | bool); | |
411a20d6 | 711 | |
fb3f88cc | 712 | |
3f84bf08 | 713 | /* From tree-sra.c: */ |
e4b5cace MJ |
714 | tree build_ref_for_offset (location_t, tree, HOST_WIDE_INT, tree, |
715 | gimple_stmt_iterator *, bool); | |
3f84bf08 | 716 | |
518dc859 | 717 | #endif /* IPA_PROP_H */ |