1 /* Interprocedural analyses.
2 Copyright (C) 2005-2019 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-fnsummary.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
;
59 function_summary
<ipcp_transformation
*> *ipcp_transformation_sum
= NULL
;
61 /* Edge summary for IPA-CP edge information. */
62 ipa_edge_args_sum_t
*ipa_edge_args_sum
;
64 /* Traits for a hash table for reusing already existing ipa_bits. */
66 struct ipa_bit_ggc_hash_traits
: public ggc_cache_remove
<ipa_bits
*>
68 typedef ipa_bits
*value_type
;
69 typedef ipa_bits
*compare_type
;
71 hash (const ipa_bits
*p
)
73 hashval_t t
= (hashval_t
) p
->value
.to_shwi ();
74 return iterative_hash_host_wide_int (p
->mask
.to_shwi (), t
);
77 equal (const ipa_bits
*a
, const ipa_bits
*b
)
79 return a
->value
== b
->value
&& a
->mask
== b
->mask
;
82 mark_empty (ipa_bits
*&p
)
87 is_empty (const ipa_bits
*p
)
92 is_deleted (const ipa_bits
*p
)
94 return p
== reinterpret_cast<const ipa_bits
*> (1);
97 mark_deleted (ipa_bits
*&p
)
99 p
= reinterpret_cast<ipa_bits
*> (1);
103 /* Hash table for avoid repeated allocations of equal ipa_bits. */
104 static GTY ((cache
)) hash_table
<ipa_bit_ggc_hash_traits
> *ipa_bits_hash_table
;
106 /* Traits for a hash table for reusing value_ranges used for IPA. Note that
107 the equiv bitmap is not hashed and is expected to be NULL. */
109 struct ipa_vr_ggc_hash_traits
: public ggc_cache_remove
<value_range_base
*>
111 typedef value_range_base
*value_type
;
112 typedef value_range_base
*compare_type
;
114 hash (const value_range_base
*p
)
116 inchash::hash
hstate (p
->kind ());
117 inchash::add_expr (p
->min (), hstate
);
118 inchash::add_expr (p
->max (), hstate
);
119 return hstate
.end ();
122 equal (const value_range_base
*a
, const value_range_base
*b
)
124 return a
->equal_p (*b
);
127 mark_empty (value_range_base
*&p
)
132 is_empty (const value_range_base
*p
)
137 is_deleted (const value_range_base
*p
)
139 return p
== reinterpret_cast<const value_range_base
*> (1);
142 mark_deleted (value_range_base
*&p
)
144 p
= reinterpret_cast<value_range_base
*> (1);
148 /* Hash table for avoid repeated allocations of equal value_ranges. */
149 static GTY ((cache
)) hash_table
<ipa_vr_ggc_hash_traits
> *ipa_vr_hash_table
;
151 /* Holders of ipa cgraph hooks: */
152 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
154 /* Description of a reference to an IPA constant. */
155 struct ipa_cst_ref_desc
157 /* Edge that corresponds to the statement which took the reference. */
158 struct cgraph_edge
*cs
;
159 /* Linked list of duplicates created when call graph edges are cloned. */
160 struct ipa_cst_ref_desc
*next_duplicate
;
161 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
162 if out of control. */
166 /* Allocation pool for reference descriptions. */
168 static object_allocator
<ipa_cst_ref_desc
> ipa_refdesc_pool
169 ("IPA-PROP ref descriptions");
171 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
172 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
175 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
177 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
181 return !opt_for_fn (node
->decl
, optimize
) || !opt_for_fn (node
->decl
, flag_ipa_cp
);
184 /* Return index of the formal whose tree is PTREE in function which corresponds
188 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
, va_gc
> *descriptors
,
193 count
= vec_safe_length (descriptors
);
194 for (i
= 0; i
< count
; i
++)
195 if ((*descriptors
)[i
].decl_or_type
== ptree
)
201 /* Return index of the formal whose tree is PTREE in function which corresponds
205 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
207 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
210 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
214 ipa_populate_param_decls (struct cgraph_node
*node
,
215 vec
<ipa_param_descriptor
, va_gc
> &descriptors
)
223 gcc_assert (gimple_has_body_p (fndecl
));
224 fnargs
= DECL_ARGUMENTS (fndecl
);
226 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
228 descriptors
[param_num
].decl_or_type
= parm
;
229 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
),
235 /* Return how many formal parameters FNDECL has. */
238 count_formal_params (tree fndecl
)
242 gcc_assert (gimple_has_body_p (fndecl
));
244 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
250 /* Return the declaration of Ith formal parameter of the function corresponding
251 to INFO. Note there is no setter function as this array is built just once
252 using ipa_initialize_node_params. */
255 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
257 fprintf (file
, "param #%i", i
);
258 if ((*info
->descriptors
)[i
].decl_or_type
)
261 print_generic_expr (file
, (*info
->descriptors
)[i
].decl_or_type
);
265 /* If necessary, allocate vector of parameter descriptors in info of NODE.
266 Return true if they were allocated, false if not. */
269 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
271 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
273 if (!info
->descriptors
&& param_count
)
275 vec_safe_grow_cleared (info
->descriptors
, param_count
);
282 /* Initialize the ipa_node_params structure associated with NODE by counting
283 the function parameters, creating the descriptors and populating their
287 ipa_initialize_node_params (struct cgraph_node
*node
)
289 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
291 if (!info
->descriptors
292 && ipa_alloc_node_params (node
, count_formal_params (node
->decl
)))
293 ipa_populate_param_decls (node
, *info
->descriptors
);
296 /* Print the jump functions associated with call graph edge CS to file F. */
299 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
303 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
304 for (i
= 0; i
< count
; i
++)
306 struct ipa_jump_func
*jump_func
;
307 enum jump_func_type type
;
309 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
310 type
= jump_func
->type
;
312 fprintf (f
, " param %d: ", i
);
313 if (type
== IPA_JF_UNKNOWN
)
314 fprintf (f
, "UNKNOWN\n");
315 else if (type
== IPA_JF_CONST
)
317 tree val
= jump_func
->value
.constant
.value
;
318 fprintf (f
, "CONST: ");
319 print_generic_expr (f
, val
);
320 if (TREE_CODE (val
) == ADDR_EXPR
321 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
324 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)));
328 else if (type
== IPA_JF_PASS_THROUGH
)
330 fprintf (f
, "PASS THROUGH: ");
331 fprintf (f
, "%d, op %s",
332 jump_func
->value
.pass_through
.formal_id
,
333 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
334 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
337 print_generic_expr (f
, jump_func
->value
.pass_through
.operand
);
339 if (jump_func
->value
.pass_through
.agg_preserved
)
340 fprintf (f
, ", agg_preserved");
343 else if (type
== IPA_JF_ANCESTOR
)
345 fprintf (f
, "ANCESTOR: ");
346 fprintf (f
, "%d, offset " HOST_WIDE_INT_PRINT_DEC
,
347 jump_func
->value
.ancestor
.formal_id
,
348 jump_func
->value
.ancestor
.offset
);
349 if (jump_func
->value
.ancestor
.agg_preserved
)
350 fprintf (f
, ", agg_preserved");
354 if (jump_func
->agg
.items
)
356 struct ipa_agg_jf_item
*item
;
359 fprintf (f
, " Aggregate passed by %s:\n",
360 jump_func
->agg
.by_ref
? "reference" : "value");
361 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
363 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
365 if (TYPE_P (item
->value
))
366 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
367 tree_to_uhwi (TYPE_SIZE (item
->value
)));
370 fprintf (f
, "cst: ");
371 print_generic_expr (f
, item
->value
);
377 struct ipa_polymorphic_call_context
*ctx
378 = ipa_get_ith_polymorhic_call_context (IPA_EDGE_REF (cs
), i
);
379 if (ctx
&& !ctx
->useless_p ())
381 fprintf (f
, " Context: ");
382 ctx
->dump (dump_file
);
387 fprintf (f
, " value: ");
388 print_hex (jump_func
->bits
->value
, f
);
389 fprintf (f
, ", mask: ");
390 print_hex (jump_func
->bits
->mask
, f
);
394 fprintf (f
, " Unknown bits\n");
400 (jump_func
->m_vr
->kind () == VR_ANTI_RANGE
) ? "~" : "");
401 print_decs (wi::to_wide (jump_func
->m_vr
->min ()), f
);
403 print_decs (wi::to_wide (jump_func
->m_vr
->max ()), f
);
407 fprintf (f
, " Unknown VR\n");
412 /* Print the jump functions of all arguments on all call graph edges going from
416 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
418 struct cgraph_edge
*cs
;
420 fprintf (f
, " Jump functions of caller %s:\n", node
->dump_name ());
421 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
423 if (!ipa_edge_args_info_available_for_edge_p (cs
))
426 fprintf (f
, " callsite %s -> %s : \n",
428 cs
->callee
->dump_name ());
429 ipa_print_node_jump_functions_for_edge (f
, cs
);
432 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
434 struct cgraph_indirect_call_info
*ii
;
435 if (!ipa_edge_args_info_available_for_edge_p (cs
))
438 ii
= cs
->indirect_info
;
439 if (ii
->agg_contents
)
440 fprintf (f
, " indirect %s callsite, calling param %i, "
441 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
442 ii
->member_ptr
? "member ptr" : "aggregate",
443 ii
->param_index
, ii
->offset
,
444 ii
->by_ref
? "by reference" : "by_value");
446 fprintf (f
, " indirect %s callsite, calling param %i, "
447 "offset " HOST_WIDE_INT_PRINT_DEC
,
448 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
453 fprintf (f
, ", for stmt ");
454 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
459 ii
->context
.dump (f
);
460 ipa_print_node_jump_functions_for_edge (f
, cs
);
464 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
467 ipa_print_all_jump_functions (FILE *f
)
469 struct cgraph_node
*node
;
471 fprintf (f
, "\nJump functions:\n");
472 FOR_EACH_FUNCTION (node
)
474 ipa_print_node_jump_functions (f
, node
);
478 /* Set jfunc to be a know-really nothing jump function. */
481 ipa_set_jf_unknown (struct ipa_jump_func
*jfunc
)
483 jfunc
->type
= IPA_JF_UNKNOWN
;
488 /* Set JFUNC to be a copy of another jmp (to be used by jump function
489 combination code). The two functions will share their rdesc. */
492 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
493 struct ipa_jump_func
*src
)
496 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
497 dst
->type
= IPA_JF_CONST
;
498 dst
->value
.constant
= src
->value
.constant
;
501 /* Set JFUNC to be a constant jmp function. */
504 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
505 struct cgraph_edge
*cs
)
507 jfunc
->type
= IPA_JF_CONST
;
508 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
510 if (TREE_CODE (constant
) == ADDR_EXPR
511 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
513 struct ipa_cst_ref_desc
*rdesc
;
515 rdesc
= ipa_refdesc_pool
.allocate ();
517 rdesc
->next_duplicate
= NULL
;
519 jfunc
->value
.constant
.rdesc
= rdesc
;
522 jfunc
->value
.constant
.rdesc
= NULL
;
525 /* Set JFUNC to be a simple pass-through jump function. */
527 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
530 jfunc
->type
= IPA_JF_PASS_THROUGH
;
531 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
532 jfunc
->value
.pass_through
.formal_id
= formal_id
;
533 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
534 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
537 /* Set JFUNC to be an unary pass through jump function. */
540 ipa_set_jf_unary_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
541 enum tree_code operation
)
543 jfunc
->type
= IPA_JF_PASS_THROUGH
;
544 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
545 jfunc
->value
.pass_through
.formal_id
= formal_id
;
546 jfunc
->value
.pass_through
.operation
= operation
;
547 jfunc
->value
.pass_through
.agg_preserved
= false;
549 /* Set JFUNC to be an arithmetic pass through jump function. */
552 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
553 tree operand
, enum tree_code operation
)
555 jfunc
->type
= IPA_JF_PASS_THROUGH
;
556 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
557 jfunc
->value
.pass_through
.formal_id
= formal_id
;
558 jfunc
->value
.pass_through
.operation
= operation
;
559 jfunc
->value
.pass_through
.agg_preserved
= false;
562 /* Set JFUNC to be an ancestor jump function. */
565 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
566 int formal_id
, bool agg_preserved
)
568 jfunc
->type
= IPA_JF_ANCESTOR
;
569 jfunc
->value
.ancestor
.formal_id
= formal_id
;
570 jfunc
->value
.ancestor
.offset
= offset
;
571 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
574 /* Get IPA BB information about the given BB. FBI is the context of analyzis
575 of this function body. */
577 static struct ipa_bb_info
*
578 ipa_get_bb_info (struct ipa_func_body_info
*fbi
, basic_block bb
)
580 gcc_checking_assert (fbi
);
581 return &fbi
->bb_infos
[bb
->index
];
584 /* Structure to be passed in between detect_type_change and
585 check_stmt_for_type_change. */
587 struct prop_type_change_info
589 /* Offset into the object where there is the virtual method pointer we are
591 HOST_WIDE_INT offset
;
592 /* The declaration or SSA_NAME pointer of the base that we are checking for
595 /* Set to true if dynamic type change has been detected. */
596 bool type_maybe_changed
;
599 /* Return true if STMT can modify a virtual method table pointer.
601 This function makes special assumptions about both constructors and
602 destructors which are all the functions that are allowed to alter the VMT
603 pointers. It assumes that destructors begin with assignment into all VMT
604 pointers and that constructors essentially look in the following way:
606 1) The very first thing they do is that they call constructors of ancestor
607 sub-objects that have them.
609 2) Then VMT pointers of this and all its ancestors is set to new values
610 corresponding to the type corresponding to the constructor.
612 3) Only afterwards, other stuff such as constructor of member sub-objects
613 and the code written by the user is run. Only this may include calling
614 virtual functions, directly or indirectly.
616 There is no way to call a constructor of an ancestor sub-object in any
619 This means that we do not have to care whether constructors get the correct
620 type information because they will always change it (in fact, if we define
621 the type to be given by the VMT pointer, it is undefined).
623 The most important fact to derive from the above is that if, for some
624 statement in the section 3, we try to detect whether the dynamic type has
625 changed, we can safely ignore all calls as we examine the function body
626 backwards until we reach statements in section 2 because these calls cannot
627 be ancestor constructors or destructors (if the input is not bogus) and so
628 do not change the dynamic type (this holds true only for automatically
629 allocated objects but at the moment we devirtualize only these). We then
630 must detect that statements in section 2 change the dynamic type and can try
631 to derive the new type. That is enough and we can stop, we will never see
632 the calls into constructors of sub-objects in this code. Therefore we can
633 safely ignore all call statements that we traverse.
637 stmt_may_be_vtbl_ptr_store (gimple
*stmt
)
639 if (is_gimple_call (stmt
))
641 if (gimple_clobber_p (stmt
))
643 else if (is_gimple_assign (stmt
))
645 tree lhs
= gimple_assign_lhs (stmt
);
647 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
649 if (flag_strict_aliasing
650 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
653 if (TREE_CODE (lhs
) == COMPONENT_REF
654 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
656 /* In the future we might want to use get_ref_base_and_extent to find
657 if there is a field corresponding to the offset and if so, proceed
658 almost like if it was a component ref. */
664 /* Callback of walk_aliased_vdefs and a helper function for detect_type_change
665 to check whether a particular statement may modify the virtual table
666 pointerIt stores its result into DATA, which points to a
667 prop_type_change_info structure. */
670 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
672 gimple
*stmt
= SSA_NAME_DEF_STMT (vdef
);
673 struct prop_type_change_info
*tci
= (struct prop_type_change_info
*) data
;
675 if (stmt_may_be_vtbl_ptr_store (stmt
))
677 tci
->type_maybe_changed
= true;
684 /* See if ARG is PARAM_DECl describing instance passed by pointer
685 or reference in FUNCTION. Return false if the dynamic type may change
686 in between beggining of the function until CALL is invoked.
688 Generally functions are not allowed to change type of such instances,
689 but they call destructors. We assume that methods can not destroy the THIS
690 pointer. Also as a special cases, constructor and destructors may change
691 type of the THIS pointer. */
694 param_type_may_change_p (tree function
, tree arg
, gimple
*call
)
696 /* Pure functions can not do any changes on the dynamic type;
697 that require writting to memory. */
698 if (flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
700 /* We need to check if we are within inlined consturctor
701 or destructor (ideally we would have way to check that the
702 inline cdtor is actually working on ARG, but we don't have
703 easy tie on this, so punt on all non-pure cdtors.
704 We may also record the types of cdtors and once we know type
705 of the instance match them.
707 Also code unification optimizations may merge calls from
708 different blocks making return values unreliable. So
709 do nothing during late optimization. */
710 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
712 if (TREE_CODE (arg
) == SSA_NAME
713 && SSA_NAME_IS_DEFAULT_DEF (arg
)
714 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
)
716 /* Normal (non-THIS) argument. */
717 if ((SSA_NAME_VAR (arg
) != DECL_ARGUMENTS (function
)
718 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
)
719 /* THIS pointer of an method - here we want to watch constructors
720 and destructors as those definitely may change the dynamic
722 || (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
723 && !DECL_CXX_CONSTRUCTOR_P (function
)
724 && !DECL_CXX_DESTRUCTOR_P (function
)
725 && (SSA_NAME_VAR (arg
) == DECL_ARGUMENTS (function
))))
727 /* Walk the inline stack and watch out for ctors/dtors. */
728 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
729 block
= BLOCK_SUPERCONTEXT (block
))
730 if (inlined_polymorphic_ctor_dtor_block_p (block
, false))
738 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
739 callsite CALL) by looking for assignments to its virtual table pointer. If
740 it is, return true and fill in the jump function JFUNC with relevant type
741 information or set it to unknown. ARG is the object itself (not a pointer
742 to it, unless dereferenced). BASE is the base of the memory access as
743 returned by get_ref_base_and_extent, as is the offset.
745 This is helper function for detect_type_change and detect_type_change_ssa
746 that does the heavy work which is usually unnecesary. */
749 detect_type_change_from_memory_writes (tree arg
, tree base
, tree comp_type
,
750 gcall
*call
, struct ipa_jump_func
*jfunc
,
751 HOST_WIDE_INT offset
)
753 struct prop_type_change_info tci
;
755 bool entry_reached
= false;
757 gcc_checking_assert (DECL_P (arg
)
758 || TREE_CODE (arg
) == MEM_REF
759 || handled_component_p (arg
));
761 comp_type
= TYPE_MAIN_VARIANT (comp_type
);
763 /* Const calls cannot call virtual methods through VMT and so type changes do
765 if (!flag_devirtualize
|| !gimple_vuse (call
)
766 /* Be sure expected_type is polymorphic. */
768 || TREE_CODE (comp_type
) != RECORD_TYPE
769 || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))
770 || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))))
773 ao_ref_init (&ao
, arg
);
776 ao
.size
= POINTER_SIZE
;
777 ao
.max_size
= ao
.size
;
780 tci
.object
= get_base_address (arg
);
781 tci
.type_maybe_changed
= false;
783 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
784 &tci
, NULL
, &entry_reached
);
785 if (!tci
.type_maybe_changed
)
788 ipa_set_jf_unknown (jfunc
);
792 /* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
793 If it is, return true and fill in the jump function JFUNC with relevant type
794 information or set it to unknown. ARG is the object itself (not a pointer
795 to it, unless dereferenced). BASE is the base of the memory access as
796 returned by get_ref_base_and_extent, as is the offset. */
799 detect_type_change (tree arg
, tree base
, tree comp_type
, gcall
*call
,
800 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
802 if (!flag_devirtualize
)
805 if (TREE_CODE (base
) == MEM_REF
806 && !param_type_may_change_p (current_function_decl
,
807 TREE_OPERAND (base
, 0),
810 return detect_type_change_from_memory_writes (arg
, base
, comp_type
,
811 call
, jfunc
, offset
);
814 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
815 SSA name (its dereference will become the base and the offset is assumed to
819 detect_type_change_ssa (tree arg
, tree comp_type
,
820 gcall
*call
, struct ipa_jump_func
*jfunc
)
822 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
823 if (!flag_devirtualize
824 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
827 if (!param_type_may_change_p (current_function_decl
, arg
, call
))
830 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
831 build_int_cst (ptr_type_node
, 0));
833 return detect_type_change_from_memory_writes (arg
, arg
, comp_type
,
837 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
838 boolean variable pointed to by DATA. */
841 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
844 bool *b
= (bool *) data
;
849 /* Return true if we have already walked so many statements in AA that we
850 should really just start giving up. */
853 aa_overwalked (struct ipa_func_body_info
*fbi
)
855 gcc_checking_assert (fbi
);
856 return fbi
->aa_walked
> (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS
);
859 /* Find the nearest valid aa status for parameter specified by INDEX that
862 static struct ipa_param_aa_status
*
863 find_dominating_aa_status (struct ipa_func_body_info
*fbi
, basic_block bb
,
868 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
871 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
872 if (!bi
->param_aa_statuses
.is_empty ()
873 && bi
->param_aa_statuses
[index
].valid
)
874 return &bi
->param_aa_statuses
[index
];
878 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
879 structures and/or intialize the result with a dominating description as
882 static struct ipa_param_aa_status
*
883 parm_bb_aa_status_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
,
886 gcc_checking_assert (fbi
);
887 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
888 if (bi
->param_aa_statuses
.is_empty ())
889 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
890 struct ipa_param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
893 gcc_checking_assert (!paa
->parm_modified
894 && !paa
->ref_modified
895 && !paa
->pt_modified
);
896 struct ipa_param_aa_status
*dom_paa
;
897 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
907 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
908 a value known not to be modified in this function before reaching the
909 statement STMT. FBI holds information about the function we have so far
910 gathered but do not survive the summary building stage. */
913 parm_preserved_before_stmt_p (struct ipa_func_body_info
*fbi
, int index
,
914 gimple
*stmt
, tree parm_load
)
916 struct ipa_param_aa_status
*paa
;
917 bool modified
= false;
920 tree base
= get_base_address (parm_load
);
921 gcc_assert (TREE_CODE (base
) == PARM_DECL
);
922 if (TREE_READONLY (base
))
925 /* FIXME: FBI can be NULL if we are being called from outside
926 ipa_node_analysis or ipcp_transform_function, which currently happens
927 during inlining analysis. It would be great to extend fbi's lifetime and
928 always have it. Currently, we are just not afraid of too much walking in
932 if (aa_overwalked (fbi
))
934 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
935 if (paa
->parm_modified
)
941 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
942 ao_ref_init (&refd
, parm_load
);
943 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
946 fbi
->aa_walked
+= walked
;
948 paa
->parm_modified
= true;
952 /* If STMT is an assignment that loads a value from an parameter declaration,
953 return the index of the parameter in ipa_node_params which has not been
954 modified. Otherwise return -1. */
957 load_from_unmodified_param (struct ipa_func_body_info
*fbi
,
958 vec
<ipa_param_descriptor
, va_gc
> *descriptors
,
964 if (!gimple_assign_single_p (stmt
))
967 op1
= gimple_assign_rhs1 (stmt
);
968 if (TREE_CODE (op1
) != PARM_DECL
)
971 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
973 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
979 /* Return true if memory reference REF (which must be a load through parameter
980 with INDEX) loads data that are known to be unmodified in this function
981 before reaching statement STMT. */
984 parm_ref_data_preserved_p (struct ipa_func_body_info
*fbi
,
985 int index
, gimple
*stmt
, tree ref
)
987 struct ipa_param_aa_status
*paa
;
988 bool modified
= false;
991 /* FIXME: FBI can be NULL if we are being called from outside
992 ipa_node_analysis or ipcp_transform_function, which currently happens
993 during inlining analysis. It would be great to extend fbi's lifetime and
994 always have it. Currently, we are just not afraid of too much walking in
998 if (aa_overwalked (fbi
))
1000 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
1001 if (paa
->ref_modified
)
1007 gcc_checking_assert (gimple_vuse (stmt
));
1008 ao_ref_init (&refd
, ref
);
1009 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
1012 fbi
->aa_walked
+= walked
;
1013 if (paa
&& modified
)
1014 paa
->ref_modified
= true;
1018 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
1019 is known to be unmodified in this function before reaching call statement
1020 CALL into which it is passed. FBI describes the function body. */
1023 parm_ref_data_pass_through_p (struct ipa_func_body_info
*fbi
, int index
,
1024 gimple
*call
, tree parm
)
1026 bool modified
= false;
1029 /* It's unnecessary to calculate anything about memory contnets for a const
1030 function because it is not goin to use it. But do not cache the result
1031 either. Also, no such calculations for non-pointers. */
1032 if (!gimple_vuse (call
)
1033 || !POINTER_TYPE_P (TREE_TYPE (parm
))
1034 || aa_overwalked (fbi
))
1037 struct ipa_param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
,
1040 if (paa
->pt_modified
)
1043 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
1044 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
1046 fbi
->aa_walked
+= walked
;
1048 paa
->pt_modified
= true;
1052 /* Return true if we can prove that OP is a memory reference loading
1053 data from an aggregate passed as a parameter.
1055 The function works in two modes. If GUARANTEED_UNMODIFIED is NULL, it return
1056 false if it cannot prove that the value has not been modified before the
1057 load in STMT. If GUARANTEED_UNMODIFIED is not NULL, it will return true even
1058 if it cannot prove the value has not been modified, in that case it will
1059 store false to *GUARANTEED_UNMODIFIED, otherwise it will store true there.
1061 INFO and PARMS_AINFO describe parameters of the current function (but the
1062 latter can be NULL), STMT is the load statement. If function returns true,
1063 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
1064 within the aggregate and whether it is a load from a value passed by
1065 reference respectively. */
1068 ipa_load_from_parm_agg (struct ipa_func_body_info
*fbi
,
1069 vec
<ipa_param_descriptor
, va_gc
> *descriptors
,
1070 gimple
*stmt
, tree op
, int *index_p
,
1071 HOST_WIDE_INT
*offset_p
, HOST_WIDE_INT
*size_p
,
1072 bool *by_ref_p
, bool *guaranteed_unmodified
)
1077 tree base
= get_ref_base_and_extent_hwi (op
, offset_p
, &size
, &reverse
);
1084 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
1086 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
1092 if (guaranteed_unmodified
)
1093 *guaranteed_unmodified
= true;
1099 if (TREE_CODE (base
) != MEM_REF
1100 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1101 || !integer_zerop (TREE_OPERAND (base
, 1)))
1104 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1106 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1107 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1111 /* This branch catches situations where a pointer parameter is not a
1112 gimple register, for example:
1114 void hip7(S*) (struct S * p)
1116 void (*<T2e4>) (struct S *) D.1867;
1121 D.1867_2 = p.1_1->f;
1126 gimple
*def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1127 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1132 bool data_preserved
= parm_ref_data_preserved_p (fbi
, index
, stmt
, op
);
1133 if (!data_preserved
&& !guaranteed_unmodified
)
1140 if (guaranteed_unmodified
)
1141 *guaranteed_unmodified
= data_preserved
;
1147 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1148 of an assignment statement STMT, try to determine whether we are actually
1149 handling any of the following cases and construct an appropriate jump
1150 function into JFUNC if so:
1152 1) The passed value is loaded from a formal parameter which is not a gimple
1153 register (most probably because it is addressable, the value has to be
1154 scalar) and we can guarantee the value has not changed. This case can
1155 therefore be described by a simple pass-through jump function. For example:
1164 2) The passed value can be described by a simple arithmetic pass-through
1171 D.2064_4 = a.1(D) + 4;
1174 This case can also occur in combination of the previous one, e.g.:
1182 D.2064_4 = a.0_3 + 4;
1185 3) The passed value is an address of an object within another one (which
1186 also passed by reference). Such situations are described by an ancestor
1187 jump function and describe situations such as:
1189 B::foo() (struct B * const this)
1193 D.1845_2 = &this_1(D)->D.1748;
1196 INFO is the structure describing individual parameters access different
1197 stages of IPA optimizations. PARMS_AINFO contains the information that is
1198 only needed for intraprocedural analysis. */
1201 compute_complex_assign_jump_func (struct ipa_func_body_info
*fbi
,
1202 struct ipa_node_params
*info
,
1203 struct ipa_jump_func
*jfunc
,
1204 gcall
*call
, gimple
*stmt
, tree name
,
1207 HOST_WIDE_INT offset
, size
;
1208 tree op1
, tc_ssa
, base
, ssa
;
1212 op1
= gimple_assign_rhs1 (stmt
);
1214 if (TREE_CODE (op1
) == SSA_NAME
)
1216 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1217 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1219 index
= load_from_unmodified_param (fbi
, info
->descriptors
,
1220 SSA_NAME_DEF_STMT (op1
));
1225 index
= load_from_unmodified_param (fbi
, info
->descriptors
, stmt
);
1226 tc_ssa
= gimple_assign_lhs (stmt
);
1231 switch (gimple_assign_rhs_class (stmt
))
1233 case GIMPLE_BINARY_RHS
:
1235 tree op2
= gimple_assign_rhs2 (stmt
);
1236 if (!is_gimple_ip_invariant (op2
)
1237 || ((TREE_CODE_CLASS (gimple_assign_rhs_code (stmt
))
1239 && !useless_type_conversion_p (TREE_TYPE (name
),
1243 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1244 gimple_assign_rhs_code (stmt
));
1247 case GIMPLE_SINGLE_RHS
:
1249 bool agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
,
1251 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1254 case GIMPLE_UNARY_RHS
:
1255 if (is_gimple_assign (stmt
)
1256 && gimple_assign_rhs_class (stmt
) == GIMPLE_UNARY_RHS
1257 && ! CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)))
1258 ipa_set_jf_unary_pass_through (jfunc
, index
,
1259 gimple_assign_rhs_code (stmt
));
1265 if (TREE_CODE (op1
) != ADDR_EXPR
)
1267 op1
= TREE_OPERAND (op1
, 0);
1268 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1270 base
= get_ref_base_and_extent_hwi (op1
, &offset
, &size
, &reverse
);
1271 offset_int mem_offset
;
1273 || TREE_CODE (base
) != MEM_REF
1274 || !mem_ref_offset (base
).is_constant (&mem_offset
))
1276 offset
+= mem_offset
.to_short_addr () * BITS_PER_UNIT
;
1277 ssa
= TREE_OPERAND (base
, 0);
1278 if (TREE_CODE (ssa
) != SSA_NAME
1279 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1283 /* Dynamic types are changed in constructors and destructors. */
1284 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1285 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1286 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1287 parm_ref_data_pass_through_p (fbi
, index
, call
, ssa
));
1290 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1293 iftmp.1_3 = &obj_2(D)->D.1762;
1295 The base of the MEM_REF must be a default definition SSA NAME of a
1296 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1297 whole MEM_REF expression is returned and the offset calculated from any
1298 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1299 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1302 get_ancestor_addr_info (gimple
*assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1305 tree expr
, parm
, obj
;
1308 if (!gimple_assign_single_p (assign
))
1310 expr
= gimple_assign_rhs1 (assign
);
1312 if (TREE_CODE (expr
) != ADDR_EXPR
)
1314 expr
= TREE_OPERAND (expr
, 0);
1316 expr
= get_ref_base_and_extent_hwi (expr
, offset
, &size
, &reverse
);
1318 offset_int mem_offset
;
1320 || TREE_CODE (expr
) != MEM_REF
1321 || !mem_ref_offset (expr
).is_constant (&mem_offset
))
1323 parm
= TREE_OPERAND (expr
, 0);
1324 if (TREE_CODE (parm
) != SSA_NAME
1325 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1326 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1329 *offset
+= mem_offset
.to_short_addr () * BITS_PER_UNIT
;
1335 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1336 statement PHI, try to find out whether NAME is in fact a
1337 multiple-inheritance typecast from a descendant into an ancestor of a formal
1338 parameter and thus can be described by an ancestor jump function and if so,
1339 write the appropriate function into JFUNC.
1341 Essentially we want to match the following pattern:
1349 iftmp.1_3 = &obj_2(D)->D.1762;
1352 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1353 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1357 compute_complex_ancestor_jump_func (struct ipa_func_body_info
*fbi
,
1358 struct ipa_node_params
*info
,
1359 struct ipa_jump_func
*jfunc
,
1360 gcall
*call
, gphi
*phi
)
1362 HOST_WIDE_INT offset
;
1363 gimple
*assign
, *cond
;
1364 basic_block phi_bb
, assign_bb
, cond_bb
;
1365 tree tmp
, parm
, expr
, obj
;
1368 if (gimple_phi_num_args (phi
) != 2)
1371 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1372 tmp
= PHI_ARG_DEF (phi
, 0);
1373 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1374 tmp
= PHI_ARG_DEF (phi
, 1);
1377 if (TREE_CODE (tmp
) != SSA_NAME
1378 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1379 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1380 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1383 assign
= SSA_NAME_DEF_STMT (tmp
);
1384 assign_bb
= gimple_bb (assign
);
1385 if (!single_pred_p (assign_bb
))
1387 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1390 parm
= TREE_OPERAND (expr
, 0);
1391 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1395 cond_bb
= single_pred (assign_bb
);
1396 cond
= last_stmt (cond_bb
);
1398 || gimple_code (cond
) != GIMPLE_COND
1399 || gimple_cond_code (cond
) != NE_EXPR
1400 || gimple_cond_lhs (cond
) != parm
1401 || !integer_zerop (gimple_cond_rhs (cond
)))
1404 phi_bb
= gimple_bb (phi
);
1405 for (i
= 0; i
< 2; i
++)
1407 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1408 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1412 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1413 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
));
1416 /* Inspect the given TYPE and return true iff it has the same structure (the
1417 same number of fields of the same types) as a C++ member pointer. If
1418 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1419 corresponding fields there. */
1422 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1426 if (TREE_CODE (type
) != RECORD_TYPE
)
1429 fld
= TYPE_FIELDS (type
);
1430 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1431 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1432 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1438 fld
= DECL_CHAIN (fld
);
1439 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1440 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1445 if (DECL_CHAIN (fld
))
1451 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1452 return the rhs of its defining statement. Otherwise return RHS as it
1456 get_ssa_def_if_simple_copy (tree rhs
)
1458 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1460 gimple
*def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1462 if (gimple_assign_single_p (def_stmt
))
1463 rhs
= gimple_assign_rhs1 (def_stmt
);
1470 /* Simple linked list, describing known contents of an aggregate beforere
1473 struct ipa_known_agg_contents_list
1475 /* Offset and size of the described part of the aggregate. */
1476 HOST_WIDE_INT offset
, size
;
1477 /* Known constant value or NULL if the contents is known to be unknown. */
1479 /* Pointer to the next structure in the list. */
1480 struct ipa_known_agg_contents_list
*next
;
1483 /* Find the proper place in linked list of ipa_known_agg_contents_list
1484 structures where to put a new one with the given LHS_OFFSET and LHS_SIZE,
1485 unless there is a partial overlap, in which case return NULL, or such
1486 element is already there, in which case set *ALREADY_THERE to true. */
1488 static struct ipa_known_agg_contents_list
**
1489 get_place_in_agg_contents_list (struct ipa_known_agg_contents_list
**list
,
1490 HOST_WIDE_INT lhs_offset
,
1491 HOST_WIDE_INT lhs_size
,
1492 bool *already_there
)
1494 struct ipa_known_agg_contents_list
**p
= list
;
1495 while (*p
&& (*p
)->offset
< lhs_offset
)
1497 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1502 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1504 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1505 /* We already know this value is subsequently overwritten with
1507 *already_there
= true;
1509 /* Otherwise this is a partial overlap which we cannot
1516 /* Build aggregate jump function from LIST, assuming there are exactly
1517 CONST_COUNT constant entries there and that th offset of the passed argument
1518 is ARG_OFFSET and store it into JFUNC. */
1521 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1522 int const_count
, HOST_WIDE_INT arg_offset
,
1523 struct ipa_jump_func
*jfunc
)
1525 vec_alloc (jfunc
->agg
.items
, const_count
);
1530 struct ipa_agg_jf_item item
;
1531 item
.offset
= list
->offset
- arg_offset
;
1532 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1533 item
.value
= unshare_expr_without_location (list
->constant
);
1534 jfunc
->agg
.items
->quick_push (item
);
1540 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1541 in ARG is filled in with constant values. ARG can either be an aggregate
1542 expression or a pointer to an aggregate. ARG_TYPE is the type of the
1543 aggregate. JFUNC is the jump function into which the constants are
1544 subsequently stored. */
1547 determine_locally_known_aggregate_parts (gcall
*call
, tree arg
,
1549 struct ipa_jump_func
*jfunc
)
1551 struct ipa_known_agg_contents_list
*list
= NULL
;
1552 int item_count
= 0, const_count
= 0;
1553 HOST_WIDE_INT arg_offset
, arg_size
;
1554 gimple_stmt_iterator gsi
;
1556 bool check_ref
, by_ref
;
1559 if (PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
) == 0)
1562 /* The function operates in three stages. First, we prepare check_ref, r,
1563 arg_base and arg_offset based on what is actually passed as an actual
1566 if (POINTER_TYPE_P (arg_type
))
1569 if (TREE_CODE (arg
) == SSA_NAME
)
1572 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
)))
1573 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
1578 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1579 arg_size
= tree_to_uhwi (type_size
);
1580 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1582 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1586 arg
= TREE_OPERAND (arg
, 0);
1587 arg_base
= get_ref_base_and_extent_hwi (arg
, &arg_offset
,
1588 &arg_size
, &reverse
);
1591 if (DECL_P (arg_base
))
1594 ao_ref_init (&r
, arg_base
);
1606 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1610 arg_base
= get_ref_base_and_extent_hwi (arg
, &arg_offset
,
1611 &arg_size
, &reverse
);
1615 ao_ref_init (&r
, arg
);
1618 /* Second stage walks back the BB, looks at individual statements and as long
1619 as it is confident of how the statements affect contents of the
1620 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1622 gsi
= gsi_for_stmt (call
);
1624 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1626 struct ipa_known_agg_contents_list
*n
, **p
;
1627 gimple
*stmt
= gsi_stmt (gsi
);
1628 HOST_WIDE_INT lhs_offset
, lhs_size
;
1629 tree lhs
, rhs
, lhs_base
;
1632 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1634 if (!gimple_assign_single_p (stmt
))
1637 lhs
= gimple_assign_lhs (stmt
);
1638 rhs
= gimple_assign_rhs1 (stmt
);
1639 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1640 || TREE_CODE (lhs
) == BIT_FIELD_REF
1641 || contains_bitfld_component_ref_p (lhs
))
1644 lhs_base
= get_ref_base_and_extent_hwi (lhs
, &lhs_offset
,
1645 &lhs_size
, &reverse
);
1651 if (TREE_CODE (lhs_base
) != MEM_REF
1652 || TREE_OPERAND (lhs_base
, 0) != arg_base
1653 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1656 else if (lhs_base
!= arg_base
)
1658 if (DECL_P (lhs_base
))
1664 bool already_there
= false;
1665 p
= get_place_in_agg_contents_list (&list
, lhs_offset
, lhs_size
,
1672 rhs
= get_ssa_def_if_simple_copy (rhs
);
1673 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1675 n
->offset
= lhs_offset
;
1676 if (is_gimple_ip_invariant (rhs
))
1682 n
->constant
= NULL_TREE
;
1687 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1688 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1692 /* Third stage just goes over the list and creates an appropriate vector of
1693 ipa_agg_jf_item structures out of it, of sourse only if there are
1694 any known constants to begin with. */
1698 jfunc
->agg
.by_ref
= by_ref
;
1699 build_agg_jump_func_from_list (list
, const_count
, arg_offset
, jfunc
);
1703 /* Return the Ith param type of callee associated with call graph
1707 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1710 tree type
= (e
->callee
1711 ? TREE_TYPE (e
->callee
->decl
)
1712 : gimple_call_fntype (e
->call_stmt
));
1713 tree t
= TYPE_ARG_TYPES (type
);
1715 for (n
= 0; n
< i
; n
++)
1722 return TREE_VALUE (t
);
1725 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1726 for (n
= 0; n
< i
; n
++)
1733 return TREE_TYPE (t
);
1737 /* Return ipa_bits with VALUE and MASK values, which can be either a newly
1738 allocated structure or a previously existing one shared with other jump
1739 functions and/or transformation summaries. */
1742 ipa_get_ipa_bits_for_value (const widest_int
&value
, const widest_int
&mask
)
1748 ipa_bits
**slot
= ipa_bits_hash_table
->find_slot (&tmp
, INSERT
);
1752 ipa_bits
*res
= ggc_alloc
<ipa_bits
> ();
1760 /* Assign to JF a pointer to ipa_bits structure with VALUE and MASK. Use hash
1761 table in order to avoid creating multiple same ipa_bits structures. */
1764 ipa_set_jfunc_bits (ipa_jump_func
*jf
, const widest_int
&value
,
1765 const widest_int
&mask
)
1767 jf
->bits
= ipa_get_ipa_bits_for_value (value
, mask
);
1770 /* Return a pointer to a value_range just like *TMP, but either find it in
1771 ipa_vr_hash_table or allocate it in GC memory. TMP->equiv must be NULL. */
1773 static value_range_base
*
1774 ipa_get_value_range (value_range_base
*tmp
)
1776 value_range_base
**slot
= ipa_vr_hash_table
->find_slot (tmp
, INSERT
);
1780 value_range_base
*vr
= ggc_alloc
<value_range_base
> ();
1787 /* Return a pointer to a value range consisting of TYPE, MIN, MAX and an empty
1788 equiv set. Use hash table in order to avoid creating multiple same copies of
1791 static value_range_base
*
1792 ipa_get_value_range (enum value_range_kind type
, tree min
, tree max
)
1794 value_range_base
tmp (type
, min
, max
);
1795 return ipa_get_value_range (&tmp
);
1798 /* Assign to JF a pointer to a value_range structure with TYPE, MIN and MAX and
1799 a NULL equiv bitmap. Use hash table in order to avoid creating multiple
1800 same value_range structures. */
1803 ipa_set_jfunc_vr (ipa_jump_func
*jf
, enum value_range_kind type
,
1806 jf
->m_vr
= ipa_get_value_range (type
, min
, max
);
1809 /* Assign to JF a pointer to a value_range just liek TMP but either fetch a
1810 copy from ipa_vr_hash_table or allocate a new on in GC memory. */
1813 ipa_set_jfunc_vr (ipa_jump_func
*jf
, value_range_base
*tmp
)
1815 jf
->m_vr
= ipa_get_value_range (tmp
);
1818 /* Compute jump function for all arguments of callsite CS and insert the
1819 information in the jump_functions array in the ipa_edge_args corresponding
1820 to this callsite. */
1823 ipa_compute_jump_functions_for_edge (struct ipa_func_body_info
*fbi
,
1824 struct cgraph_edge
*cs
)
1826 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1827 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1828 gcall
*call
= cs
->call_stmt
;
1829 int n
, arg_num
= gimple_call_num_args (call
);
1830 bool useful_context
= false;
1832 if (arg_num
== 0 || args
->jump_functions
)
1834 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1835 if (flag_devirtualize
)
1836 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, arg_num
);
1838 if (gimple_call_internal_p (call
))
1840 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1843 for (n
= 0; n
< arg_num
; n
++)
1845 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1846 tree arg
= gimple_call_arg (call
, n
);
1847 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1848 if (flag_devirtualize
&& POINTER_TYPE_P (TREE_TYPE (arg
)))
1851 struct ipa_polymorphic_call_context
context (cs
->caller
->decl
,
1854 context
.get_dynamic_type (instance
, arg
, NULL
, cs
->call_stmt
);
1855 *ipa_get_ith_polymorhic_call_context (args
, n
) = context
;
1856 if (!context
.useless_p ())
1857 useful_context
= true;
1860 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1862 bool addr_nonzero
= false;
1863 bool strict_overflow
= false;
1865 if (TREE_CODE (arg
) == SSA_NAME
1867 && get_ptr_nonnull (arg
))
1868 addr_nonzero
= true;
1869 else if (tree_single_nonzero_warnv_p (arg
, &strict_overflow
))
1870 addr_nonzero
= true;
1874 tree z
= build_int_cst (TREE_TYPE (arg
), 0);
1875 ipa_set_jfunc_vr (jfunc
, VR_ANTI_RANGE
, z
, z
);
1878 gcc_assert (!jfunc
->m_vr
);
1883 value_range_kind type
;
1884 if (TREE_CODE (arg
) == SSA_NAME
1886 && (type
= get_range_info (arg
, &min
, &max
))
1887 && (type
== VR_RANGE
|| type
== VR_ANTI_RANGE
))
1889 value_range_base resvr
;
1890 value_range_base
tmpvr (type
,
1891 wide_int_to_tree (TREE_TYPE (arg
), min
),
1892 wide_int_to_tree (TREE_TYPE (arg
), max
));
1893 extract_range_from_unary_expr (&resvr
, NOP_EXPR
, param_type
,
1894 &tmpvr
, TREE_TYPE (arg
));
1895 if (!resvr
.undefined_p () && !resvr
.varying_p ())
1896 ipa_set_jfunc_vr (jfunc
, &resvr
);
1898 gcc_assert (!jfunc
->m_vr
);
1901 gcc_assert (!jfunc
->m_vr
);
1904 if (INTEGRAL_TYPE_P (TREE_TYPE (arg
))
1905 && (TREE_CODE (arg
) == SSA_NAME
|| TREE_CODE (arg
) == INTEGER_CST
))
1907 if (TREE_CODE (arg
) == SSA_NAME
)
1908 ipa_set_jfunc_bits (jfunc
, 0,
1909 widest_int::from (get_nonzero_bits (arg
),
1910 TYPE_SIGN (TREE_TYPE (arg
))));
1912 ipa_set_jfunc_bits (jfunc
, wi::to_widest (arg
), 0);
1914 else if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1916 unsigned HOST_WIDE_INT bitpos
;
1919 get_pointer_alignment_1 (arg
, &align
, &bitpos
);
1920 widest_int mask
= wi::bit_and_not
1921 (wi::mask
<widest_int
> (TYPE_PRECISION (TREE_TYPE (arg
)), false),
1922 align
/ BITS_PER_UNIT
- 1);
1923 widest_int value
= bitpos
/ BITS_PER_UNIT
;
1924 ipa_set_jfunc_bits (jfunc
, value
, mask
);
1927 gcc_assert (!jfunc
->bits
);
1929 if (is_gimple_ip_invariant (arg
)
1931 && is_global_var (arg
)
1932 && TREE_READONLY (arg
)))
1933 ipa_set_jf_constant (jfunc
, arg
, cs
);
1934 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1935 && TREE_CODE (arg
) == PARM_DECL
)
1937 int index
= ipa_get_param_decl_index (info
, arg
);
1939 gcc_assert (index
>=0);
1940 /* Aggregate passed by value, check for pass-through, otherwise we
1941 will attempt to fill in aggregate contents later in this
1943 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
1945 ipa_set_jf_simple_pass_through (jfunc
, index
, false);
1949 else if (TREE_CODE (arg
) == SSA_NAME
)
1951 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1953 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1957 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
1958 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1963 gimple
*stmt
= SSA_NAME_DEF_STMT (arg
);
1964 if (is_gimple_assign (stmt
))
1965 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
1966 call
, stmt
, arg
, param_type
);
1967 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1968 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
1970 as_a
<gphi
*> (stmt
));
1974 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1975 passed (because type conversions are ignored in gimple). Usually we can
1976 safely get type from function declaration, but in case of K&R prototypes or
1977 variadic functions we can try our luck with type of the pointer passed.
1978 TODO: Since we look for actual initialization of the memory object, we may better
1979 work out the type based on the memory stores we find. */
1981 param_type
= TREE_TYPE (arg
);
1983 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1984 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1985 && (jfunc
->type
!= IPA_JF_ANCESTOR
1986 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1987 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1988 || POINTER_TYPE_P (param_type
)))
1989 determine_locally_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1991 if (!useful_context
)
1992 vec_free (args
->polymorphic_call_contexts
);
1995 /* Compute jump functions for all edges - both direct and indirect - outgoing
1999 ipa_compute_jump_functions_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2001 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
2003 struct cgraph_edge
*cs
;
2005 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
2007 struct cgraph_node
*callee
= cs
->callee
;
2011 callee
->ultimate_alias_target ();
2012 /* We do not need to bother analyzing calls to unknown functions
2013 unless they may become known during lto/whopr. */
2014 if (!callee
->definition
&& !flag_lto
)
2017 ipa_compute_jump_functions_for_edge (fbi
, cs
);
2021 /* If STMT looks like a statement loading a value from a member pointer formal
2022 parameter, return that parameter and store the offset of the field to
2023 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
2024 might be clobbered). If USE_DELTA, then we look for a use of the delta
2025 field rather than the pfn. */
2028 ipa_get_stmt_member_ptr_load_param (gimple
*stmt
, bool use_delta
,
2029 HOST_WIDE_INT
*offset_p
)
2031 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
2033 if (!gimple_assign_single_p (stmt
))
2036 rhs
= gimple_assign_rhs1 (stmt
);
2037 if (TREE_CODE (rhs
) == COMPONENT_REF
)
2039 ref_field
= TREE_OPERAND (rhs
, 1);
2040 rhs
= TREE_OPERAND (rhs
, 0);
2043 ref_field
= NULL_TREE
;
2044 if (TREE_CODE (rhs
) != MEM_REF
)
2046 rec
= TREE_OPERAND (rhs
, 0);
2047 if (TREE_CODE (rec
) != ADDR_EXPR
)
2049 rec
= TREE_OPERAND (rec
, 0);
2050 if (TREE_CODE (rec
) != PARM_DECL
2051 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
2053 ref_offset
= TREE_OPERAND (rhs
, 1);
2060 *offset_p
= int_bit_position (fld
);
2064 if (integer_nonzerop (ref_offset
))
2066 return ref_field
== fld
? rec
: NULL_TREE
;
2069 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
2073 /* Returns true iff T is an SSA_NAME defined by a statement. */
2076 ipa_is_ssa_with_stmt_def (tree t
)
2078 if (TREE_CODE (t
) == SSA_NAME
2079 && !SSA_NAME_IS_DEFAULT_DEF (t
))
2085 /* Find the indirect call graph edge corresponding to STMT and mark it as a
2086 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
2087 indirect call graph edge. */
2089 static struct cgraph_edge
*
2090 ipa_note_param_call (struct cgraph_node
*node
, int param_index
,
2093 struct cgraph_edge
*cs
;
2095 cs
= node
->get_edge (stmt
);
2096 cs
->indirect_info
->param_index
= param_index
;
2097 cs
->indirect_info
->agg_contents
= 0;
2098 cs
->indirect_info
->member_ptr
= 0;
2099 cs
->indirect_info
->guaranteed_unmodified
= 0;
2103 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
2104 (described by INFO). PARMS_AINFO is a pointer to a vector containing
2105 intermediate information about each formal parameter. Currently it checks
2106 whether the call calls a pointer that is a formal parameter and if so, the
2107 parameter is marked with the called flag and an indirect call graph edge
2108 describing the call is created. This is very simple for ordinary pointers
2109 represented in SSA but not-so-nice when it comes to member pointers. The
2110 ugly part of this function does nothing more than trying to match the
2111 pattern of such a call. An example of such a pattern is the gimple dump
2112 below, the call is on the last line:
2115 f$__delta_5 = f.__delta;
2116 f$__pfn_24 = f.__pfn;
2120 f$__delta_5 = MEM[(struct *)&f];
2121 f$__pfn_24 = MEM[(struct *)&f + 4B];
2123 and a few lines below:
2126 D.2496_3 = (int) f$__pfn_24;
2127 D.2497_4 = D.2496_3 & 1;
2134 D.2500_7 = (unsigned int) f$__delta_5;
2135 D.2501_8 = &S + D.2500_7;
2136 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
2137 D.2503_10 = *D.2502_9;
2138 D.2504_12 = f$__pfn_24 + -1;
2139 D.2505_13 = (unsigned int) D.2504_12;
2140 D.2506_14 = D.2503_10 + D.2505_13;
2141 D.2507_15 = *D.2506_14;
2142 iftmp.11_16 = (String:: *) D.2507_15;
2145 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
2146 D.2500_19 = (unsigned int) f$__delta_5;
2147 D.2508_20 = &S + D.2500_19;
2148 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
2150 Such patterns are results of simple calls to a member pointer:
2152 int doprinting (int (MyString::* f)(int) const)
2154 MyString S ("somestring");
2159 Moreover, the function also looks for called pointers loaded from aggregates
2160 passed by value or reference. */
2163 ipa_analyze_indirect_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
,
2166 struct ipa_node_params
*info
= fbi
->info
;
2167 HOST_WIDE_INT offset
;
2170 if (SSA_NAME_IS_DEFAULT_DEF (target
))
2172 tree var
= SSA_NAME_VAR (target
);
2173 int index
= ipa_get_param_decl_index (info
, var
);
2175 ipa_note_param_call (fbi
->node
, index
, call
);
2180 gimple
*def
= SSA_NAME_DEF_STMT (target
);
2181 bool guaranteed_unmodified
;
2182 if (gimple_assign_single_p (def
)
2183 && ipa_load_from_parm_agg (fbi
, info
->descriptors
, def
,
2184 gimple_assign_rhs1 (def
), &index
, &offset
,
2185 NULL
, &by_ref
, &guaranteed_unmodified
))
2187 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2188 cs
->indirect_info
->offset
= offset
;
2189 cs
->indirect_info
->agg_contents
= 1;
2190 cs
->indirect_info
->by_ref
= by_ref
;
2191 cs
->indirect_info
->guaranteed_unmodified
= guaranteed_unmodified
;
2195 /* Now we need to try to match the complex pattern of calling a member
2197 if (gimple_code (def
) != GIMPLE_PHI
2198 || gimple_phi_num_args (def
) != 2
2199 || !POINTER_TYPE_P (TREE_TYPE (target
))
2200 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2203 /* First, we need to check whether one of these is a load from a member
2204 pointer that is a parameter to this function. */
2205 tree n1
= PHI_ARG_DEF (def
, 0);
2206 tree n2
= PHI_ARG_DEF (def
, 1);
2207 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2209 gimple
*d1
= SSA_NAME_DEF_STMT (n1
);
2210 gimple
*d2
= SSA_NAME_DEF_STMT (n2
);
2213 basic_block bb
, virt_bb
;
2214 basic_block join
= gimple_bb (def
);
2215 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2217 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2220 bb
= EDGE_PRED (join
, 0)->src
;
2221 virt_bb
= gimple_bb (d2
);
2223 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2225 bb
= EDGE_PRED (join
, 1)->src
;
2226 virt_bb
= gimple_bb (d1
);
2231 /* Second, we need to check that the basic blocks are laid out in the way
2232 corresponding to the pattern. */
2234 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2235 || single_pred (virt_bb
) != bb
2236 || single_succ (virt_bb
) != join
)
2239 /* Third, let's see that the branching is done depending on the least
2240 significant bit of the pfn. */
2242 gimple
*branch
= last_stmt (bb
);
2243 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2246 if ((gimple_cond_code (branch
) != NE_EXPR
2247 && gimple_cond_code (branch
) != EQ_EXPR
)
2248 || !integer_zerop (gimple_cond_rhs (branch
)))
2251 tree cond
= gimple_cond_lhs (branch
);
2252 if (!ipa_is_ssa_with_stmt_def (cond
))
2255 def
= SSA_NAME_DEF_STMT (cond
);
2256 if (!is_gimple_assign (def
)
2257 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2258 || !integer_onep (gimple_assign_rhs2 (def
)))
2261 cond
= gimple_assign_rhs1 (def
);
2262 if (!ipa_is_ssa_with_stmt_def (cond
))
2265 def
= SSA_NAME_DEF_STMT (cond
);
2267 if (is_gimple_assign (def
)
2268 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2270 cond
= gimple_assign_rhs1 (def
);
2271 if (!ipa_is_ssa_with_stmt_def (cond
))
2273 def
= SSA_NAME_DEF_STMT (cond
);
2277 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2278 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2279 == ptrmemfunc_vbit_in_delta
),
2284 index
= ipa_get_param_decl_index (info
, rec
);
2286 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2288 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2289 cs
->indirect_info
->offset
= offset
;
2290 cs
->indirect_info
->agg_contents
= 1;
2291 cs
->indirect_info
->member_ptr
= 1;
2292 cs
->indirect_info
->guaranteed_unmodified
= 1;
2298 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2299 object referenced in the expression is a formal parameter of the caller
2300 FBI->node (described by FBI->info), create a call note for the
2304 ipa_analyze_virtual_call_uses (struct ipa_func_body_info
*fbi
,
2305 gcall
*call
, tree target
)
2307 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2309 HOST_WIDE_INT anc_offset
;
2311 if (!flag_devirtualize
)
2314 if (TREE_CODE (obj
) != SSA_NAME
)
2317 struct ipa_node_params
*info
= fbi
->info
;
2318 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2320 struct ipa_jump_func jfunc
;
2321 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2325 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2326 gcc_assert (index
>= 0);
2327 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2333 struct ipa_jump_func jfunc
;
2334 gimple
*stmt
= SSA_NAME_DEF_STMT (obj
);
2337 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2340 index
= ipa_get_param_decl_index (info
,
2341 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2342 gcc_assert (index
>= 0);
2343 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2344 call
, &jfunc
, anc_offset
))
2348 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2349 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2350 ii
->offset
= anc_offset
;
2351 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2352 ii
->otr_type
= obj_type_ref_class (target
);
2353 ii
->polymorphic
= 1;
2356 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2357 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2358 containing intermediate information about each formal parameter. */
2361 ipa_analyze_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
)
2363 tree target
= gimple_call_fn (call
);
2366 || (TREE_CODE (target
) != SSA_NAME
2367 && !virtual_method_call_p (target
)))
2370 struct cgraph_edge
*cs
= fbi
->node
->get_edge (call
);
2371 /* If we previously turned the call into a direct call, there is
2372 no need to analyze. */
2373 if (cs
&& !cs
->indirect_unknown_callee
)
2376 if (cs
->indirect_info
->polymorphic
&& flag_devirtualize
)
2379 tree target
= gimple_call_fn (call
);
2380 ipa_polymorphic_call_context
context (current_function_decl
,
2381 target
, call
, &instance
);
2383 gcc_checking_assert (cs
->indirect_info
->otr_type
2384 == obj_type_ref_class (target
));
2385 gcc_checking_assert (cs
->indirect_info
->otr_token
2386 == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target
)));
2388 cs
->indirect_info
->vptr_changed
2389 = !context
.get_dynamic_type (instance
,
2390 OBJ_TYPE_REF_OBJECT (target
),
2391 obj_type_ref_class (target
), call
);
2392 cs
->indirect_info
->context
= context
;
2395 if (TREE_CODE (target
) == SSA_NAME
)
2396 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2397 else if (virtual_method_call_p (target
))
2398 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2402 /* Analyze the call statement STMT with respect to formal parameters (described
2403 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2404 formal parameters are called. */
2407 ipa_analyze_stmt_uses (struct ipa_func_body_info
*fbi
, gimple
*stmt
)
2409 if (is_gimple_call (stmt
))
2410 ipa_analyze_call_uses (fbi
, as_a
<gcall
*> (stmt
));
2413 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2414 If OP is a parameter declaration, mark it as used in the info structure
2418 visit_ref_for_mod_analysis (gimple
*, tree op
, tree
, void *data
)
2420 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2422 op
= get_base_address (op
);
2424 && TREE_CODE (op
) == PARM_DECL
)
2426 int index
= ipa_get_param_decl_index (info
, op
);
2427 gcc_assert (index
>= 0);
2428 ipa_set_param_used (info
, index
, true);
2434 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2435 the findings in various structures of the associated ipa_node_params
2436 structure, such as parameter flags, notes etc. FBI holds various data about
2437 the function being analyzed. */
2440 ipa_analyze_params_uses_in_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2442 gimple_stmt_iterator gsi
;
2443 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2445 gimple
*stmt
= gsi_stmt (gsi
);
2447 if (is_gimple_debug (stmt
))
2450 ipa_analyze_stmt_uses (fbi
, stmt
);
2451 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2452 visit_ref_for_mod_analysis
,
2453 visit_ref_for_mod_analysis
,
2454 visit_ref_for_mod_analysis
);
2456 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2457 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2458 visit_ref_for_mod_analysis
,
2459 visit_ref_for_mod_analysis
,
2460 visit_ref_for_mod_analysis
);
2463 /* Calculate controlled uses of parameters of NODE. */
2466 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2468 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2470 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2472 tree parm
= ipa_get_param (info
, i
);
2473 int controlled_uses
= 0;
2475 /* For SSA regs see if parameter is used. For non-SSA we compute
2476 the flag during modification analysis. */
2477 if (is_gimple_reg (parm
))
2479 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2481 if (ddef
&& !has_zero_uses (ddef
))
2483 imm_use_iterator imm_iter
;
2484 use_operand_p use_p
;
2486 ipa_set_param_used (info
, i
, true);
2487 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2488 if (!is_gimple_call (USE_STMT (use_p
)))
2490 if (!is_gimple_debug (USE_STMT (use_p
)))
2492 controlled_uses
= IPA_UNDESCRIBED_USE
;
2500 controlled_uses
= 0;
2503 controlled_uses
= IPA_UNDESCRIBED_USE
;
2504 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2508 /* Free stuff in BI. */
2511 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2513 bi
->cg_edges
.release ();
2514 bi
->param_aa_statuses
.release ();
2517 /* Dominator walker driving the analysis. */
2519 class analysis_dom_walker
: public dom_walker
2522 analysis_dom_walker (struct ipa_func_body_info
*fbi
)
2523 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2525 virtual edge
before_dom_children (basic_block
);
2528 struct ipa_func_body_info
*m_fbi
;
2532 analysis_dom_walker::before_dom_children (basic_block bb
)
2534 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2535 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2539 /* Release body info FBI. */
2542 ipa_release_body_info (struct ipa_func_body_info
*fbi
)
2545 struct ipa_bb_info
*bi
;
2547 FOR_EACH_VEC_ELT (fbi
->bb_infos
, i
, bi
)
2548 free_ipa_bb_info (bi
);
2549 fbi
->bb_infos
.release ();
2552 /* Initialize the array describing properties of formal parameters
2553 of NODE, analyze their uses and compute jump functions associated
2554 with actual arguments of calls from within NODE. */
2557 ipa_analyze_node (struct cgraph_node
*node
)
2559 struct ipa_func_body_info fbi
;
2560 struct ipa_node_params
*info
;
2562 ipa_check_create_node_params ();
2563 ipa_check_create_edge_args ();
2564 info
= IPA_NODE_REF (node
);
2566 if (info
->analysis_done
)
2568 info
->analysis_done
= 1;
2570 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2572 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2574 ipa_set_param_used (info
, i
, true);
2575 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2580 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2582 calculate_dominance_info (CDI_DOMINATORS
);
2583 ipa_initialize_node_params (node
);
2584 ipa_analyze_controlled_uses (node
);
2587 fbi
.info
= IPA_NODE_REF (node
);
2588 fbi
.bb_infos
= vNULL
;
2589 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2590 fbi
.param_count
= ipa_get_param_count (info
);
2593 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2595 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2596 bi
->cg_edges
.safe_push (cs
);
2599 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2601 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2602 bi
->cg_edges
.safe_push (cs
);
2605 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2607 ipa_release_body_info (&fbi
);
2608 free_dominance_info (CDI_DOMINATORS
);
2612 /* Update the jump functions associated with call graph edge E when the call
2613 graph edge CS is being inlined, assuming that E->caller is already (possibly
2614 indirectly) inlined into CS->callee and that E has not been inlined. */
2617 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2618 struct cgraph_edge
*e
)
2620 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2621 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2622 int count
= ipa_get_cs_argument_count (args
);
2625 for (i
= 0; i
< count
; i
++)
2627 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2628 struct ipa_polymorphic_call_context
*dst_ctx
2629 = ipa_get_ith_polymorhic_call_context (args
, i
);
2631 if (dst
->type
== IPA_JF_ANCESTOR
)
2633 struct ipa_jump_func
*src
;
2634 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2635 struct ipa_polymorphic_call_context
*src_ctx
2636 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2638 /* Variable number of arguments can cause havoc if we try to access
2639 one that does not exist in the inlined edge. So make sure we
2641 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2643 ipa_set_jf_unknown (dst
);
2647 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2649 if (src_ctx
&& !src_ctx
->useless_p ())
2651 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2653 /* TODO: Make type preserved safe WRT contexts. */
2654 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2655 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2656 ctx
.offset_by (dst
->value
.ancestor
.offset
);
2657 if (!ctx
.useless_p ())
2661 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2663 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2666 dst_ctx
->combine_with (ctx
);
2671 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2673 struct ipa_agg_jf_item
*item
;
2676 /* Currently we do not produce clobber aggregate jump functions,
2677 replace with merging when we do. */
2678 gcc_assert (!dst
->agg
.items
);
2680 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2681 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2682 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2683 item
->offset
-= dst
->value
.ancestor
.offset
;
2686 if (src
->type
== IPA_JF_PASS_THROUGH
2687 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2689 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2690 dst
->value
.ancestor
.agg_preserved
&=
2691 src
->value
.pass_through
.agg_preserved
;
2693 else if (src
->type
== IPA_JF_PASS_THROUGH
2694 && TREE_CODE_CLASS (src
->value
.pass_through
.operation
) == tcc_unary
)
2696 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2697 dst
->value
.ancestor
.agg_preserved
= false;
2699 else if (src
->type
== IPA_JF_ANCESTOR
)
2701 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2702 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2703 dst
->value
.ancestor
.agg_preserved
&=
2704 src
->value
.ancestor
.agg_preserved
;
2707 ipa_set_jf_unknown (dst
);
2709 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2711 struct ipa_jump_func
*src
;
2712 /* We must check range due to calls with variable number of arguments
2713 and we cannot combine jump functions with operations. */
2714 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2715 && (dst
->value
.pass_through
.formal_id
2716 < ipa_get_cs_argument_count (top
)))
2718 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2719 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2720 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2721 struct ipa_polymorphic_call_context
*src_ctx
2722 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2724 if (src_ctx
&& !src_ctx
->useless_p ())
2726 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2728 /* TODO: Make type preserved safe WRT contexts. */
2729 if (!ipa_get_jf_pass_through_type_preserved (dst
))
2730 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2731 if (!ctx
.useless_p ())
2735 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2737 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2739 dst_ctx
->combine_with (ctx
);
2744 case IPA_JF_UNKNOWN
:
2745 ipa_set_jf_unknown (dst
);
2748 ipa_set_jf_cst_copy (dst
, src
);
2751 case IPA_JF_PASS_THROUGH
:
2753 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2754 enum tree_code operation
;
2755 operation
= ipa_get_jf_pass_through_operation (src
);
2757 if (operation
== NOP_EXPR
)
2761 && ipa_get_jf_pass_through_agg_preserved (src
);
2762 ipa_set_jf_simple_pass_through (dst
, formal_id
, agg_p
);
2764 else if (TREE_CODE_CLASS (operation
) == tcc_unary
)
2765 ipa_set_jf_unary_pass_through (dst
, formal_id
, operation
);
2768 tree operand
= ipa_get_jf_pass_through_operand (src
);
2769 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2774 case IPA_JF_ANCESTOR
:
2778 && ipa_get_jf_ancestor_agg_preserved (src
);
2779 ipa_set_ancestor_jf (dst
,
2780 ipa_get_jf_ancestor_offset (src
),
2781 ipa_get_jf_ancestor_formal_id (src
),
2790 && (dst_agg_p
|| !src
->agg
.by_ref
))
2792 /* Currently we do not produce clobber aggregate jump
2793 functions, replace with merging when we do. */
2794 gcc_assert (!dst
->agg
.items
);
2796 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2797 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2801 ipa_set_jf_unknown (dst
);
2806 /* If TARGET is an addr_expr of a function declaration, make it the
2807 (SPECULATIVE)destination of an indirect edge IE and return the edge.
2808 Otherwise, return NULL. */
2810 struct cgraph_edge
*
2811 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
,
2814 struct cgraph_node
*callee
;
2815 bool unreachable
= false;
2817 if (TREE_CODE (target
) == ADDR_EXPR
)
2818 target
= TREE_OPERAND (target
, 0);
2819 if (TREE_CODE (target
) != FUNCTION_DECL
)
2821 target
= canonicalize_constructor_val (target
, NULL
);
2822 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2824 /* Member pointer call that goes through a VMT lookup. */
2825 if (ie
->indirect_info
->member_ptr
2826 /* Or if target is not an invariant expression and we do not
2827 know if it will evaulate to function at runtime.
2828 This can happen when folding through &VAR, where &VAR
2829 is IP invariant, but VAR itself is not.
2831 TODO: Revisit this when GCC 5 is branched. It seems that
2832 member_ptr check is not needed and that we may try to fold
2833 the expression and see if VAR is readonly. */
2834 || !is_gimple_ip_invariant (target
))
2836 if (dump_enabled_p ())
2838 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
2839 "discovered direct call non-invariant %s\n",
2840 ie
->caller
->dump_name ());
2846 if (dump_enabled_p ())
2848 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
2849 "discovered direct call to non-function in %s, "
2850 "making it __builtin_unreachable\n",
2851 ie
->caller
->dump_name ());
2854 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2855 callee
= cgraph_node::get_create (target
);
2859 callee
= cgraph_node::get (target
);
2862 callee
= cgraph_node::get (target
);
2864 /* Because may-edges are not explicitely represented and vtable may be external,
2865 we may create the first reference to the object in the unit. */
2866 if (!callee
|| callee
->global
.inlined_to
)
2869 /* We are better to ensure we can refer to it.
2870 In the case of static functions we are out of luck, since we already
2871 removed its body. In the case of public functions we may or may
2872 not introduce the reference. */
2873 if (!canonicalize_constructor_val (target
, NULL
)
2874 || !TREE_PUBLIC (target
))
2877 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2878 "(%s -> %s) but can not refer to it. Giving up.\n",
2879 ie
->caller
->dump_name (),
2880 ie
->callee
->dump_name ());
2883 callee
= cgraph_node::get_create (target
);
2886 /* If the edge is already speculated. */
2887 if (speculative
&& ie
->speculative
)
2889 struct cgraph_edge
*e2
;
2890 struct ipa_ref
*ref
;
2891 ie
->speculative_call_info (e2
, ie
, ref
);
2892 if (e2
->callee
->ultimate_alias_target ()
2893 != callee
->ultimate_alias_target ())
2896 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative "
2897 "target (%s -> %s) but the call is already "
2898 "speculated to %s. Giving up.\n",
2899 ie
->caller
->dump_name (), callee
->dump_name (),
2900 e2
->callee
->dump_name ());
2905 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2906 "(%s -> %s) this agree with previous speculation.\n",
2907 ie
->caller
->dump_name (), callee
->dump_name ());
2912 if (!dbg_cnt (devirt
))
2915 ipa_check_create_node_params ();
2917 /* We can not make edges to inline clones. It is bug that someone removed
2918 the cgraph node too early. */
2919 gcc_assert (!callee
->global
.inlined_to
);
2921 if (dump_file
&& !unreachable
)
2923 fprintf (dump_file
, "ipa-prop: Discovered %s call to a %s target "
2924 "(%s -> %s), for stmt ",
2925 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2926 speculative
? "speculative" : "known",
2927 ie
->caller
->dump_name (),
2928 callee
->dump_name ());
2930 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2932 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2934 if (dump_enabled_p ())
2936 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
2937 "converting indirect call in %s to direct call to %s\n",
2938 ie
->caller
->name (), callee
->name ());
2942 struct cgraph_edge
*orig
= ie
;
2943 ie
= ie
->make_direct (callee
);
2944 /* If we resolved speculative edge the cost is already up to date
2945 for direct call (adjusted by inline_edge_duplication_hook). */
2948 ipa_call_summary
*es
= ipa_call_summaries
->get (ie
);
2949 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2950 - eni_size_weights
.call_cost
);
2951 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2952 - eni_time_weights
.call_cost
);
2957 if (!callee
->can_be_discarded_p ())
2960 alias
= dyn_cast
<cgraph_node
*> (callee
->noninterposable_alias ());
2964 /* make_speculative will update ie's cost to direct call cost. */
2965 ie
= ie
->make_speculative
2966 (callee
, ie
->count
.apply_scale (8, 10));
2972 /* Attempt to locate an interprocedural constant at a given REQ_OFFSET in
2973 CONSTRUCTOR and return it. Return NULL if the search fails for some
2977 find_constructor_constant_at_offset (tree constructor
, HOST_WIDE_INT req_offset
)
2979 tree type
= TREE_TYPE (constructor
);
2980 if (TREE_CODE (type
) != ARRAY_TYPE
2981 && TREE_CODE (type
) != RECORD_TYPE
)
2986 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (constructor
), ix
, index
, val
)
2988 HOST_WIDE_INT elt_offset
;
2989 if (TREE_CODE (type
) == ARRAY_TYPE
)
2992 tree unit_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
2993 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
2997 if (TREE_CODE (index
) == RANGE_EXPR
)
2998 off
= wi::to_offset (TREE_OPERAND (index
, 0));
3000 off
= wi::to_offset (index
);
3001 if (TYPE_DOMAIN (type
) && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)))
3003 tree low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
3004 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
3005 off
= wi::sext (off
- wi::to_offset (low_bound
),
3006 TYPE_PRECISION (TREE_TYPE (index
)));
3008 off
*= wi::to_offset (unit_size
);
3009 /* ??? Handle more than just the first index of a
3013 off
= wi::to_offset (unit_size
) * ix
;
3015 off
= wi::lshift (off
, LOG2_BITS_PER_UNIT
);
3016 if (!wi::fits_shwi_p (off
) || wi::neg_p (off
))
3018 elt_offset
= off
.to_shwi ();
3020 else if (TREE_CODE (type
) == RECORD_TYPE
)
3022 gcc_checking_assert (index
&& TREE_CODE (index
) == FIELD_DECL
);
3023 if (DECL_BIT_FIELD (index
))
3025 elt_offset
= int_bit_position (index
);
3030 if (elt_offset
> req_offset
)
3033 if (TREE_CODE (val
) == CONSTRUCTOR
)
3034 return find_constructor_constant_at_offset (val
,
3035 req_offset
- elt_offset
);
3037 if (elt_offset
== req_offset
3038 && is_gimple_reg_type (TREE_TYPE (val
))
3039 && is_gimple_ip_invariant (val
))
3045 /* Check whether SCALAR could be used to look up an aggregate interprocedural
3046 invariant from a static constructor and if so, return it. Otherwise return
3050 ipa_find_agg_cst_from_init (tree scalar
, HOST_WIDE_INT offset
, bool by_ref
)
3054 if (TREE_CODE (scalar
) != ADDR_EXPR
)
3056 scalar
= TREE_OPERAND (scalar
, 0);
3060 || !is_global_var (scalar
)
3061 || !TREE_READONLY (scalar
)
3062 || !DECL_INITIAL (scalar
)
3063 || TREE_CODE (DECL_INITIAL (scalar
)) != CONSTRUCTOR
)
3066 return find_constructor_constant_at_offset (DECL_INITIAL (scalar
), offset
);
3069 /* Retrieve value from aggregate jump function AGG or static initializer of
3070 SCALAR (which can be NULL) for the given OFFSET or return NULL if there is
3071 none. BY_REF specifies whether the value has to be passed by reference or
3072 by value. If FROM_GLOBAL_CONSTANT is non-NULL, then the boolean it points
3073 to is set to true if the value comes from an initializer of a constant. */
3076 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
, tree scalar
,
3077 HOST_WIDE_INT offset
, bool by_ref
,
3078 bool *from_global_constant
)
3080 struct ipa_agg_jf_item
*item
;
3085 tree res
= ipa_find_agg_cst_from_init (scalar
, offset
, by_ref
);
3088 if (from_global_constant
)
3089 *from_global_constant
= true;
3095 || by_ref
!= agg
->by_ref
)
3098 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
3099 if (item
->offset
== offset
)
3101 /* Currently we do not have clobber values, return NULL for them once
3103 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
3104 if (from_global_constant
)
3105 *from_global_constant
= false;
3111 /* Remove a reference to SYMBOL from the list of references of a node given by
3112 reference description RDESC. Return true if the reference has been
3113 successfully found and removed. */
3116 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
3118 struct ipa_ref
*to_del
;
3119 struct cgraph_edge
*origin
;
3124 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
3125 origin
->lto_stmt_uid
);
3129 to_del
->remove_reference ();
3131 fprintf (dump_file
, "ipa-prop: Removed a reference from %s to %s.\n",
3132 origin
->caller
->dump_name (), xstrdup_for_dump (symbol
->name ()));
3136 /* If JFUNC has a reference description with refcount different from
3137 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
3138 NULL. JFUNC must be a constant jump function. */
3140 static struct ipa_cst_ref_desc
*
3141 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
3143 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
3144 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
3150 /* If the value of constant jump function JFUNC is an address of a function
3151 declaration, return the associated call graph node. Otherwise return
3154 static cgraph_node
*
3155 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
3157 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
3158 tree cst
= ipa_get_jf_constant (jfunc
);
3159 if (TREE_CODE (cst
) != ADDR_EXPR
3160 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
3163 return cgraph_node::get (TREE_OPERAND (cst
, 0));
3167 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
3168 refcount and if it hits zero, remove reference to SYMBOL from the caller of
3169 the edge specified in the rdesc. Return false if either the symbol or the
3170 reference could not be found, otherwise return true. */
3173 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
3175 struct ipa_cst_ref_desc
*rdesc
;
3176 if (jfunc
->type
== IPA_JF_CONST
3177 && (rdesc
= jfunc_rdesc_usable (jfunc
))
3178 && --rdesc
->refcount
== 0)
3180 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
3184 return remove_described_reference (symbol
, rdesc
);
3189 /* Try to find a destination for indirect edge IE that corresponds to a simple
3190 call or a call of a member function pointer and where the destination is a
3191 pointer formal parameter described by jump function JFUNC. TARGET_TYPE is
3192 the type of the parameter to which the result of JFUNC is passed. If it can
3193 be determined, return the newly direct edge, otherwise return NULL.
3194 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
3196 static struct cgraph_edge
*
3197 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
3198 struct ipa_jump_func
*jfunc
, tree target_type
,
3199 struct ipa_node_params
*new_root_info
)
3201 struct cgraph_edge
*cs
;
3203 bool agg_contents
= ie
->indirect_info
->agg_contents
;
3204 tree scalar
= ipa_value_from_jfunc (new_root_info
, jfunc
, target_type
);
3207 bool from_global_constant
;
3208 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3209 ie
->indirect_info
->offset
,
3210 ie
->indirect_info
->by_ref
,
3211 &from_global_constant
);
3213 && !from_global_constant
3214 && !ie
->indirect_info
->guaranteed_unmodified
)
3221 cs
= ipa_make_edge_direct_to_target (ie
, target
);
3223 if (cs
&& !agg_contents
)
3226 gcc_checking_assert (cs
->callee
3228 || jfunc
->type
!= IPA_JF_CONST
3229 || !cgraph_node_for_jfunc (jfunc
)
3230 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
3231 ok
= try_decrement_rdesc_refcount (jfunc
);
3232 gcc_checking_assert (ok
);
3238 /* Return the target to be used in cases of impossible devirtualization. IE
3239 and target (the latter can be NULL) are dumped when dumping is enabled. */
3242 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
3248 "Type inconsistent devirtualization: %s->%s\n",
3249 ie
->caller
->dump_name (),
3250 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
3253 "No devirtualization target in %s\n",
3254 ie
->caller
->dump_name ());
3256 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
3257 cgraph_node::get_create (new_target
);
3261 /* Try to find a destination for indirect edge IE that corresponds to a virtual
3262 call based on a formal parameter which is described by jump function JFUNC
3263 and if it can be determined, make it direct and return the direct edge.
3264 Otherwise, return NULL. CTX describes the polymorphic context that the
3265 parameter the call is based on brings along with it. */
3267 static struct cgraph_edge
*
3268 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
3269 struct ipa_jump_func
*jfunc
,
3270 struct ipa_polymorphic_call_context ctx
)
3273 bool speculative
= false;
3275 if (!opt_for_fn (ie
->caller
->decl
, flag_devirtualize
))
3278 gcc_assert (!ie
->indirect_info
->by_ref
);
3280 /* Try to do lookup via known virtual table pointer value. */
3281 if (!ie
->indirect_info
->vptr_changed
3282 || opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
))
3285 unsigned HOST_WIDE_INT offset
;
3286 tree scalar
= (jfunc
->type
== IPA_JF_CONST
) ? ipa_get_jf_constant (jfunc
)
3288 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3289 ie
->indirect_info
->offset
,
3291 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
3294 t
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
3295 vtable
, offset
, &can_refer
);
3299 || (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
3300 && DECL_FUNCTION_CODE (t
) == BUILT_IN_UNREACHABLE
)
3301 || !possible_polymorphic_call_target_p
3302 (ie
, cgraph_node::get (t
)))
3304 /* Do not speculate builtin_unreachable, it is stupid! */
3305 if (!ie
->indirect_info
->vptr_changed
)
3306 target
= ipa_impossible_devirt_target (ie
, target
);
3313 speculative
= ie
->indirect_info
->vptr_changed
;
3319 ipa_polymorphic_call_context
ie_context (ie
);
3320 vec
<cgraph_node
*>targets
;
3323 ctx
.offset_by (ie
->indirect_info
->offset
);
3324 if (ie
->indirect_info
->vptr_changed
)
3325 ctx
.possible_dynamic_type_change (ie
->in_polymorphic_cdtor
,
3326 ie
->indirect_info
->otr_type
);
3327 ctx
.combine_with (ie_context
, ie
->indirect_info
->otr_type
);
3328 targets
= possible_polymorphic_call_targets
3329 (ie
->indirect_info
->otr_type
,
3330 ie
->indirect_info
->otr_token
,
3332 if (final
&& targets
.length () <= 1)
3334 speculative
= false;
3335 if (targets
.length () == 1)
3336 target
= targets
[0]->decl
;
3338 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3340 else if (!target
&& opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
)
3341 && !ie
->speculative
&& ie
->maybe_hot_p ())
3344 n
= try_speculative_devirtualization (ie
->indirect_info
->otr_type
,
3345 ie
->indirect_info
->otr_token
,
3346 ie
->indirect_info
->context
);
3356 if (!possible_polymorphic_call_target_p
3357 (ie
, cgraph_node::get_create (target
)))
3361 target
= ipa_impossible_devirt_target (ie
, target
);
3363 return ipa_make_edge_direct_to_target (ie
, target
, speculative
);
3369 /* Update the param called notes associated with NODE when CS is being inlined,
3370 assuming NODE is (potentially indirectly) inlined into CS->callee.
3371 Moreover, if the callee is discovered to be constant, create a new cgraph
3372 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3373 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3376 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3377 struct cgraph_node
*node
,
3378 vec
<cgraph_edge
*> *new_edges
)
3380 struct ipa_edge_args
*top
;
3381 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3382 struct ipa_node_params
*new_root_info
, *inlined_node_info
;
3385 ipa_check_create_edge_args ();
3386 top
= IPA_EDGE_REF (cs
);
3387 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3388 ? cs
->caller
->global
.inlined_to
3390 inlined_node_info
= IPA_NODE_REF (cs
->callee
->function_symbol ());
3392 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3394 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3395 struct ipa_jump_func
*jfunc
;
3397 cgraph_node
*spec_target
= NULL
;
3399 next_ie
= ie
->next_callee
;
3401 if (ici
->param_index
== -1)
3404 /* We must check range due to calls with variable number of arguments: */
3405 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3407 ici
->param_index
= -1;
3411 param_index
= ici
->param_index
;
3412 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3414 if (ie
->speculative
)
3416 struct cgraph_edge
*de
;
3417 struct ipa_ref
*ref
;
3418 ie
->speculative_call_info (de
, ie
, ref
);
3419 spec_target
= de
->callee
;
3422 if (!opt_for_fn (node
->decl
, flag_indirect_inlining
))
3423 new_direct_edge
= NULL
;
3424 else if (ici
->polymorphic
)
3426 ipa_polymorphic_call_context ctx
;
3427 ctx
= ipa_context_from_jfunc (new_root_info
, cs
, param_index
, jfunc
);
3428 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
, ctx
);
3432 tree target_type
= ipa_get_type (inlined_node_info
, param_index
);
3433 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3438 /* If speculation was removed, then we need to do nothing. */
3439 if (new_direct_edge
&& new_direct_edge
!= ie
3440 && new_direct_edge
->callee
== spec_target
)
3442 new_direct_edge
->indirect_inlining_edge
= 1;
3443 top
= IPA_EDGE_REF (cs
);
3445 if (!new_direct_edge
->speculative
)
3448 else if (new_direct_edge
)
3450 new_direct_edge
->indirect_inlining_edge
= 1;
3451 if (new_direct_edge
->call_stmt
)
3452 new_direct_edge
->call_stmt_cannot_inline_p
3453 = !gimple_check_call_matching_types (
3454 new_direct_edge
->call_stmt
,
3455 new_direct_edge
->callee
->decl
, false);
3458 new_edges
->safe_push (new_direct_edge
);
3461 top
= IPA_EDGE_REF (cs
);
3462 /* If speculative edge was introduced we still need to update
3463 call info of the indirect edge. */
3464 if (!new_direct_edge
->speculative
)
3467 if (jfunc
->type
== IPA_JF_PASS_THROUGH
3468 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3470 if (ici
->agg_contents
3471 && !ipa_get_jf_pass_through_agg_preserved (jfunc
)
3472 && !ici
->polymorphic
)
3473 ici
->param_index
= -1;
3476 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3477 if (ici
->polymorphic
3478 && !ipa_get_jf_pass_through_type_preserved (jfunc
))
3479 ici
->vptr_changed
= true;
3482 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3484 if (ici
->agg_contents
3485 && !ipa_get_jf_ancestor_agg_preserved (jfunc
)
3486 && !ici
->polymorphic
)
3487 ici
->param_index
= -1;
3490 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3491 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3492 if (ici
->polymorphic
3493 && !ipa_get_jf_ancestor_type_preserved (jfunc
))
3494 ici
->vptr_changed
= true;
3498 /* Either we can find a destination for this edge now or never. */
3499 ici
->param_index
= -1;
3505 /* Recursively traverse subtree of NODE (including node) made of inlined
3506 cgraph_edges when CS has been inlined and invoke
3507 update_indirect_edges_after_inlining on all nodes and
3508 update_jump_functions_after_inlining on all non-inlined edges that lead out
3509 of this subtree. Newly discovered indirect edges will be added to
3510 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3514 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3515 struct cgraph_node
*node
,
3516 vec
<cgraph_edge
*> *new_edges
)
3518 struct cgraph_edge
*e
;
3521 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3523 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3524 if (!e
->inline_failed
)
3525 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3527 update_jump_functions_after_inlining (cs
, e
);
3528 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3529 update_jump_functions_after_inlining (cs
, e
);
3534 /* Combine two controlled uses counts as done during inlining. */
3537 combine_controlled_uses_counters (int c
, int d
)
3539 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3540 return IPA_UNDESCRIBED_USE
;
3545 /* Propagate number of controlled users from CS->caleee to the new root of the
3546 tree of inlined nodes. */
3549 propagate_controlled_uses (struct cgraph_edge
*cs
)
3551 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3552 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3553 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3554 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3555 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3558 count
= MIN (ipa_get_cs_argument_count (args
),
3559 ipa_get_param_count (old_root_info
));
3560 for (i
= 0; i
< count
; i
++)
3562 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3563 struct ipa_cst_ref_desc
*rdesc
;
3565 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3568 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3569 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3570 d
= ipa_get_controlled_uses (old_root_info
, i
);
3572 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3573 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3574 c
= combine_controlled_uses_counters (c
, d
);
3575 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3576 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3578 struct cgraph_node
*n
;
3579 struct ipa_ref
*ref
;
3580 tree t
= new_root_info
->known_csts
[src_idx
];
3582 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3583 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3584 && (n
= cgraph_node::get (TREE_OPERAND (t
, 0)))
3585 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3588 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3589 "reference from %s to %s.\n",
3590 new_root
->dump_name (),
3592 ref
->remove_reference ();
3596 else if (jf
->type
== IPA_JF_CONST
3597 && (rdesc
= jfunc_rdesc_usable (jf
)))
3599 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3600 int c
= rdesc
->refcount
;
3601 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3602 if (rdesc
->refcount
== 0)
3604 tree cst
= ipa_get_jf_constant (jf
);
3605 struct cgraph_node
*n
;
3606 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3607 && TREE_CODE (TREE_OPERAND (cst
, 0))
3609 n
= cgraph_node::get (TREE_OPERAND (cst
, 0));
3612 struct cgraph_node
*clone
;
3614 ok
= remove_described_reference (n
, rdesc
);
3615 gcc_checking_assert (ok
);
3618 while (clone
->global
.inlined_to
3619 && clone
!= rdesc
->cs
->caller
3620 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3622 struct ipa_ref
*ref
;
3623 ref
= clone
->find_reference (n
, NULL
, 0);
3627 fprintf (dump_file
, "ipa-prop: Removing "
3628 "cloning-created reference "
3630 clone
->dump_name (),
3632 ref
->remove_reference ();
3634 clone
= clone
->callers
->caller
;
3641 for (i
= ipa_get_param_count (old_root_info
);
3642 i
< ipa_get_cs_argument_count (args
);
3645 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3647 if (jf
->type
== IPA_JF_CONST
)
3649 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3651 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3653 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3654 ipa_set_controlled_uses (new_root_info
,
3655 jf
->value
.pass_through
.formal_id
,
3656 IPA_UNDESCRIBED_USE
);
3660 /* Update jump functions and call note functions on inlining the call site CS.
3661 CS is expected to lead to a node already cloned by
3662 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3663 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3667 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3668 vec
<cgraph_edge
*> *new_edges
)
3671 /* Do nothing if the preparation phase has not been carried out yet
3672 (i.e. during early inlining). */
3673 if (!ipa_node_params_sum
)
3675 gcc_assert (ipa_edge_args_sum
);
3677 propagate_controlled_uses (cs
);
3678 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3683 /* Ensure that array of edge arguments infos is big enough to accommodate a
3684 structure for all edges and reallocates it if not. Also, allocate
3685 associated hash tables is they do not already exist. */
3688 ipa_check_create_edge_args (void)
3690 if (!ipa_edge_args_sum
)
3692 = (new (ggc_cleared_alloc
<ipa_edge_args_sum_t
> ())
3693 ipa_edge_args_sum_t (symtab
, true));
3694 if (!ipa_bits_hash_table
)
3695 ipa_bits_hash_table
= hash_table
<ipa_bit_ggc_hash_traits
>::create_ggc (37);
3696 if (!ipa_vr_hash_table
)
3697 ipa_vr_hash_table
= hash_table
<ipa_vr_ggc_hash_traits
>::create_ggc (37);
3700 /* Free all ipa_edge structures. */
3703 ipa_free_all_edge_args (void)
3705 if (!ipa_edge_args_sum
)
3708 ipa_edge_args_sum
->release ();
3709 ipa_edge_args_sum
= NULL
;
3712 /* Free all ipa_node_params structures. */
3715 ipa_free_all_node_params (void)
3717 ipa_node_params_sum
->release ();
3718 ipa_node_params_sum
= NULL
;
3721 /* Initialize IPA CP transformation summary and also allocate any necessary hash
3722 tables if they do not already exist. */
3725 ipcp_transformation_initialize (void)
3727 if (!ipa_bits_hash_table
)
3728 ipa_bits_hash_table
= hash_table
<ipa_bit_ggc_hash_traits
>::create_ggc (37);
3729 if (!ipa_vr_hash_table
)
3730 ipa_vr_hash_table
= hash_table
<ipa_vr_ggc_hash_traits
>::create_ggc (37);
3731 if (ipcp_transformation_sum
== NULL
)
3732 ipcp_transformation_sum
= ipcp_transformation_t::create_ggc (symtab
);
3735 /* Set the aggregate replacements of NODE to be AGGVALS. */
3738 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3739 struct ipa_agg_replacement_value
*aggvals
)
3741 ipcp_transformation_initialize ();
3742 ipcp_transformation
*s
= ipcp_transformation_sum
->get_create (node
);
3743 s
->agg_values
= aggvals
;
3746 /* Hook that is called by cgraph.c when an edge is removed. Adjust reference
3747 count data structures accordingly. */
3750 ipa_edge_args_sum_t::remove (cgraph_edge
*cs
, ipa_edge_args
*args
)
3752 if (args
->jump_functions
)
3754 struct ipa_jump_func
*jf
;
3756 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3758 struct ipa_cst_ref_desc
*rdesc
;
3759 try_decrement_rdesc_refcount (jf
);
3760 if (jf
->type
== IPA_JF_CONST
3761 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3768 /* Method invoked when an edge is duplicated. Copy ipa_edge_args and adjust
3769 reference count data strucutres accordingly. */
3772 ipa_edge_args_sum_t::duplicate (cgraph_edge
*src
, cgraph_edge
*dst
,
3773 ipa_edge_args
*old_args
, ipa_edge_args
*new_args
)
3777 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3778 if (old_args
->polymorphic_call_contexts
)
3779 new_args
->polymorphic_call_contexts
3780 = vec_safe_copy (old_args
->polymorphic_call_contexts
);
3782 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3784 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3785 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3787 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3789 if (src_jf
->type
== IPA_JF_CONST
)
3791 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3794 dst_jf
->value
.constant
.rdesc
= NULL
;
3795 else if (src
->caller
== dst
->caller
)
3797 struct ipa_ref
*ref
;
3798 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3799 gcc_checking_assert (n
);
3800 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3802 gcc_checking_assert (ref
);
3803 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3805 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3806 dst_rdesc
->cs
= dst
;
3807 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3808 dst_rdesc
->next_duplicate
= NULL
;
3809 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3811 else if (src_rdesc
->cs
== src
)
3813 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3814 dst_rdesc
->cs
= dst
;
3815 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3816 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3817 src_rdesc
->next_duplicate
= dst_rdesc
;
3818 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3822 struct ipa_cst_ref_desc
*dst_rdesc
;
3823 /* This can happen during inlining, when a JFUNC can refer to a
3824 reference taken in a function up in the tree of inline clones.
3825 We need to find the duplicate that refers to our tree of
3828 gcc_assert (dst
->caller
->global
.inlined_to
);
3829 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3831 dst_rdesc
= dst_rdesc
->next_duplicate
)
3833 struct cgraph_node
*top
;
3834 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3835 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3836 : dst_rdesc
->cs
->caller
;
3837 if (dst
->caller
->global
.inlined_to
== top
)
3840 gcc_assert (dst_rdesc
);
3841 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3844 else if (dst_jf
->type
== IPA_JF_PASS_THROUGH
3845 && src
->caller
== dst
->caller
)
3847 struct cgraph_node
*inline_root
= dst
->caller
->global
.inlined_to
3848 ? dst
->caller
->global
.inlined_to
: dst
->caller
;
3849 struct ipa_node_params
*root_info
= IPA_NODE_REF (inline_root
);
3850 int idx
= ipa_get_jf_pass_through_formal_id (dst_jf
);
3852 int c
= ipa_get_controlled_uses (root_info
, idx
);
3853 if (c
!= IPA_UNDESCRIBED_USE
)
3856 ipa_set_controlled_uses (root_info
, idx
, c
);
3862 /* Analyze newly added function into callgraph. */
3865 ipa_add_new_function (cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3867 if (node
->has_gimple_body_p ())
3868 ipa_analyze_node (node
);
3871 /* Hook that is called by summary when a node is duplicated. */
3874 ipa_node_params_t::duplicate(cgraph_node
*src
, cgraph_node
*dst
,
3875 ipa_node_params
*old_info
,
3876 ipa_node_params
*new_info
)
3878 ipa_agg_replacement_value
*old_av
, *new_av
;
3880 new_info
->descriptors
= vec_safe_copy (old_info
->descriptors
);
3881 new_info
->lattices
= NULL
;
3882 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3883 new_info
->known_csts
= old_info
->known_csts
.copy ();
3884 new_info
->known_contexts
= old_info
->known_contexts
.copy ();
3886 new_info
->analysis_done
= old_info
->analysis_done
;
3887 new_info
->node_enqueued
= old_info
->node_enqueued
;
3888 new_info
->versionable
= old_info
->versionable
;
3890 old_av
= ipa_get_agg_replacements_for_node (src
);
3896 struct ipa_agg_replacement_value
*v
;
3898 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3899 memcpy (v
, old_av
, sizeof (*v
));
3902 old_av
= old_av
->next
;
3904 ipa_set_node_agg_value_chain (dst
, new_av
);
3907 ipcp_transformation
*src_trans
= ipcp_get_transformation_summary (src
);
3911 ipcp_transformation_initialize ();
3912 src_trans
= ipcp_transformation_sum
->get_create (src
);
3913 ipcp_transformation
*dst_trans
3914 = ipcp_transformation_sum
->get_create (dst
);
3916 dst_trans
->bits
= vec_safe_copy (src_trans
->bits
);
3918 const vec
<ipa_vr
, va_gc
> *src_vr
= src_trans
->m_vr
;
3919 vec
<ipa_vr
, va_gc
> *&dst_vr
3920 = ipcp_get_transformation_summary (dst
)->m_vr
;
3921 if (vec_safe_length (src_trans
->m_vr
) > 0)
3923 vec_safe_reserve_exact (dst_vr
, src_vr
->length ());
3924 for (unsigned i
= 0; i
< src_vr
->length (); ++i
)
3925 dst_vr
->quick_push ((*src_vr
)[i
]);
3930 /* Register our cgraph hooks if they are not already there. */
3933 ipa_register_cgraph_hooks (void)
3935 ipa_check_create_node_params ();
3936 ipa_check_create_edge_args ();
3938 function_insertion_hook_holder
=
3939 symtab
->add_cgraph_insertion_hook (&ipa_add_new_function
, NULL
);
3942 /* Unregister our cgraph hooks if they are not already there. */
3945 ipa_unregister_cgraph_hooks (void)
3947 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
3948 function_insertion_hook_holder
= NULL
;
3951 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3952 longer needed after ipa-cp. */
3955 ipa_free_all_structures_after_ipa_cp (void)
3957 if (!optimize
&& !in_lto_p
)
3959 ipa_free_all_edge_args ();
3960 ipa_free_all_node_params ();
3961 ipcp_sources_pool
.release ();
3962 ipcp_cst_values_pool
.release ();
3963 ipcp_poly_ctx_values_pool
.release ();
3964 ipcp_agg_lattice_pool
.release ();
3965 ipa_unregister_cgraph_hooks ();
3966 ipa_refdesc_pool
.release ();
3970 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3971 longer needed after indirect inlining. */
3974 ipa_free_all_structures_after_iinln (void)
3976 ipa_free_all_edge_args ();
3977 ipa_free_all_node_params ();
3978 ipa_unregister_cgraph_hooks ();
3979 ipcp_sources_pool
.release ();
3980 ipcp_cst_values_pool
.release ();
3981 ipcp_poly_ctx_values_pool
.release ();
3982 ipcp_agg_lattice_pool
.release ();
3983 ipa_refdesc_pool
.release ();
3986 /* Print ipa_tree_map data structures of all functions in the
3990 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3993 struct ipa_node_params
*info
;
3995 if (!node
->definition
)
3997 info
= IPA_NODE_REF (node
);
3998 fprintf (f
, " function %s parameter descriptors:\n", node
->dump_name ());
3999 count
= ipa_get_param_count (info
);
4000 for (i
= 0; i
< count
; i
++)
4005 ipa_dump_param (f
, info
, i
);
4006 if (ipa_is_param_used (info
, i
))
4007 fprintf (f
, " used");
4008 c
= ipa_get_controlled_uses (info
, i
);
4009 if (c
== IPA_UNDESCRIBED_USE
)
4010 fprintf (f
, " undescribed_use");
4012 fprintf (f
, " controlled_uses=%i", c
);
4017 /* Print ipa_tree_map data structures of all functions in the
4021 ipa_print_all_params (FILE * f
)
4023 struct cgraph_node
*node
;
4025 fprintf (f
, "\nFunction parameters:\n");
4026 FOR_EACH_FUNCTION (node
)
4027 ipa_print_node_params (f
, node
);
4030 /* Dump the AV linked list. */
4033 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4036 fprintf (f
, " Aggregate replacements:");
4037 for (; av
; av
= av
->next
)
4039 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4040 av
->index
, av
->offset
);
4041 print_generic_expr (f
, av
->value
);
4047 /* Stream out jump function JUMP_FUNC to OB. */
4050 ipa_write_jump_function (struct output_block
*ob
,
4051 struct ipa_jump_func
*jump_func
)
4053 struct ipa_agg_jf_item
*item
;
4054 struct bitpack_d bp
;
4058 /* ADDR_EXPRs are very comon IP invariants; save some streamer data
4059 as well as WPA memory by handling them specially. */
4060 if (jump_func
->type
== IPA_JF_CONST
4061 && TREE_CODE (jump_func
->value
.constant
.value
) == ADDR_EXPR
)
4064 streamer_write_uhwi (ob
, jump_func
->type
* 2 + flag
);
4065 switch (jump_func
->type
)
4067 case IPA_JF_UNKNOWN
:
4071 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4072 stream_write_tree (ob
,
4074 ? TREE_OPERAND (jump_func
->value
.constant
.value
, 0)
4075 : jump_func
->value
.constant
.value
, true);
4077 case IPA_JF_PASS_THROUGH
:
4078 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4079 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4081 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4082 bp
= bitpack_create (ob
->main_stream
);
4083 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4084 streamer_write_bitpack (&bp
);
4086 else if (TREE_CODE_CLASS (jump_func
->value
.pass_through
.operation
)
4088 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4091 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4092 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4095 case IPA_JF_ANCESTOR
:
4096 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4097 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4098 bp
= bitpack_create (ob
->main_stream
);
4099 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4100 streamer_write_bitpack (&bp
);
4104 count
= vec_safe_length (jump_func
->agg
.items
);
4105 streamer_write_uhwi (ob
, count
);
4108 bp
= bitpack_create (ob
->main_stream
);
4109 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4110 streamer_write_bitpack (&bp
);
4113 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4115 streamer_write_uhwi (ob
, item
->offset
);
4116 stream_write_tree (ob
, item
->value
, true);
4119 bp
= bitpack_create (ob
->main_stream
);
4120 bp_pack_value (&bp
, !!jump_func
->bits
, 1);
4121 streamer_write_bitpack (&bp
);
4122 if (jump_func
->bits
)
4124 streamer_write_widest_int (ob
, jump_func
->bits
->value
);
4125 streamer_write_widest_int (ob
, jump_func
->bits
->mask
);
4127 bp_pack_value (&bp
, !!jump_func
->m_vr
, 1);
4128 streamer_write_bitpack (&bp
);
4129 if (jump_func
->m_vr
)
4131 streamer_write_enum (ob
->main_stream
, value_rang_type
,
4132 VR_LAST
, jump_func
->m_vr
->kind ());
4133 stream_write_tree (ob
, jump_func
->m_vr
->min (), true);
4134 stream_write_tree (ob
, jump_func
->m_vr
->max (), true);
4138 /* Read in jump function JUMP_FUNC from IB. */
4141 ipa_read_jump_function (struct lto_input_block
*ib
,
4142 struct ipa_jump_func
*jump_func
,
4143 struct cgraph_edge
*cs
,
4144 struct data_in
*data_in
,
4147 enum jump_func_type jftype
;
4148 enum tree_code operation
;
4150 int val
= streamer_read_uhwi (ib
);
4151 bool flag
= val
& 1;
4153 jftype
= (enum jump_func_type
) (val
/ 2);
4156 case IPA_JF_UNKNOWN
:
4157 ipa_set_jf_unknown (jump_func
);
4161 tree t
= stream_read_tree (ib
, data_in
);
4162 if (flag
&& prevails
)
4163 t
= build_fold_addr_expr (t
);
4164 ipa_set_jf_constant (jump_func
, t
, cs
);
4167 case IPA_JF_PASS_THROUGH
:
4168 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4169 if (operation
== NOP_EXPR
)
4171 int formal_id
= streamer_read_uhwi (ib
);
4172 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4173 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4174 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
);
4176 else if (TREE_CODE_CLASS (operation
) == tcc_unary
)
4178 int formal_id
= streamer_read_uhwi (ib
);
4179 ipa_set_jf_unary_pass_through (jump_func
, formal_id
, operation
);
4183 tree operand
= stream_read_tree (ib
, data_in
);
4184 int formal_id
= streamer_read_uhwi (ib
);
4185 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4189 case IPA_JF_ANCESTOR
:
4191 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4192 int formal_id
= streamer_read_uhwi (ib
);
4193 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4194 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4195 ipa_set_ancestor_jf (jump_func
, offset
, formal_id
, agg_preserved
);
4199 fatal_error (UNKNOWN_LOCATION
, "invalid jump function in LTO stream");
4202 count
= streamer_read_uhwi (ib
);
4204 vec_alloc (jump_func
->agg
.items
, count
);
4207 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4208 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4210 for (i
= 0; i
< count
; i
++)
4212 struct ipa_agg_jf_item item
;
4213 item
.offset
= streamer_read_uhwi (ib
);
4214 item
.value
= stream_read_tree (ib
, data_in
);
4216 jump_func
->agg
.items
->quick_push (item
);
4219 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4220 bool bits_known
= bp_unpack_value (&bp
, 1);
4223 widest_int value
= streamer_read_widest_int (ib
);
4224 widest_int mask
= streamer_read_widest_int (ib
);
4226 ipa_set_jfunc_bits (jump_func
, value
, mask
);
4229 jump_func
->bits
= NULL
;
4231 struct bitpack_d vr_bp
= streamer_read_bitpack (ib
);
4232 bool vr_known
= bp_unpack_value (&vr_bp
, 1);
4235 enum value_range_kind type
= streamer_read_enum (ib
, value_range_kind
,
4237 tree min
= stream_read_tree (ib
, data_in
);
4238 tree max
= stream_read_tree (ib
, data_in
);
4240 ipa_set_jfunc_vr (jump_func
, type
, min
, max
);
4243 jump_func
->m_vr
= NULL
;
4246 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4247 relevant to indirect inlining to OB. */
4250 ipa_write_indirect_edge_info (struct output_block
*ob
,
4251 struct cgraph_edge
*cs
)
4253 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4254 struct bitpack_d bp
;
4256 streamer_write_hwi (ob
, ii
->param_index
);
4257 bp
= bitpack_create (ob
->main_stream
);
4258 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4259 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4260 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4261 bp_pack_value (&bp
, ii
->by_ref
, 1);
4262 bp_pack_value (&bp
, ii
->guaranteed_unmodified
, 1);
4263 bp_pack_value (&bp
, ii
->vptr_changed
, 1);
4264 streamer_write_bitpack (&bp
);
4265 if (ii
->agg_contents
|| ii
->polymorphic
)
4266 streamer_write_hwi (ob
, ii
->offset
);
4268 gcc_assert (ii
->offset
== 0);
4270 if (ii
->polymorphic
)
4272 streamer_write_hwi (ob
, ii
->otr_token
);
4273 stream_write_tree (ob
, ii
->otr_type
, true);
4274 ii
->context
.stream_out (ob
);
4278 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4279 relevant to indirect inlining from IB. */
4282 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4283 struct data_in
*data_in
,
4284 struct cgraph_edge
*cs
)
4286 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4287 struct bitpack_d bp
;
4289 ii
->param_index
= (int) streamer_read_hwi (ib
);
4290 bp
= streamer_read_bitpack (ib
);
4291 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4292 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4293 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4294 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4295 ii
->guaranteed_unmodified
= bp_unpack_value (&bp
, 1);
4296 ii
->vptr_changed
= bp_unpack_value (&bp
, 1);
4297 if (ii
->agg_contents
|| ii
->polymorphic
)
4298 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4301 if (ii
->polymorphic
)
4303 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4304 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4305 ii
->context
.stream_in (ib
, data_in
);
4309 /* Stream out NODE info to OB. */
4312 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4315 lto_symtab_encoder_t encoder
;
4316 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4318 struct cgraph_edge
*e
;
4319 struct bitpack_d bp
;
4321 encoder
= ob
->decl_state
->symtab_node_encoder
;
4322 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4323 streamer_write_uhwi (ob
, node_ref
);
4325 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4326 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4327 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4328 bp
= bitpack_create (ob
->main_stream
);
4329 gcc_assert (info
->analysis_done
4330 || ipa_get_param_count (info
) == 0);
4331 gcc_assert (!info
->node_enqueued
);
4332 gcc_assert (!info
->ipcp_orig_node
);
4333 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4334 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4335 streamer_write_bitpack (&bp
);
4336 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4338 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4339 stream_write_tree (ob
, ipa_get_type (info
, j
), true);
4341 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4343 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4345 streamer_write_uhwi (ob
,
4346 ipa_get_cs_argument_count (args
) * 2
4347 + (args
->polymorphic_call_contexts
!= NULL
));
4348 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4350 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4351 if (args
->polymorphic_call_contexts
!= NULL
)
4352 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4355 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4357 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4359 streamer_write_uhwi (ob
,
4360 ipa_get_cs_argument_count (args
) * 2
4361 + (args
->polymorphic_call_contexts
!= NULL
));
4362 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4364 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4365 if (args
->polymorphic_call_contexts
!= NULL
)
4366 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4368 ipa_write_indirect_edge_info (ob
, e
);
4372 /* Stream in edge E from IB. */
4375 ipa_read_edge_info (struct lto_input_block
*ib
,
4376 struct data_in
*data_in
,
4377 struct cgraph_edge
*e
, bool prevails
)
4379 int count
= streamer_read_uhwi (ib
);
4380 bool contexts_computed
= count
& 1;
4385 if (prevails
&& e
->possibly_call_in_translation_unit_p ())
4387 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4388 vec_safe_grow_cleared (args
->jump_functions
, count
);
4389 if (contexts_computed
)
4390 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4391 for (int k
= 0; k
< count
; k
++)
4393 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4395 if (contexts_computed
)
4396 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in
4402 for (int k
= 0; k
< count
; k
++)
4404 struct ipa_jump_func dummy
;
4405 ipa_read_jump_function (ib
, &dummy
, e
,
4407 if (contexts_computed
)
4409 struct ipa_polymorphic_call_context ctx
;
4410 ctx
.stream_in (ib
, data_in
);
4416 /* Stream in NODE info from IB. */
4419 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4420 struct data_in
*data_in
)
4423 struct cgraph_edge
*e
;
4424 struct bitpack_d bp
;
4425 bool prevails
= node
->prevailing_p ();
4426 struct ipa_node_params
*info
= prevails
? IPA_NODE_REF (node
) : NULL
;
4428 int param_count
= streamer_read_uhwi (ib
);
4431 ipa_alloc_node_params (node
, param_count
);
4432 for (k
= 0; k
< param_count
; k
++)
4433 (*info
->descriptors
)[k
].move_cost
= streamer_read_uhwi (ib
);
4434 if (ipa_get_param_count (info
) != 0)
4435 info
->analysis_done
= true;
4436 info
->node_enqueued
= false;
4439 for (k
= 0; k
< param_count
; k
++)
4440 streamer_read_uhwi (ib
);
4442 bp
= streamer_read_bitpack (ib
);
4443 for (k
= 0; k
< param_count
; k
++)
4445 bool used
= bp_unpack_value (&bp
, 1);
4448 ipa_set_param_used (info
, k
, used
);
4450 for (k
= 0; k
< param_count
; k
++)
4452 int nuses
= streamer_read_hwi (ib
);
4453 tree type
= stream_read_tree (ib
, data_in
);
4457 ipa_set_controlled_uses (info
, k
, nuses
);
4458 (*info
->descriptors
)[k
].decl_or_type
= type
;
4461 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4462 ipa_read_edge_info (ib
, data_in
, e
, prevails
);
4463 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4465 ipa_read_edge_info (ib
, data_in
, e
, prevails
);
4466 ipa_read_indirect_edge_info (ib
, data_in
, e
);
4470 /* Write jump functions for nodes in SET. */
4473 ipa_prop_write_jump_functions (void)
4475 struct cgraph_node
*node
;
4476 struct output_block
*ob
;
4477 unsigned int count
= 0;
4478 lto_symtab_encoder_iterator lsei
;
4479 lto_symtab_encoder_t encoder
;
4481 if (!ipa_node_params_sum
|| !ipa_edge_args_sum
)
4484 ob
= create_output_block (LTO_section_jump_functions
);
4485 encoder
= ob
->decl_state
->symtab_node_encoder
;
4487 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4488 lsei_next_function_in_partition (&lsei
))
4490 node
= lsei_cgraph_node (lsei
);
4491 if (node
->has_gimple_body_p ()
4492 && IPA_NODE_REF (node
) != NULL
)
4496 streamer_write_uhwi (ob
, count
);
4498 /* Process all of the functions. */
4499 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4500 lsei_next_function_in_partition (&lsei
))
4502 node
= lsei_cgraph_node (lsei
);
4503 if (node
->has_gimple_body_p ()
4504 && IPA_NODE_REF (node
) != NULL
)
4505 ipa_write_node_info (ob
, node
);
4507 streamer_write_char_stream (ob
->main_stream
, 0);
4508 produce_asm (ob
, NULL
);
4509 destroy_output_block (ob
);
4512 /* Read section in file FILE_DATA of length LEN with data DATA. */
4515 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
4518 const struct lto_function_header
*header
=
4519 (const struct lto_function_header
*) data
;
4520 const int cfg_offset
= sizeof (struct lto_function_header
);
4521 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4522 const int string_offset
= main_offset
+ header
->main_size
;
4523 struct data_in
*data_in
;
4527 lto_input_block
ib_main ((const char *) data
+ main_offset
,
4528 header
->main_size
, file_data
->mode_table
);
4531 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4532 header
->string_size
, vNULL
);
4533 count
= streamer_read_uhwi (&ib_main
);
4535 for (i
= 0; i
< count
; i
++)
4538 struct cgraph_node
*node
;
4539 lto_symtab_encoder_t encoder
;
4541 index
= streamer_read_uhwi (&ib_main
);
4542 encoder
= file_data
->symtab_node_encoder
;
4543 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
4545 gcc_assert (node
->definition
);
4546 ipa_read_node_info (&ib_main
, node
, data_in
);
4548 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4550 lto_data_in_delete (data_in
);
4553 /* Read ipcp jump functions. */
4556 ipa_prop_read_jump_functions (void)
4558 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4559 struct lto_file_decl_data
*file_data
;
4562 ipa_check_create_node_params ();
4563 ipa_check_create_edge_args ();
4564 ipa_register_cgraph_hooks ();
4566 while ((file_data
= file_data_vec
[j
++]))
4569 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
4572 ipa_prop_read_section (file_data
, data
, len
);
4577 write_ipcp_transformation_info (output_block
*ob
, cgraph_node
*node
)
4580 unsigned int count
= 0;
4581 lto_symtab_encoder_t encoder
;
4582 struct ipa_agg_replacement_value
*aggvals
, *av
;
4584 aggvals
= ipa_get_agg_replacements_for_node (node
);
4585 encoder
= ob
->decl_state
->symtab_node_encoder
;
4586 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4587 streamer_write_uhwi (ob
, node_ref
);
4589 for (av
= aggvals
; av
; av
= av
->next
)
4591 streamer_write_uhwi (ob
, count
);
4593 for (av
= aggvals
; av
; av
= av
->next
)
4595 struct bitpack_d bp
;
4597 streamer_write_uhwi (ob
, av
->offset
);
4598 streamer_write_uhwi (ob
, av
->index
);
4599 stream_write_tree (ob
, av
->value
, true);
4601 bp
= bitpack_create (ob
->main_stream
);
4602 bp_pack_value (&bp
, av
->by_ref
, 1);
4603 streamer_write_bitpack (&bp
);
4606 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
4607 if (ts
&& vec_safe_length (ts
->m_vr
) > 0)
4609 count
= ts
->m_vr
->length ();
4610 streamer_write_uhwi (ob
, count
);
4611 for (unsigned i
= 0; i
< count
; ++i
)
4613 struct bitpack_d bp
;
4614 ipa_vr
*parm_vr
= &(*ts
->m_vr
)[i
];
4615 bp
= bitpack_create (ob
->main_stream
);
4616 bp_pack_value (&bp
, parm_vr
->known
, 1);
4617 streamer_write_bitpack (&bp
);
4620 streamer_write_enum (ob
->main_stream
, value_rang_type
,
4621 VR_LAST
, parm_vr
->type
);
4622 streamer_write_wide_int (ob
, parm_vr
->min
);
4623 streamer_write_wide_int (ob
, parm_vr
->max
);
4628 streamer_write_uhwi (ob
, 0);
4630 if (ts
&& vec_safe_length (ts
->bits
) > 0)
4632 count
= ts
->bits
->length ();
4633 streamer_write_uhwi (ob
, count
);
4635 for (unsigned i
= 0; i
< count
; ++i
)
4637 const ipa_bits
*bits_jfunc
= (*ts
->bits
)[i
];
4638 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
4639 bp_pack_value (&bp
, !!bits_jfunc
, 1);
4640 streamer_write_bitpack (&bp
);
4643 streamer_write_widest_int (ob
, bits_jfunc
->value
);
4644 streamer_write_widest_int (ob
, bits_jfunc
->mask
);
4649 streamer_write_uhwi (ob
, 0);
4652 /* Stream in the aggregate value replacement chain for NODE from IB. */
4655 read_ipcp_transformation_info (lto_input_block
*ib
, cgraph_node
*node
,
4658 struct ipa_agg_replacement_value
*aggvals
= NULL
;
4659 unsigned int count
, i
;
4661 count
= streamer_read_uhwi (ib
);
4662 for (i
= 0; i
<count
; i
++)
4664 struct ipa_agg_replacement_value
*av
;
4665 struct bitpack_d bp
;
4667 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
4668 av
->offset
= streamer_read_uhwi (ib
);
4669 av
->index
= streamer_read_uhwi (ib
);
4670 av
->value
= stream_read_tree (ib
, data_in
);
4671 bp
= streamer_read_bitpack (ib
);
4672 av
->by_ref
= bp_unpack_value (&bp
, 1);
4676 ipa_set_node_agg_value_chain (node
, aggvals
);
4678 count
= streamer_read_uhwi (ib
);
4681 ipcp_transformation_initialize ();
4682 ipcp_transformation
*ts
= ipcp_transformation_sum
->get_create (node
);
4683 vec_safe_grow_cleared (ts
->m_vr
, count
);
4684 for (i
= 0; i
< count
; i
++)
4687 parm_vr
= &(*ts
->m_vr
)[i
];
4688 struct bitpack_d bp
;
4689 bp
= streamer_read_bitpack (ib
);
4690 parm_vr
->known
= bp_unpack_value (&bp
, 1);
4693 parm_vr
->type
= streamer_read_enum (ib
, value_range_kind
,
4695 parm_vr
->min
= streamer_read_wide_int (ib
);
4696 parm_vr
->max
= streamer_read_wide_int (ib
);
4700 count
= streamer_read_uhwi (ib
);
4703 ipcp_transformation_initialize ();
4704 ipcp_transformation
*ts
= ipcp_transformation_sum
->get_create (node
);
4705 vec_safe_grow_cleared (ts
->bits
, count
);
4707 for (i
= 0; i
< count
; i
++)
4709 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4710 bool known
= bp_unpack_value (&bp
, 1);
4714 = ipa_get_ipa_bits_for_value (streamer_read_widest_int (ib
),
4715 streamer_read_widest_int (ib
));
4716 (*ts
->bits
)[i
] = bits
;
4722 /* Write all aggregate replacement for nodes in set. */
4725 ipcp_write_transformation_summaries (void)
4727 struct cgraph_node
*node
;
4728 struct output_block
*ob
;
4729 unsigned int count
= 0;
4730 lto_symtab_encoder_iterator lsei
;
4731 lto_symtab_encoder_t encoder
;
4733 ob
= create_output_block (LTO_section_ipcp_transform
);
4734 encoder
= ob
->decl_state
->symtab_node_encoder
;
4736 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4737 lsei_next_function_in_partition (&lsei
))
4739 node
= lsei_cgraph_node (lsei
);
4740 if (node
->has_gimple_body_p ())
4744 streamer_write_uhwi (ob
, count
);
4746 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4747 lsei_next_function_in_partition (&lsei
))
4749 node
= lsei_cgraph_node (lsei
);
4750 if (node
->has_gimple_body_p ())
4751 write_ipcp_transformation_info (ob
, node
);
4753 streamer_write_char_stream (ob
->main_stream
, 0);
4754 produce_asm (ob
, NULL
);
4755 destroy_output_block (ob
);
4758 /* Read replacements section in file FILE_DATA of length LEN with data
4762 read_replacements_section (struct lto_file_decl_data
*file_data
,
4766 const struct lto_function_header
*header
=
4767 (const struct lto_function_header
*) data
;
4768 const int cfg_offset
= sizeof (struct lto_function_header
);
4769 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4770 const int string_offset
= main_offset
+ header
->main_size
;
4771 struct data_in
*data_in
;
4775 lto_input_block
ib_main ((const char *) data
+ main_offset
,
4776 header
->main_size
, file_data
->mode_table
);
4778 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4779 header
->string_size
, vNULL
);
4780 count
= streamer_read_uhwi (&ib_main
);
4782 for (i
= 0; i
< count
; i
++)
4785 struct cgraph_node
*node
;
4786 lto_symtab_encoder_t encoder
;
4788 index
= streamer_read_uhwi (&ib_main
);
4789 encoder
= file_data
->symtab_node_encoder
;
4790 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
4792 gcc_assert (node
->definition
);
4793 read_ipcp_transformation_info (&ib_main
, node
, data_in
);
4795 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4797 lto_data_in_delete (data_in
);
4800 /* Read IPA-CP aggregate replacements. */
4803 ipcp_read_transformation_summaries (void)
4805 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4806 struct lto_file_decl_data
*file_data
;
4809 while ((file_data
= file_data_vec
[j
++]))
4812 const char *data
= lto_get_section_data (file_data
,
4813 LTO_section_ipcp_transform
,
4816 read_replacements_section (file_data
, data
, len
);
4820 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
4824 adjust_agg_replacement_values (struct cgraph_node
*node
,
4825 struct ipa_agg_replacement_value
*aggval
)
4827 struct ipa_agg_replacement_value
*v
;
4828 int i
, c
= 0, d
= 0, *adj
;
4830 if (!node
->clone
.combined_args_to_skip
)
4833 for (v
= aggval
; v
; v
= v
->next
)
4835 gcc_assert (v
->index
>= 0);
4841 adj
= XALLOCAVEC (int, c
);
4842 for (i
= 0; i
< c
; i
++)
4843 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
4851 for (v
= aggval
; v
; v
= v
->next
)
4852 v
->index
= adj
[v
->index
];
4855 /* Dominator walker driving the ipcp modification phase. */
4857 class ipcp_modif_dom_walker
: public dom_walker
4860 ipcp_modif_dom_walker (struct ipa_func_body_info
*fbi
,
4861 vec
<ipa_param_descriptor
, va_gc
> *descs
,
4862 struct ipa_agg_replacement_value
*av
,
4864 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
4865 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
4867 virtual edge
before_dom_children (basic_block
);
4870 struct ipa_func_body_info
*m_fbi
;
4871 vec
<ipa_param_descriptor
, va_gc
> *m_descriptors
;
4872 struct ipa_agg_replacement_value
*m_aggval
;
4873 bool *m_something_changed
, *m_cfg_changed
;
4877 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
4879 gimple_stmt_iterator gsi
;
4880 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4882 struct ipa_agg_replacement_value
*v
;
4883 gimple
*stmt
= gsi_stmt (gsi
);
4885 HOST_WIDE_INT offset
, size
;
4889 if (!gimple_assign_load_p (stmt
))
4891 rhs
= gimple_assign_rhs1 (stmt
);
4892 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
4897 while (handled_component_p (t
))
4899 /* V_C_E can do things like convert an array of integers to one
4900 bigger integer and similar things we do not handle below. */
4901 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
4906 t
= TREE_OPERAND (t
, 0);
4911 if (!ipa_load_from_parm_agg (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
4912 &offset
, &size
, &by_ref
))
4914 for (v
= m_aggval
; v
; v
= v
->next
)
4915 if (v
->index
== index
4916 && v
->offset
== offset
)
4919 || v
->by_ref
!= by_ref
4920 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
4923 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
4924 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
4926 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
4927 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
4928 else if (TYPE_SIZE (TREE_TYPE (rhs
))
4929 == TYPE_SIZE (TREE_TYPE (v
->value
)))
4930 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
4935 fprintf (dump_file
, " const ");
4936 print_generic_expr (dump_file
, v
->value
);
4937 fprintf (dump_file
, " can't be converted to type of ");
4938 print_generic_expr (dump_file
, rhs
);
4939 fprintf (dump_file
, "\n");
4947 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4949 fprintf (dump_file
, "Modifying stmt:\n ");
4950 print_gimple_stmt (dump_file
, stmt
, 0);
4952 gimple_assign_set_rhs_from_tree (&gsi
, val
);
4955 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4957 fprintf (dump_file
, "into:\n ");
4958 print_gimple_stmt (dump_file
, stmt
, 0);
4959 fprintf (dump_file
, "\n");
4962 *m_something_changed
= true;
4963 if (maybe_clean_eh_stmt (stmt
)
4964 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
4965 *m_cfg_changed
= true;
4970 /* Update bits info of formal parameters as described in
4971 ipcp_transformation. */
4974 ipcp_update_bits (struct cgraph_node
*node
)
4976 tree parm
= DECL_ARGUMENTS (node
->decl
);
4977 tree next_parm
= parm
;
4978 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
4980 if (!ts
|| vec_safe_length (ts
->bits
) == 0)
4983 vec
<ipa_bits
*, va_gc
> &bits
= *ts
->bits
;
4984 unsigned count
= bits
.length ();
4986 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
4988 if (node
->clone
.combined_args_to_skip
4989 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
4992 gcc_checking_assert (parm
);
4993 next_parm
= DECL_CHAIN (parm
);
4996 || !(INTEGRAL_TYPE_P (TREE_TYPE (parm
))
4997 || POINTER_TYPE_P (TREE_TYPE (parm
)))
4998 || !is_gimple_reg (parm
))
5001 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5007 fprintf (dump_file
, "Adjusting mask for param %u to ", i
);
5008 print_hex (bits
[i
]->mask
, dump_file
);
5009 fprintf (dump_file
, "\n");
5012 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5014 unsigned prec
= TYPE_PRECISION (TREE_TYPE (ddef
));
5015 signop sgn
= TYPE_SIGN (TREE_TYPE (ddef
));
5017 wide_int nonzero_bits
= wide_int::from (bits
[i
]->mask
, prec
, UNSIGNED
)
5018 | wide_int::from (bits
[i
]->value
, prec
, sgn
);
5019 set_nonzero_bits (ddef
, nonzero_bits
);
5023 unsigned tem
= bits
[i
]->mask
.to_uhwi ();
5024 unsigned HOST_WIDE_INT bitpos
= bits
[i
]->value
.to_uhwi ();
5025 unsigned align
= tem
& -tem
;
5026 unsigned misalign
= bitpos
& (align
- 1);
5031 fprintf (dump_file
, "Adjusting align: %u, misalign: %u\n", align
, misalign
);
5033 unsigned old_align
, old_misalign
;
5034 struct ptr_info_def
*pi
= get_ptr_info (ddef
);
5035 bool old_known
= get_ptr_info_alignment (pi
, &old_align
, &old_misalign
);
5038 && old_align
> align
)
5042 fprintf (dump_file
, "But alignment was already %u.\n", old_align
);
5043 if ((old_misalign
& (align
- 1)) != misalign
)
5044 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5045 old_misalign
, misalign
);
5051 && ((misalign
& (old_align
- 1)) != old_misalign
)
5053 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5054 old_misalign
, misalign
);
5056 set_ptr_info_alignment (pi
, align
, misalign
);
5062 /* Update value range of formal parameters as described in
5063 ipcp_transformation. */
5066 ipcp_update_vr (struct cgraph_node
*node
)
5068 tree fndecl
= node
->decl
;
5069 tree parm
= DECL_ARGUMENTS (fndecl
);
5070 tree next_parm
= parm
;
5071 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
5072 if (!ts
|| vec_safe_length (ts
->m_vr
) == 0)
5074 const vec
<ipa_vr
, va_gc
> &vr
= *ts
->m_vr
;
5075 unsigned count
= vr
.length ();
5077 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5079 if (node
->clone
.combined_args_to_skip
5080 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5082 gcc_checking_assert (parm
);
5083 next_parm
= DECL_CHAIN (parm
);
5084 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5086 if (!ddef
|| !is_gimple_reg (parm
))
5090 && (vr
[i
].type
== VR_RANGE
|| vr
[i
].type
== VR_ANTI_RANGE
))
5092 tree type
= TREE_TYPE (ddef
);
5093 unsigned prec
= TYPE_PRECISION (type
);
5094 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5098 fprintf (dump_file
, "Setting value range of param %u ", i
);
5099 fprintf (dump_file
, "%s[",
5100 (vr
[i
].type
== VR_ANTI_RANGE
) ? "~" : "");
5101 print_decs (vr
[i
].min
, dump_file
);
5102 fprintf (dump_file
, ", ");
5103 print_decs (vr
[i
].max
, dump_file
);
5104 fprintf (dump_file
, "]\n");
5106 set_range_info (ddef
, vr
[i
].type
,
5107 wide_int_storage::from (vr
[i
].min
, prec
,
5109 wide_int_storage::from (vr
[i
].max
, prec
,
5112 else if (POINTER_TYPE_P (TREE_TYPE (ddef
))
5113 && vr
[i
].type
== VR_ANTI_RANGE
5114 && wi::eq_p (vr
[i
].min
, 0)
5115 && wi::eq_p (vr
[i
].max
, 0))
5118 fprintf (dump_file
, "Setting nonnull for %u\n", i
);
5119 set_ptr_nonnull (ddef
);
5125 /* IPCP transformation phase doing propagation of aggregate values. */
5128 ipcp_transform_function (struct cgraph_node
*node
)
5130 vec
<ipa_param_descriptor
, va_gc
> *descriptors
= NULL
;
5131 struct ipa_func_body_info fbi
;
5132 struct ipa_agg_replacement_value
*aggval
;
5134 bool cfg_changed
= false, something_changed
= false;
5136 gcc_checking_assert (cfun
);
5137 gcc_checking_assert (current_function_decl
);
5140 fprintf (dump_file
, "Modification phase of node %s\n",
5141 node
->dump_name ());
5143 ipcp_update_bits (node
);
5144 ipcp_update_vr (node
);
5145 aggval
= ipa_get_agg_replacements_for_node (node
);
5148 param_count
= count_formal_params (node
->decl
);
5149 if (param_count
== 0)
5151 adjust_agg_replacement_values (node
, aggval
);
5153 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5157 fbi
.bb_infos
= vNULL
;
5158 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5159 fbi
.param_count
= param_count
;
5162 vec_safe_grow_cleared (descriptors
, param_count
);
5163 ipa_populate_param_decls (node
, *descriptors
);
5164 calculate_dominance_info (CDI_DOMINATORS
);
5165 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5166 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5169 struct ipa_bb_info
*bi
;
5170 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5171 free_ipa_bb_info (bi
);
5172 fbi
.bb_infos
.release ();
5173 free_dominance_info (CDI_DOMINATORS
);
5175 ipcp_transformation
*s
= ipcp_transformation_sum
->get (node
);
5176 s
->agg_values
= NULL
;
5180 vec_free (descriptors
);
5182 if (!something_changed
)
5184 else if (cfg_changed
)
5185 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5187 return TODO_update_ssa_only_virtuals
;
5190 #include "gt-ipa-prop.h"