1 /* Interprocedural analyses.
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
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
8 Software Foundation; either version 3, or (at your option) any later
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
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "alloc-pool.h"
28 #include "tree-pass.h"
30 #include "tree-streamer.h"
32 #include "diagnostic.h"
33 #include "fold-const.h"
34 #include "gimple-fold.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
40 #include "gimple-iterator.h"
41 #include "gimplify-me.h"
42 #include "gimple-walk.h"
43 #include "symbol-summary.h"
47 #include "tree-inline.h"
48 #include "ipa-inline.h"
49 #include "gimple-pretty-print.h"
51 #include "ipa-utils.h"
56 /* Function summary where the parameter infos are actually stored. */
57 ipa_node_params_t
*ipa_node_params_sum
= NULL
;
58 /* Vector of IPA-CP transformation data for each clone. */
59 vec
<ipcp_transformation_summary
, va_gc
> *ipcp_transformations
;
60 /* Vector where the parameter infos are actually stored. */
61 vec
<ipa_edge_args
, va_gc
> *ipa_edge_args_vector
;
63 /* Holders of ipa cgraph hooks: */
64 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
65 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
66 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
68 /* Description of a reference to an IPA constant. */
69 struct ipa_cst_ref_desc
71 /* Edge that corresponds to the statement which took the reference. */
72 struct cgraph_edge
*cs
;
73 /* Linked list of duplicates created when call graph edges are cloned. */
74 struct ipa_cst_ref_desc
*next_duplicate
;
75 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
80 /* Allocation pool for reference descriptions. */
82 static object_allocator
<ipa_cst_ref_desc
> ipa_refdesc_pool
83 ("IPA-PROP ref descriptions");
85 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
86 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
89 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
91 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
95 return !opt_for_fn (node
->decl
, optimize
) || !opt_for_fn (node
->decl
, flag_ipa_cp
);
98 /* Return index of the formal whose tree is PTREE in function which corresponds
102 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
> descriptors
, tree ptree
)
106 count
= descriptors
.length ();
107 for (i
= 0; i
< count
; i
++)
108 if (descriptors
[i
].decl_or_type
== ptree
)
114 /* Return index of the formal whose tree is PTREE in function which corresponds
118 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
120 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
123 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
127 ipa_populate_param_decls (struct cgraph_node
*node
,
128 vec
<ipa_param_descriptor
> &descriptors
)
136 gcc_assert (gimple_has_body_p (fndecl
));
137 fnargs
= DECL_ARGUMENTS (fndecl
);
139 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
141 descriptors
[param_num
].decl_or_type
= parm
;
142 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
),
148 /* Return how many formal parameters FNDECL has. */
151 count_formal_params (tree fndecl
)
155 gcc_assert (gimple_has_body_p (fndecl
));
157 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
163 /* Return the declaration of Ith formal parameter of the function corresponding
164 to INFO. Note there is no setter function as this array is built just once
165 using ipa_initialize_node_params. */
168 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
170 fprintf (file
, "param #%i", i
);
171 if (info
->descriptors
[i
].decl_or_type
)
174 print_generic_expr (file
, info
->descriptors
[i
].decl_or_type
, 0);
178 /* Initialize the ipa_node_params structure associated with NODE
179 to hold PARAM_COUNT parameters. */
182 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
184 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
186 if (!info
->descriptors
.exists () && param_count
)
187 info
->descriptors
.safe_grow_cleared (param_count
);
190 /* Initialize the ipa_node_params structure associated with NODE by counting
191 the function parameters, creating the descriptors and populating their
195 ipa_initialize_node_params (struct cgraph_node
*node
)
197 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
199 if (!info
->descriptors
.exists ())
201 ipa_alloc_node_params (node
, count_formal_params (node
->decl
));
202 ipa_populate_param_decls (node
, info
->descriptors
);
206 /* Print the jump functions associated with call graph edge CS to file F. */
209 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
213 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
214 for (i
= 0; i
< count
; i
++)
216 struct ipa_jump_func
*jump_func
;
217 enum jump_func_type type
;
219 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
220 type
= jump_func
->type
;
222 fprintf (f
, " param %d: ", i
);
223 if (type
== IPA_JF_UNKNOWN
)
224 fprintf (f
, "UNKNOWN\n");
225 else if (type
== IPA_JF_CONST
)
227 tree val
= jump_func
->value
.constant
.value
;
228 fprintf (f
, "CONST: ");
229 print_generic_expr (f
, val
, 0);
230 if (TREE_CODE (val
) == ADDR_EXPR
231 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
234 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
239 else if (type
== IPA_JF_PASS_THROUGH
)
241 fprintf (f
, "PASS THROUGH: ");
242 fprintf (f
, "%d, op %s",
243 jump_func
->value
.pass_through
.formal_id
,
244 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
245 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
248 print_generic_expr (f
,
249 jump_func
->value
.pass_through
.operand
, 0);
251 if (jump_func
->value
.pass_through
.agg_preserved
)
252 fprintf (f
, ", agg_preserved");
255 else if (type
== IPA_JF_ANCESTOR
)
257 fprintf (f
, "ANCESTOR: ");
258 fprintf (f
, "%d, offset " HOST_WIDE_INT_PRINT_DEC
,
259 jump_func
->value
.ancestor
.formal_id
,
260 jump_func
->value
.ancestor
.offset
);
261 if (jump_func
->value
.ancestor
.agg_preserved
)
262 fprintf (f
, ", agg_preserved");
266 if (jump_func
->agg
.items
)
268 struct ipa_agg_jf_item
*item
;
271 fprintf (f
, " Aggregate passed by %s:\n",
272 jump_func
->agg
.by_ref
? "reference" : "value");
273 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
275 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
277 if (TYPE_P (item
->value
))
278 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
279 tree_to_uhwi (TYPE_SIZE (item
->value
)));
282 fprintf (f
, "cst: ");
283 print_generic_expr (f
, item
->value
, 0);
289 struct ipa_polymorphic_call_context
*ctx
290 = ipa_get_ith_polymorhic_call_context (IPA_EDGE_REF (cs
), i
);
291 if (ctx
&& !ctx
->useless_p ())
293 fprintf (f
, " Context: ");
294 ctx
->dump (dump_file
);
297 if (jump_func
->bits
.known
)
299 fprintf (f
, " value: "); print_hex (jump_func
->bits
.value
, f
);
300 fprintf (f
, ", mask: "); print_hex (jump_func
->bits
.mask
, f
);
304 fprintf (f
, " Unknown bits\n");
306 if (jump_func
->vr_known
)
310 (jump_func
->m_vr
.type
== VR_ANTI_RANGE
) ? "~" : "");
311 print_decs (jump_func
->m_vr
.min
, f
);
313 print_decs (jump_func
->m_vr
.max
, f
);
317 fprintf (f
, " Unknown VR\n");
322 /* Print the jump functions of all arguments on all call graph edges going from
326 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
328 struct cgraph_edge
*cs
;
330 fprintf (f
, " Jump functions of caller %s/%i:\n", node
->name (),
332 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
334 if (!ipa_edge_args_info_available_for_edge_p (cs
))
337 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
338 xstrdup_for_dump (node
->name ()), node
->order
,
339 xstrdup_for_dump (cs
->callee
->name ()),
341 ipa_print_node_jump_functions_for_edge (f
, cs
);
344 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
346 struct cgraph_indirect_call_info
*ii
;
347 if (!ipa_edge_args_info_available_for_edge_p (cs
))
350 ii
= cs
->indirect_info
;
351 if (ii
->agg_contents
)
352 fprintf (f
, " indirect %s callsite, calling param %i, "
353 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
354 ii
->member_ptr
? "member ptr" : "aggregate",
355 ii
->param_index
, ii
->offset
,
356 ii
->by_ref
? "by reference" : "by_value");
358 fprintf (f
, " indirect %s callsite, calling param %i, "
359 "offset " HOST_WIDE_INT_PRINT_DEC
,
360 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
365 fprintf (f
, ", for stmt ");
366 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
371 ii
->context
.dump (f
);
372 ipa_print_node_jump_functions_for_edge (f
, cs
);
376 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
379 ipa_print_all_jump_functions (FILE *f
)
381 struct cgraph_node
*node
;
383 fprintf (f
, "\nJump functions:\n");
384 FOR_EACH_FUNCTION (node
)
386 ipa_print_node_jump_functions (f
, node
);
390 /* Set jfunc to be a know-really nothing jump function. */
393 ipa_set_jf_unknown (struct ipa_jump_func
*jfunc
)
395 jfunc
->type
= IPA_JF_UNKNOWN
;
396 jfunc
->bits
.known
= false;
397 jfunc
->vr_known
= false;
400 /* Set JFUNC to be a copy of another jmp (to be used by jump function
401 combination code). The two functions will share their rdesc. */
404 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
405 struct ipa_jump_func
*src
)
408 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
409 dst
->type
= IPA_JF_CONST
;
410 dst
->value
.constant
= src
->value
.constant
;
413 /* Set JFUNC to be a constant jmp function. */
416 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
417 struct cgraph_edge
*cs
)
419 jfunc
->type
= IPA_JF_CONST
;
420 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
422 if (TREE_CODE (constant
) == ADDR_EXPR
423 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
425 struct ipa_cst_ref_desc
*rdesc
;
427 rdesc
= ipa_refdesc_pool
.allocate ();
429 rdesc
->next_duplicate
= NULL
;
431 jfunc
->value
.constant
.rdesc
= rdesc
;
434 jfunc
->value
.constant
.rdesc
= NULL
;
437 /* Set JFUNC to be a simple pass-through jump function. */
439 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
442 jfunc
->type
= IPA_JF_PASS_THROUGH
;
443 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
444 jfunc
->value
.pass_through
.formal_id
= formal_id
;
445 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
446 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
449 /* Set JFUNC to be an unary pass through jump function. */
452 ipa_set_jf_unary_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
453 enum tree_code operation
)
455 jfunc
->type
= IPA_JF_PASS_THROUGH
;
456 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
457 jfunc
->value
.pass_through
.formal_id
= formal_id
;
458 jfunc
->value
.pass_through
.operation
= operation
;
459 jfunc
->value
.pass_through
.agg_preserved
= false;
461 /* Set JFUNC to be an arithmetic pass through jump function. */
464 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
465 tree operand
, enum tree_code operation
)
467 jfunc
->type
= IPA_JF_PASS_THROUGH
;
468 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
469 jfunc
->value
.pass_through
.formal_id
= formal_id
;
470 jfunc
->value
.pass_through
.operation
= operation
;
471 jfunc
->value
.pass_through
.agg_preserved
= false;
474 /* Set JFUNC to be an ancestor jump function. */
477 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
478 int formal_id
, bool agg_preserved
)
480 jfunc
->type
= IPA_JF_ANCESTOR
;
481 jfunc
->value
.ancestor
.formal_id
= formal_id
;
482 jfunc
->value
.ancestor
.offset
= offset
;
483 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
486 /* Get IPA BB information about the given BB. FBI is the context of analyzis
487 of this function body. */
489 static struct ipa_bb_info
*
490 ipa_get_bb_info (struct ipa_func_body_info
*fbi
, basic_block bb
)
492 gcc_checking_assert (fbi
);
493 return &fbi
->bb_infos
[bb
->index
];
496 /* Structure to be passed in between detect_type_change and
497 check_stmt_for_type_change. */
499 struct prop_type_change_info
501 /* Offset into the object where there is the virtual method pointer we are
503 HOST_WIDE_INT offset
;
504 /* The declaration or SSA_NAME pointer of the base that we are checking for
507 /* Set to true if dynamic type change has been detected. */
508 bool type_maybe_changed
;
511 /* Return true if STMT can modify a virtual method table pointer.
513 This function makes special assumptions about both constructors and
514 destructors which are all the functions that are allowed to alter the VMT
515 pointers. It assumes that destructors begin with assignment into all VMT
516 pointers and that constructors essentially look in the following way:
518 1) The very first thing they do is that they call constructors of ancestor
519 sub-objects that have them.
521 2) Then VMT pointers of this and all its ancestors is set to new values
522 corresponding to the type corresponding to the constructor.
524 3) Only afterwards, other stuff such as constructor of member sub-objects
525 and the code written by the user is run. Only this may include calling
526 virtual functions, directly or indirectly.
528 There is no way to call a constructor of an ancestor sub-object in any
531 This means that we do not have to care whether constructors get the correct
532 type information because they will always change it (in fact, if we define
533 the type to be given by the VMT pointer, it is undefined).
535 The most important fact to derive from the above is that if, for some
536 statement in the section 3, we try to detect whether the dynamic type has
537 changed, we can safely ignore all calls as we examine the function body
538 backwards until we reach statements in section 2 because these calls cannot
539 be ancestor constructors or destructors (if the input is not bogus) and so
540 do not change the dynamic type (this holds true only for automatically
541 allocated objects but at the moment we devirtualize only these). We then
542 must detect that statements in section 2 change the dynamic type and can try
543 to derive the new type. That is enough and we can stop, we will never see
544 the calls into constructors of sub-objects in this code. Therefore we can
545 safely ignore all call statements that we traverse.
549 stmt_may_be_vtbl_ptr_store (gimple
*stmt
)
551 if (is_gimple_call (stmt
))
553 if (gimple_clobber_p (stmt
))
555 else if (is_gimple_assign (stmt
))
557 tree lhs
= gimple_assign_lhs (stmt
);
559 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
561 if (flag_strict_aliasing
562 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
565 if (TREE_CODE (lhs
) == COMPONENT_REF
566 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
568 /* In the future we might want to use get_base_ref_and_offset to find
569 if there is a field corresponding to the offset and if so, proceed
570 almost like if it was a component ref. */
576 /* Callback of walk_aliased_vdefs and a helper function for detect_type_change
577 to check whether a particular statement may modify the virtual table
578 pointerIt stores its result into DATA, which points to a
579 prop_type_change_info structure. */
582 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
584 gimple
*stmt
= SSA_NAME_DEF_STMT (vdef
);
585 struct prop_type_change_info
*tci
= (struct prop_type_change_info
*) data
;
587 if (stmt_may_be_vtbl_ptr_store (stmt
))
589 tci
->type_maybe_changed
= true;
596 /* See if ARG is PARAM_DECl describing instance passed by pointer
597 or reference in FUNCTION. Return false if the dynamic type may change
598 in between beggining of the function until CALL is invoked.
600 Generally functions are not allowed to change type of such instances,
601 but they call destructors. We assume that methods can not destroy the THIS
602 pointer. Also as a special cases, constructor and destructors may change
603 type of the THIS pointer. */
606 param_type_may_change_p (tree function
, tree arg
, gimple
*call
)
608 /* Pure functions can not do any changes on the dynamic type;
609 that require writting to memory. */
610 if (flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
612 /* We need to check if we are within inlined consturctor
613 or destructor (ideally we would have way to check that the
614 inline cdtor is actually working on ARG, but we don't have
615 easy tie on this, so punt on all non-pure cdtors.
616 We may also record the types of cdtors and once we know type
617 of the instance match them.
619 Also code unification optimizations may merge calls from
620 different blocks making return values unreliable. So
621 do nothing during late optimization. */
622 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
624 if (TREE_CODE (arg
) == SSA_NAME
625 && SSA_NAME_IS_DEFAULT_DEF (arg
)
626 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
)
628 /* Normal (non-THIS) argument. */
629 if ((SSA_NAME_VAR (arg
) != DECL_ARGUMENTS (function
)
630 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
)
631 /* THIS pointer of an method - here we want to watch constructors
632 and destructors as those definitely may change the dynamic
634 || (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
635 && !DECL_CXX_CONSTRUCTOR_P (function
)
636 && !DECL_CXX_DESTRUCTOR_P (function
)
637 && (SSA_NAME_VAR (arg
) == DECL_ARGUMENTS (function
))))
639 /* Walk the inline stack and watch out for ctors/dtors. */
640 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
641 block
= BLOCK_SUPERCONTEXT (block
))
642 if (inlined_polymorphic_ctor_dtor_block_p (block
, false))
650 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
651 callsite CALL) by looking for assignments to its virtual table pointer. If
652 it is, return true and fill in the jump function JFUNC with relevant type
653 information or set it to unknown. ARG is the object itself (not a pointer
654 to it, unless dereferenced). BASE is the base of the memory access as
655 returned by get_ref_base_and_extent, as is the offset.
657 This is helper function for detect_type_change and detect_type_change_ssa
658 that does the heavy work which is usually unnecesary. */
661 detect_type_change_from_memory_writes (tree arg
, tree base
, tree comp_type
,
662 gcall
*call
, struct ipa_jump_func
*jfunc
,
663 HOST_WIDE_INT offset
)
665 struct prop_type_change_info tci
;
667 bool entry_reached
= false;
669 gcc_checking_assert (DECL_P (arg
)
670 || TREE_CODE (arg
) == MEM_REF
671 || handled_component_p (arg
));
673 comp_type
= TYPE_MAIN_VARIANT (comp_type
);
675 /* Const calls cannot call virtual methods through VMT and so type changes do
677 if (!flag_devirtualize
|| !gimple_vuse (call
)
678 /* Be sure expected_type is polymorphic. */
680 || TREE_CODE (comp_type
) != RECORD_TYPE
681 || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))
682 || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))))
685 ao_ref_init (&ao
, arg
);
688 ao
.size
= POINTER_SIZE
;
689 ao
.max_size
= ao
.size
;
692 tci
.object
= get_base_address (arg
);
693 tci
.type_maybe_changed
= false;
695 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
696 &tci
, NULL
, &entry_reached
);
697 if (!tci
.type_maybe_changed
)
700 ipa_set_jf_unknown (jfunc
);
704 /* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
705 If it is, return true and fill in the jump function JFUNC with relevant type
706 information or set it to unknown. ARG is the object itself (not a pointer
707 to it, unless dereferenced). BASE is the base of the memory access as
708 returned by get_ref_base_and_extent, as is the offset. */
711 detect_type_change (tree arg
, tree base
, tree comp_type
, gcall
*call
,
712 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
714 if (!flag_devirtualize
)
717 if (TREE_CODE (base
) == MEM_REF
718 && !param_type_may_change_p (current_function_decl
,
719 TREE_OPERAND (base
, 0),
722 return detect_type_change_from_memory_writes (arg
, base
, comp_type
,
723 call
, jfunc
, offset
);
726 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
727 SSA name (its dereference will become the base and the offset is assumed to
731 detect_type_change_ssa (tree arg
, tree comp_type
,
732 gcall
*call
, struct ipa_jump_func
*jfunc
)
734 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
735 if (!flag_devirtualize
736 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
739 if (!param_type_may_change_p (current_function_decl
, arg
, call
))
742 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
743 build_int_cst (ptr_type_node
, 0));
745 return detect_type_change_from_memory_writes (arg
, arg
, comp_type
,
749 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
750 boolean variable pointed to by DATA. */
753 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
756 bool *b
= (bool *) data
;
761 /* Return true if we have already walked so many statements in AA that we
762 should really just start giving up. */
765 aa_overwalked (struct ipa_func_body_info
*fbi
)
767 gcc_checking_assert (fbi
);
768 return fbi
->aa_walked
> (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS
);
771 /* Find the nearest valid aa status for parameter specified by INDEX that
774 static struct ipa_param_aa_status
*
775 find_dominating_aa_status (struct ipa_func_body_info
*fbi
, basic_block bb
,
780 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
783 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
784 if (!bi
->param_aa_statuses
.is_empty ()
785 && bi
->param_aa_statuses
[index
].valid
)
786 return &bi
->param_aa_statuses
[index
];
790 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
791 structures and/or intialize the result with a dominating description as
794 static struct ipa_param_aa_status
*
795 parm_bb_aa_status_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
,
798 gcc_checking_assert (fbi
);
799 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
800 if (bi
->param_aa_statuses
.is_empty ())
801 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
802 struct ipa_param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
805 gcc_checking_assert (!paa
->parm_modified
806 && !paa
->ref_modified
807 && !paa
->pt_modified
);
808 struct ipa_param_aa_status
*dom_paa
;
809 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
819 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
820 a value known not to be modified in this function before reaching the
821 statement STMT. FBI holds information about the function we have so far
822 gathered but do not survive the summary building stage. */
825 parm_preserved_before_stmt_p (struct ipa_func_body_info
*fbi
, int index
,
826 gimple
*stmt
, tree parm_load
)
828 struct ipa_param_aa_status
*paa
;
829 bool modified
= false;
832 tree base
= get_base_address (parm_load
);
833 gcc_assert (TREE_CODE (base
) == PARM_DECL
);
834 if (TREE_READONLY (base
))
837 /* FIXME: FBI can be NULL if we are being called from outside
838 ipa_node_analysis or ipcp_transform_function, which currently happens
839 during inlining analysis. It would be great to extend fbi's lifetime and
840 always have it. Currently, we are just not afraid of too much walking in
844 if (aa_overwalked (fbi
))
846 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
847 if (paa
->parm_modified
)
853 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
854 ao_ref_init (&refd
, parm_load
);
855 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
858 fbi
->aa_walked
+= walked
;
860 paa
->parm_modified
= true;
864 /* Main worker for load_from_unmodified_param and load_from_param.
865 If STMT is an assignment that loads a value from an parameter declaration,
866 return the index of the parameter in ipa_node_params. Otherwise return -1. */
869 load_from_param_1 (struct ipa_func_body_info
*fbi
,
870 vec
<ipa_param_descriptor
> descriptors
,
876 gcc_checking_assert (is_gimple_assign (stmt
));
877 op1
= gimple_assign_rhs1 (stmt
);
878 if (TREE_CODE (op1
) != PARM_DECL
)
881 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
883 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
889 /* If STMT is an assignment that loads a value from an parameter declaration,
890 return the index of the parameter in ipa_node_params which has not been
891 modified. Otherwise return -1. */
894 load_from_unmodified_param (struct ipa_func_body_info
*fbi
,
895 vec
<ipa_param_descriptor
> descriptors
,
898 if (!gimple_assign_single_p (stmt
))
901 return load_from_param_1 (fbi
, descriptors
, stmt
);
904 /* If STMT is an assignment that loads a value from an parameter declaration,
905 return the index of the parameter in ipa_node_params. Otherwise return -1. */
908 load_from_param (struct ipa_func_body_info
*fbi
,
909 vec
<ipa_param_descriptor
> descriptors
,
912 if (!is_gimple_assign (stmt
))
915 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
916 if ((get_gimple_rhs_class (rhs_code
) != GIMPLE_SINGLE_RHS
)
917 && (get_gimple_rhs_class (rhs_code
) != GIMPLE_UNARY_RHS
))
920 return load_from_param_1 (fbi
, descriptors
, stmt
);
923 /* Return true if memory reference REF (which must be a load through parameter
924 with INDEX) loads data that are known to be unmodified in this function
925 before reaching statement STMT. */
928 parm_ref_data_preserved_p (struct ipa_func_body_info
*fbi
,
929 int index
, gimple
*stmt
, tree ref
)
931 struct ipa_param_aa_status
*paa
;
932 bool modified
= false;
935 /* FIXME: FBI can be NULL if we are being called from outside
936 ipa_node_analysis or ipcp_transform_function, which currently happens
937 during inlining analysis. It would be great to extend fbi's lifetime and
938 always have it. Currently, we are just not afraid of too much walking in
942 if (aa_overwalked (fbi
))
944 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
945 if (paa
->ref_modified
)
951 gcc_checking_assert (gimple_vuse (stmt
));
952 ao_ref_init (&refd
, ref
);
953 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
956 fbi
->aa_walked
+= walked
;
958 paa
->ref_modified
= true;
962 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
963 is known to be unmodified in this function before reaching call statement
964 CALL into which it is passed. FBI describes the function body. */
967 parm_ref_data_pass_through_p (struct ipa_func_body_info
*fbi
, int index
,
968 gimple
*call
, tree parm
)
970 bool modified
= false;
973 /* It's unnecessary to calculate anything about memory contnets for a const
974 function because it is not goin to use it. But do not cache the result
975 either. Also, no such calculations for non-pointers. */
976 if (!gimple_vuse (call
)
977 || !POINTER_TYPE_P (TREE_TYPE (parm
))
978 || aa_overwalked (fbi
))
981 struct ipa_param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
,
984 if (paa
->pt_modified
)
987 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
988 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
990 fbi
->aa_walked
+= walked
;
992 paa
->pt_modified
= true;
996 /* Return true if we can prove that OP is a memory reference loading
997 data from an aggregate passed as a parameter.
999 The function works in two modes. If GUARANTEED_UNMODIFIED is NULL, it return
1000 false if it cannot prove that the value has not been modified before the
1001 load in STMT. If GUARANTEED_UNMODIFIED is not NULL, it will return true even
1002 if it cannot prove the value has not been modified, in that case it will
1003 store false to *GUARANTEED_UNMODIFIED, otherwise it will store true there.
1005 INFO and PARMS_AINFO describe parameters of the current function (but the
1006 latter can be NULL), STMT is the load statement. If function returns true,
1007 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
1008 within the aggregate and whether it is a load from a value passed by
1009 reference respectively. */
1012 ipa_load_from_parm_agg (struct ipa_func_body_info
*fbi
,
1013 vec
<ipa_param_descriptor
> descriptors
,
1014 gimple
*stmt
, tree op
, int *index_p
,
1015 HOST_WIDE_INT
*offset_p
, HOST_WIDE_INT
*size_p
,
1016 bool *by_ref_p
, bool *guaranteed_unmodified
)
1019 HOST_WIDE_INT size
, max_size
;
1022 = get_ref_base_and_extent (op
, offset_p
, &size
, &max_size
, &reverse
);
1024 if (max_size
== -1 || max_size
!= size
|| *offset_p
< 0)
1029 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
1031 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
1037 if (guaranteed_unmodified
)
1038 *guaranteed_unmodified
= true;
1044 if (TREE_CODE (base
) != MEM_REF
1045 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1046 || !integer_zerop (TREE_OPERAND (base
, 1)))
1049 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1051 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1052 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1056 /* This branch catches situations where a pointer parameter is not a
1057 gimple register, for example:
1059 void hip7(S*) (struct S * p)
1061 void (*<T2e4>) (struct S *) D.1867;
1066 D.1867_2 = p.1_1->f;
1071 gimple
*def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1072 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1077 bool data_preserved
= parm_ref_data_preserved_p (fbi
, index
, stmt
, op
);
1078 if (!data_preserved
&& !guaranteed_unmodified
)
1085 if (guaranteed_unmodified
)
1086 *guaranteed_unmodified
= data_preserved
;
1092 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1093 of an assignment statement STMT, try to determine whether we are actually
1094 handling any of the following cases and construct an appropriate jump
1095 function into JFUNC if so:
1097 1) The passed value is loaded from a formal parameter which is not a gimple
1098 register (most probably because it is addressable, the value has to be
1099 scalar) and we can guarantee the value has not changed. This case can
1100 therefore be described by a simple pass-through jump function. For example:
1109 2) The passed value can be described by a simple arithmetic pass-through
1116 D.2064_4 = a.1(D) + 4;
1119 This case can also occur in combination of the previous one, e.g.:
1127 D.2064_4 = a.0_3 + 4;
1130 3) The passed value is an address of an object within another one (which
1131 also passed by reference). Such situations are described by an ancestor
1132 jump function and describe situations such as:
1134 B::foo() (struct B * const this)
1138 D.1845_2 = &this_1(D)->D.1748;
1141 INFO is the structure describing individual parameters access different
1142 stages of IPA optimizations. PARMS_AINFO contains the information that is
1143 only needed for intraprocedural analysis. */
1146 compute_complex_assign_jump_func (struct ipa_func_body_info
*fbi
,
1147 struct ipa_node_params
*info
,
1148 struct ipa_jump_func
*jfunc
,
1149 gcall
*call
, gimple
*stmt
, tree name
,
1152 HOST_WIDE_INT offset
, size
, max_size
;
1153 tree op1
, tc_ssa
, base
, ssa
;
1156 gimple
*stmt2
= stmt
;
1158 op1
= gimple_assign_rhs1 (stmt
);
1160 if (TREE_CODE (op1
) == SSA_NAME
)
1162 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1163 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1166 index
= load_from_param (fbi
, info
->descriptors
,
1167 SSA_NAME_DEF_STMT (op1
));
1168 stmt2
= SSA_NAME_DEF_STMT (op1
);
1174 index
= load_from_param (fbi
, info
->descriptors
, stmt
);
1175 tc_ssa
= gimple_assign_lhs (stmt
);
1180 tree op2
= gimple_assign_rhs2 (stmt
);
1184 if (!is_gimple_ip_invariant (op2
)
1185 || (TREE_CODE_CLASS (gimple_expr_code (stmt
)) != tcc_comparison
1186 && !useless_type_conversion_p (TREE_TYPE (name
),
1190 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1191 gimple_assign_rhs_code (stmt
));
1193 else if (gimple_assign_single_p (stmt
))
1195 bool agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, tc_ssa
);
1196 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1198 else if (is_gimple_assign (stmt2
)
1199 && (gimple_expr_code (stmt2
) != NOP_EXPR
)
1200 && (TREE_CODE_CLASS (gimple_expr_code (stmt2
)) == tcc_unary
))
1202 ipa_set_jf_unary_pass_through (jfunc
, index
,
1203 gimple_assign_rhs_code (stmt2
));
1208 if (TREE_CODE (op1
) != ADDR_EXPR
)
1210 op1
= TREE_OPERAND (op1
, 0);
1211 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1213 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
, &reverse
);
1214 if (TREE_CODE (base
) != MEM_REF
1215 /* If this is a varying address, punt. */
1217 || max_size
!= size
)
1219 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1220 ssa
= TREE_OPERAND (base
, 0);
1221 if (TREE_CODE (ssa
) != SSA_NAME
1222 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1226 /* Dynamic types are changed in constructors and destructors. */
1227 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1228 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1229 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1230 parm_ref_data_pass_through_p (fbi
, index
, call
, ssa
));
1233 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1236 iftmp.1_3 = &obj_2(D)->D.1762;
1238 The base of the MEM_REF must be a default definition SSA NAME of a
1239 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1240 whole MEM_REF expression is returned and the offset calculated from any
1241 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1242 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1245 get_ancestor_addr_info (gimple
*assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1247 HOST_WIDE_INT size
, max_size
;
1248 tree expr
, parm
, obj
;
1251 if (!gimple_assign_single_p (assign
))
1253 expr
= gimple_assign_rhs1 (assign
);
1255 if (TREE_CODE (expr
) != ADDR_EXPR
)
1257 expr
= TREE_OPERAND (expr
, 0);
1259 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
, &reverse
);
1261 if (TREE_CODE (expr
) != MEM_REF
1262 /* If this is a varying address, punt. */
1267 parm
= TREE_OPERAND (expr
, 0);
1268 if (TREE_CODE (parm
) != SSA_NAME
1269 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1270 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1273 *offset
+= mem_ref_offset (expr
).to_short_addr () * BITS_PER_UNIT
;
1279 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1280 statement PHI, try to find out whether NAME is in fact a
1281 multiple-inheritance typecast from a descendant into an ancestor of a formal
1282 parameter and thus can be described by an ancestor jump function and if so,
1283 write the appropriate function into JFUNC.
1285 Essentially we want to match the following pattern:
1293 iftmp.1_3 = &obj_2(D)->D.1762;
1296 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1297 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1301 compute_complex_ancestor_jump_func (struct ipa_func_body_info
*fbi
,
1302 struct ipa_node_params
*info
,
1303 struct ipa_jump_func
*jfunc
,
1304 gcall
*call
, gphi
*phi
)
1306 HOST_WIDE_INT offset
;
1307 gimple
*assign
, *cond
;
1308 basic_block phi_bb
, assign_bb
, cond_bb
;
1309 tree tmp
, parm
, expr
, obj
;
1312 if (gimple_phi_num_args (phi
) != 2)
1315 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1316 tmp
= PHI_ARG_DEF (phi
, 0);
1317 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1318 tmp
= PHI_ARG_DEF (phi
, 1);
1321 if (TREE_CODE (tmp
) != SSA_NAME
1322 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1323 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1324 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1327 assign
= SSA_NAME_DEF_STMT (tmp
);
1328 assign_bb
= gimple_bb (assign
);
1329 if (!single_pred_p (assign_bb
))
1331 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1334 parm
= TREE_OPERAND (expr
, 0);
1335 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1339 cond_bb
= single_pred (assign_bb
);
1340 cond
= last_stmt (cond_bb
);
1342 || gimple_code (cond
) != GIMPLE_COND
1343 || gimple_cond_code (cond
) != NE_EXPR
1344 || gimple_cond_lhs (cond
) != parm
1345 || !integer_zerop (gimple_cond_rhs (cond
)))
1348 phi_bb
= gimple_bb (phi
);
1349 for (i
= 0; i
< 2; i
++)
1351 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1352 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1356 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1357 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
));
1360 /* Inspect the given TYPE and return true iff it has the same structure (the
1361 same number of fields of the same types) as a C++ member pointer. If
1362 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1363 corresponding fields there. */
1366 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1370 if (TREE_CODE (type
) != RECORD_TYPE
)
1373 fld
= TYPE_FIELDS (type
);
1374 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1375 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1376 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1382 fld
= DECL_CHAIN (fld
);
1383 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1384 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1389 if (DECL_CHAIN (fld
))
1395 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1396 return the rhs of its defining statement. Otherwise return RHS as it
1400 get_ssa_def_if_simple_copy (tree rhs
)
1402 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1404 gimple
*def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1406 if (gimple_assign_single_p (def_stmt
))
1407 rhs
= gimple_assign_rhs1 (def_stmt
);
1414 /* Simple linked list, describing known contents of an aggregate beforere
1417 struct ipa_known_agg_contents_list
1419 /* Offset and size of the described part of the aggregate. */
1420 HOST_WIDE_INT offset
, size
;
1421 /* Known constant value or NULL if the contents is known to be unknown. */
1423 /* Pointer to the next structure in the list. */
1424 struct ipa_known_agg_contents_list
*next
;
1427 /* Find the proper place in linked list of ipa_known_agg_contents_list
1428 structures where to put a new one with the given LHS_OFFSET and LHS_SIZE,
1429 unless there is a partial overlap, in which case return NULL, or such
1430 element is already there, in which case set *ALREADY_THERE to true. */
1432 static struct ipa_known_agg_contents_list
**
1433 get_place_in_agg_contents_list (struct ipa_known_agg_contents_list
**list
,
1434 HOST_WIDE_INT lhs_offset
,
1435 HOST_WIDE_INT lhs_size
,
1436 bool *already_there
)
1438 struct ipa_known_agg_contents_list
**p
= list
;
1439 while (*p
&& (*p
)->offset
< lhs_offset
)
1441 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1446 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1448 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1449 /* We already know this value is subsequently overwritten with
1451 *already_there
= true;
1453 /* Otherwise this is a partial overlap which we cannot
1460 /* Build aggregate jump function from LIST, assuming there are exactly
1461 CONST_COUNT constant entries there and that th offset of the passed argument
1462 is ARG_OFFSET and store it into JFUNC. */
1465 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1466 int const_count
, HOST_WIDE_INT arg_offset
,
1467 struct ipa_jump_func
*jfunc
)
1469 vec_alloc (jfunc
->agg
.items
, const_count
);
1474 struct ipa_agg_jf_item item
;
1475 item
.offset
= list
->offset
- arg_offset
;
1476 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1477 item
.value
= unshare_expr_without_location (list
->constant
);
1478 jfunc
->agg
.items
->quick_push (item
);
1484 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1485 in ARG is filled in with constant values. ARG can either be an aggregate
1486 expression or a pointer to an aggregate. ARG_TYPE is the type of the
1487 aggregate. JFUNC is the jump function into which the constants are
1488 subsequently stored. */
1491 determine_locally_known_aggregate_parts (gcall
*call
, tree arg
,
1493 struct ipa_jump_func
*jfunc
)
1495 struct ipa_known_agg_contents_list
*list
= NULL
;
1496 int item_count
= 0, const_count
= 0;
1497 HOST_WIDE_INT arg_offset
, arg_size
;
1498 gimple_stmt_iterator gsi
;
1500 bool check_ref
, by_ref
;
1503 if (PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
) == 0)
1506 /* The function operates in three stages. First, we prepare check_ref, r,
1507 arg_base and arg_offset based on what is actually passed as an actual
1510 if (POINTER_TYPE_P (arg_type
))
1513 if (TREE_CODE (arg
) == SSA_NAME
)
1516 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
))))
1521 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1522 arg_size
= tree_to_uhwi (type_size
);
1523 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1525 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1527 HOST_WIDE_INT arg_max_size
;
1530 arg
= TREE_OPERAND (arg
, 0);
1531 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1532 &arg_max_size
, &reverse
);
1533 if (arg_max_size
== -1
1534 || arg_max_size
!= arg_size
1537 if (DECL_P (arg_base
))
1540 ao_ref_init (&r
, arg_base
);
1550 HOST_WIDE_INT arg_max_size
;
1553 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1557 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1558 &arg_max_size
, &reverse
);
1559 if (arg_max_size
== -1
1560 || arg_max_size
!= arg_size
1564 ao_ref_init (&r
, arg
);
1567 /* Second stage walks back the BB, looks at individual statements and as long
1568 as it is confident of how the statements affect contents of the
1569 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1571 gsi
= gsi_for_stmt (call
);
1573 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1575 struct ipa_known_agg_contents_list
*n
, **p
;
1576 gimple
*stmt
= gsi_stmt (gsi
);
1577 HOST_WIDE_INT lhs_offset
, lhs_size
, lhs_max_size
;
1578 tree lhs
, rhs
, lhs_base
;
1581 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1583 if (!gimple_assign_single_p (stmt
))
1586 lhs
= gimple_assign_lhs (stmt
);
1587 rhs
= gimple_assign_rhs1 (stmt
);
1588 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1589 || TREE_CODE (lhs
) == BIT_FIELD_REF
1590 || contains_bitfld_component_ref_p (lhs
))
1593 lhs_base
= get_ref_base_and_extent (lhs
, &lhs_offset
, &lhs_size
,
1594 &lhs_max_size
, &reverse
);
1595 if (lhs_max_size
== -1
1596 || lhs_max_size
!= lhs_size
)
1601 if (TREE_CODE (lhs_base
) != MEM_REF
1602 || TREE_OPERAND (lhs_base
, 0) != arg_base
1603 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1606 else if (lhs_base
!= arg_base
)
1608 if (DECL_P (lhs_base
))
1614 bool already_there
= false;
1615 p
= get_place_in_agg_contents_list (&list
, lhs_offset
, lhs_size
,
1622 rhs
= get_ssa_def_if_simple_copy (rhs
);
1623 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1625 n
->offset
= lhs_offset
;
1626 if (is_gimple_ip_invariant (rhs
))
1632 n
->constant
= NULL_TREE
;
1637 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1638 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1642 /* Third stage just goes over the list and creates an appropriate vector of
1643 ipa_agg_jf_item structures out of it, of sourse only if there are
1644 any known constants to begin with. */
1648 jfunc
->agg
.by_ref
= by_ref
;
1649 build_agg_jump_func_from_list (list
, const_count
, arg_offset
, jfunc
);
1653 /* Return the Ith param type of callee associated with call graph
1657 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1660 tree type
= (e
->callee
1661 ? TREE_TYPE (e
->callee
->decl
)
1662 : gimple_call_fntype (e
->call_stmt
));
1663 tree t
= TYPE_ARG_TYPES (type
);
1665 for (n
= 0; n
< i
; n
++)
1672 return TREE_VALUE (t
);
1675 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1676 for (n
= 0; n
< i
; n
++)
1683 return TREE_TYPE (t
);
1687 /* Compute jump function for all arguments of callsite CS and insert the
1688 information in the jump_functions array in the ipa_edge_args corresponding
1689 to this callsite. */
1692 ipa_compute_jump_functions_for_edge (struct ipa_func_body_info
*fbi
,
1693 struct cgraph_edge
*cs
)
1695 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1696 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1697 gcall
*call
= cs
->call_stmt
;
1698 int n
, arg_num
= gimple_call_num_args (call
);
1699 bool useful_context
= false;
1701 if (arg_num
== 0 || args
->jump_functions
)
1703 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1704 if (flag_devirtualize
)
1705 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, arg_num
);
1707 if (gimple_call_internal_p (call
))
1709 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1712 for (n
= 0; n
< arg_num
; n
++)
1714 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1715 tree arg
= gimple_call_arg (call
, n
);
1716 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1717 if (flag_devirtualize
&& POINTER_TYPE_P (TREE_TYPE (arg
)))
1720 struct ipa_polymorphic_call_context
context (cs
->caller
->decl
,
1723 context
.get_dynamic_type (instance
, arg
, NULL
, cs
->call_stmt
);
1724 *ipa_get_ith_polymorhic_call_context (args
, n
) = context
;
1725 if (!context
.useless_p ())
1726 useful_context
= true;
1729 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1731 bool addr_nonzero
= false;
1732 bool strict_overflow
= false;
1734 if (TREE_CODE (arg
) == SSA_NAME
1736 && get_ptr_nonnull (arg
))
1737 addr_nonzero
= true;
1738 else if (tree_single_nonzero_warnv_p (arg
, &strict_overflow
))
1739 addr_nonzero
= true;
1743 jfunc
->vr_known
= true;
1744 jfunc
->m_vr
.type
= VR_ANTI_RANGE
;
1745 jfunc
->m_vr
.min
= build_int_cst (TREE_TYPE (arg
), 0);
1746 jfunc
->m_vr
.max
= build_int_cst (TREE_TYPE (arg
), 0);
1747 jfunc
->m_vr
.equiv
= NULL
;
1750 gcc_assert (!jfunc
->vr_known
);
1755 value_range_type type
;
1756 if (TREE_CODE (arg
) == SSA_NAME
1758 && (type
= get_range_info (arg
, &min
, &max
))
1759 && (type
== VR_RANGE
|| type
== VR_ANTI_RANGE
))
1764 vr
.min
= wide_int_to_tree (TREE_TYPE (arg
), min
);
1765 vr
.max
= wide_int_to_tree (TREE_TYPE (arg
), max
);
1767 extract_range_from_unary_expr (&jfunc
->m_vr
,
1770 &vr
, TREE_TYPE (arg
));
1771 if (jfunc
->m_vr
.type
== VR_RANGE
1772 || jfunc
->m_vr
.type
== VR_ANTI_RANGE
)
1773 jfunc
->vr_known
= true;
1775 jfunc
->vr_known
= false;
1778 gcc_assert (!jfunc
->vr_known
);
1781 if (INTEGRAL_TYPE_P (TREE_TYPE (arg
))
1782 && (TREE_CODE (arg
) == SSA_NAME
|| TREE_CODE (arg
) == INTEGER_CST
))
1784 jfunc
->bits
.known
= true;
1786 if (TREE_CODE (arg
) == SSA_NAME
)
1788 jfunc
->bits
.value
= 0;
1789 jfunc
->bits
.mask
= widest_int::from (get_nonzero_bits (arg
),
1790 TYPE_SIGN (TREE_TYPE (arg
)));
1794 jfunc
->bits
.value
= wi::to_widest (arg
);
1795 jfunc
->bits
.mask
= 0;
1798 else if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1800 unsigned HOST_WIDE_INT bitpos
;
1803 jfunc
->bits
.known
= true;
1804 get_pointer_alignment_1 (arg
, &align
, &bitpos
);
1805 jfunc
->bits
.mask
= wi::mask
<widest_int
>(TYPE_PRECISION (TREE_TYPE (arg
)), false)
1806 .and_not (align
/ BITS_PER_UNIT
- 1);
1807 jfunc
->bits
.value
= bitpos
/ BITS_PER_UNIT
;
1810 gcc_assert (!jfunc
->bits
.known
);
1812 if (is_gimple_ip_invariant (arg
)
1814 && is_global_var (arg
)
1815 && TREE_READONLY (arg
)))
1816 ipa_set_jf_constant (jfunc
, arg
, cs
);
1817 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1818 && TREE_CODE (arg
) == PARM_DECL
)
1820 int index
= ipa_get_param_decl_index (info
, arg
);
1822 gcc_assert (index
>=0);
1823 /* Aggregate passed by value, check for pass-through, otherwise we
1824 will attempt to fill in aggregate contents later in this
1826 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
1828 ipa_set_jf_simple_pass_through (jfunc
, index
, false);
1832 else if (TREE_CODE (arg
) == SSA_NAME
)
1834 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1836 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1840 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
1841 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1846 gimple
*stmt
= SSA_NAME_DEF_STMT (arg
);
1847 if (is_gimple_assign (stmt
))
1848 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
1849 call
, stmt
, arg
, param_type
);
1850 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1851 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
1853 as_a
<gphi
*> (stmt
));
1857 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1858 passed (because type conversions are ignored in gimple). Usually we can
1859 safely get type from function declaration, but in case of K&R prototypes or
1860 variadic functions we can try our luck with type of the pointer passed.
1861 TODO: Since we look for actual initialization of the memory object, we may better
1862 work out the type based on the memory stores we find. */
1864 param_type
= TREE_TYPE (arg
);
1866 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1867 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1868 && (jfunc
->type
!= IPA_JF_ANCESTOR
1869 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1870 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1871 || POINTER_TYPE_P (param_type
)))
1872 determine_locally_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1874 if (!useful_context
)
1875 vec_free (args
->polymorphic_call_contexts
);
1878 /* Compute jump functions for all edges - both direct and indirect - outgoing
1882 ipa_compute_jump_functions_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
1884 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
1886 struct cgraph_edge
*cs
;
1888 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
1890 struct cgraph_node
*callee
= cs
->callee
;
1894 callee
->ultimate_alias_target ();
1895 /* We do not need to bother analyzing calls to unknown functions
1896 unless they may become known during lto/whopr. */
1897 if (!callee
->definition
&& !flag_lto
)
1900 ipa_compute_jump_functions_for_edge (fbi
, cs
);
1904 /* If STMT looks like a statement loading a value from a member pointer formal
1905 parameter, return that parameter and store the offset of the field to
1906 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1907 might be clobbered). If USE_DELTA, then we look for a use of the delta
1908 field rather than the pfn. */
1911 ipa_get_stmt_member_ptr_load_param (gimple
*stmt
, bool use_delta
,
1912 HOST_WIDE_INT
*offset_p
)
1914 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
1916 if (!gimple_assign_single_p (stmt
))
1919 rhs
= gimple_assign_rhs1 (stmt
);
1920 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1922 ref_field
= TREE_OPERAND (rhs
, 1);
1923 rhs
= TREE_OPERAND (rhs
, 0);
1926 ref_field
= NULL_TREE
;
1927 if (TREE_CODE (rhs
) != MEM_REF
)
1929 rec
= TREE_OPERAND (rhs
, 0);
1930 if (TREE_CODE (rec
) != ADDR_EXPR
)
1932 rec
= TREE_OPERAND (rec
, 0);
1933 if (TREE_CODE (rec
) != PARM_DECL
1934 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1936 ref_offset
= TREE_OPERAND (rhs
, 1);
1943 *offset_p
= int_bit_position (fld
);
1947 if (integer_nonzerop (ref_offset
))
1949 return ref_field
== fld
? rec
: NULL_TREE
;
1952 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
1956 /* Returns true iff T is an SSA_NAME defined by a statement. */
1959 ipa_is_ssa_with_stmt_def (tree t
)
1961 if (TREE_CODE (t
) == SSA_NAME
1962 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1968 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1969 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1970 indirect call graph edge. */
1972 static struct cgraph_edge
*
1973 ipa_note_param_call (struct cgraph_node
*node
, int param_index
,
1976 struct cgraph_edge
*cs
;
1978 cs
= node
->get_edge (stmt
);
1979 cs
->indirect_info
->param_index
= param_index
;
1980 cs
->indirect_info
->agg_contents
= 0;
1981 cs
->indirect_info
->member_ptr
= 0;
1982 cs
->indirect_info
->guaranteed_unmodified
= 0;
1986 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1987 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1988 intermediate information about each formal parameter. Currently it checks
1989 whether the call calls a pointer that is a formal parameter and if so, the
1990 parameter is marked with the called flag and an indirect call graph edge
1991 describing the call is created. This is very simple for ordinary pointers
1992 represented in SSA but not-so-nice when it comes to member pointers. The
1993 ugly part of this function does nothing more than trying to match the
1994 pattern of such a call. An example of such a pattern is the gimple dump
1995 below, the call is on the last line:
1998 f$__delta_5 = f.__delta;
1999 f$__pfn_24 = f.__pfn;
2003 f$__delta_5 = MEM[(struct *)&f];
2004 f$__pfn_24 = MEM[(struct *)&f + 4B];
2006 and a few lines below:
2009 D.2496_3 = (int) f$__pfn_24;
2010 D.2497_4 = D.2496_3 & 1;
2017 D.2500_7 = (unsigned int) f$__delta_5;
2018 D.2501_8 = &S + D.2500_7;
2019 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
2020 D.2503_10 = *D.2502_9;
2021 D.2504_12 = f$__pfn_24 + -1;
2022 D.2505_13 = (unsigned int) D.2504_12;
2023 D.2506_14 = D.2503_10 + D.2505_13;
2024 D.2507_15 = *D.2506_14;
2025 iftmp.11_16 = (String:: *) D.2507_15;
2028 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
2029 D.2500_19 = (unsigned int) f$__delta_5;
2030 D.2508_20 = &S + D.2500_19;
2031 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
2033 Such patterns are results of simple calls to a member pointer:
2035 int doprinting (int (MyString::* f)(int) const)
2037 MyString S ("somestring");
2042 Moreover, the function also looks for called pointers loaded from aggregates
2043 passed by value or reference. */
2046 ipa_analyze_indirect_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
,
2049 struct ipa_node_params
*info
= fbi
->info
;
2050 HOST_WIDE_INT offset
;
2053 if (SSA_NAME_IS_DEFAULT_DEF (target
))
2055 tree var
= SSA_NAME_VAR (target
);
2056 int index
= ipa_get_param_decl_index (info
, var
);
2058 ipa_note_param_call (fbi
->node
, index
, call
);
2063 gimple
*def
= SSA_NAME_DEF_STMT (target
);
2064 bool guaranteed_unmodified
;
2065 if (gimple_assign_single_p (def
)
2066 && ipa_load_from_parm_agg (fbi
, info
->descriptors
, def
,
2067 gimple_assign_rhs1 (def
), &index
, &offset
,
2068 NULL
, &by_ref
, &guaranteed_unmodified
))
2070 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2071 cs
->indirect_info
->offset
= offset
;
2072 cs
->indirect_info
->agg_contents
= 1;
2073 cs
->indirect_info
->by_ref
= by_ref
;
2074 cs
->indirect_info
->guaranteed_unmodified
= guaranteed_unmodified
;
2078 /* Now we need to try to match the complex pattern of calling a member
2080 if (gimple_code (def
) != GIMPLE_PHI
2081 || gimple_phi_num_args (def
) != 2
2082 || !POINTER_TYPE_P (TREE_TYPE (target
))
2083 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2086 /* First, we need to check whether one of these is a load from a member
2087 pointer that is a parameter to this function. */
2088 tree n1
= PHI_ARG_DEF (def
, 0);
2089 tree n2
= PHI_ARG_DEF (def
, 1);
2090 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2092 gimple
*d1
= SSA_NAME_DEF_STMT (n1
);
2093 gimple
*d2
= SSA_NAME_DEF_STMT (n2
);
2096 basic_block bb
, virt_bb
;
2097 basic_block join
= gimple_bb (def
);
2098 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2100 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2103 bb
= EDGE_PRED (join
, 0)->src
;
2104 virt_bb
= gimple_bb (d2
);
2106 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2108 bb
= EDGE_PRED (join
, 1)->src
;
2109 virt_bb
= gimple_bb (d1
);
2114 /* Second, we need to check that the basic blocks are laid out in the way
2115 corresponding to the pattern. */
2117 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2118 || single_pred (virt_bb
) != bb
2119 || single_succ (virt_bb
) != join
)
2122 /* Third, let's see that the branching is done depending on the least
2123 significant bit of the pfn. */
2125 gimple
*branch
= last_stmt (bb
);
2126 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2129 if ((gimple_cond_code (branch
) != NE_EXPR
2130 && gimple_cond_code (branch
) != EQ_EXPR
)
2131 || !integer_zerop (gimple_cond_rhs (branch
)))
2134 tree cond
= gimple_cond_lhs (branch
);
2135 if (!ipa_is_ssa_with_stmt_def (cond
))
2138 def
= SSA_NAME_DEF_STMT (cond
);
2139 if (!is_gimple_assign (def
)
2140 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2141 || !integer_onep (gimple_assign_rhs2 (def
)))
2144 cond
= gimple_assign_rhs1 (def
);
2145 if (!ipa_is_ssa_with_stmt_def (cond
))
2148 def
= SSA_NAME_DEF_STMT (cond
);
2150 if (is_gimple_assign (def
)
2151 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2153 cond
= gimple_assign_rhs1 (def
);
2154 if (!ipa_is_ssa_with_stmt_def (cond
))
2156 def
= SSA_NAME_DEF_STMT (cond
);
2160 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2161 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2162 == ptrmemfunc_vbit_in_delta
),
2167 index
= ipa_get_param_decl_index (info
, rec
);
2169 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2171 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2172 cs
->indirect_info
->offset
= offset
;
2173 cs
->indirect_info
->agg_contents
= 1;
2174 cs
->indirect_info
->member_ptr
= 1;
2175 cs
->indirect_info
->guaranteed_unmodified
= 1;
2181 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2182 object referenced in the expression is a formal parameter of the caller
2183 FBI->node (described by FBI->info), create a call note for the
2187 ipa_analyze_virtual_call_uses (struct ipa_func_body_info
*fbi
,
2188 gcall
*call
, tree target
)
2190 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2192 HOST_WIDE_INT anc_offset
;
2194 if (!flag_devirtualize
)
2197 if (TREE_CODE (obj
) != SSA_NAME
)
2200 struct ipa_node_params
*info
= fbi
->info
;
2201 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2203 struct ipa_jump_func jfunc
;
2204 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2208 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2209 gcc_assert (index
>= 0);
2210 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2216 struct ipa_jump_func jfunc
;
2217 gimple
*stmt
= SSA_NAME_DEF_STMT (obj
);
2220 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2223 index
= ipa_get_param_decl_index (info
,
2224 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2225 gcc_assert (index
>= 0);
2226 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2227 call
, &jfunc
, anc_offset
))
2231 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2232 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2233 ii
->offset
= anc_offset
;
2234 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2235 ii
->otr_type
= obj_type_ref_class (target
);
2236 ii
->polymorphic
= 1;
2239 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2240 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2241 containing intermediate information about each formal parameter. */
2244 ipa_analyze_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
)
2246 tree target
= gimple_call_fn (call
);
2249 || (TREE_CODE (target
) != SSA_NAME
2250 && !virtual_method_call_p (target
)))
2253 struct cgraph_edge
*cs
= fbi
->node
->get_edge (call
);
2254 /* If we previously turned the call into a direct call, there is
2255 no need to analyze. */
2256 if (cs
&& !cs
->indirect_unknown_callee
)
2259 if (cs
->indirect_info
->polymorphic
&& flag_devirtualize
)
2262 tree target
= gimple_call_fn (call
);
2263 ipa_polymorphic_call_context
context (current_function_decl
,
2264 target
, call
, &instance
);
2266 gcc_checking_assert (cs
->indirect_info
->otr_type
2267 == obj_type_ref_class (target
));
2268 gcc_checking_assert (cs
->indirect_info
->otr_token
2269 == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target
)));
2271 cs
->indirect_info
->vptr_changed
2272 = !context
.get_dynamic_type (instance
,
2273 OBJ_TYPE_REF_OBJECT (target
),
2274 obj_type_ref_class (target
), call
);
2275 cs
->indirect_info
->context
= context
;
2278 if (TREE_CODE (target
) == SSA_NAME
)
2279 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2280 else if (virtual_method_call_p (target
))
2281 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2285 /* Analyze the call statement STMT with respect to formal parameters (described
2286 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2287 formal parameters are called. */
2290 ipa_analyze_stmt_uses (struct ipa_func_body_info
*fbi
, gimple
*stmt
)
2292 if (is_gimple_call (stmt
))
2293 ipa_analyze_call_uses (fbi
, as_a
<gcall
*> (stmt
));
2296 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2297 If OP is a parameter declaration, mark it as used in the info structure
2301 visit_ref_for_mod_analysis (gimple
*, tree op
, tree
, void *data
)
2303 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2305 op
= get_base_address (op
);
2307 && TREE_CODE (op
) == PARM_DECL
)
2309 int index
= ipa_get_param_decl_index (info
, op
);
2310 gcc_assert (index
>= 0);
2311 ipa_set_param_used (info
, index
, true);
2317 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2318 the findings in various structures of the associated ipa_node_params
2319 structure, such as parameter flags, notes etc. FBI holds various data about
2320 the function being analyzed. */
2323 ipa_analyze_params_uses_in_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2325 gimple_stmt_iterator gsi
;
2326 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2328 gimple
*stmt
= gsi_stmt (gsi
);
2330 if (is_gimple_debug (stmt
))
2333 ipa_analyze_stmt_uses (fbi
, stmt
);
2334 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2335 visit_ref_for_mod_analysis
,
2336 visit_ref_for_mod_analysis
,
2337 visit_ref_for_mod_analysis
);
2339 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2340 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2341 visit_ref_for_mod_analysis
,
2342 visit_ref_for_mod_analysis
,
2343 visit_ref_for_mod_analysis
);
2346 /* Calculate controlled uses of parameters of NODE. */
2349 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2351 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2353 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2355 tree parm
= ipa_get_param (info
, i
);
2356 int controlled_uses
= 0;
2358 /* For SSA regs see if parameter is used. For non-SSA we compute
2359 the flag during modification analysis. */
2360 if (is_gimple_reg (parm
))
2362 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2364 if (ddef
&& !has_zero_uses (ddef
))
2366 imm_use_iterator imm_iter
;
2367 use_operand_p use_p
;
2369 ipa_set_param_used (info
, i
, true);
2370 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2371 if (!is_gimple_call (USE_STMT (use_p
)))
2373 if (!is_gimple_debug (USE_STMT (use_p
)))
2375 controlled_uses
= IPA_UNDESCRIBED_USE
;
2383 controlled_uses
= 0;
2386 controlled_uses
= IPA_UNDESCRIBED_USE
;
2387 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2391 /* Free stuff in BI. */
2394 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2396 bi
->cg_edges
.release ();
2397 bi
->param_aa_statuses
.release ();
2400 /* Dominator walker driving the analysis. */
2402 class analysis_dom_walker
: public dom_walker
2405 analysis_dom_walker (struct ipa_func_body_info
*fbi
)
2406 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2408 virtual edge
before_dom_children (basic_block
);
2411 struct ipa_func_body_info
*m_fbi
;
2415 analysis_dom_walker::before_dom_children (basic_block bb
)
2417 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2418 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2422 /* Release body info FBI. */
2425 ipa_release_body_info (struct ipa_func_body_info
*fbi
)
2428 struct ipa_bb_info
*bi
;
2430 FOR_EACH_VEC_ELT (fbi
->bb_infos
, i
, bi
)
2431 free_ipa_bb_info (bi
);
2432 fbi
->bb_infos
.release ();
2435 /* Initialize the array describing properties of formal parameters
2436 of NODE, analyze their uses and compute jump functions associated
2437 with actual arguments of calls from within NODE. */
2440 ipa_analyze_node (struct cgraph_node
*node
)
2442 struct ipa_func_body_info fbi
;
2443 struct ipa_node_params
*info
;
2445 ipa_check_create_node_params ();
2446 ipa_check_create_edge_args ();
2447 info
= IPA_NODE_REF (node
);
2449 if (info
->analysis_done
)
2451 info
->analysis_done
= 1;
2453 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2455 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2457 ipa_set_param_used (info
, i
, true);
2458 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2463 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2465 calculate_dominance_info (CDI_DOMINATORS
);
2466 ipa_initialize_node_params (node
);
2467 ipa_analyze_controlled_uses (node
);
2470 fbi
.info
= IPA_NODE_REF (node
);
2471 fbi
.bb_infos
= vNULL
;
2472 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2473 fbi
.param_count
= ipa_get_param_count (info
);
2476 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2478 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2479 bi
->cg_edges
.safe_push (cs
);
2482 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2484 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2485 bi
->cg_edges
.safe_push (cs
);
2488 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2490 ipa_release_body_info (&fbi
);
2491 free_dominance_info (CDI_DOMINATORS
);
2495 /* Update the jump functions associated with call graph edge E when the call
2496 graph edge CS is being inlined, assuming that E->caller is already (possibly
2497 indirectly) inlined into CS->callee and that E has not been inlined. */
2500 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2501 struct cgraph_edge
*e
)
2503 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2504 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2505 int count
= ipa_get_cs_argument_count (args
);
2508 for (i
= 0; i
< count
; i
++)
2510 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2511 struct ipa_polymorphic_call_context
*dst_ctx
2512 = ipa_get_ith_polymorhic_call_context (args
, i
);
2514 if (dst
->type
== IPA_JF_ANCESTOR
)
2516 struct ipa_jump_func
*src
;
2517 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2518 struct ipa_polymorphic_call_context
*src_ctx
2519 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2521 /* Variable number of arguments can cause havoc if we try to access
2522 one that does not exist in the inlined edge. So make sure we
2524 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2526 ipa_set_jf_unknown (dst
);
2530 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2532 if (src_ctx
&& !src_ctx
->useless_p ())
2534 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2536 /* TODO: Make type preserved safe WRT contexts. */
2537 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2538 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2539 ctx
.offset_by (dst
->value
.ancestor
.offset
);
2540 if (!ctx
.useless_p ())
2544 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2546 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2549 dst_ctx
->combine_with (ctx
);
2554 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2556 struct ipa_agg_jf_item
*item
;
2559 /* Currently we do not produce clobber aggregate jump functions,
2560 replace with merging when we do. */
2561 gcc_assert (!dst
->agg
.items
);
2563 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2564 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2565 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2566 item
->offset
-= dst
->value
.ancestor
.offset
;
2569 if (src
->type
== IPA_JF_PASS_THROUGH
2570 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2572 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2573 dst
->value
.ancestor
.agg_preserved
&=
2574 src
->value
.pass_through
.agg_preserved
;
2576 else if (src
->type
== IPA_JF_ANCESTOR
)
2578 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2579 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2580 dst
->value
.ancestor
.agg_preserved
&=
2581 src
->value
.ancestor
.agg_preserved
;
2584 ipa_set_jf_unknown (dst
);
2586 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2588 struct ipa_jump_func
*src
;
2589 /* We must check range due to calls with variable number of arguments
2590 and we cannot combine jump functions with operations. */
2591 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2592 && (dst
->value
.pass_through
.formal_id
2593 < ipa_get_cs_argument_count (top
)))
2595 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2596 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2597 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2598 struct ipa_polymorphic_call_context
*src_ctx
2599 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2601 if (src_ctx
&& !src_ctx
->useless_p ())
2603 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2605 /* TODO: Make type preserved safe WRT contexts. */
2606 if (!ipa_get_jf_pass_through_type_preserved (dst
))
2607 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2608 if (!ctx
.useless_p ())
2612 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2614 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2616 dst_ctx
->combine_with (ctx
);
2621 case IPA_JF_UNKNOWN
:
2622 ipa_set_jf_unknown (dst
);
2625 ipa_set_jf_cst_copy (dst
, src
);
2628 case IPA_JF_PASS_THROUGH
:
2630 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2631 enum tree_code operation
;
2632 operation
= ipa_get_jf_pass_through_operation (src
);
2634 if (operation
== NOP_EXPR
)
2638 && ipa_get_jf_pass_through_agg_preserved (src
);
2639 ipa_set_jf_simple_pass_through (dst
, formal_id
, agg_p
);
2643 tree operand
= ipa_get_jf_pass_through_operand (src
);
2644 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2649 case IPA_JF_ANCESTOR
:
2653 && ipa_get_jf_ancestor_agg_preserved (src
);
2654 ipa_set_ancestor_jf (dst
,
2655 ipa_get_jf_ancestor_offset (src
),
2656 ipa_get_jf_ancestor_formal_id (src
),
2665 && (dst_agg_p
|| !src
->agg
.by_ref
))
2667 /* Currently we do not produce clobber aggregate jump
2668 functions, replace with merging when we do. */
2669 gcc_assert (!dst
->agg
.items
);
2671 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2672 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2676 ipa_set_jf_unknown (dst
);
2681 /* If TARGET is an addr_expr of a function declaration, make it the
2682 (SPECULATIVE)destination of an indirect edge IE and return the edge.
2683 Otherwise, return NULL. */
2685 struct cgraph_edge
*
2686 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
,
2689 struct cgraph_node
*callee
;
2690 struct inline_edge_summary
*es
= inline_edge_summary (ie
);
2691 bool unreachable
= false;
2693 if (TREE_CODE (target
) == ADDR_EXPR
)
2694 target
= TREE_OPERAND (target
, 0);
2695 if (TREE_CODE (target
) != FUNCTION_DECL
)
2697 target
= canonicalize_constructor_val (target
, NULL
);
2698 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2700 /* Member pointer call that goes through a VMT lookup. */
2701 if (ie
->indirect_info
->member_ptr
2702 /* Or if target is not an invariant expression and we do not
2703 know if it will evaulate to function at runtime.
2704 This can happen when folding through &VAR, where &VAR
2705 is IP invariant, but VAR itself is not.
2707 TODO: Revisit this when GCC 5 is branched. It seems that
2708 member_ptr check is not needed and that we may try to fold
2709 the expression and see if VAR is readonly. */
2710 || !is_gimple_ip_invariant (target
))
2712 if (dump_enabled_p ())
2714 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2715 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2716 "discovered direct call non-invariant "
2718 ie
->caller
->name (), ie
->caller
->order
);
2724 if (dump_enabled_p ())
2726 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2727 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2728 "discovered direct call to non-function in %s/%i, "
2729 "making it __builtin_unreachable\n",
2730 ie
->caller
->name (), ie
->caller
->order
);
2733 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2734 callee
= cgraph_node::get_create (target
);
2738 callee
= cgraph_node::get (target
);
2741 callee
= cgraph_node::get (target
);
2743 /* Because may-edges are not explicitely represented and vtable may be external,
2744 we may create the first reference to the object in the unit. */
2745 if (!callee
|| callee
->global
.inlined_to
)
2748 /* We are better to ensure we can refer to it.
2749 In the case of static functions we are out of luck, since we already
2750 removed its body. In the case of public functions we may or may
2751 not introduce the reference. */
2752 if (!canonicalize_constructor_val (target
, NULL
)
2753 || !TREE_PUBLIC (target
))
2756 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2757 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2758 xstrdup_for_dump (ie
->caller
->name ()),
2760 xstrdup_for_dump (ie
->callee
->name ()),
2764 callee
= cgraph_node::get_create (target
);
2767 /* If the edge is already speculated. */
2768 if (speculative
&& ie
->speculative
)
2770 struct cgraph_edge
*e2
;
2771 struct ipa_ref
*ref
;
2772 ie
->speculative_call_info (e2
, ie
, ref
);
2773 if (e2
->callee
->ultimate_alias_target ()
2774 != callee
->ultimate_alias_target ())
2777 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2778 "(%s/%i -> %s/%i) but the call is already speculated to %s/%i. Giving up.\n",
2779 xstrdup_for_dump (ie
->caller
->name ()),
2781 xstrdup_for_dump (callee
->name ()),
2783 xstrdup_for_dump (e2
->callee
->name ()),
2789 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2790 "(%s/%i -> %s/%i) this agree with previous speculation.\n",
2791 xstrdup_for_dump (ie
->caller
->name ()),
2793 xstrdup_for_dump (callee
->name ()),
2799 if (!dbg_cnt (devirt
))
2802 ipa_check_create_node_params ();
2804 /* We can not make edges to inline clones. It is bug that someone removed
2805 the cgraph node too early. */
2806 gcc_assert (!callee
->global
.inlined_to
);
2808 if (dump_file
&& !unreachable
)
2810 fprintf (dump_file
, "ipa-prop: Discovered %s call to a %s target "
2811 "(%s/%i -> %s/%i), for stmt ",
2812 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2813 speculative
? "speculative" : "known",
2814 xstrdup_for_dump (ie
->caller
->name ()),
2816 xstrdup_for_dump (callee
->name ()),
2819 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2821 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2823 if (dump_enabled_p ())
2825 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2827 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2828 "converting indirect call in %s to direct call to %s\n",
2829 ie
->caller
->name (), callee
->name ());
2833 struct cgraph_edge
*orig
= ie
;
2834 ie
= ie
->make_direct (callee
);
2835 /* If we resolved speculative edge the cost is already up to date
2836 for direct call (adjusted by inline_edge_duplication_hook). */
2839 es
= inline_edge_summary (ie
);
2840 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2841 - eni_size_weights
.call_cost
);
2842 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2843 - eni_time_weights
.call_cost
);
2848 if (!callee
->can_be_discarded_p ())
2851 alias
= dyn_cast
<cgraph_node
*> (callee
->noninterposable_alias ());
2855 /* make_speculative will update ie's cost to direct call cost. */
2856 ie
= ie
->make_speculative
2857 (callee
, ie
->count
* 8 / 10, ie
->frequency
* 8 / 10);
2863 /* Attempt to locate an interprocedural constant at a given REQ_OFFSET in
2864 CONSTRUCTOR and return it. Return NULL if the search fails for some
2868 find_constructor_constant_at_offset (tree constructor
, HOST_WIDE_INT req_offset
)
2870 tree type
= TREE_TYPE (constructor
);
2871 if (TREE_CODE (type
) != ARRAY_TYPE
2872 && TREE_CODE (type
) != RECORD_TYPE
)
2877 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (constructor
), ix
, index
, val
)
2879 HOST_WIDE_INT elt_offset
;
2880 if (TREE_CODE (type
) == ARRAY_TYPE
)
2883 tree unit_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
2884 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
2888 off
= wi::to_offset (index
);
2889 if (TYPE_DOMAIN (type
) && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)))
2891 tree low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
2892 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
2893 off
= wi::sext (off
- wi::to_offset (low_bound
),
2894 TYPE_PRECISION (TREE_TYPE (index
)));
2896 off
*= wi::to_offset (unit_size
);
2899 off
= wi::to_offset (unit_size
) * ix
;
2901 off
= wi::lshift (off
, LOG2_BITS_PER_UNIT
);
2902 if (!wi::fits_shwi_p (off
) || wi::neg_p (off
))
2904 elt_offset
= off
.to_shwi ();
2906 else if (TREE_CODE (type
) == RECORD_TYPE
)
2908 gcc_checking_assert (index
&& TREE_CODE (index
) == FIELD_DECL
);
2909 if (DECL_BIT_FIELD (index
))
2911 elt_offset
= int_bit_position (index
);
2916 if (elt_offset
> req_offset
)
2919 if (TREE_CODE (val
) == CONSTRUCTOR
)
2920 return find_constructor_constant_at_offset (val
,
2921 req_offset
- elt_offset
);
2923 if (elt_offset
== req_offset
2924 && is_gimple_reg_type (TREE_TYPE (val
))
2925 && is_gimple_ip_invariant (val
))
2931 /* Check whether SCALAR could be used to look up an aggregate interprocedural
2932 invariant from a static constructor and if so, return it. Otherwise return
2936 ipa_find_agg_cst_from_init (tree scalar
, HOST_WIDE_INT offset
, bool by_ref
)
2940 if (TREE_CODE (scalar
) != ADDR_EXPR
)
2942 scalar
= TREE_OPERAND (scalar
, 0);
2946 || !is_global_var (scalar
)
2947 || !TREE_READONLY (scalar
)
2948 || !DECL_INITIAL (scalar
)
2949 || TREE_CODE (DECL_INITIAL (scalar
)) != CONSTRUCTOR
)
2952 return find_constructor_constant_at_offset (DECL_INITIAL (scalar
), offset
);
2955 /* Retrieve value from aggregate jump function AGG or static initializer of
2956 SCALAR (which can be NULL) for the given OFFSET or return NULL if there is
2957 none. BY_REF specifies whether the value has to be passed by reference or
2958 by value. If FROM_GLOBAL_CONSTANT is non-NULL, then the boolean it points
2959 to is set to true if the value comes from an initializer of a constant. */
2962 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
, tree scalar
,
2963 HOST_WIDE_INT offset
, bool by_ref
,
2964 bool *from_global_constant
)
2966 struct ipa_agg_jf_item
*item
;
2971 tree res
= ipa_find_agg_cst_from_init (scalar
, offset
, by_ref
);
2974 if (from_global_constant
)
2975 *from_global_constant
= true;
2981 || by_ref
!= agg
->by_ref
)
2984 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2985 if (item
->offset
== offset
)
2987 /* Currently we do not have clobber values, return NULL for them once
2989 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2990 if (from_global_constant
)
2991 *from_global_constant
= false;
2997 /* Remove a reference to SYMBOL from the list of references of a node given by
2998 reference description RDESC. Return true if the reference has been
2999 successfully found and removed. */
3002 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
3004 struct ipa_ref
*to_del
;
3005 struct cgraph_edge
*origin
;
3010 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
3011 origin
->lto_stmt_uid
);
3015 to_del
->remove_reference ();
3017 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
3018 xstrdup_for_dump (origin
->caller
->name ()),
3019 origin
->caller
->order
, xstrdup_for_dump (symbol
->name ()));
3023 /* If JFUNC has a reference description with refcount different from
3024 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
3025 NULL. JFUNC must be a constant jump function. */
3027 static struct ipa_cst_ref_desc
*
3028 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
3030 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
3031 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
3037 /* If the value of constant jump function JFUNC is an address of a function
3038 declaration, return the associated call graph node. Otherwise return
3041 static cgraph_node
*
3042 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
3044 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
3045 tree cst
= ipa_get_jf_constant (jfunc
);
3046 if (TREE_CODE (cst
) != ADDR_EXPR
3047 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
3050 return cgraph_node::get (TREE_OPERAND (cst
, 0));
3054 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
3055 refcount and if it hits zero, remove reference to SYMBOL from the caller of
3056 the edge specified in the rdesc. Return false if either the symbol or the
3057 reference could not be found, otherwise return true. */
3060 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
3062 struct ipa_cst_ref_desc
*rdesc
;
3063 if (jfunc
->type
== IPA_JF_CONST
3064 && (rdesc
= jfunc_rdesc_usable (jfunc
))
3065 && --rdesc
->refcount
== 0)
3067 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
3071 return remove_described_reference (symbol
, rdesc
);
3076 /* Try to find a destination for indirect edge IE that corresponds to a simple
3077 call or a call of a member function pointer and where the destination is a
3078 pointer formal parameter described by jump function JFUNC. If it can be
3079 determined, return the newly direct edge, otherwise return NULL.
3080 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
3082 static struct cgraph_edge
*
3083 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
3084 struct ipa_jump_func
*jfunc
,
3085 struct ipa_node_params
*new_root_info
)
3087 struct cgraph_edge
*cs
;
3089 bool agg_contents
= ie
->indirect_info
->agg_contents
;
3090 tree scalar
= ipa_value_from_jfunc (new_root_info
, jfunc
);
3093 bool from_global_constant
;
3094 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3095 ie
->indirect_info
->offset
,
3096 ie
->indirect_info
->by_ref
,
3097 &from_global_constant
);
3099 && !from_global_constant
3100 && !ie
->indirect_info
->guaranteed_unmodified
)
3107 cs
= ipa_make_edge_direct_to_target (ie
, target
);
3109 if (cs
&& !agg_contents
)
3112 gcc_checking_assert (cs
->callee
3114 || jfunc
->type
!= IPA_JF_CONST
3115 || !cgraph_node_for_jfunc (jfunc
)
3116 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
3117 ok
= try_decrement_rdesc_refcount (jfunc
);
3118 gcc_checking_assert (ok
);
3124 /* Return the target to be used in cases of impossible devirtualization. IE
3125 and target (the latter can be NULL) are dumped when dumping is enabled. */
3128 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
3134 "Type inconsistent devirtualization: %s/%i->%s\n",
3135 ie
->caller
->name (), ie
->caller
->order
,
3136 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
3139 "No devirtualization target in %s/%i\n",
3140 ie
->caller
->name (), ie
->caller
->order
);
3142 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
3143 cgraph_node::get_create (new_target
);
3147 /* Try to find a destination for indirect edge IE that corresponds to a virtual
3148 call based on a formal parameter which is described by jump function JFUNC
3149 and if it can be determined, make it direct and return the direct edge.
3150 Otherwise, return NULL. CTX describes the polymorphic context that the
3151 parameter the call is based on brings along with it. */
3153 static struct cgraph_edge
*
3154 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
3155 struct ipa_jump_func
*jfunc
,
3156 struct ipa_polymorphic_call_context ctx
)
3159 bool speculative
= false;
3161 if (!opt_for_fn (ie
->caller
->decl
, flag_devirtualize
))
3164 gcc_assert (!ie
->indirect_info
->by_ref
);
3166 /* Try to do lookup via known virtual table pointer value. */
3167 if (!ie
->indirect_info
->vptr_changed
3168 || opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
))
3171 unsigned HOST_WIDE_INT offset
;
3172 tree scalar
= (jfunc
->type
== IPA_JF_CONST
) ? ipa_get_jf_constant (jfunc
)
3174 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3175 ie
->indirect_info
->offset
,
3177 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
3180 t
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
3181 vtable
, offset
, &can_refer
);
3185 || (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
3186 && DECL_FUNCTION_CODE (t
) == BUILT_IN_UNREACHABLE
)
3187 || !possible_polymorphic_call_target_p
3188 (ie
, cgraph_node::get (t
)))
3190 /* Do not speculate builtin_unreachable, it is stupid! */
3191 if (!ie
->indirect_info
->vptr_changed
)
3192 target
= ipa_impossible_devirt_target (ie
, target
);
3199 speculative
= ie
->indirect_info
->vptr_changed
;
3205 ipa_polymorphic_call_context
ie_context (ie
);
3206 vec
<cgraph_node
*>targets
;
3209 ctx
.offset_by (ie
->indirect_info
->offset
);
3210 if (ie
->indirect_info
->vptr_changed
)
3211 ctx
.possible_dynamic_type_change (ie
->in_polymorphic_cdtor
,
3212 ie
->indirect_info
->otr_type
);
3213 ctx
.combine_with (ie_context
, ie
->indirect_info
->otr_type
);
3214 targets
= possible_polymorphic_call_targets
3215 (ie
->indirect_info
->otr_type
,
3216 ie
->indirect_info
->otr_token
,
3218 if (final
&& targets
.length () <= 1)
3220 speculative
= false;
3221 if (targets
.length () == 1)
3222 target
= targets
[0]->decl
;
3224 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3226 else if (!target
&& opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
)
3227 && !ie
->speculative
&& ie
->maybe_hot_p ())
3230 n
= try_speculative_devirtualization (ie
->indirect_info
->otr_type
,
3231 ie
->indirect_info
->otr_token
,
3232 ie
->indirect_info
->context
);
3242 if (!possible_polymorphic_call_target_p
3243 (ie
, cgraph_node::get_create (target
)))
3247 target
= ipa_impossible_devirt_target (ie
, target
);
3249 return ipa_make_edge_direct_to_target (ie
, target
, speculative
);
3255 /* Update the param called notes associated with NODE when CS is being inlined,
3256 assuming NODE is (potentially indirectly) inlined into CS->callee.
3257 Moreover, if the callee is discovered to be constant, create a new cgraph
3258 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3259 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3262 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3263 struct cgraph_node
*node
,
3264 vec
<cgraph_edge
*> *new_edges
)
3266 struct ipa_edge_args
*top
;
3267 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3268 struct ipa_node_params
*new_root_info
;
3271 ipa_check_create_edge_args ();
3272 top
= IPA_EDGE_REF (cs
);
3273 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3274 ? cs
->caller
->global
.inlined_to
3277 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3279 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3280 struct ipa_jump_func
*jfunc
;
3282 cgraph_node
*spec_target
= NULL
;
3284 next_ie
= ie
->next_callee
;
3286 if (ici
->param_index
== -1)
3289 /* We must check range due to calls with variable number of arguments: */
3290 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3292 ici
->param_index
= -1;
3296 param_index
= ici
->param_index
;
3297 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3299 if (ie
->speculative
)
3301 struct cgraph_edge
*de
;
3302 struct ipa_ref
*ref
;
3303 ie
->speculative_call_info (de
, ie
, ref
);
3304 spec_target
= de
->callee
;
3307 if (!opt_for_fn (node
->decl
, flag_indirect_inlining
))
3308 new_direct_edge
= NULL
;
3309 else if (ici
->polymorphic
)
3311 ipa_polymorphic_call_context ctx
;
3312 ctx
= ipa_context_from_jfunc (new_root_info
, cs
, param_index
, jfunc
);
3313 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
, ctx
);
3316 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3318 /* If speculation was removed, then we need to do nothing. */
3319 if (new_direct_edge
&& new_direct_edge
!= ie
3320 && new_direct_edge
->callee
== spec_target
)
3322 new_direct_edge
->indirect_inlining_edge
= 1;
3323 top
= IPA_EDGE_REF (cs
);
3325 if (!new_direct_edge
->speculative
)
3328 else if (new_direct_edge
)
3330 new_direct_edge
->indirect_inlining_edge
= 1;
3331 if (new_direct_edge
->call_stmt
)
3332 new_direct_edge
->call_stmt_cannot_inline_p
3333 = !gimple_check_call_matching_types (
3334 new_direct_edge
->call_stmt
,
3335 new_direct_edge
->callee
->decl
, false);
3338 new_edges
->safe_push (new_direct_edge
);
3341 top
= IPA_EDGE_REF (cs
);
3342 /* If speculative edge was introduced we still need to update
3343 call info of the indirect edge. */
3344 if (!new_direct_edge
->speculative
)
3347 if (jfunc
->type
== IPA_JF_PASS_THROUGH
3348 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3350 if (ici
->agg_contents
3351 && !ipa_get_jf_pass_through_agg_preserved (jfunc
)
3352 && !ici
->polymorphic
)
3353 ici
->param_index
= -1;
3356 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3357 if (ici
->polymorphic
3358 && !ipa_get_jf_pass_through_type_preserved (jfunc
))
3359 ici
->vptr_changed
= true;
3362 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3364 if (ici
->agg_contents
3365 && !ipa_get_jf_ancestor_agg_preserved (jfunc
)
3366 && !ici
->polymorphic
)
3367 ici
->param_index
= -1;
3370 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3371 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3372 if (ici
->polymorphic
3373 && !ipa_get_jf_ancestor_type_preserved (jfunc
))
3374 ici
->vptr_changed
= true;
3378 /* Either we can find a destination for this edge now or never. */
3379 ici
->param_index
= -1;
3385 /* Recursively traverse subtree of NODE (including node) made of inlined
3386 cgraph_edges when CS has been inlined and invoke
3387 update_indirect_edges_after_inlining on all nodes and
3388 update_jump_functions_after_inlining on all non-inlined edges that lead out
3389 of this subtree. Newly discovered indirect edges will be added to
3390 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3394 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3395 struct cgraph_node
*node
,
3396 vec
<cgraph_edge
*> *new_edges
)
3398 struct cgraph_edge
*e
;
3401 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3403 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3404 if (!e
->inline_failed
)
3405 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3407 update_jump_functions_after_inlining (cs
, e
);
3408 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3409 update_jump_functions_after_inlining (cs
, e
);
3414 /* Combine two controlled uses counts as done during inlining. */
3417 combine_controlled_uses_counters (int c
, int d
)
3419 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3420 return IPA_UNDESCRIBED_USE
;
3425 /* Propagate number of controlled users from CS->caleee to the new root of the
3426 tree of inlined nodes. */
3429 propagate_controlled_uses (struct cgraph_edge
*cs
)
3431 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3432 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3433 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3434 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3435 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3438 count
= MIN (ipa_get_cs_argument_count (args
),
3439 ipa_get_param_count (old_root_info
));
3440 for (i
= 0; i
< count
; i
++)
3442 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3443 struct ipa_cst_ref_desc
*rdesc
;
3445 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3448 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3449 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3450 d
= ipa_get_controlled_uses (old_root_info
, i
);
3452 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3453 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3454 c
= combine_controlled_uses_counters (c
, d
);
3455 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3456 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3458 struct cgraph_node
*n
;
3459 struct ipa_ref
*ref
;
3460 tree t
= new_root_info
->known_csts
[src_idx
];
3462 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3463 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3464 && (n
= cgraph_node::get (TREE_OPERAND (t
, 0)))
3465 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3468 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3469 "reference from %s/%i to %s/%i.\n",
3470 xstrdup_for_dump (new_root
->name ()),
3472 xstrdup_for_dump (n
->name ()), n
->order
);
3473 ref
->remove_reference ();
3477 else if (jf
->type
== IPA_JF_CONST
3478 && (rdesc
= jfunc_rdesc_usable (jf
)))
3480 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3481 int c
= rdesc
->refcount
;
3482 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3483 if (rdesc
->refcount
== 0)
3485 tree cst
= ipa_get_jf_constant (jf
);
3486 struct cgraph_node
*n
;
3487 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3488 && TREE_CODE (TREE_OPERAND (cst
, 0))
3490 n
= cgraph_node::get (TREE_OPERAND (cst
, 0));
3493 struct cgraph_node
*clone
;
3495 ok
= remove_described_reference (n
, rdesc
);
3496 gcc_checking_assert (ok
);
3499 while (clone
->global
.inlined_to
3500 && clone
!= rdesc
->cs
->caller
3501 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3503 struct ipa_ref
*ref
;
3504 ref
= clone
->find_reference (n
, NULL
, 0);
3508 fprintf (dump_file
, "ipa-prop: Removing "
3509 "cloning-created reference "
3510 "from %s/%i to %s/%i.\n",
3511 xstrdup_for_dump (clone
->name ()),
3513 xstrdup_for_dump (n
->name ()),
3515 ref
->remove_reference ();
3517 clone
= clone
->callers
->caller
;
3524 for (i
= ipa_get_param_count (old_root_info
);
3525 i
< ipa_get_cs_argument_count (args
);
3528 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3530 if (jf
->type
== IPA_JF_CONST
)
3532 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3534 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3536 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3537 ipa_set_controlled_uses (new_root_info
,
3538 jf
->value
.pass_through
.formal_id
,
3539 IPA_UNDESCRIBED_USE
);
3543 /* Update jump functions and call note functions on inlining the call site CS.
3544 CS is expected to lead to a node already cloned by
3545 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3546 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3550 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3551 vec
<cgraph_edge
*> *new_edges
)
3554 /* Do nothing if the preparation phase has not been carried out yet
3555 (i.e. during early inlining). */
3556 if (!ipa_node_params_sum
)
3558 gcc_assert (ipa_edge_args_vector
);
3560 propagate_controlled_uses (cs
);
3561 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3566 /* Frees all dynamically allocated structures that the argument info points
3570 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3572 vec_free (args
->jump_functions
);
3573 memset (args
, 0, sizeof (*args
));
3576 /* Free all ipa_edge structures. */
3579 ipa_free_all_edge_args (void)
3582 struct ipa_edge_args
*args
;
3584 if (!ipa_edge_args_vector
)
3587 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3588 ipa_free_edge_args_substructures (args
);
3590 vec_free (ipa_edge_args_vector
);
3593 /* Frees all dynamically allocated structures that the param info points
3596 ipa_node_params::~ipa_node_params ()
3598 descriptors
.release ();
3600 /* Lattice values and their sources are deallocated with their alocation
3602 known_csts
.release ();
3603 known_contexts
.release ();
3606 ipcp_orig_node
= NULL
;
3609 do_clone_for_all_contexts
= 0;
3610 is_all_contexts_clone
= 0;
3614 /* Free all ipa_node_params structures. */
3617 ipa_free_all_node_params (void)
3619 delete ipa_node_params_sum
;
3620 ipa_node_params_sum
= NULL
;
3623 /* Grow ipcp_transformations if necessary. */
3626 ipcp_grow_transformations_if_necessary (void)
3628 if (vec_safe_length (ipcp_transformations
)
3629 <= (unsigned) symtab
->cgraph_max_uid
)
3630 vec_safe_grow_cleared (ipcp_transformations
, symtab
->cgraph_max_uid
+ 1);
3633 /* Set the aggregate replacements of NODE to be AGGVALS. */
3636 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3637 struct ipa_agg_replacement_value
*aggvals
)
3639 ipcp_grow_transformations_if_necessary ();
3640 (*ipcp_transformations
)[node
->uid
].agg_values
= aggvals
;
3643 /* Hook that is called by cgraph.c when an edge is removed. */
3646 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3648 struct ipa_edge_args
*args
;
3650 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3651 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3654 args
= IPA_EDGE_REF (cs
);
3655 if (args
->jump_functions
)
3657 struct ipa_jump_func
*jf
;
3659 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3661 struct ipa_cst_ref_desc
*rdesc
;
3662 try_decrement_rdesc_refcount (jf
);
3663 if (jf
->type
== IPA_JF_CONST
3664 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3670 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3673 /* Hook that is called by cgraph.c when an edge is duplicated. */
3676 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3679 struct ipa_edge_args
*old_args
, *new_args
;
3682 ipa_check_create_edge_args ();
3684 old_args
= IPA_EDGE_REF (src
);
3685 new_args
= IPA_EDGE_REF (dst
);
3687 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3688 if (old_args
->polymorphic_call_contexts
)
3689 new_args
->polymorphic_call_contexts
3690 = vec_safe_copy (old_args
->polymorphic_call_contexts
);
3692 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3694 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3695 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3697 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3699 if (src_jf
->type
== IPA_JF_CONST
)
3701 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3704 dst_jf
->value
.constant
.rdesc
= NULL
;
3705 else if (src
->caller
== dst
->caller
)
3707 struct ipa_ref
*ref
;
3708 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3709 gcc_checking_assert (n
);
3710 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3712 gcc_checking_assert (ref
);
3713 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3715 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3716 dst_rdesc
->cs
= dst
;
3717 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3718 dst_rdesc
->next_duplicate
= NULL
;
3719 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3721 else if (src_rdesc
->cs
== src
)
3723 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3724 dst_rdesc
->cs
= dst
;
3725 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3726 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3727 src_rdesc
->next_duplicate
= dst_rdesc
;
3728 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3732 struct ipa_cst_ref_desc
*dst_rdesc
;
3733 /* This can happen during inlining, when a JFUNC can refer to a
3734 reference taken in a function up in the tree of inline clones.
3735 We need to find the duplicate that refers to our tree of
3738 gcc_assert (dst
->caller
->global
.inlined_to
);
3739 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3741 dst_rdesc
= dst_rdesc
->next_duplicate
)
3743 struct cgraph_node
*top
;
3744 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3745 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3746 : dst_rdesc
->cs
->caller
;
3747 if (dst
->caller
->global
.inlined_to
== top
)
3750 gcc_assert (dst_rdesc
);
3751 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3754 else if (dst_jf
->type
== IPA_JF_PASS_THROUGH
3755 && src
->caller
== dst
->caller
)
3757 struct cgraph_node
*inline_root
= dst
->caller
->global
.inlined_to
3758 ? dst
->caller
->global
.inlined_to
: dst
->caller
;
3759 struct ipa_node_params
*root_info
= IPA_NODE_REF (inline_root
);
3760 int idx
= ipa_get_jf_pass_through_formal_id (dst_jf
);
3762 int c
= ipa_get_controlled_uses (root_info
, idx
);
3763 if (c
!= IPA_UNDESCRIBED_USE
)
3766 ipa_set_controlled_uses (root_info
, idx
, c
);
3772 /* Analyze newly added function into callgraph. */
3775 ipa_add_new_function (cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3777 if (node
->has_gimple_body_p ())
3778 ipa_analyze_node (node
);
3781 /* Hook that is called by summary when a node is duplicated. */
3784 ipa_node_params_t::duplicate(cgraph_node
*src
, cgraph_node
*dst
,
3785 ipa_node_params
*old_info
,
3786 ipa_node_params
*new_info
)
3788 ipa_agg_replacement_value
*old_av
, *new_av
;
3790 new_info
->descriptors
= old_info
->descriptors
.copy ();
3791 new_info
->lattices
= NULL
;
3792 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3794 new_info
->analysis_done
= old_info
->analysis_done
;
3795 new_info
->node_enqueued
= old_info
->node_enqueued
;
3796 new_info
->versionable
= old_info
->versionable
;
3798 old_av
= ipa_get_agg_replacements_for_node (src
);
3804 struct ipa_agg_replacement_value
*v
;
3806 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3807 memcpy (v
, old_av
, sizeof (*v
));
3810 old_av
= old_av
->next
;
3812 ipa_set_node_agg_value_chain (dst
, new_av
);
3815 ipcp_transformation_summary
*src_trans
= ipcp_get_transformation_summary (src
);
3819 ipcp_grow_transformations_if_necessary ();
3820 src_trans
= ipcp_get_transformation_summary (src
);
3821 const vec
<ipa_vr
, va_gc
> *src_vr
= src_trans
->m_vr
;
3822 vec
<ipa_vr
, va_gc
> *&dst_vr
3823 = ipcp_get_transformation_summary (dst
)->m_vr
;
3824 if (vec_safe_length (src_trans
->m_vr
) > 0)
3826 vec_safe_reserve_exact (dst_vr
, src_vr
->length ());
3827 for (unsigned i
= 0; i
< src_vr
->length (); ++i
)
3828 dst_vr
->quick_push ((*src_vr
)[i
]);
3832 if (src_trans
&& vec_safe_length (src_trans
->bits
) > 0)
3834 ipcp_grow_transformations_if_necessary ();
3835 src_trans
= ipcp_get_transformation_summary (src
);
3836 const vec
<ipa_bits
, va_gc
> *src_bits
= src_trans
->bits
;
3837 vec
<ipa_bits
, va_gc
> *&dst_bits
3838 = ipcp_get_transformation_summary (dst
)->bits
;
3839 vec_safe_reserve_exact (dst_bits
, src_bits
->length ());
3840 for (unsigned i
= 0; i
< src_bits
->length (); ++i
)
3841 dst_bits
->quick_push ((*src_bits
)[i
]);
3845 /* Register our cgraph hooks if they are not already there. */
3848 ipa_register_cgraph_hooks (void)
3850 ipa_check_create_node_params ();
3852 if (!edge_removal_hook_holder
)
3853 edge_removal_hook_holder
=
3854 symtab
->add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3855 if (!edge_duplication_hook_holder
)
3856 edge_duplication_hook_holder
=
3857 symtab
->add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3858 function_insertion_hook_holder
=
3859 symtab
->add_cgraph_insertion_hook (&ipa_add_new_function
, NULL
);
3862 /* Unregister our cgraph hooks if they are not already there. */
3865 ipa_unregister_cgraph_hooks (void)
3867 symtab
->remove_edge_removal_hook (edge_removal_hook_holder
);
3868 edge_removal_hook_holder
= NULL
;
3869 symtab
->remove_edge_duplication_hook (edge_duplication_hook_holder
);
3870 edge_duplication_hook_holder
= NULL
;
3871 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
3872 function_insertion_hook_holder
= NULL
;
3875 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3876 longer needed after ipa-cp. */
3879 ipa_free_all_structures_after_ipa_cp (void)
3881 if (!optimize
&& !in_lto_p
)
3883 ipa_free_all_edge_args ();
3884 ipa_free_all_node_params ();
3885 ipcp_sources_pool
.release ();
3886 ipcp_cst_values_pool
.release ();
3887 ipcp_poly_ctx_values_pool
.release ();
3888 ipcp_agg_lattice_pool
.release ();
3889 ipa_unregister_cgraph_hooks ();
3890 ipa_refdesc_pool
.release ();
3894 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3895 longer needed after indirect inlining. */
3898 ipa_free_all_structures_after_iinln (void)
3900 ipa_free_all_edge_args ();
3901 ipa_free_all_node_params ();
3902 ipa_unregister_cgraph_hooks ();
3903 ipcp_sources_pool
.release ();
3904 ipcp_cst_values_pool
.release ();
3905 ipcp_poly_ctx_values_pool
.release ();
3906 ipcp_agg_lattice_pool
.release ();
3907 ipa_refdesc_pool
.release ();
3910 /* Print ipa_tree_map data structures of all functions in the
3914 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3917 struct ipa_node_params
*info
;
3919 if (!node
->definition
)
3921 info
= IPA_NODE_REF (node
);
3922 fprintf (f
, " function %s/%i parameter descriptors:\n",
3923 node
->name (), node
->order
);
3924 count
= ipa_get_param_count (info
);
3925 for (i
= 0; i
< count
; i
++)
3930 ipa_dump_param (f
, info
, i
);
3931 if (ipa_is_param_used (info
, i
))
3932 fprintf (f
, " used");
3933 c
= ipa_get_controlled_uses (info
, i
);
3934 if (c
== IPA_UNDESCRIBED_USE
)
3935 fprintf (f
, " undescribed_use");
3937 fprintf (f
, " controlled_uses=%i", c
);
3942 /* Print ipa_tree_map data structures of all functions in the
3946 ipa_print_all_params (FILE * f
)
3948 struct cgraph_node
*node
;
3950 fprintf (f
, "\nFunction parameters:\n");
3951 FOR_EACH_FUNCTION (node
)
3952 ipa_print_node_params (f
, node
);
3955 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3958 ipa_get_vector_of_formal_parms (tree fndecl
)
3964 gcc_assert (!flag_wpa
);
3965 count
= count_formal_params (fndecl
);
3966 args
.create (count
);
3967 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3968 args
.quick_push (parm
);
3973 /* Return a heap allocated vector containing types of formal parameters of
3974 function type FNTYPE. */
3977 ipa_get_vector_of_formal_parm_types (tree fntype
)
3983 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3986 types
.create (count
);
3987 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3988 types
.quick_push (TREE_VALUE (t
));
3993 /* Modify the function declaration FNDECL and its type according to the plan in
3994 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3995 to reflect the actual parameters being modified which are determined by the
3996 base_index field. */
3999 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
4001 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
4002 tree orig_type
= TREE_TYPE (fndecl
);
4003 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
4005 /* The following test is an ugly hack, some functions simply don't have any
4006 arguments in their type. This is probably a bug but well... */
4007 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
4008 bool last_parm_void
;
4012 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
4014 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
4016 gcc_assert (oparms
.length () + 1 == otypes
.length ());
4018 gcc_assert (oparms
.length () == otypes
.length ());
4022 last_parm_void
= false;
4026 int len
= adjustments
.length ();
4027 tree
*link
= &DECL_ARGUMENTS (fndecl
);
4028 tree new_arg_types
= NULL
;
4029 for (int i
= 0; i
< len
; i
++)
4031 struct ipa_parm_adjustment
*adj
;
4034 adj
= &adjustments
[i
];
4036 if (adj
->op
== IPA_PARM_OP_NEW
)
4039 parm
= oparms
[adj
->base_index
];
4042 if (adj
->op
== IPA_PARM_OP_COPY
)
4045 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
4048 link
= &DECL_CHAIN (parm
);
4050 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
4056 ptype
= build_pointer_type (adj
->type
);
4060 if (is_gimple_reg_type (ptype
))
4062 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
4063 if (TYPE_ALIGN (ptype
) != malign
)
4064 ptype
= build_aligned_type (ptype
, malign
);
4069 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
4071 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
4073 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
4074 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
4075 DECL_ARTIFICIAL (new_parm
) = 1;
4076 DECL_ARG_TYPE (new_parm
) = ptype
;
4077 DECL_CONTEXT (new_parm
) = fndecl
;
4078 TREE_USED (new_parm
) = 1;
4079 DECL_IGNORED_P (new_parm
) = 1;
4080 layout_decl (new_parm
, 0);
4082 if (adj
->op
== IPA_PARM_OP_NEW
)
4086 adj
->new_decl
= new_parm
;
4089 link
= &DECL_CHAIN (new_parm
);
4095 tree new_reversed
= NULL
;
4098 new_reversed
= nreverse (new_arg_types
);
4102 TREE_CHAIN (new_arg_types
) = void_list_node
;
4104 new_reversed
= void_list_node
;
4108 /* Use copy_node to preserve as much as possible from original type
4109 (debug info, attribute lists etc.)
4110 Exception is METHOD_TYPEs must have THIS argument.
4111 When we are asked to remove it, we need to build new FUNCTION_TYPE
4113 tree new_type
= NULL
;
4114 if (TREE_CODE (orig_type
) != METHOD_TYPE
4115 || (adjustments
[0].op
== IPA_PARM_OP_COPY
4116 && adjustments
[0].base_index
== 0))
4118 new_type
= build_distinct_type_copy (orig_type
);
4119 TYPE_ARG_TYPES (new_type
) = new_reversed
;
4124 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
4126 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
4127 DECL_VINDEX (fndecl
) = NULL_TREE
;
4130 /* When signature changes, we need to clear builtin info. */
4131 if (DECL_BUILT_IN (fndecl
))
4133 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
4134 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
4137 TREE_TYPE (fndecl
) = new_type
;
4138 DECL_VIRTUAL_P (fndecl
) = 0;
4139 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
4144 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
4145 If this is a directly recursive call, CS must be NULL. Otherwise it must
4146 contain the corresponding call graph edge. */
4149 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gcall
*stmt
,
4150 ipa_parm_adjustment_vec adjustments
)
4152 struct cgraph_node
*current_node
= cgraph_node::get (current_function_decl
);
4154 vec
<tree
, va_gc
> **debug_args
= NULL
;
4156 gimple_stmt_iterator gsi
, prev_gsi
;
4160 len
= adjustments
.length ();
4162 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
4163 current_node
->remove_stmt_references (stmt
);
4165 gsi
= gsi_for_stmt (stmt
);
4167 gsi_prev (&prev_gsi
);
4168 for (i
= 0; i
< len
; i
++)
4170 struct ipa_parm_adjustment
*adj
;
4172 adj
= &adjustments
[i
];
4174 if (adj
->op
== IPA_PARM_OP_COPY
)
4176 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
4178 vargs
.quick_push (arg
);
4180 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
4182 tree expr
, base
, off
;
4184 unsigned int deref_align
= 0;
4185 bool deref_base
= false;
4187 /* We create a new parameter out of the value of the old one, we can
4188 do the following kind of transformations:
4190 - A scalar passed by reference is converted to a scalar passed by
4191 value. (adj->by_ref is false and the type of the original
4192 actual argument is a pointer to a scalar).
4194 - A part of an aggregate is passed instead of the whole aggregate.
4195 The part can be passed either by value or by reference, this is
4196 determined by value of adj->by_ref. Moreover, the code below
4197 handles both situations when the original aggregate is passed by
4198 value (its type is not a pointer) and when it is passed by
4199 reference (it is a pointer to an aggregate).
4201 When the new argument is passed by reference (adj->by_ref is true)
4202 it must be a part of an aggregate and therefore we form it by
4203 simply taking the address of a reference inside the original
4206 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
4207 base
= gimple_call_arg (stmt
, adj
->base_index
);
4208 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
4209 : EXPR_LOCATION (base
);
4211 if (TREE_CODE (base
) != ADDR_EXPR
4212 && POINTER_TYPE_P (TREE_TYPE (base
)))
4213 off
= build_int_cst (adj
->alias_ptr_type
,
4214 adj
->offset
/ BITS_PER_UNIT
);
4217 HOST_WIDE_INT base_offset
;
4221 if (TREE_CODE (base
) == ADDR_EXPR
)
4223 base
= TREE_OPERAND (base
, 0);
4229 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
4230 /* Aggregate arguments can have non-invariant addresses. */
4233 base
= build_fold_addr_expr (prev_base
);
4234 off
= build_int_cst (adj
->alias_ptr_type
,
4235 adj
->offset
/ BITS_PER_UNIT
);
4237 else if (TREE_CODE (base
) == MEM_REF
)
4242 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
4244 off
= build_int_cst (adj
->alias_ptr_type
,
4246 + adj
->offset
/ BITS_PER_UNIT
);
4247 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
4249 base
= TREE_OPERAND (base
, 0);
4253 off
= build_int_cst (adj
->alias_ptr_type
,
4255 + adj
->offset
/ BITS_PER_UNIT
);
4256 base
= build_fold_addr_expr (base
);
4262 tree type
= adj
->type
;
4264 unsigned HOST_WIDE_INT misalign
;
4268 align
= deref_align
;
4273 get_pointer_alignment_1 (base
, &align
, &misalign
);
4274 if (TYPE_ALIGN (type
) > align
)
4275 align
= TYPE_ALIGN (type
);
4277 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
4279 misalign
= misalign
& (align
- 1);
4281 align
= least_bit_hwi (misalign
);
4282 if (align
< TYPE_ALIGN (type
))
4283 type
= build_aligned_type (type
, align
);
4284 base
= force_gimple_operand_gsi (&gsi
, base
,
4285 true, NULL
, true, GSI_SAME_STMT
);
4286 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
4287 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4288 /* If expr is not a valid gimple call argument emit
4289 a load into a temporary. */
4290 if (is_gimple_reg_type (TREE_TYPE (expr
)))
4292 gimple
*tem
= gimple_build_assign (NULL_TREE
, expr
);
4293 if (gimple_in_ssa_p (cfun
))
4295 gimple_set_vuse (tem
, gimple_vuse (stmt
));
4296 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
4299 expr
= create_tmp_reg (TREE_TYPE (expr
));
4300 gimple_assign_set_lhs (tem
, expr
);
4301 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
4306 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
4307 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4308 expr
= build_fold_addr_expr (expr
);
4309 expr
= force_gimple_operand_gsi (&gsi
, expr
,
4310 true, NULL
, true, GSI_SAME_STMT
);
4312 vargs
.quick_push (expr
);
4314 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
4317 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
4320 arg
= gimple_call_arg (stmt
, adj
->base_index
);
4321 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
4323 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
4325 arg
= fold_convert_loc (gimple_location (stmt
),
4326 TREE_TYPE (origin
), arg
);
4328 if (debug_args
== NULL
)
4329 debug_args
= decl_debug_args_insert (callee_decl
);
4330 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
4331 if (ddecl
== origin
)
4333 ddecl
= (**debug_args
)[ix
+ 1];
4338 ddecl
= make_node (DEBUG_EXPR_DECL
);
4339 DECL_ARTIFICIAL (ddecl
) = 1;
4340 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
4341 DECL_MODE (ddecl
) = DECL_MODE (origin
);
4343 vec_safe_push (*debug_args
, origin
);
4344 vec_safe_push (*debug_args
, ddecl
);
4346 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
4347 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
4351 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4353 fprintf (dump_file
, "replacing stmt:");
4354 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
4357 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
4359 if (gimple_call_lhs (stmt
))
4360 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
4362 gimple_set_block (new_stmt
, gimple_block (stmt
));
4363 if (gimple_has_location (stmt
))
4364 gimple_set_location (new_stmt
, gimple_location (stmt
));
4365 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
4366 gimple_call_copy_flags (new_stmt
, stmt
);
4367 if (gimple_in_ssa_p (cfun
))
4369 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4370 if (gimple_vdef (stmt
))
4372 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4373 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
4377 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4379 fprintf (dump_file
, "with stmt:");
4380 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
4381 fprintf (dump_file
, "\n");
4383 gsi_replace (&gsi
, new_stmt
, true);
4385 cs
->set_call_stmt (new_stmt
);
4388 current_node
->record_stmt_references (gsi_stmt (gsi
));
4391 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
4394 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
4395 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
4396 specifies whether the function should care about type incompatibility the
4397 current and new expressions. If it is false, the function will leave
4398 incompatibility issues to the caller. Return true iff the expression
4402 ipa_modify_expr (tree
*expr
, bool convert
,
4403 ipa_parm_adjustment_vec adjustments
)
4405 struct ipa_parm_adjustment
*cand
4406 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
4413 src
= build_simple_mem_ref (cand
->new_decl
);
4414 REF_REVERSE_STORAGE_ORDER (src
) = cand
->reverse
;
4417 src
= cand
->new_decl
;
4419 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4421 fprintf (dump_file
, "About to replace expr ");
4422 print_generic_expr (dump_file
, *expr
, 0);
4423 fprintf (dump_file
, " with ");
4424 print_generic_expr (dump_file
, src
, 0);
4425 fprintf (dump_file
, "\n");
4428 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
4430 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
4438 /* If T is an SSA_NAME, return NULL if it is not a default def or
4439 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
4440 the base variable is always returned, regardless if it is a default
4441 def. Return T if it is not an SSA_NAME. */
4444 get_ssa_base_param (tree t
, bool ignore_default_def
)
4446 if (TREE_CODE (t
) == SSA_NAME
)
4448 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
4449 return SSA_NAME_VAR (t
);
4456 /* Given an expression, return an adjustment entry specifying the
4457 transformation to be done on EXPR. If no suitable adjustment entry
4458 was found, returns NULL.
4460 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
4461 default def, otherwise bail on them.
4463 If CONVERT is non-NULL, this function will set *CONVERT if the
4464 expression provided is a component reference. ADJUSTMENTS is the
4465 adjustments vector. */
4467 ipa_parm_adjustment
*
4468 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
4469 ipa_parm_adjustment_vec adjustments
,
4470 bool ignore_default_def
)
4472 if (TREE_CODE (**expr
) == BIT_FIELD_REF
4473 || TREE_CODE (**expr
) == IMAGPART_EXPR
4474 || TREE_CODE (**expr
) == REALPART_EXPR
)
4476 *expr
= &TREE_OPERAND (**expr
, 0);
4481 HOST_WIDE_INT offset
, size
, max_size
;
4484 = get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
, &reverse
);
4485 if (!base
|| size
== -1 || max_size
== -1)
4488 if (TREE_CODE (base
) == MEM_REF
)
4490 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
4491 base
= TREE_OPERAND (base
, 0);
4494 base
= get_ssa_base_param (base
, ignore_default_def
);
4495 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4498 struct ipa_parm_adjustment
*cand
= NULL
;
4499 unsigned int len
= adjustments
.length ();
4500 for (unsigned i
= 0; i
< len
; i
++)
4502 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4504 if (adj
->base
== base
4505 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4512 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4517 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4520 index_in_adjustments_multiple_times_p (int base_index
,
4521 ipa_parm_adjustment_vec adjustments
)
4523 int i
, len
= adjustments
.length ();
4526 for (i
= 0; i
< len
; i
++)
4528 struct ipa_parm_adjustment
*adj
;
4529 adj
= &adjustments
[i
];
4531 if (adj
->base_index
== base_index
)
4543 /* Return adjustments that should have the same effect on function parameters
4544 and call arguments as if they were first changed according to adjustments in
4545 INNER and then by adjustments in OUTER. */
4547 ipa_parm_adjustment_vec
4548 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4549 ipa_parm_adjustment_vec outer
)
4551 int i
, outlen
= outer
.length ();
4552 int inlen
= inner
.length ();
4554 ipa_parm_adjustment_vec adjustments
, tmp
;
4557 for (i
= 0; i
< inlen
; i
++)
4559 struct ipa_parm_adjustment
*n
;
4562 if (n
->op
== IPA_PARM_OP_REMOVE
)
4566 /* FIXME: Handling of new arguments are not implemented yet. */
4567 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4568 tmp
.quick_push (*n
);
4572 adjustments
.create (outlen
+ removals
);
4573 for (i
= 0; i
< outlen
; i
++)
4575 struct ipa_parm_adjustment r
;
4576 struct ipa_parm_adjustment
*out
= &outer
[i
];
4577 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4579 memset (&r
, 0, sizeof (r
));
4580 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4581 if (out
->op
== IPA_PARM_OP_REMOVE
)
4583 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4585 r
.op
= IPA_PARM_OP_REMOVE
;
4586 adjustments
.quick_push (r
);
4592 /* FIXME: Handling of new arguments are not implemented yet. */
4593 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4596 r
.base_index
= in
->base_index
;
4599 /* FIXME: Create nonlocal value too. */
4601 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4602 r
.op
= IPA_PARM_OP_COPY
;
4603 else if (in
->op
== IPA_PARM_OP_COPY
)
4604 r
.offset
= out
->offset
;
4605 else if (out
->op
== IPA_PARM_OP_COPY
)
4606 r
.offset
= in
->offset
;
4608 r
.offset
= in
->offset
+ out
->offset
;
4609 adjustments
.quick_push (r
);
4612 for (i
= 0; i
< inlen
; i
++)
4614 struct ipa_parm_adjustment
*n
= &inner
[i
];
4616 if (n
->op
== IPA_PARM_OP_REMOVE
)
4617 adjustments
.quick_push (*n
);
4624 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4625 friendly way, assuming they are meant to be applied to FNDECL. */
4628 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4631 int i
, len
= adjustments
.length ();
4633 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4635 fprintf (file
, "IPA param adjustments: ");
4636 for (i
= 0; i
< len
; i
++)
4638 struct ipa_parm_adjustment
*adj
;
4639 adj
= &adjustments
[i
];
4642 fprintf (file
, " ");
4646 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4647 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4650 fprintf (file
, ", base: ");
4651 print_generic_expr (file
, adj
->base
, 0);
4655 fprintf (file
, ", new_decl: ");
4656 print_generic_expr (file
, adj
->new_decl
, 0);
4658 if (adj
->new_ssa_base
)
4660 fprintf (file
, ", new_ssa_base: ");
4661 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4664 if (adj
->op
== IPA_PARM_OP_COPY
)
4665 fprintf (file
, ", copy_param");
4666 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4667 fprintf (file
, ", remove_param");
4669 fprintf (file
, ", offset %li", (long) adj
->offset
);
4671 fprintf (file
, ", by_ref");
4672 print_node_brief (file
, ", type: ", adj
->type
, 0);
4673 fprintf (file
, "\n");
4678 /* Dump the AV linked list. */
4681 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4684 fprintf (f
, " Aggregate replacements:");
4685 for (; av
; av
= av
->next
)
4687 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4688 av
->index
, av
->offset
);
4689 print_generic_expr (f
, av
->value
, 0);
4695 /* Stream out jump function JUMP_FUNC to OB. */
4698 ipa_write_jump_function (struct output_block
*ob
,
4699 struct ipa_jump_func
*jump_func
)
4701 struct ipa_agg_jf_item
*item
;
4702 struct bitpack_d bp
;
4705 streamer_write_uhwi (ob
, jump_func
->type
);
4706 switch (jump_func
->type
)
4708 case IPA_JF_UNKNOWN
:
4712 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4713 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4715 case IPA_JF_PASS_THROUGH
:
4716 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4717 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4719 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4720 bp
= bitpack_create (ob
->main_stream
);
4721 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4722 streamer_write_bitpack (&bp
);
4724 else if (TREE_CODE_CLASS (jump_func
->value
.pass_through
.operation
)
4727 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4731 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4732 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4735 case IPA_JF_ANCESTOR
:
4736 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4737 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4738 bp
= bitpack_create (ob
->main_stream
);
4739 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4740 streamer_write_bitpack (&bp
);
4744 count
= vec_safe_length (jump_func
->agg
.items
);
4745 streamer_write_uhwi (ob
, count
);
4748 bp
= bitpack_create (ob
->main_stream
);
4749 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4750 streamer_write_bitpack (&bp
);
4753 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4755 streamer_write_uhwi (ob
, item
->offset
);
4756 stream_write_tree (ob
, item
->value
, true);
4759 bp
= bitpack_create (ob
->main_stream
);
4760 bp_pack_value (&bp
, jump_func
->bits
.known
, 1);
4761 streamer_write_bitpack (&bp
);
4762 if (jump_func
->bits
.known
)
4764 streamer_write_widest_int (ob
, jump_func
->bits
.value
);
4765 streamer_write_widest_int (ob
, jump_func
->bits
.mask
);
4767 bp_pack_value (&bp
, jump_func
->vr_known
, 1);
4768 streamer_write_bitpack (&bp
);
4769 if (jump_func
->vr_known
)
4771 streamer_write_enum (ob
->main_stream
, value_rang_type
,
4772 VR_LAST
, jump_func
->m_vr
.type
);
4773 stream_write_tree (ob
, jump_func
->m_vr
.min
, true);
4774 stream_write_tree (ob
, jump_func
->m_vr
.max
, true);
4778 /* Read in jump function JUMP_FUNC from IB. */
4781 ipa_read_jump_function (struct lto_input_block
*ib
,
4782 struct ipa_jump_func
*jump_func
,
4783 struct cgraph_edge
*cs
,
4784 struct data_in
*data_in
)
4786 enum jump_func_type jftype
;
4787 enum tree_code operation
;
4790 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4793 case IPA_JF_UNKNOWN
:
4794 ipa_set_jf_unknown (jump_func
);
4797 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4799 case IPA_JF_PASS_THROUGH
:
4800 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4801 if (operation
== NOP_EXPR
)
4803 int formal_id
= streamer_read_uhwi (ib
);
4804 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4805 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4806 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
);
4808 else if (TREE_CODE_CLASS (operation
) == tcc_unary
)
4810 int formal_id
= streamer_read_uhwi (ib
);
4811 ipa_set_jf_unary_pass_through (jump_func
, formal_id
, operation
);
4815 tree operand
= stream_read_tree (ib
, data_in
);
4816 int formal_id
= streamer_read_uhwi (ib
);
4817 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4821 case IPA_JF_ANCESTOR
:
4823 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4824 int formal_id
= streamer_read_uhwi (ib
);
4825 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4826 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4827 ipa_set_ancestor_jf (jump_func
, offset
, formal_id
, agg_preserved
);
4832 count
= streamer_read_uhwi (ib
);
4833 vec_alloc (jump_func
->agg
.items
, count
);
4836 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4837 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4839 for (i
= 0; i
< count
; i
++)
4841 struct ipa_agg_jf_item item
;
4842 item
.offset
= streamer_read_uhwi (ib
);
4843 item
.value
= stream_read_tree (ib
, data_in
);
4844 jump_func
->agg
.items
->quick_push (item
);
4847 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4848 bool bits_known
= bp_unpack_value (&bp
, 1);
4851 jump_func
->bits
.known
= true;
4852 jump_func
->bits
.value
= streamer_read_widest_int (ib
);
4853 jump_func
->bits
.mask
= streamer_read_widest_int (ib
);
4856 jump_func
->bits
.known
= false;
4858 struct bitpack_d vr_bp
= streamer_read_bitpack (ib
);
4859 bool vr_known
= bp_unpack_value (&vr_bp
, 1);
4862 jump_func
->vr_known
= true;
4863 jump_func
->m_vr
.type
= streamer_read_enum (ib
,
4866 jump_func
->m_vr
.min
= stream_read_tree (ib
, data_in
);
4867 jump_func
->m_vr
.max
= stream_read_tree (ib
, data_in
);
4870 jump_func
->vr_known
= false;
4873 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4874 relevant to indirect inlining to OB. */
4877 ipa_write_indirect_edge_info (struct output_block
*ob
,
4878 struct cgraph_edge
*cs
)
4880 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4881 struct bitpack_d bp
;
4883 streamer_write_hwi (ob
, ii
->param_index
);
4884 bp
= bitpack_create (ob
->main_stream
);
4885 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4886 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4887 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4888 bp_pack_value (&bp
, ii
->by_ref
, 1);
4889 bp_pack_value (&bp
, ii
->guaranteed_unmodified
, 1);
4890 bp_pack_value (&bp
, ii
->vptr_changed
, 1);
4891 streamer_write_bitpack (&bp
);
4892 if (ii
->agg_contents
|| ii
->polymorphic
)
4893 streamer_write_hwi (ob
, ii
->offset
);
4895 gcc_assert (ii
->offset
== 0);
4897 if (ii
->polymorphic
)
4899 streamer_write_hwi (ob
, ii
->otr_token
);
4900 stream_write_tree (ob
, ii
->otr_type
, true);
4901 ii
->context
.stream_out (ob
);
4905 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4906 relevant to indirect inlining from IB. */
4909 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4910 struct data_in
*data_in
,
4911 struct cgraph_edge
*cs
)
4913 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4914 struct bitpack_d bp
;
4916 ii
->param_index
= (int) streamer_read_hwi (ib
);
4917 bp
= streamer_read_bitpack (ib
);
4918 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4919 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4920 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4921 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4922 ii
->guaranteed_unmodified
= bp_unpack_value (&bp
, 1);
4923 ii
->vptr_changed
= bp_unpack_value (&bp
, 1);
4924 if (ii
->agg_contents
|| ii
->polymorphic
)
4925 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4928 if (ii
->polymorphic
)
4930 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4931 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4932 ii
->context
.stream_in (ib
, data_in
);
4936 /* Stream out NODE info to OB. */
4939 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4942 lto_symtab_encoder_t encoder
;
4943 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4945 struct cgraph_edge
*e
;
4946 struct bitpack_d bp
;
4948 encoder
= ob
->decl_state
->symtab_node_encoder
;
4949 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4950 streamer_write_uhwi (ob
, node_ref
);
4952 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4953 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4954 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4955 bp
= bitpack_create (ob
->main_stream
);
4956 gcc_assert (info
->analysis_done
4957 || ipa_get_param_count (info
) == 0);
4958 gcc_assert (!info
->node_enqueued
);
4959 gcc_assert (!info
->ipcp_orig_node
);
4960 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4961 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4962 streamer_write_bitpack (&bp
);
4963 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4964 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4965 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4967 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4969 streamer_write_uhwi (ob
,
4970 ipa_get_cs_argument_count (args
) * 2
4971 + (args
->polymorphic_call_contexts
!= NULL
));
4972 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4974 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4975 if (args
->polymorphic_call_contexts
!= NULL
)
4976 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4979 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4981 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4983 streamer_write_uhwi (ob
,
4984 ipa_get_cs_argument_count (args
) * 2
4985 + (args
->polymorphic_call_contexts
!= NULL
));
4986 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4988 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4989 if (args
->polymorphic_call_contexts
!= NULL
)
4990 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4992 ipa_write_indirect_edge_info (ob
, e
);
4996 /* Stream in NODE info from IB. */
4999 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
5000 struct data_in
*data_in
)
5002 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
5004 struct cgraph_edge
*e
;
5005 struct bitpack_d bp
;
5007 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
5009 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
5010 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
5012 bp
= streamer_read_bitpack (ib
);
5013 if (ipa_get_param_count (info
) != 0)
5014 info
->analysis_done
= true;
5015 info
->node_enqueued
= false;
5016 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
5017 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
5018 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
5019 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
5020 for (e
= node
->callees
; e
; e
= e
->next_callee
)
5022 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
5023 int count
= streamer_read_uhwi (ib
);
5024 bool contexts_computed
= count
& 1;
5029 vec_safe_grow_cleared (args
->jump_functions
, count
);
5030 if (contexts_computed
)
5031 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
5033 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
5035 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
5037 if (contexts_computed
)
5038 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
5041 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
5043 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
5044 int count
= streamer_read_uhwi (ib
);
5045 bool contexts_computed
= count
& 1;
5050 vec_safe_grow_cleared (args
->jump_functions
, count
);
5051 if (contexts_computed
)
5052 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
5053 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
5055 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
5057 if (contexts_computed
)
5058 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
5061 ipa_read_indirect_edge_info (ib
, data_in
, e
);
5065 /* Write jump functions for nodes in SET. */
5068 ipa_prop_write_jump_functions (void)
5070 struct cgraph_node
*node
;
5071 struct output_block
*ob
;
5072 unsigned int count
= 0;
5073 lto_symtab_encoder_iterator lsei
;
5074 lto_symtab_encoder_t encoder
;
5076 if (!ipa_node_params_sum
)
5079 ob
= create_output_block (LTO_section_jump_functions
);
5080 encoder
= ob
->decl_state
->symtab_node_encoder
;
5082 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5083 lsei_next_function_in_partition (&lsei
))
5085 node
= lsei_cgraph_node (lsei
);
5086 if (node
->has_gimple_body_p ()
5087 && IPA_NODE_REF (node
) != NULL
)
5091 streamer_write_uhwi (ob
, count
);
5093 /* Process all of the functions. */
5094 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5095 lsei_next_function_in_partition (&lsei
))
5097 node
= lsei_cgraph_node (lsei
);
5098 if (node
->has_gimple_body_p ()
5099 && IPA_NODE_REF (node
) != NULL
)
5100 ipa_write_node_info (ob
, node
);
5102 streamer_write_char_stream (ob
->main_stream
, 0);
5103 produce_asm (ob
, NULL
);
5104 destroy_output_block (ob
);
5107 /* Read section in file FILE_DATA of length LEN with data DATA. */
5110 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
5113 const struct lto_function_header
*header
=
5114 (const struct lto_function_header
*) data
;
5115 const int cfg_offset
= sizeof (struct lto_function_header
);
5116 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5117 const int string_offset
= main_offset
+ header
->main_size
;
5118 struct data_in
*data_in
;
5122 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5123 header
->main_size
, file_data
->mode_table
);
5126 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5127 header
->string_size
, vNULL
);
5128 count
= streamer_read_uhwi (&ib_main
);
5130 for (i
= 0; i
< count
; i
++)
5133 struct cgraph_node
*node
;
5134 lto_symtab_encoder_t encoder
;
5136 index
= streamer_read_uhwi (&ib_main
);
5137 encoder
= file_data
->symtab_node_encoder
;
5138 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5140 gcc_assert (node
->definition
);
5141 ipa_read_node_info (&ib_main
, node
, data_in
);
5143 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5145 lto_data_in_delete (data_in
);
5148 /* Read ipcp jump functions. */
5151 ipa_prop_read_jump_functions (void)
5153 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5154 struct lto_file_decl_data
*file_data
;
5157 ipa_check_create_node_params ();
5158 ipa_check_create_edge_args ();
5159 ipa_register_cgraph_hooks ();
5161 while ((file_data
= file_data_vec
[j
++]))
5164 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
5167 ipa_prop_read_section (file_data
, data
, len
);
5171 /* After merging units, we can get mismatch in argument counts.
5172 Also decl merging might've rendered parameter lists obsolete.
5173 Also compute called_with_variable_arg info. */
5176 ipa_update_after_lto_read (void)
5178 ipa_check_create_node_params ();
5179 ipa_check_create_edge_args ();
5183 write_ipcp_transformation_info (output_block
*ob
, cgraph_node
*node
)
5186 unsigned int count
= 0;
5187 lto_symtab_encoder_t encoder
;
5188 struct ipa_agg_replacement_value
*aggvals
, *av
;
5190 aggvals
= ipa_get_agg_replacements_for_node (node
);
5191 encoder
= ob
->decl_state
->symtab_node_encoder
;
5192 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
5193 streamer_write_uhwi (ob
, node_ref
);
5195 for (av
= aggvals
; av
; av
= av
->next
)
5197 streamer_write_uhwi (ob
, count
);
5199 for (av
= aggvals
; av
; av
= av
->next
)
5201 struct bitpack_d bp
;
5203 streamer_write_uhwi (ob
, av
->offset
);
5204 streamer_write_uhwi (ob
, av
->index
);
5205 stream_write_tree (ob
, av
->value
, true);
5207 bp
= bitpack_create (ob
->main_stream
);
5208 bp_pack_value (&bp
, av
->by_ref
, 1);
5209 streamer_write_bitpack (&bp
);
5212 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5213 if (ts
&& vec_safe_length (ts
->m_vr
) > 0)
5215 count
= ts
->m_vr
->length ();
5216 streamer_write_uhwi (ob
, count
);
5217 for (unsigned i
= 0; i
< count
; ++i
)
5219 struct bitpack_d bp
;
5220 ipa_vr
*parm_vr
= &(*ts
->m_vr
)[i
];
5221 bp
= bitpack_create (ob
->main_stream
);
5222 bp_pack_value (&bp
, parm_vr
->known
, 1);
5223 streamer_write_bitpack (&bp
);
5226 streamer_write_enum (ob
->main_stream
, value_rang_type
,
5227 VR_LAST
, parm_vr
->type
);
5228 streamer_write_wide_int (ob
, parm_vr
->min
);
5229 streamer_write_wide_int (ob
, parm_vr
->max
);
5234 streamer_write_uhwi (ob
, 0);
5236 if (ts
&& vec_safe_length (ts
->bits
) > 0)
5238 count
= ts
->bits
->length ();
5239 streamer_write_uhwi (ob
, count
);
5241 for (unsigned i
= 0; i
< count
; ++i
)
5243 const ipa_bits
& bits_jfunc
= (*ts
->bits
)[i
];
5244 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
5245 bp_pack_value (&bp
, bits_jfunc
.known
, 1);
5246 streamer_write_bitpack (&bp
);
5247 if (bits_jfunc
.known
)
5249 streamer_write_widest_int (ob
, bits_jfunc
.value
);
5250 streamer_write_widest_int (ob
, bits_jfunc
.mask
);
5255 streamer_write_uhwi (ob
, 0);
5258 /* Stream in the aggregate value replacement chain for NODE from IB. */
5261 read_ipcp_transformation_info (lto_input_block
*ib
, cgraph_node
*node
,
5264 struct ipa_agg_replacement_value
*aggvals
= NULL
;
5265 unsigned int count
, i
;
5267 count
= streamer_read_uhwi (ib
);
5268 for (i
= 0; i
<count
; i
++)
5270 struct ipa_agg_replacement_value
*av
;
5271 struct bitpack_d bp
;
5273 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
5274 av
->offset
= streamer_read_uhwi (ib
);
5275 av
->index
= streamer_read_uhwi (ib
);
5276 av
->value
= stream_read_tree (ib
, data_in
);
5277 bp
= streamer_read_bitpack (ib
);
5278 av
->by_ref
= bp_unpack_value (&bp
, 1);
5282 ipa_set_node_agg_value_chain (node
, aggvals
);
5284 count
= streamer_read_uhwi (ib
);
5287 ipcp_grow_transformations_if_necessary ();
5289 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5290 vec_safe_grow_cleared (ts
->m_vr
, count
);
5291 for (i
= 0; i
< count
; i
++)
5294 parm_vr
= &(*ts
->m_vr
)[i
];
5295 struct bitpack_d bp
;
5296 bp
= streamer_read_bitpack (ib
);
5297 parm_vr
->known
= bp_unpack_value (&bp
, 1);
5300 parm_vr
->type
= streamer_read_enum (ib
, value_range_type
,
5302 parm_vr
->min
= streamer_read_wide_int (ib
);
5303 parm_vr
->max
= streamer_read_wide_int (ib
);
5307 count
= streamer_read_uhwi (ib
);
5310 ipcp_grow_transformations_if_necessary ();
5312 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5313 vec_safe_grow_cleared (ts
->bits
, count
);
5315 for (i
= 0; i
< count
; i
++)
5317 ipa_bits
& bits_jfunc
= (*ts
->bits
)[i
];
5318 struct bitpack_d bp
= streamer_read_bitpack (ib
);
5319 bits_jfunc
.known
= bp_unpack_value (&bp
, 1);
5320 if (bits_jfunc
.known
)
5322 bits_jfunc
.value
= streamer_read_widest_int (ib
);
5323 bits_jfunc
.mask
= streamer_read_widest_int (ib
);
5329 /* Write all aggregate replacement for nodes in set. */
5332 ipcp_write_transformation_summaries (void)
5334 struct cgraph_node
*node
;
5335 struct output_block
*ob
;
5336 unsigned int count
= 0;
5337 lto_symtab_encoder_iterator lsei
;
5338 lto_symtab_encoder_t encoder
;
5340 ob
= create_output_block (LTO_section_ipcp_transform
);
5341 encoder
= ob
->decl_state
->symtab_node_encoder
;
5343 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5344 lsei_next_function_in_partition (&lsei
))
5346 node
= lsei_cgraph_node (lsei
);
5347 if (node
->has_gimple_body_p ())
5351 streamer_write_uhwi (ob
, count
);
5353 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5354 lsei_next_function_in_partition (&lsei
))
5356 node
= lsei_cgraph_node (lsei
);
5357 if (node
->has_gimple_body_p ())
5358 write_ipcp_transformation_info (ob
, node
);
5360 streamer_write_char_stream (ob
->main_stream
, 0);
5361 produce_asm (ob
, NULL
);
5362 destroy_output_block (ob
);
5365 /* Read replacements section in file FILE_DATA of length LEN with data
5369 read_replacements_section (struct lto_file_decl_data
*file_data
,
5373 const struct lto_function_header
*header
=
5374 (const struct lto_function_header
*) data
;
5375 const int cfg_offset
= sizeof (struct lto_function_header
);
5376 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5377 const int string_offset
= main_offset
+ header
->main_size
;
5378 struct data_in
*data_in
;
5382 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5383 header
->main_size
, file_data
->mode_table
);
5385 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5386 header
->string_size
, vNULL
);
5387 count
= streamer_read_uhwi (&ib_main
);
5389 for (i
= 0; i
< count
; i
++)
5392 struct cgraph_node
*node
;
5393 lto_symtab_encoder_t encoder
;
5395 index
= streamer_read_uhwi (&ib_main
);
5396 encoder
= file_data
->symtab_node_encoder
;
5397 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5399 gcc_assert (node
->definition
);
5400 read_ipcp_transformation_info (&ib_main
, node
, data_in
);
5402 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5404 lto_data_in_delete (data_in
);
5407 /* Read IPA-CP aggregate replacements. */
5410 ipcp_read_transformation_summaries (void)
5412 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5413 struct lto_file_decl_data
*file_data
;
5416 while ((file_data
= file_data_vec
[j
++]))
5419 const char *data
= lto_get_section_data (file_data
,
5420 LTO_section_ipcp_transform
,
5423 read_replacements_section (file_data
, data
, len
);
5427 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5431 adjust_agg_replacement_values (struct cgraph_node
*node
,
5432 struct ipa_agg_replacement_value
*aggval
)
5434 struct ipa_agg_replacement_value
*v
;
5435 int i
, c
= 0, d
= 0, *adj
;
5437 if (!node
->clone
.combined_args_to_skip
)
5440 for (v
= aggval
; v
; v
= v
->next
)
5442 gcc_assert (v
->index
>= 0);
5448 adj
= XALLOCAVEC (int, c
);
5449 for (i
= 0; i
< c
; i
++)
5450 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5458 for (v
= aggval
; v
; v
= v
->next
)
5459 v
->index
= adj
[v
->index
];
5462 /* Dominator walker driving the ipcp modification phase. */
5464 class ipcp_modif_dom_walker
: public dom_walker
5467 ipcp_modif_dom_walker (struct ipa_func_body_info
*fbi
,
5468 vec
<ipa_param_descriptor
> descs
,
5469 struct ipa_agg_replacement_value
*av
,
5471 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5472 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5474 virtual edge
before_dom_children (basic_block
);
5477 struct ipa_func_body_info
*m_fbi
;
5478 vec
<ipa_param_descriptor
> m_descriptors
;
5479 struct ipa_agg_replacement_value
*m_aggval
;
5480 bool *m_something_changed
, *m_cfg_changed
;
5484 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5486 gimple_stmt_iterator gsi
;
5487 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5489 struct ipa_agg_replacement_value
*v
;
5490 gimple
*stmt
= gsi_stmt (gsi
);
5492 HOST_WIDE_INT offset
, size
;
5496 if (!gimple_assign_load_p (stmt
))
5498 rhs
= gimple_assign_rhs1 (stmt
);
5499 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5504 while (handled_component_p (t
))
5506 /* V_C_E can do things like convert an array of integers to one
5507 bigger integer and similar things we do not handle below. */
5508 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
5513 t
= TREE_OPERAND (t
, 0);
5518 if (!ipa_load_from_parm_agg (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5519 &offset
, &size
, &by_ref
))
5521 for (v
= m_aggval
; v
; v
= v
->next
)
5522 if (v
->index
== index
5523 && v
->offset
== offset
)
5526 || v
->by_ref
!= by_ref
5527 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
5530 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5531 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5533 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5534 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5535 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5536 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5537 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5542 fprintf (dump_file
, " const ");
5543 print_generic_expr (dump_file
, v
->value
, 0);
5544 fprintf (dump_file
, " can't be converted to type of ");
5545 print_generic_expr (dump_file
, rhs
, 0);
5546 fprintf (dump_file
, "\n");
5554 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5556 fprintf (dump_file
, "Modifying stmt:\n ");
5557 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5559 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5562 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5564 fprintf (dump_file
, "into:\n ");
5565 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5566 fprintf (dump_file
, "\n");
5569 *m_something_changed
= true;
5570 if (maybe_clean_eh_stmt (stmt
)
5571 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5572 *m_cfg_changed
= true;
5577 /* Update bits info of formal parameters as described in
5578 ipcp_transformation_summary. */
5581 ipcp_update_bits (struct cgraph_node
*node
)
5583 tree parm
= DECL_ARGUMENTS (node
->decl
);
5584 tree next_parm
= parm
;
5585 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5587 if (!ts
|| vec_safe_length (ts
->bits
) == 0)
5590 vec
<ipa_bits
, va_gc
> &bits
= *ts
->bits
;
5591 unsigned count
= bits
.length ();
5593 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5595 if (node
->clone
.combined_args_to_skip
5596 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5599 gcc_checking_assert (parm
);
5600 next_parm
= DECL_CHAIN (parm
);
5603 || !(INTEGRAL_TYPE_P (TREE_TYPE (parm
)) || POINTER_TYPE_P (TREE_TYPE (parm
)))
5604 || !is_gimple_reg (parm
))
5607 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5613 fprintf (dump_file
, "Adjusting mask for param %u to ", i
);
5614 print_hex (bits
[i
].mask
, dump_file
);
5615 fprintf (dump_file
, "\n");
5618 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5620 unsigned prec
= TYPE_PRECISION (TREE_TYPE (ddef
));
5621 signop sgn
= TYPE_SIGN (TREE_TYPE (ddef
));
5623 wide_int nonzero_bits
= wide_int::from (bits
[i
].mask
, prec
, UNSIGNED
)
5624 | wide_int::from (bits
[i
].value
, prec
, sgn
);
5625 set_nonzero_bits (ddef
, nonzero_bits
);
5629 unsigned tem
= bits
[i
].mask
.to_uhwi ();
5630 unsigned HOST_WIDE_INT bitpos
= bits
[i
].value
.to_uhwi ();
5631 unsigned align
= tem
& -tem
;
5632 unsigned misalign
= bitpos
& (align
- 1);
5637 fprintf (dump_file
, "Adjusting align: %u, misalign: %u\n", align
, misalign
);
5639 unsigned old_align
, old_misalign
;
5640 struct ptr_info_def
*pi
= get_ptr_info (ddef
);
5641 bool old_known
= get_ptr_info_alignment (pi
, &old_align
, &old_misalign
);
5644 && old_align
> align
)
5648 fprintf (dump_file
, "But alignment was already %u.\n", old_align
);
5649 if ((old_misalign
& (align
- 1)) != misalign
)
5650 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5651 old_misalign
, misalign
);
5657 && ((misalign
& (old_align
- 1)) != old_misalign
)
5659 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5660 old_misalign
, misalign
);
5662 set_ptr_info_alignment (pi
, align
, misalign
);
5668 /* Update value range of formal parameters as described in
5669 ipcp_transformation_summary. */
5672 ipcp_update_vr (struct cgraph_node
*node
)
5674 tree fndecl
= node
->decl
;
5675 tree parm
= DECL_ARGUMENTS (fndecl
);
5676 tree next_parm
= parm
;
5677 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5678 if (!ts
|| vec_safe_length (ts
->m_vr
) == 0)
5680 const vec
<ipa_vr
, va_gc
> &vr
= *ts
->m_vr
;
5681 unsigned count
= vr
.length ();
5683 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5685 if (node
->clone
.combined_args_to_skip
5686 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5688 gcc_checking_assert (parm
);
5689 next_parm
= DECL_CHAIN (parm
);
5690 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5692 if (!ddef
|| !is_gimple_reg (parm
))
5696 && (vr
[i
].type
== VR_RANGE
|| vr
[i
].type
== VR_ANTI_RANGE
))
5698 tree type
= TREE_TYPE (ddef
);
5699 unsigned prec
= TYPE_PRECISION (type
);
5700 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5704 fprintf (dump_file
, "Setting value range of param %u ", i
);
5705 fprintf (dump_file
, "%s[",
5706 (vr
[i
].type
== VR_ANTI_RANGE
) ? "~" : "");
5707 print_decs (vr
[i
].min
, dump_file
);
5708 fprintf (dump_file
, ", ");
5709 print_decs (vr
[i
].max
, dump_file
);
5710 fprintf (dump_file
, "]\n");
5712 set_range_info (ddef
, vr
[i
].type
,
5713 wide_int_storage::from (vr
[i
].min
, prec
,
5715 wide_int_storage::from (vr
[i
].max
, prec
,
5718 else if (POINTER_TYPE_P (TREE_TYPE (ddef
))
5719 && vr
[i
].type
== VR_ANTI_RANGE
5720 && wi::eq_p (vr
[i
].min
, 0)
5721 && wi::eq_p (vr
[i
].max
, 0))
5724 fprintf (dump_file
, "Setting nonnull for %u\n", i
);
5725 set_ptr_nonnull (ddef
);
5731 /* IPCP transformation phase doing propagation of aggregate values. */
5734 ipcp_transform_function (struct cgraph_node
*node
)
5736 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
5737 struct ipa_func_body_info fbi
;
5738 struct ipa_agg_replacement_value
*aggval
;
5740 bool cfg_changed
= false, something_changed
= false;
5742 gcc_checking_assert (cfun
);
5743 gcc_checking_assert (current_function_decl
);
5746 fprintf (dump_file
, "Modification phase of node %s/%i\n",
5747 node
->name (), node
->order
);
5749 ipcp_update_bits (node
);
5750 ipcp_update_vr (node
);
5751 aggval
= ipa_get_agg_replacements_for_node (node
);
5754 param_count
= count_formal_params (node
->decl
);
5755 if (param_count
== 0)
5757 adjust_agg_replacement_values (node
, aggval
);
5759 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5763 fbi
.bb_infos
= vNULL
;
5764 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5765 fbi
.param_count
= param_count
;
5768 descriptors
.safe_grow_cleared (param_count
);
5769 ipa_populate_param_decls (node
, descriptors
);
5770 calculate_dominance_info (CDI_DOMINATORS
);
5771 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5772 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5775 struct ipa_bb_info
*bi
;
5776 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5777 free_ipa_bb_info (bi
);
5778 fbi
.bb_infos
.release ();
5779 free_dominance_info (CDI_DOMINATORS
);
5780 (*ipcp_transformations
)[node
->uid
].agg_values
= NULL
;
5781 (*ipcp_transformations
)[node
->uid
].bits
= NULL
;
5782 (*ipcp_transformations
)[node
->uid
].m_vr
= NULL
;
5784 descriptors
.release ();
5786 if (!something_changed
)
5788 else if (cfg_changed
)
5789 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5791 return TODO_update_ssa_only_virtuals
;