]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/ipa-prop.h
call_summary to keep info about cgraph_edges
[thirdparty/gcc.git] / gcc / ipa-prop.h
CommitLineData
3b22db66 1/* Interprocedural analyses.
aad93da1 2 Copyright (C) 2005-2017 Free Software Foundation, Inc.
3b22db66 3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8c4c00c1 8Software Foundation; either version 3, or (at your option) any later
3b22db66 9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
8c4c00c1 17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
3b22db66 19
20#ifndef IPA_PROP_H
21#define IPA_PROP_H
22
3b22db66 23/* The following definitions and interfaces are used by
ba3a7ba0 24 interprocedural analyses or parameters. */
25
096295f6 26#define IPA_UNDESCRIBED_USE -1
27
ba3a7ba0 28/* ipa-prop.c stuff (ipa-cp, indirect inlining): */
3b22db66 29
1917e945 30/* A jump function for a callsite represents the values passed as actual
821d0e0f 31 arguments of the callsite. They were originally proposed in a paper called
32 "Interprocedural Constant Propagation", by David Callahan, Keith D Cooper,
33 Ken Kennedy, Linda Torczon in Comp86, pg 152-161. There are three main
34 types of values :
5215027d 35
36 Pass-through - the caller's formal parameter is passed as an actual
37 argument, possibly one simple operation performed on it.
38 Constant - a constant (is_gimple_ip_invariant)is passed as an actual
39 argument.
40 Unknown - neither of the above.
41
6378ffb3 42 IPA_JF_ANCESTOR is a special pass-through jump function, which means that
43 the result is an address of a part of the object pointed to by the formal
44 parameter to which the function refers. It is mainly intended to represent
47ae02b7 45 getting addresses of ancestor fields in C++
6378ffb3 46 (e.g. &this_1(D)->D.1766.D.1756). Note that if the original pointer is
47 NULL, ancestor jump function must behave like a simple pass-through.
48
49 Other pass-through functions can either simply pass on an unchanged formal
50 parameter or can apply one simple binary operation to it (such jump
51 functions are called polynomial).
52
6378ffb3 53 Jump functions are computed in ipa-prop.c by function
54 update_call_notes_after_inlining. Some information can be lost and jump
55 functions degraded accordingly when inlining, see
56 update_call_notes_after_inlining in the same file. */
5215027d 57
3b22db66 58enum jump_func_type
59{
ba3a7ba0 60 IPA_JF_UNKNOWN = 0, /* newly allocated and zeroed jump functions default */
6378ffb3 61 IPA_JF_CONST, /* represented by field costant */
6378ffb3 62 IPA_JF_PASS_THROUGH, /* represented by field pass_through */
63 IPA_JF_ANCESTOR /* represented by field ancestor */
3b22db66 64};
65
096295f6 66struct ipa_cst_ref_desc;
67
68/* Structure holding data required to describe a constant jump function. */
69struct GTY(()) ipa_constant_data
70{
71 /* THe value of the constant. */
72 tree value;
73 /* Pointer to the structure that describes the reference. */
74 struct ipa_cst_ref_desc GTY((skip)) *rdesc;
75};
76
5215027d 77/* Structure holding data required to describe a pass-through jump function. */
78
8867b500 79struct GTY(()) ipa_pass_through_data
5215027d 80{
81 /* If an operation is to be performed on the original parameter, this is the
82 second (constant) operand. */
83 tree operand;
84 /* Number of the caller's formal parameter being passed. */
85 int formal_id;
86 /* Operation that is performed on the argument before it is passed on.
87 NOP_EXPR means no operation. Otherwise oper must be a simple binary
88 arithmetic operation where the caller's parameter is the first operand and
89 operand field from this structure is the second one. */
90 enum tree_code operation;
0d491188 91 /* When the passed value is a pointer, it is set to true only when we are
92 certain that no write to the object it points to has occurred since the
93 caller functions started execution, except for changes noted in the
94 aggregate part of the jump function (see description of
95 ipa_agg_jump_function). The flag is used only when the operation is
96 NOP_EXPR. */
ad4a8b28 97 unsigned agg_preserved : 1;
5215027d 98};
99
6378ffb3 100/* Structure holding data required to describe an ancestor pass-through
101 jump function. */
5215027d 102
8867b500 103struct GTY(()) ipa_ancestor_jf_data
5215027d 104{
105 /* Offset of the field representing the ancestor. */
106 HOST_WIDE_INT offset;
5215027d 107 /* Number of the caller's formal parameter being passed. */
108 int formal_id;
0d491188 109 /* Flag with the same meaning like agg_preserve in ipa_pass_through_data. */
ad4a8b28 110 unsigned agg_preserved : 1;
5215027d 111};
112
0d491188 113/* An element in an aggegate part of a jump function describing a known value
114 at a given offset. When it is part of a pass-through jump function with
115 agg_preserved set or an ancestor jump function with agg_preserved set, all
116 unlisted positions are assumed to be preserved but the value can be a type
117 node, which means that the particular piece (starting at offset and having
118 the size of the type) is clobbered with an unknown value. When
119 agg_preserved is false or the type of the containing jump function is
120 different, all unlisted parts are assumed to be unknown and all values must
a04e8d62 121 fulfill is_gimple_ip_invariant. */
0d491188 122
b3e7c666 123struct GTY(()) ipa_agg_jf_item
0d491188 124{
125 /* The offset at which the known value is located within the aggregate. */
126 HOST_WIDE_INT offset;
127
128 /* The known constant or type if this is a clobber. */
129 tree value;
b3e7c666 130};
0d491188 131
0d491188 132
133/* Aggregate jump function - i.e. description of contents of aggregates passed
134 either by reference or value. */
135
136struct GTY(()) ipa_agg_jump_function
f8daee9b 137{
0d491188 138 /* Description of the individual items. */
b3e7c666 139 vec<ipa_agg_jf_item, va_gc> *items;
0d491188 140 /* True if the data was passed by reference (as opposed to by value). */
141 bool by_ref;
f8daee9b 142};
143
0d491188 144typedef struct ipa_agg_jump_function *ipa_agg_jump_function_p;
0d491188 145
a54071b2 146/* Information about zero/non-zero bits. */
147struct GTY(()) ipa_bits
148{
149 /* The propagated value. */
150 widest_int value;
151 /* Mask corresponding to the value.
152 Similar to ccp_lattice_t, if xth bit of mask is 0,
153 implies xth bit of value is constant. */
154 widest_int mask;
a54071b2 155};
156
25a8e007 157/* Info about value ranges. */
97cb825b 158
25a8e007 159struct GTY(()) ipa_vr
160{
161 /* The data fields below are valid only if known is true. */
162 bool known;
163 enum value_range_type type;
164 wide_int min;
165 wide_int max;
166};
167
1917e945 168/* A jump function for a callsite represents the values passed as actual
169 arguments of the callsite. See enum jump_func_type for the various
3b22db66 170 types of jump functions supported. */
b3e7c666 171struct GTY (()) ipa_jump_func
3b22db66 172{
0d491188 173 /* Aggregate contants description. See struct ipa_agg_jump_function and its
174 description. */
175 struct ipa_agg_jump_function agg;
176
97cb825b 177 /* Information about zero/non-zero bits. The pointed to structure is shared
178 betweed different jump functions. Use ipa_set_jfunc_bits to set this
179 field. */
180 struct ipa_bits *bits;
a54071b2 181
72b16d90 182 /* Information about value range, containing valid data only when vr_known is
97cb825b 183 true. The pointed to structure is shared betweed different jump
184 functions. Use ipa_set_jfunc_vr to set this field. */
185 struct value_range *m_vr;
25a8e007 186
3b22db66 187 enum jump_func_type type;
8867b500 188 /* Represents a value of a jump function. pass_through is used only in jump
189 function context. constant represents the actual constant in constant jump
190 functions and member_cst holds constant c++ member functions. */
191 union jump_func_value
192 {
096295f6 193 struct ipa_constant_data GTY ((tag ("IPA_JF_CONST"))) constant;
8867b500 194 struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through;
195 struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor;
8867b500 196 } GTY ((desc ("%1.type"))) value;
b3e7c666 197};
b22832dc 198
3b22db66 199
4fa83f96 200/* Return the constant stored in a constant jump functin JFUNC. */
201
202static inline tree
203ipa_get_jf_constant (struct ipa_jump_func *jfunc)
204{
205 gcc_checking_assert (jfunc->type == IPA_JF_CONST);
096295f6 206 return jfunc->value.constant.value;
207}
208
209static inline struct ipa_cst_ref_desc *
210ipa_get_jf_constant_rdesc (struct ipa_jump_func *jfunc)
211{
212 gcc_checking_assert (jfunc->type == IPA_JF_CONST);
213 return jfunc->value.constant.rdesc;
4fa83f96 214}
215
216/* Return the operand of a pass through jmp function JFUNC. */
217
218static inline tree
219ipa_get_jf_pass_through_operand (struct ipa_jump_func *jfunc)
220{
221 gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
222 return jfunc->value.pass_through.operand;
223}
224
225/* Return the number of the caller's formal parameter that a pass through jump
226 function JFUNC refers to. */
227
228static inline int
229ipa_get_jf_pass_through_formal_id (struct ipa_jump_func *jfunc)
230{
231 gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
232 return jfunc->value.pass_through.formal_id;
233}
234
235/* Return operation of a pass through jump function JFUNC. */
236
237static inline enum tree_code
238ipa_get_jf_pass_through_operation (struct ipa_jump_func *jfunc)
239{
240 gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
241 return jfunc->value.pass_through.operation;
242}
243
ad4a8b28 244/* Return the agg_preserved flag of a pass through jump function JFUNC. */
0d491188 245
246static inline bool
247ipa_get_jf_pass_through_agg_preserved (struct ipa_jump_func *jfunc)
248{
249 gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
250 return jfunc->value.pass_through.agg_preserved;
251}
252
245ab191 253/* Return true if pass through jump function JFUNC preserves type
254 information. */
ad4a8b28 255
256static inline bool
257ipa_get_jf_pass_through_type_preserved (struct ipa_jump_func *jfunc)
258{
259 gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
245ab191 260 return jfunc->value.pass_through.agg_preserved;
ad4a8b28 261}
262
4fa83f96 263/* Return the offset of an ancestor jump function JFUNC. */
264
265static inline HOST_WIDE_INT
266ipa_get_jf_ancestor_offset (struct ipa_jump_func *jfunc)
267{
268 gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
269 return jfunc->value.ancestor.offset;
270}
271
4fa83f96 272/* Return the number of the caller's formal parameter that an ancestor jump
273 function JFUNC refers to. */
274
275static inline int
276ipa_get_jf_ancestor_formal_id (struct ipa_jump_func *jfunc)
277{
278 gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
279 return jfunc->value.ancestor.formal_id;
280}
281
ad4a8b28 282/* Return the agg_preserved flag of an ancestor jump function JFUNC. */
4fa83f96 283
0d491188 284static inline bool
285ipa_get_jf_ancestor_agg_preserved (struct ipa_jump_func *jfunc)
4fa83f96 286{
0d491188 287 gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
288 return jfunc->value.ancestor.agg_preserved;
4fa83f96 289}
290
245ab191 291/* Return true if ancestor jump function JFUNC presrves type information. */
ad4a8b28 292
293static inline bool
294ipa_get_jf_ancestor_type_preserved (struct ipa_jump_func *jfunc)
295{
296 gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
245ab191 297 return jfunc->value.ancestor.agg_preserved;
ad4a8b28 298}
299
821d0e0f 300/* Summary describing a single formal parameter. */
6378ffb3 301
7af25a10 302struct GTY(()) ipa_param_descriptor
3f2ff969 303{
a54071b2 304 /* In analysis and modification phase, this is the PARAM_DECL of this
305 parameter, in IPA LTO phase, this is the type of the the described
306 parameter or NULL if not known. Do not read this field directly but
307 through ipa_get_param and ipa_get_type as appropriate. */
308 tree decl_or_type;
096295f6 309 /* If all uses of the parameter are described by ipa-prop structures, this
310 says how many there are. If any use could not be described by means of
311 ipa-prop structures, this is IPA_UNDESCRIBED_USE. */
312 int controlled_uses;
09ab6335 313 unsigned int move_cost : 31;
bc1b408a 314 /* The parameter is used. */
315 unsigned used : 1;
3f2ff969 316};
317
3889f2e2 318/* ipa_node_params stores information related to formal parameters of functions
319 and some other information for interprocedural passes that operate on
320 parameters (such as ipa-cp). */
821d0e0f 321
7af25a10 322struct GTY((for_user)) ipa_node_params
3b22db66 323{
3ca1e19c 324 /* Default constructor. */
325 ipa_node_params ();
326
327 /* Default destructor. */
328 ~ipa_node_params ();
329
821d0e0f 330 /* Information about individual formal parameters that are gathered when
331 summaries are generated. */
7af25a10 332 vec<ipa_param_descriptor, va_gc> *descriptors;
821d0e0f 333 /* Pointer to an array of structures describing individual formal
334 parameters. */
7af25a10 335 struct ipcp_param_lattices * GTY((skip)) lattices;
821d0e0f 336 /* Only for versioned nodes this field would not be NULL,
337 it points to the node that IPA cp cloned from. */
7af25a10 338 struct cgraph_node * GTY((skip)) ipcp_orig_node;
245ab191 339 /* If this node is an ipa-cp clone, these are the known constants that
340 describe what it has been specialized for. */
7af25a10 341 vec<tree> GTY((skip)) known_csts;
245ab191 342 /* If this node is an ipa-cp clone, these are the known polymorphic contexts
343 that describe what it has been specialized for. */
7af25a10 344 vec<ipa_polymorphic_call_context> GTY((skip)) known_contexts;
24430d08 345 /* Whether the param uses analysis and jump function computation has already
346 been performed. */
347 unsigned analysis_done : 1;
821d0e0f 348 /* Whether the function is enqueued in ipa-cp propagation stack. */
609c710b 349 unsigned node_enqueued : 1;
821d0e0f 350 /* Whether we should create a specialized version based on values that are
351 known to be constant in all contexts. */
87228246 352 unsigned do_clone_for_all_contexts : 1;
353 /* Set if this is an IPA-CP clone for all contexts. */
354 unsigned is_all_contexts_clone : 1;
821d0e0f 355 /* Node has been completely replaced by clones and will be removed after
356 ipa-cp is finished. */
357 unsigned node_dead : 1;
39fcd838 358 /* Node is involved in a recursion, potentionally indirect. */
359 unsigned node_within_scc : 1;
360 /* Node is calling a private function called only once. */
361 unsigned node_calling_single_call : 1;
b8681788 362 /* False when there is something makes versioning impossible. */
363 unsigned versionable : 1;
3b22db66 364};
365
3ca1e19c 366inline
367ipa_node_params::ipa_node_params ()
368: descriptors (NULL), lattices (NULL), ipcp_orig_node (NULL),
369 known_csts (vNULL), known_contexts (vNULL), analysis_done (0),
370 node_enqueued (0), do_clone_for_all_contexts (0), is_all_contexts_clone (0),
371 node_dead (0), node_within_scc (0), node_calling_single_call (0),
372 versionable (0)
373{
374}
375
376inline
377ipa_node_params::~ipa_node_params ()
378{
379 free (lattices);
380 known_csts.release ();
381 known_contexts.release ();
382}
383
1a673ff0 384/* Intermediate information that we get from alias analysis about a particular
385 parameter in a particular basic_block. When a parameter or the memory it
9ea91b78 386 references is marked modified, we use that information in all dominated
387 blocks without consulting alias analysis oracle. */
1a673ff0 388
9ea91b78 389struct ipa_param_aa_status
1a673ff0 390{
391 /* Set when this structure contains meaningful information. If not, the
392 structure describing a dominating BB should be used instead. */
393 bool valid;
394
395 /* Whether we have seen something which might have modified the data in
396 question. PARM is for the parameter itself, REF is for data it points to
397 but using the alias type of individual accesses and PT is the same thing
398 but for computing aggregate pass-through functions using a very inclusive
399 ao_ref. */
400 bool parm_modified, ref_modified, pt_modified;
401};
402
403/* Information related to a given BB that used only when looking at function
404 body. */
405
406struct ipa_bb_info
407{
408 /* Call graph edges going out of this BB. */
409 vec<cgraph_edge *> cg_edges;
410 /* Alias analysis statuses of each formal parameter at this bb. */
9ea91b78 411 vec<ipa_param_aa_status> param_aa_statuses;
1a673ff0 412};
413
414/* Structure with global information that is only used when looking at function
415 body. */
416
9ea91b78 417struct ipa_func_body_info
1a673ff0 418{
419 /* The node that is being analyzed. */
420 cgraph_node *node;
421
422 /* Its info. */
423 struct ipa_node_params *info;
424
425 /* Information about individual BBs. */
426 vec<ipa_bb_info> bb_infos;
427
428 /* Number of parameters. */
429 int param_count;
430
431 /* Number of statements already walked by when analyzing this function. */
432 unsigned int aa_walked;
433};
434
3889f2e2 435/* ipa_node_params access functions. Please use these to access fields that
436 are or will be shared among various passes. */
437
3889f2e2 438/* Return the number of formal parameters. */
1917e945 439
3889f2e2 440static inline int
441ipa_get_param_count (struct ipa_node_params *info)
442{
7af25a10 443 return vec_safe_length (info->descriptors);
3889f2e2 444}
445
3f2ff969 446/* Return the declaration of Ith formal parameter of the function corresponding
447 to INFO. Note there is no setter function as this array is built just once
a54071b2 448 using ipa_initialize_node_params. This function should not be called in
449 WPA. */
1917e945 450
3889f2e2 451static inline tree
3f2ff969 452ipa_get_param (struct ipa_node_params *info, int i)
3889f2e2 453{
7af25a10 454 gcc_checking_assert (info->descriptors);
09ab6335 455 gcc_checking_assert (!flag_wpa);
7af25a10 456 tree t = (*info->descriptors)[i].decl_or_type;
a54071b2 457 gcc_checking_assert (TREE_CODE (t) == PARM_DECL);
458 return t;
459}
460
461/* Return the type of Ith formal parameter of the function corresponding
462 to INFO if it is known or NULL if not. */
463
464static inline tree
465ipa_get_type (struct ipa_node_params *info, int i)
466{
7af25a10 467 gcc_checking_assert (info->descriptors);
468 tree t = (*info->descriptors)[i].decl_or_type;
a54071b2 469 if (!t)
470 return NULL;
471 if (TYPE_P (t))
472 return t;
473 gcc_checking_assert (TREE_CODE (t) == PARM_DECL);
474 return TREE_TYPE (t);
bc1b408a 475}
476
09ab6335 477/* Return the move cost of Ith formal parameter of the function corresponding
478 to INFO. */
479
480static inline int
481ipa_get_param_move_cost (struct ipa_node_params *info, int i)
482{
7af25a10 483 gcc_checking_assert (info->descriptors);
484 return (*info->descriptors)[i].move_cost;
09ab6335 485}
486
821d0e0f 487/* Set the used flag corresponding to the Ith formal parameter of the function
488 associated with INFO to VAL. */
1caef38b 489
821d0e0f 490static inline void
491ipa_set_param_used (struct ipa_node_params *info, int i, bool val)
1caef38b 492{
7af25a10 493 gcc_checking_assert (info->descriptors);
494 (*info->descriptors)[i].used = val;
1caef38b 495}
496
096295f6 497/* Return how many uses described by ipa-prop a parameter has or
498 IPA_UNDESCRIBED_USE if there is a use that is not described by these
499 structures. */
500static inline int
501ipa_get_controlled_uses (struct ipa_node_params *info, int i)
502{
7af25a10 503 /* FIXME: introducing speculation causes out of bounds access here. */
504 if (vec_safe_length (info->descriptors) > (unsigned)i)
505 return (*info->descriptors)[i].controlled_uses;
072ec6eb 506 return IPA_UNDESCRIBED_USE;
096295f6 507}
508
509/* Set the controlled counter of a given parameter. */
510
511static inline void
512ipa_set_controlled_uses (struct ipa_node_params *info, int i, int val)
513{
7af25a10 514 gcc_checking_assert (info->descriptors);
515 (*info->descriptors)[i].controlled_uses = val;
096295f6 516}
517
821d0e0f 518/* Return the used flag corresponding to the Ith formal parameter of the
519 function associated with INFO. */
1caef38b 520
521static inline bool
821d0e0f 522ipa_is_param_used (struct ipa_node_params *info, int i)
1caef38b 523{
7af25a10 524 gcc_checking_assert (info->descriptors);
525 return (*info->descriptors)[i].used;
1caef38b 526}
527
803a7988 528/* Information about replacements done in aggregates for a given node (each
529 node has its linked list). */
530struct GTY(()) ipa_agg_replacement_value
531{
532 /* Next item in the linked list. */
533 struct ipa_agg_replacement_value *next;
534 /* Offset within the aggregate. */
535 HOST_WIDE_INT offset;
536 /* The constant value. */
537 tree value;
538 /* The paramter index. */
539 int index;
c42e4f2e 540 /* Whether the value was passed by reference. */
541 bool by_ref;
803a7988 542};
543
ae7b7bc8 544/* Structure holding information for the transformation phase of IPA-CP. */
545
546struct GTY(()) ipcp_transformation_summary
547{
548 /* Linked list of known aggregate values. */
549 ipa_agg_replacement_value *agg_values;
a54071b2 550 /* Known bits information. */
97cb825b 551 vec<ipa_bits *, va_gc> *bits;
25a8e007 552 /* Value range information. */
553 vec<ipa_vr, va_gc> *m_vr;
ae7b7bc8 554};
803a7988 555
556void ipa_set_node_agg_value_chain (struct cgraph_node *node,
557 struct ipa_agg_replacement_value *aggvals);
ae7b7bc8 558void ipcp_grow_transformations_if_necessary (void);
803a7988 559
10d560f3 560/* ipa_edge_args stores information related to a callsite and particularly its
561 arguments. It can be accessed by the IPA_EDGE_REF macro. */
b3e7c666 562struct GTY(()) ipa_edge_args
3b22db66 563{
b22832dc 564 /* Vector of the callsite's jump function of each parameter. */
b3e7c666 565 vec<ipa_jump_func, va_gc> *jump_functions;
072ec6eb 566 vec<ipa_polymorphic_call_context, va_gc> *polymorphic_call_contexts;
b3e7c666 567};
3b22db66 568
3889f2e2 569/* ipa_edge_args access functions. Please use these to access fields that
570 are or will be shared among various passes. */
571
3889f2e2 572/* Return the number of actual arguments. */
1917e945 573
3889f2e2 574static inline int
575ipa_get_cs_argument_count (struct ipa_edge_args *args)
576{
f1f41a6c 577 return vec_safe_length (args->jump_functions);
3889f2e2 578}
579
580/* Returns a pointer to the jump function for the ith argument. Please note
581 there is no setter function as jump functions are all set up in
582 ipa_compute_jump_functions. */
1917e945 583
3889f2e2 584static inline struct ipa_jump_func *
585ipa_get_ith_jump_func (struct ipa_edge_args *args, int i)
586{
f1f41a6c 587 return &(*args->jump_functions)[i];
3889f2e2 588}
589
072ec6eb 590/* Returns a pointer to the polymorphic call context for the ith argument.
591 NULL if contexts are not computed. */
592static inline struct ipa_polymorphic_call_context *
593ipa_get_ith_polymorhic_call_context (struct ipa_edge_args *args, int i)
594{
595 if (!args->polymorphic_call_contexts)
596 return NULL;
597 return &(*args->polymorphic_call_contexts)[i];
598}
599
b4bae7a0 600/* Function summary for ipa_node_params. */
7af25a10 601class GTY((user)) ipa_node_params_t: public function_summary <ipa_node_params *>
2cc80ac3 602{
603public:
7af25a10 604 ipa_node_params_t (symbol_table *table, bool ggc):
605 function_summary<ipa_node_params *> (table, ggc) { }
545eff8f 606
2cc80ac3 607 /* Hook that is called by summary when a node is duplicated. */
608 virtual void duplicate (cgraph_node *node,
609 cgraph_node *node2,
610 ipa_node_params *data,
611 ipa_node_params *data2);
612};
613
614/* Function summary where the parameter infos are actually stored. */
7af25a10 615extern GTY(()) ipa_node_params_t * ipa_node_params_sum;
616
ae7b7bc8 617/* Vector of IPA-CP transformation data for each clone. */
618extern GTY(()) vec<ipcp_transformation_summary, va_gc> *ipcp_transformations;
545eff8f 619/* Vector where the parameter infos are actually stored. */
b3e7c666 620extern GTY(()) vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
545eff8f 621
7af25a10 622
545eff8f 623/* Return the associated parameter/argument info corresponding to the given
624 node/edge. */
2cc80ac3 625#define IPA_NODE_REF(NODE) (ipa_node_params_sum->get (NODE))
f1f41a6c 626#define IPA_EDGE_REF(EDGE) (&(*ipa_edge_args_vector)[(EDGE)->uid])
545eff8f 627/* This macro checks validity of index returned by
628 ipa_get_param_decl_index function. */
629#define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1)
630
631/* Creating and freeing ipa_node_params and ipa_edge_args. */
632void ipa_create_all_node_params (void);
633void ipa_create_all_edge_args (void);
97cb825b 634void ipa_check_create_edge_args (void);
545eff8f 635void ipa_free_edge_args_substructures (struct ipa_edge_args *);
545eff8f 636void ipa_free_all_node_params (void);
637void ipa_free_all_edge_args (void);
799c8711 638void ipa_free_all_structures_after_ipa_cp (void);
639void ipa_free_all_structures_after_iinln (void);
2cc80ac3 640
545eff8f 641void ipa_register_cgraph_hooks (void);
09809ecc 642int count_formal_params (tree fndecl);
545eff8f 643
644/* This function ensures the array of node param infos is big enough to
1917e945 645 accommodate a structure for all nodes and reallocates it if not. */
646
545eff8f 647static inline void
648ipa_check_create_node_params (void)
649{
2cc80ac3 650 if (!ipa_node_params_sum)
7af25a10 651 ipa_node_params_sum
652 = (new (ggc_cleared_alloc <ipa_node_params_t> ())
653 ipa_node_params_t (symtab, true));
545eff8f 654}
655
1917e945 656/* Returns true if the array of edge infos is large enough to accommodate an
86c96e3a 657 info for EDGE. The main purpose of this function is that debug dumping
658 function can check info availability without causing reallocations. */
1917e945 659
86c96e3a 660static inline bool
661ipa_edge_args_info_available_for_edge_p (struct cgraph_edge *edge)
662{
f1f41a6c 663 return ((unsigned) edge->uid < vec_safe_length (ipa_edge_args_vector));
86c96e3a 664}
665
ae7b7bc8 666static inline ipcp_transformation_summary *
667ipcp_get_transformation_summary (cgraph_node *node)
668{
669 if ((unsigned) node->uid >= vec_safe_length (ipcp_transformations))
670 return NULL;
671 return &(*ipcp_transformations)[node->uid];
672}
673
803a7988 674/* Return the aggregate replacements for NODE, if there are any. */
675
676static inline struct ipa_agg_replacement_value *
ae7b7bc8 677ipa_get_agg_replacements_for_node (cgraph_node *node)
803a7988 678{
ae7b7bc8 679 ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
680 return ts ? ts->agg_values : NULL;
803a7988 681}
682
3f2ff969 683/* Function formal parameters related computations. */
684void ipa_initialize_node_params (struct cgraph_node *node);
3f2ff969 685bool ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
415d1b9a 686 vec<cgraph_edge *> *new_edges);
3b22db66 687
1caef38b 688/* Indirect edge and binfo processing. */
20da2013 689tree ipa_get_indirect_edge_target (struct cgraph_edge *ie,
f1f41a6c 690 vec<tree> ,
245ab191 691 vec<ipa_polymorphic_call_context>,
f21a87d8 692 vec<ipa_agg_jump_function_p>,
693 bool *);
072ec6eb 694struct cgraph_edge *ipa_make_edge_direct_to_target (struct cgraph_edge *, tree,
695 bool speculative = false);
3bc62a51 696tree ipa_impossible_devirt_target (struct cgraph_edge *, tree);
97cb825b 697ipa_bits *ipa_get_ipa_bits_for_value (const widest_int &value,
698 const widest_int &mask);
699
1caef38b 700
821d0e0f 701/* Functions related to both. */
702void ipa_analyze_node (struct cgraph_node *);
1caef38b 703
0d491188 704/* Aggregate jump function related functions. */
665ff45b 705tree ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *agg, tree scalar,
706 HOST_WIDE_INT offset, bool by_ref,
707 bool *from_global_constant = NULL);
708bool ipa_load_from_parm_agg (struct ipa_func_body_info *fbi,
7af25a10 709 vec<ipa_param_descriptor, va_gc> *descriptors,
665ff45b 710 gimple *stmt, tree op, int *index_p,
711 HOST_WIDE_INT *offset_p, HOST_WIDE_INT *size_p,
712 bool *by_ref, bool *guaranteed_unmodified = NULL);
0d491188 713
3b22db66 714/* Debugging interface. */
11b73810 715void ipa_print_node_params (FILE *, struct cgraph_node *node);
716void ipa_print_all_params (FILE *);
f8daee9b 717void ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node);
718void ipa_print_all_jump_functions (FILE * f);
821d0e0f 719void ipcp_verify_propagated_values (void);
720
8361d32f 721template <typename value>
722class ipcp_value;
723
e16712b1 724extern object_allocator<ipcp_value<tree> > ipcp_cst_values_pool;
725extern object_allocator<ipcp_value<ipa_polymorphic_call_context> >
8361d32f 726 ipcp_poly_ctx_values_pool;
727
728template <typename valtype>
729class ipcp_value_source;
730
e16712b1 731extern object_allocator<ipcp_value_source<tree> > ipcp_sources_pool;
8361d32f 732
733class ipcp_agg_lattice;
734
e16712b1 735extern object_allocator<ipcp_agg_lattice> ipcp_agg_lattice_pool;
3b22db66 736
6bcfabf2 737/* Operation to be performed for the parameter in ipa_parm_adjustment
738 below. */
739enum ipa_parm_op {
740 IPA_PARM_OP_NONE,
741
742 /* This describes a brand new parameter.
743
744 The field `type' should be set to the new type, `arg_prefix'
745 should be set to the string prefix for the new DECL_NAME, and
746 `new_decl' will ultimately hold the newly created argument. */
747 IPA_PARM_OP_NEW,
748
749 /* This new parameter is an unmodified parameter at index base_index. */
750 IPA_PARM_OP_COPY,
751
752 /* This adjustment describes a parameter that is about to be removed
753 completely. Most users will probably need to book keep those so that they
754 don't leave behinfd any non default def ssa names belonging to them. */
755 IPA_PARM_OP_REMOVE
756};
757
547f1802 758/* Structure to describe transformations of formal parameters and actual
759 arguments. Each instance describes one new parameter and they are meant to
760 be stored in a vector. Additionally, most users will probably want to store
761 adjustments about parameters that are being removed altogether so that SSA
762 names belonging to them can be replaced by SSA names of an artificial
763 variable. */
764struct ipa_parm_adjustment
765{
766 /* The original PARM_DECL itself, helpful for processing of the body of the
767 function itself. Intended for traversing function bodies.
768 ipa_modify_formal_parameters, ipa_modify_call_arguments and
769 ipa_combine_adjustments ignore this and use base_index.
770 ipa_modify_formal_parameters actually sets this. */
771 tree base;
772
773 /* Type of the new parameter. However, if by_ref is true, the real type will
774 be a pointer to this type. */
775 tree type;
776
14c9496e 777 /* Alias refrerence type to be used in MEM_REFs when adjusting caller
778 arguments. */
779 tree alias_ptr_type;
780
6bcfabf2 781 /* The new declaration when creating/replacing a parameter. Created
782 by ipa_modify_formal_parameters, useful for functions modifying
783 the body accordingly. For brand new arguments, this is the newly
784 created argument. */
785 tree new_decl;
547f1802 786
787 /* New declaration of a substitute variable that we may use to replace all
788 non-default-def ssa names when a parm decl is going away. */
789 tree new_ssa_base;
790
791 /* If non-NULL and the original parameter is to be removed (copy_param below
792 is NULL), this is going to be its nonlocalized vars value. */
793 tree nonlocal_value;
794
6bcfabf2 795 /* This holds the prefix to be used for the new DECL_NAME. */
796 const char *arg_prefix;
797
547f1802 798 /* Offset into the original parameter (for the cases when the new parameter
799 is a component of an original one). */
800 HOST_WIDE_INT offset;
801
6bcfabf2 802 /* Zero based index of the original parameter this one is based on. */
547f1802 803 int base_index;
804
6bcfabf2 805 /* Whether this parameter is a new parameter, a copy of an old one,
806 or one about to be removed. */
807 enum ipa_parm_op op;
547f1802 808
292237f3 809 /* Storage order of the original parameter (for the cases when the new
810 parameter is a component of an original one). */
811 unsigned reverse : 1;
812
547f1802 813 /* The parameter is to be passed by reference. */
814 unsigned by_ref : 1;
815};
816
b3e7c666 817typedef vec<ipa_parm_adjustment> ipa_parm_adjustment_vec;
547f1802 818
f1f41a6c 819vec<tree> ipa_get_vector_of_formal_parms (tree fndecl);
6bcfabf2 820vec<tree> ipa_get_vector_of_formal_parm_types (tree fntype);
821void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec);
1a91d914 822void ipa_modify_call_arguments (struct cgraph_edge *, gcall *,
547f1802 823 ipa_parm_adjustment_vec);
824ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec,
825 ipa_parm_adjustment_vec);
826void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree);
803a7988 827void ipa_dump_agg_replacement_values (FILE *f,
828 struct ipa_agg_replacement_value *av);
eab36a5a 829void ipa_prop_write_jump_functions (void);
8867b500 830void ipa_prop_read_jump_functions (void);
ae7b7bc8 831void ipcp_write_transformation_summaries (void);
832void ipcp_read_transformation_summaries (void);
8867b500 833void ipa_update_after_lto_read (void);
a41f2a28 834int ipa_get_param_decl_index (struct ipa_node_params *, tree);
20da2013 835tree ipa_value_from_jfunc (struct ipa_node_params *info,
836 struct ipa_jump_func *jfunc);
803a7988 837unsigned int ipcp_transform_function (struct cgraph_node *node);
245ab191 838ipa_polymorphic_call_context ipa_context_from_jfunc (ipa_node_params *,
839 cgraph_edge *,
840 int,
841 ipa_jump_func *);
09ab6335 842void ipa_dump_param (FILE *, struct ipa_node_params *info, int i);
6bcfabf2 843bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec);
844ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *,
845 ipa_parm_adjustment_vec,
846 bool);
73bd7d5f 847void ipa_release_body_info (struct ipa_func_body_info *);
166f8178 848tree ipa_get_callee_param_type (struct cgraph_edge *e, int i);
8867b500 849
547f1802 850/* From tree-sra.c: */
292237f3 851tree build_ref_for_offset (location_t, tree, HOST_WIDE_INT, bool, tree,
a60aac35 852 gimple_stmt_iterator *, bool);
547f1802 853
415309e2 854/* In ipa-cp.c */
855void ipa_cp_c_finalize (void);
856
3b22db66 857#endif /* IPA_PROP_H */