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"
50 #include "ipa-utils.h"
54 #include "tree-cfgcleanup.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
*>
111 typedef value_range
*value_type
;
112 typedef value_range
*compare_type
;
114 hash (const value_range
*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
*a
, const value_range
*b
)
124 return a
->equal_p (*b
);
127 mark_empty (value_range
*&p
)
132 is_empty (const value_range
*p
)
137 is_deleted (const value_range
*p
)
139 return p
== reinterpret_cast<const value_range
*> (1);
142 mark_deleted (value_range
*&p
)
144 p
= reinterpret_cast<value_range
*> (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 (class 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 unsigned int cost
= estimate_move_cost (TREE_TYPE (parm
), true);
230 descriptors
[param_num
].move_cost
= cost
;
231 /* Watch overflow, move_cost is a bitfield. */
232 gcc_checking_assert (cost
== descriptors
[param_num
].move_cost
);
237 /* Return how many formal parameters FNDECL has. */
240 count_formal_params (tree fndecl
)
244 gcc_assert (gimple_has_body_p (fndecl
));
246 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
252 /* Return the declaration of Ith formal parameter of the function corresponding
253 to INFO. Note there is no setter function as this array is built just once
254 using ipa_initialize_node_params. */
257 ipa_dump_param (FILE *file
, class ipa_node_params
*info
, int i
)
259 fprintf (file
, "param #%i", i
);
260 if ((*info
->descriptors
)[i
].decl_or_type
)
263 print_generic_expr (file
, (*info
->descriptors
)[i
].decl_or_type
);
267 /* If necessary, allocate vector of parameter descriptors in info of NODE.
268 Return true if they were allocated, false if not. */
271 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
273 class ipa_node_params
*info
= IPA_NODE_REF_GET_CREATE (node
);
275 if (!info
->descriptors
&& param_count
)
277 vec_safe_grow_cleared (info
->descriptors
, param_count
);
284 /* Initialize the ipa_node_params structure associated with NODE by counting
285 the function parameters, creating the descriptors and populating their
289 ipa_initialize_node_params (struct cgraph_node
*node
)
291 class ipa_node_params
*info
= IPA_NODE_REF_GET_CREATE (node
);
293 if (!info
->descriptors
294 && ipa_alloc_node_params (node
, count_formal_params (node
->decl
)))
295 ipa_populate_param_decls (node
, *info
->descriptors
);
298 /* Print the jump functions associated with call graph edge CS to file F. */
301 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
305 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
306 for (i
= 0; i
< count
; i
++)
308 struct ipa_jump_func
*jump_func
;
309 enum jump_func_type type
;
311 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
312 type
= jump_func
->type
;
314 fprintf (f
, " param %d: ", i
);
315 if (type
== IPA_JF_UNKNOWN
)
316 fprintf (f
, "UNKNOWN\n");
317 else if (type
== IPA_JF_CONST
)
319 tree val
= jump_func
->value
.constant
.value
;
320 fprintf (f
, "CONST: ");
321 print_generic_expr (f
, val
);
322 if (TREE_CODE (val
) == ADDR_EXPR
323 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
326 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)));
330 else if (type
== IPA_JF_PASS_THROUGH
)
332 fprintf (f
, "PASS THROUGH: ");
333 fprintf (f
, "%d, op %s",
334 jump_func
->value
.pass_through
.formal_id
,
335 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
336 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
339 print_generic_expr (f
, jump_func
->value
.pass_through
.operand
);
341 if (jump_func
->value
.pass_through
.agg_preserved
)
342 fprintf (f
, ", agg_preserved");
345 else if (type
== IPA_JF_ANCESTOR
)
347 fprintf (f
, "ANCESTOR: ");
348 fprintf (f
, "%d, offset " HOST_WIDE_INT_PRINT_DEC
,
349 jump_func
->value
.ancestor
.formal_id
,
350 jump_func
->value
.ancestor
.offset
);
351 if (jump_func
->value
.ancestor
.agg_preserved
)
352 fprintf (f
, ", agg_preserved");
356 if (jump_func
->agg
.items
)
358 struct ipa_agg_jf_item
*item
;
361 fprintf (f
, " Aggregate passed by %s:\n",
362 jump_func
->agg
.by_ref
? "reference" : "value");
363 FOR_EACH_VEC_ELT (*jump_func
->agg
.items
, j
, item
)
365 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
367 fprintf (f
, "type: ");
368 print_generic_expr (f
, item
->type
);
370 if (item
->jftype
== IPA_JF_PASS_THROUGH
)
371 fprintf (f
, "PASS THROUGH: %d,",
372 item
->value
.pass_through
.formal_id
);
373 else if (item
->jftype
== IPA_JF_LOAD_AGG
)
375 fprintf (f
, "LOAD AGG: %d",
376 item
->value
.pass_through
.formal_id
);
377 fprintf (f
, " [offset: " HOST_WIDE_INT_PRINT_DEC
", by %s],",
378 item
->value
.load_agg
.offset
,
379 item
->value
.load_agg
.by_ref
? "reference"
383 if (item
->jftype
== IPA_JF_PASS_THROUGH
384 || item
->jftype
== IPA_JF_LOAD_AGG
)
386 fprintf (f
, " op %s",
387 get_tree_code_name (item
->value
.pass_through
.operation
));
388 if (item
->value
.pass_through
.operation
!= NOP_EXPR
)
391 print_generic_expr (f
, item
->value
.pass_through
.operand
);
394 else if (item
->jftype
== IPA_JF_CONST
)
396 fprintf (f
, "CONST: ");
397 print_generic_expr (f
, item
->value
.constant
);
399 else if (item
->jftype
== IPA_JF_UNKNOWN
)
400 fprintf (f
, "UNKNOWN: " HOST_WIDE_INT_PRINT_DEC
" bits",
401 tree_to_uhwi (TYPE_SIZE (item
->type
)));
406 class ipa_polymorphic_call_context
*ctx
407 = ipa_get_ith_polymorhic_call_context (IPA_EDGE_REF (cs
), i
);
408 if (ctx
&& !ctx
->useless_p ())
410 fprintf (f
, " Context: ");
411 ctx
->dump (dump_file
);
416 fprintf (f
, " value: ");
417 print_hex (jump_func
->bits
->value
, f
);
418 fprintf (f
, ", mask: ");
419 print_hex (jump_func
->bits
->mask
, f
);
423 fprintf (f
, " Unknown bits\n");
429 (jump_func
->m_vr
->kind () == VR_ANTI_RANGE
) ? "~" : "");
430 print_decs (wi::to_wide (jump_func
->m_vr
->min ()), f
);
432 print_decs (wi::to_wide (jump_func
->m_vr
->max ()), f
);
436 fprintf (f
, " Unknown VR\n");
441 /* Print the jump functions of all arguments on all call graph edges going from
445 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
447 struct cgraph_edge
*cs
;
449 fprintf (f
, " Jump functions of caller %s:\n", node
->dump_name ());
450 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
453 fprintf (f
, " callsite %s -> %s : \n",
455 cs
->callee
->dump_name ());
456 if (!ipa_edge_args_info_available_for_edge_p (cs
))
457 fprintf (f
, " no arg info\n");
459 ipa_print_node_jump_functions_for_edge (f
, cs
);
462 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
464 class cgraph_indirect_call_info
*ii
;
466 ii
= cs
->indirect_info
;
467 if (ii
->agg_contents
)
468 fprintf (f
, " indirect %s callsite, calling param %i, "
469 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
470 ii
->member_ptr
? "member ptr" : "aggregate",
471 ii
->param_index
, ii
->offset
,
472 ii
->by_ref
? "by reference" : "by_value");
474 fprintf (f
, " indirect %s callsite, calling param %i, "
475 "offset " HOST_WIDE_INT_PRINT_DEC
,
476 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
481 fprintf (f
, ", for stmt ");
482 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
487 ii
->context
.dump (f
);
488 if (!ipa_edge_args_info_available_for_edge_p (cs
))
489 fprintf (f
, " no arg info\n");
491 ipa_print_node_jump_functions_for_edge (f
, cs
);
495 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
498 ipa_print_all_jump_functions (FILE *f
)
500 struct cgraph_node
*node
;
502 fprintf (f
, "\nJump functions:\n");
503 FOR_EACH_FUNCTION (node
)
505 ipa_print_node_jump_functions (f
, node
);
509 /* Set jfunc to be a know-really nothing jump function. */
512 ipa_set_jf_unknown (struct ipa_jump_func
*jfunc
)
514 jfunc
->type
= IPA_JF_UNKNOWN
;
517 /* Set JFUNC to be a copy of another jmp (to be used by jump function
518 combination code). The two functions will share their rdesc. */
521 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
522 struct ipa_jump_func
*src
)
525 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
526 dst
->type
= IPA_JF_CONST
;
527 dst
->value
.constant
= src
->value
.constant
;
530 /* Set JFUNC to be a constant jmp function. */
533 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
534 struct cgraph_edge
*cs
)
536 jfunc
->type
= IPA_JF_CONST
;
537 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
539 if (TREE_CODE (constant
) == ADDR_EXPR
540 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
542 struct ipa_cst_ref_desc
*rdesc
;
544 rdesc
= ipa_refdesc_pool
.allocate ();
546 rdesc
->next_duplicate
= NULL
;
548 jfunc
->value
.constant
.rdesc
= rdesc
;
551 jfunc
->value
.constant
.rdesc
= NULL
;
554 /* Set JFUNC to be a simple pass-through jump function. */
556 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
559 jfunc
->type
= IPA_JF_PASS_THROUGH
;
560 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
561 jfunc
->value
.pass_through
.formal_id
= formal_id
;
562 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
563 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
566 /* Set JFUNC to be an unary pass through jump function. */
569 ipa_set_jf_unary_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
570 enum tree_code operation
)
572 jfunc
->type
= IPA_JF_PASS_THROUGH
;
573 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
574 jfunc
->value
.pass_through
.formal_id
= formal_id
;
575 jfunc
->value
.pass_through
.operation
= operation
;
576 jfunc
->value
.pass_through
.agg_preserved
= false;
578 /* Set JFUNC to be an arithmetic pass through jump function. */
581 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
582 tree operand
, enum tree_code operation
)
584 jfunc
->type
= IPA_JF_PASS_THROUGH
;
585 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
586 jfunc
->value
.pass_through
.formal_id
= formal_id
;
587 jfunc
->value
.pass_through
.operation
= operation
;
588 jfunc
->value
.pass_through
.agg_preserved
= false;
591 /* Set JFUNC to be an ancestor jump function. */
594 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
595 int formal_id
, bool agg_preserved
)
597 jfunc
->type
= IPA_JF_ANCESTOR
;
598 jfunc
->value
.ancestor
.formal_id
= formal_id
;
599 jfunc
->value
.ancestor
.offset
= offset
;
600 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
603 /* Get IPA BB information about the given BB. FBI is the context of analyzis
604 of this function body. */
606 static struct ipa_bb_info
*
607 ipa_get_bb_info (struct ipa_func_body_info
*fbi
, basic_block bb
)
609 gcc_checking_assert (fbi
);
610 return &fbi
->bb_infos
[bb
->index
];
613 /* Structure to be passed in between detect_type_change and
614 check_stmt_for_type_change. */
616 struct prop_type_change_info
618 /* Offset into the object where there is the virtual method pointer we are
620 HOST_WIDE_INT offset
;
621 /* The declaration or SSA_NAME pointer of the base that we are checking for
624 /* Set to true if dynamic type change has been detected. */
625 bool type_maybe_changed
;
628 /* Return true if STMT can modify a virtual method table pointer.
630 This function makes special assumptions about both constructors and
631 destructors which are all the functions that are allowed to alter the VMT
632 pointers. It assumes that destructors begin with assignment into all VMT
633 pointers and that constructors essentially look in the following way:
635 1) The very first thing they do is that they call constructors of ancestor
636 sub-objects that have them.
638 2) Then VMT pointers of this and all its ancestors is set to new values
639 corresponding to the type corresponding to the constructor.
641 3) Only afterwards, other stuff such as constructor of member sub-objects
642 and the code written by the user is run. Only this may include calling
643 virtual functions, directly or indirectly.
645 There is no way to call a constructor of an ancestor sub-object in any
648 This means that we do not have to care whether constructors get the correct
649 type information because they will always change it (in fact, if we define
650 the type to be given by the VMT pointer, it is undefined).
652 The most important fact to derive from the above is that if, for some
653 statement in the section 3, we try to detect whether the dynamic type has
654 changed, we can safely ignore all calls as we examine the function body
655 backwards until we reach statements in section 2 because these calls cannot
656 be ancestor constructors or destructors (if the input is not bogus) and so
657 do not change the dynamic type (this holds true only for automatically
658 allocated objects but at the moment we devirtualize only these). We then
659 must detect that statements in section 2 change the dynamic type and can try
660 to derive the new type. That is enough and we can stop, we will never see
661 the calls into constructors of sub-objects in this code. Therefore we can
662 safely ignore all call statements that we traverse.
666 stmt_may_be_vtbl_ptr_store (gimple
*stmt
)
668 if (is_gimple_call (stmt
))
670 if (gimple_clobber_p (stmt
))
672 else if (is_gimple_assign (stmt
))
674 tree lhs
= gimple_assign_lhs (stmt
);
676 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
678 if (flag_strict_aliasing
679 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
682 if (TREE_CODE (lhs
) == COMPONENT_REF
683 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
685 /* In the future we might want to use get_ref_base_and_extent to find
686 if there is a field corresponding to the offset and if so, proceed
687 almost like if it was a component ref. */
693 /* Callback of walk_aliased_vdefs and a helper function for detect_type_change
694 to check whether a particular statement may modify the virtual table
695 pointerIt stores its result into DATA, which points to a
696 prop_type_change_info structure. */
699 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
701 gimple
*stmt
= SSA_NAME_DEF_STMT (vdef
);
702 struct prop_type_change_info
*tci
= (struct prop_type_change_info
*) data
;
704 if (stmt_may_be_vtbl_ptr_store (stmt
))
706 tci
->type_maybe_changed
= true;
713 /* See if ARG is PARAM_DECl describing instance passed by pointer
714 or reference in FUNCTION. Return false if the dynamic type may change
715 in between beggining of the function until CALL is invoked.
717 Generally functions are not allowed to change type of such instances,
718 but they call destructors. We assume that methods cannot destroy the THIS
719 pointer. Also as a special cases, constructor and destructors may change
720 type of the THIS pointer. */
723 param_type_may_change_p (tree function
, tree arg
, gimple
*call
)
725 /* Pure functions cannot do any changes on the dynamic type;
726 that require writting to memory. */
727 if (flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
729 /* We need to check if we are within inlined consturctor
730 or destructor (ideally we would have way to check that the
731 inline cdtor is actually working on ARG, but we don't have
732 easy tie on this, so punt on all non-pure cdtors.
733 We may also record the types of cdtors and once we know type
734 of the instance match them.
736 Also code unification optimizations may merge calls from
737 different blocks making return values unreliable. So
738 do nothing during late optimization. */
739 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
741 if (TREE_CODE (arg
) == SSA_NAME
742 && SSA_NAME_IS_DEFAULT_DEF (arg
)
743 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
)
745 /* Normal (non-THIS) argument. */
746 if ((SSA_NAME_VAR (arg
) != DECL_ARGUMENTS (function
)
747 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
)
748 /* THIS pointer of an method - here we want to watch constructors
749 and destructors as those definitely may change the dynamic
751 || (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
752 && !DECL_CXX_CONSTRUCTOR_P (function
)
753 && !DECL_CXX_DESTRUCTOR_P (function
)
754 && (SSA_NAME_VAR (arg
) == DECL_ARGUMENTS (function
))))
756 /* Walk the inline stack and watch out for ctors/dtors. */
757 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
758 block
= BLOCK_SUPERCONTEXT (block
))
759 if (inlined_polymorphic_ctor_dtor_block_p (block
, false))
767 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
768 callsite CALL) by looking for assignments to its virtual table pointer. If
769 it is, return true. ARG is the object itself (not a pointer
770 to it, unless dereferenced). BASE is the base of the memory access as
771 returned by get_ref_base_and_extent, as is the offset.
773 This is helper function for detect_type_change and detect_type_change_ssa
774 that does the heavy work which is usually unnecesary. */
777 detect_type_change_from_memory_writes (ipa_func_body_info
*fbi
, tree arg
,
778 tree base
, tree comp_type
, gcall
*call
,
779 HOST_WIDE_INT offset
)
781 struct prop_type_change_info tci
;
784 gcc_checking_assert (DECL_P (arg
)
785 || TREE_CODE (arg
) == MEM_REF
786 || handled_component_p (arg
));
788 comp_type
= TYPE_MAIN_VARIANT (comp_type
);
790 /* Const calls cannot call virtual methods through VMT and so type changes do
792 if (!flag_devirtualize
|| !gimple_vuse (call
)
793 /* Be sure expected_type is polymorphic. */
795 || TREE_CODE (comp_type
) != RECORD_TYPE
796 || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))
797 || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))))
800 ao_ref_init (&ao
, arg
);
803 ao
.size
= POINTER_SIZE
;
804 ao
.max_size
= ao
.size
;
807 tci
.object
= get_base_address (arg
);
808 tci
.type_maybe_changed
= false;
811 = walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
812 &tci
, NULL
, NULL
, fbi
->aa_walk_budget
+ 1);
814 if (walked
>= 0 && !tci
.type_maybe_changed
)
820 /* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
821 If it is, return true. ARG is the object itself (not a pointer
822 to it, unless dereferenced). BASE is the base of the memory access as
823 returned by get_ref_base_and_extent, as is the offset. */
826 detect_type_change (ipa_func_body_info
*fbi
, tree arg
, tree base
,
827 tree comp_type
, gcall
*call
,
828 HOST_WIDE_INT offset
)
830 if (!flag_devirtualize
)
833 if (TREE_CODE (base
) == MEM_REF
834 && !param_type_may_change_p (current_function_decl
,
835 TREE_OPERAND (base
, 0),
838 return detect_type_change_from_memory_writes (fbi
, arg
, base
, comp_type
,
842 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
843 SSA name (its dereference will become the base and the offset is assumed to
847 detect_type_change_ssa (ipa_func_body_info
*fbi
, tree arg
, tree comp_type
,
850 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
851 if (!flag_devirtualize
852 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
855 if (!param_type_may_change_p (current_function_decl
, arg
, call
))
858 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
859 build_int_cst (ptr_type_node
, 0));
861 return detect_type_change_from_memory_writes (fbi
, arg
, arg
, comp_type
,
865 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
866 boolean variable pointed to by DATA. */
869 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
872 bool *b
= (bool *) data
;
877 /* Find the nearest valid aa status for parameter specified by INDEX that
880 static struct ipa_param_aa_status
*
881 find_dominating_aa_status (struct ipa_func_body_info
*fbi
, basic_block bb
,
886 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
889 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
890 if (!bi
->param_aa_statuses
.is_empty ()
891 && bi
->param_aa_statuses
[index
].valid
)
892 return &bi
->param_aa_statuses
[index
];
896 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
897 structures and/or intialize the result with a dominating description as
900 static struct ipa_param_aa_status
*
901 parm_bb_aa_status_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
,
904 gcc_checking_assert (fbi
);
905 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
906 if (bi
->param_aa_statuses
.is_empty ())
907 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
908 struct ipa_param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
911 gcc_checking_assert (!paa
->parm_modified
912 && !paa
->ref_modified
913 && !paa
->pt_modified
);
914 struct ipa_param_aa_status
*dom_paa
;
915 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
925 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
926 a value known not to be modified in this function before reaching the
927 statement STMT. FBI holds information about the function we have so far
928 gathered but do not survive the summary building stage. */
931 parm_preserved_before_stmt_p (struct ipa_func_body_info
*fbi
, int index
,
932 gimple
*stmt
, tree parm_load
)
934 struct ipa_param_aa_status
*paa
;
935 bool modified
= false;
938 tree base
= get_base_address (parm_load
);
939 gcc_assert (TREE_CODE (base
) == PARM_DECL
);
940 if (TREE_READONLY (base
))
943 gcc_checking_assert (fbi
);
944 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
945 if (paa
->parm_modified
)
948 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
949 ao_ref_init (&refd
, parm_load
);
950 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
951 &modified
, NULL
, NULL
,
952 fbi
->aa_walk_budget
+ 1);
957 fbi
->aa_walk_budget
= 0;
960 fbi
->aa_walk_budget
-= walked
;
962 paa
->parm_modified
= true;
966 /* If STMT is an assignment that loads a value from an parameter declaration,
967 return the index of the parameter in ipa_node_params which has not been
968 modified. Otherwise return -1. */
971 load_from_unmodified_param (struct ipa_func_body_info
*fbi
,
972 vec
<ipa_param_descriptor
, va_gc
> *descriptors
,
978 if (!gimple_assign_single_p (stmt
))
981 op1
= gimple_assign_rhs1 (stmt
);
982 if (TREE_CODE (op1
) != PARM_DECL
)
985 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
987 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
993 /* Return true if memory reference REF (which must be a load through parameter
994 with INDEX) loads data that are known to be unmodified in this function
995 before reaching statement STMT. */
998 parm_ref_data_preserved_p (struct ipa_func_body_info
*fbi
,
999 int index
, gimple
*stmt
, tree ref
)
1001 struct ipa_param_aa_status
*paa
;
1002 bool modified
= false;
1005 gcc_checking_assert (fbi
);
1006 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
1007 if (paa
->ref_modified
)
1010 gcc_checking_assert (gimple_vuse (stmt
));
1011 ao_ref_init (&refd
, ref
);
1012 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
1013 &modified
, NULL
, NULL
,
1014 fbi
->aa_walk_budget
+ 1);
1018 fbi
->aa_walk_budget
= 0;
1021 fbi
->aa_walk_budget
-= walked
;
1023 paa
->ref_modified
= true;
1027 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
1028 is known to be unmodified in this function before reaching call statement
1029 CALL into which it is passed. FBI describes the function body. */
1032 parm_ref_data_pass_through_p (struct ipa_func_body_info
*fbi
, int index
,
1033 gimple
*call
, tree parm
)
1035 bool modified
= false;
1038 /* It's unnecessary to calculate anything about memory contnets for a const
1039 function because it is not goin to use it. But do not cache the result
1040 either. Also, no such calculations for non-pointers. */
1041 if (!gimple_vuse (call
)
1042 || !POINTER_TYPE_P (TREE_TYPE (parm
)))
1045 struct ipa_param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
,
1048 if (paa
->pt_modified
)
1051 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
1052 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
1053 &modified
, NULL
, NULL
,
1054 fbi
->aa_walk_budget
+ 1);
1057 fbi
->aa_walk_budget
= 0;
1061 fbi
->aa_walk_budget
-= walked
;
1063 paa
->pt_modified
= true;
1067 /* Return true if we can prove that OP is a memory reference loading
1068 data from an aggregate passed as a parameter.
1070 The function works in two modes. If GUARANTEED_UNMODIFIED is NULL, it return
1071 false if it cannot prove that the value has not been modified before the
1072 load in STMT. If GUARANTEED_UNMODIFIED is not NULL, it will return true even
1073 if it cannot prove the value has not been modified, in that case it will
1074 store false to *GUARANTEED_UNMODIFIED, otherwise it will store true there.
1076 INFO and PARMS_AINFO describe parameters of the current function (but the
1077 latter can be NULL), STMT is the load statement. If function returns true,
1078 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
1079 within the aggregate and whether it is a load from a value passed by
1080 reference respectively. */
1083 ipa_load_from_parm_agg (struct ipa_func_body_info
*fbi
,
1084 vec
<ipa_param_descriptor
, va_gc
> *descriptors
,
1085 gimple
*stmt
, tree op
, int *index_p
,
1086 HOST_WIDE_INT
*offset_p
, poly_int64
*size_p
,
1087 bool *by_ref_p
, bool *guaranteed_unmodified
)
1092 tree base
= get_ref_base_and_extent_hwi (op
, offset_p
, &size
, &reverse
);
1099 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
1101 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
1107 if (guaranteed_unmodified
)
1108 *guaranteed_unmodified
= true;
1114 if (TREE_CODE (base
) != MEM_REF
1115 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1116 || !integer_zerop (TREE_OPERAND (base
, 1)))
1119 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1121 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1122 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1126 /* This branch catches situations where a pointer parameter is not a
1127 gimple register, for example:
1129 void hip7(S*) (struct S * p)
1131 void (*<T2e4>) (struct S *) D.1867;
1136 D.1867_2 = p.1_1->f;
1141 gimple
*def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1142 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1147 bool data_preserved
= parm_ref_data_preserved_p (fbi
, index
, stmt
, op
);
1148 if (!data_preserved
&& !guaranteed_unmodified
)
1155 if (guaranteed_unmodified
)
1156 *guaranteed_unmodified
= data_preserved
;
1162 /* If STMT is an assignment that loads a value from a parameter declaration,
1163 or from an aggregate passed as the parameter either by value or reference,
1164 return the index of the parameter in ipa_node_params. Otherwise return -1.
1166 FBI holds gathered information about the function. INFO describes
1167 parameters of the function, STMT is the assignment statement. If it is a
1168 memory load from an aggregate, *OFFSET_P is filled with offset within the
1169 aggregate, and *BY_REF_P specifies whether the aggregate is passed by
1173 load_from_unmodified_param_or_agg (struct ipa_func_body_info
*fbi
,
1174 class ipa_node_params
*info
,
1176 HOST_WIDE_INT
*offset_p
,
1179 int index
= load_from_unmodified_param (fbi
, info
->descriptors
, stmt
);
1182 /* Load value from a parameter declaration. */
1189 if (!gimple_assign_load_p (stmt
))
1192 tree rhs
= gimple_assign_rhs1 (stmt
);
1194 /* Skip memory reference containing VIEW_CONVERT_EXPR. */
1195 for (tree t
= rhs
; handled_component_p (t
); t
= TREE_OPERAND (t
, 0))
1196 if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
1199 /* Skip memory reference containing bit-field. */
1200 if (TREE_CODE (rhs
) == BIT_FIELD_REF
1201 || contains_bitfld_component_ref_p (rhs
))
1204 if (!ipa_load_from_parm_agg (fbi
, info
->descriptors
, stmt
, rhs
, &index
,
1205 offset_p
, &size
, by_ref_p
))
1208 gcc_assert (!maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (rhs
))),
1212 tree param_type
= ipa_get_type (info
, index
);
1214 if (!param_type
|| !AGGREGATE_TYPE_P (param_type
))
1217 else if (TREE_THIS_VOLATILE (rhs
))
1223 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1224 of an assignment statement STMT, try to determine whether we are actually
1225 handling any of the following cases and construct an appropriate jump
1226 function into JFUNC if so:
1228 1) The passed value is loaded from a formal parameter which is not a gimple
1229 register (most probably because it is addressable, the value has to be
1230 scalar) and we can guarantee the value has not changed. This case can
1231 therefore be described by a simple pass-through jump function. For example:
1240 2) The passed value can be described by a simple arithmetic pass-through
1247 D.2064_4 = a.1(D) + 4;
1250 This case can also occur in combination of the previous one, e.g.:
1258 D.2064_4 = a.0_3 + 4;
1261 3) The passed value is an address of an object within another one (which
1262 also passed by reference). Such situations are described by an ancestor
1263 jump function and describe situations such as:
1265 B::foo() (struct B * const this)
1269 D.1845_2 = &this_1(D)->D.1748;
1272 INFO is the structure describing individual parameters access different
1273 stages of IPA optimizations. PARMS_AINFO contains the information that is
1274 only needed for intraprocedural analysis. */
1277 compute_complex_assign_jump_func (struct ipa_func_body_info
*fbi
,
1278 class ipa_node_params
*info
,
1279 struct ipa_jump_func
*jfunc
,
1280 gcall
*call
, gimple
*stmt
, tree name
,
1283 HOST_WIDE_INT offset
, size
;
1284 tree op1
, tc_ssa
, base
, ssa
;
1288 op1
= gimple_assign_rhs1 (stmt
);
1290 if (TREE_CODE (op1
) == SSA_NAME
)
1292 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1293 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1295 index
= load_from_unmodified_param (fbi
, info
->descriptors
,
1296 SSA_NAME_DEF_STMT (op1
));
1301 index
= load_from_unmodified_param (fbi
, info
->descriptors
, stmt
);
1302 tc_ssa
= gimple_assign_lhs (stmt
);
1307 switch (gimple_assign_rhs_class (stmt
))
1309 case GIMPLE_BINARY_RHS
:
1311 tree op2
= gimple_assign_rhs2 (stmt
);
1312 if (!is_gimple_ip_invariant (op2
)
1313 || ((TREE_CODE_CLASS (gimple_assign_rhs_code (stmt
))
1315 && !useless_type_conversion_p (TREE_TYPE (name
),
1319 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1320 gimple_assign_rhs_code (stmt
));
1323 case GIMPLE_SINGLE_RHS
:
1325 bool agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
,
1327 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1330 case GIMPLE_UNARY_RHS
:
1331 if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)))
1332 ipa_set_jf_unary_pass_through (jfunc
, index
,
1333 gimple_assign_rhs_code (stmt
));
1339 if (TREE_CODE (op1
) != ADDR_EXPR
)
1341 op1
= TREE_OPERAND (op1
, 0);
1342 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1344 base
= get_ref_base_and_extent_hwi (op1
, &offset
, &size
, &reverse
);
1345 offset_int mem_offset
;
1347 || TREE_CODE (base
) != MEM_REF
1348 || !mem_ref_offset (base
).is_constant (&mem_offset
))
1350 offset
+= mem_offset
.to_short_addr () * BITS_PER_UNIT
;
1351 ssa
= TREE_OPERAND (base
, 0);
1352 if (TREE_CODE (ssa
) != SSA_NAME
1353 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1357 /* Dynamic types are changed in constructors and destructors. */
1358 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1359 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1360 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1361 parm_ref_data_pass_through_p (fbi
, index
, call
, ssa
));
1364 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1367 iftmp.1_3 = &obj_2(D)->D.1762;
1369 The base of the MEM_REF must be a default definition SSA NAME of a
1370 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1371 whole MEM_REF expression is returned and the offset calculated from any
1372 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1373 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1376 get_ancestor_addr_info (gimple
*assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1379 tree expr
, parm
, obj
;
1382 if (!gimple_assign_single_p (assign
))
1384 expr
= gimple_assign_rhs1 (assign
);
1386 if (TREE_CODE (expr
) != ADDR_EXPR
)
1388 expr
= TREE_OPERAND (expr
, 0);
1390 expr
= get_ref_base_and_extent_hwi (expr
, offset
, &size
, &reverse
);
1392 offset_int mem_offset
;
1394 || TREE_CODE (expr
) != MEM_REF
1395 || !mem_ref_offset (expr
).is_constant (&mem_offset
))
1397 parm
= TREE_OPERAND (expr
, 0);
1398 if (TREE_CODE (parm
) != SSA_NAME
1399 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1400 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1403 *offset
+= mem_offset
.to_short_addr () * BITS_PER_UNIT
;
1409 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1410 statement PHI, try to find out whether NAME is in fact a
1411 multiple-inheritance typecast from a descendant into an ancestor of a formal
1412 parameter and thus can be described by an ancestor jump function and if so,
1413 write the appropriate function into JFUNC.
1415 Essentially we want to match the following pattern:
1423 iftmp.1_3 = &obj_2(D)->D.1762;
1426 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1427 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1431 compute_complex_ancestor_jump_func (struct ipa_func_body_info
*fbi
,
1432 class ipa_node_params
*info
,
1433 struct ipa_jump_func
*jfunc
,
1434 gcall
*call
, gphi
*phi
)
1436 HOST_WIDE_INT offset
;
1437 gimple
*assign
, *cond
;
1438 basic_block phi_bb
, assign_bb
, cond_bb
;
1439 tree tmp
, parm
, expr
, obj
;
1442 if (gimple_phi_num_args (phi
) != 2)
1445 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1446 tmp
= PHI_ARG_DEF (phi
, 0);
1447 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1448 tmp
= PHI_ARG_DEF (phi
, 1);
1451 if (TREE_CODE (tmp
) != SSA_NAME
1452 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1453 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1454 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1457 assign
= SSA_NAME_DEF_STMT (tmp
);
1458 assign_bb
= gimple_bb (assign
);
1459 if (!single_pred_p (assign_bb
))
1461 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1464 parm
= TREE_OPERAND (expr
, 0);
1465 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1469 cond_bb
= single_pred (assign_bb
);
1470 cond
= last_stmt (cond_bb
);
1472 || gimple_code (cond
) != GIMPLE_COND
1473 || gimple_cond_code (cond
) != NE_EXPR
1474 || gimple_cond_lhs (cond
) != parm
1475 || !integer_zerop (gimple_cond_rhs (cond
)))
1478 phi_bb
= gimple_bb (phi
);
1479 for (i
= 0; i
< 2; i
++)
1481 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1482 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1486 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1487 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
));
1490 /* Inspect the given TYPE and return true iff it has the same structure (the
1491 same number of fields of the same types) as a C++ member pointer. If
1492 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1493 corresponding fields there. */
1496 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1500 if (TREE_CODE (type
) != RECORD_TYPE
)
1503 fld
= TYPE_FIELDS (type
);
1504 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1505 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1506 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1512 fld
= DECL_CHAIN (fld
);
1513 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1514 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1519 if (DECL_CHAIN (fld
))
1525 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1526 return the rhs of its defining statement, and this statement is stored in
1527 *RHS_STMT. Otherwise return RHS as it is. */
1530 get_ssa_def_if_simple_copy (tree rhs
, gimple
**rhs_stmt
)
1532 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1534 gimple
*def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1536 if (gimple_assign_single_p (def_stmt
))
1537 rhs
= gimple_assign_rhs1 (def_stmt
);
1540 *rhs_stmt
= def_stmt
;
1545 /* Simple linked list, describing contents of an aggregate before call. */
1547 struct ipa_known_agg_contents_list
1549 /* Offset and size of the described part of the aggregate. */
1550 HOST_WIDE_INT offset
, size
;
1552 /* Type of the described part of the aggregate. */
1555 /* Known constant value or jump function data describing contents. */
1556 struct ipa_load_agg_data value
;
1558 /* Pointer to the next structure in the list. */
1559 struct ipa_known_agg_contents_list
*next
;
1562 /* Add an aggregate content item into a linked list of
1563 ipa_known_agg_contents_list structure, in which all elements
1564 are sorted ascendingly by offset. */
1567 add_to_agg_contents_list (struct ipa_known_agg_contents_list
**plist
,
1568 struct ipa_known_agg_contents_list
*item
)
1570 struct ipa_known_agg_contents_list
*list
= *plist
;
1572 for (; list
; list
= list
->next
)
1574 if (list
->offset
>= item
->offset
)
1577 plist
= &list
->next
;
1584 /* Check whether a given aggregate content is clobbered by certain element in
1585 a linked list of ipa_known_agg_contents_list. */
1588 clobber_by_agg_contents_list_p (struct ipa_known_agg_contents_list
*list
,
1589 struct ipa_known_agg_contents_list
*item
)
1591 for (; list
; list
= list
->next
)
1593 if (list
->offset
>= item
->offset
)
1594 return list
->offset
< item
->offset
+ item
->size
;
1596 if (list
->offset
+ list
->size
> item
->offset
)
1603 /* Build aggregate jump function from LIST, assuming there are exactly
1604 VALUE_COUNT entries there and that offset of the passed argument
1605 is ARG_OFFSET and store it into JFUNC. */
1608 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1609 int value_count
, HOST_WIDE_INT arg_offset
,
1610 struct ipa_jump_func
*jfunc
)
1612 vec_alloc (jfunc
->agg
.items
, value_count
);
1613 for (; list
; list
= list
->next
)
1615 struct ipa_agg_jf_item item
;
1616 tree operand
= list
->value
.pass_through
.operand
;
1618 if (list
->value
.pass_through
.formal_id
>= 0)
1620 /* Content value is derived from some formal paramerter. */
1621 if (list
->value
.offset
>= 0)
1622 item
.jftype
= IPA_JF_LOAD_AGG
;
1624 item
.jftype
= IPA_JF_PASS_THROUGH
;
1626 item
.value
.load_agg
= list
->value
;
1628 item
.value
.pass_through
.operand
1629 = unshare_expr_without_location (operand
);
1633 /* Content value is known constant. */
1634 item
.jftype
= IPA_JF_CONST
;
1635 item
.value
.constant
= unshare_expr_without_location (operand
);
1640 item
.type
= list
->type
;
1641 gcc_assert (tree_to_shwi (TYPE_SIZE (list
->type
)) == list
->size
);
1643 item
.offset
= list
->offset
- arg_offset
;
1644 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1646 jfunc
->agg
.items
->quick_push (item
);
1650 /* Given an assignment statement STMT, try to collect information into
1651 AGG_VALUE that will be used to construct jump function for RHS of the
1652 assignment, from which content value of an aggregate part comes.
1654 Besides constant and simple pass-through jump functions, also try to
1655 identify whether it matches the following pattern that can be described by
1656 a load-value-from-aggregate jump function, which is a derivative of simple
1657 pass-through jump function.
1663 *(q_5 + 4) = *(p_3(D) + 28) op 1;
1667 Here IPA_LOAD_AGG_DATA data structure is informative enough to describe
1668 constant, simple pass-through and load-vale-from-aggregate. If value
1669 is constant, it will be kept in field OPERAND, and field FORMAL_ID is
1670 set to -1. For simple pass-through and load-value-from-aggregate, field
1671 FORMAL_ID specifies the related formal parameter index, and field
1672 OFFSET can be used to distinguish them, -1 means simple pass-through,
1673 otherwise means load-value-from-aggregate. */
1676 analyze_agg_content_value (struct ipa_func_body_info
*fbi
,
1677 struct ipa_load_agg_data
*agg_value
,
1680 tree lhs
= gimple_assign_lhs (stmt
);
1681 tree rhs1
= gimple_assign_rhs1 (stmt
);
1682 enum tree_code code
;
1685 /* Initialize jump function data for the aggregate part. */
1686 memset (agg_value
, 0, sizeof (*agg_value
));
1687 agg_value
->pass_through
.operation
= NOP_EXPR
;
1688 agg_value
->pass_through
.formal_id
= -1;
1689 agg_value
->offset
= -1;
1691 if (AGGREGATE_TYPE_P (TREE_TYPE (lhs
)) /* TODO: Support aggregate type. */
1692 || TREE_THIS_VOLATILE (lhs
)
1693 || TREE_CODE (lhs
) == BIT_FIELD_REF
1694 || contains_bitfld_component_ref_p (lhs
))
1697 /* Skip SSA copies. */
1698 while (gimple_assign_rhs_class (stmt
) == GIMPLE_SINGLE_RHS
)
1700 if (TREE_CODE (rhs1
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (rhs1
))
1703 stmt
= SSA_NAME_DEF_STMT (rhs1
);
1704 if (!is_gimple_assign (stmt
))
1707 rhs1
= gimple_assign_rhs1 (stmt
);
1710 code
= gimple_assign_rhs_code (stmt
);
1711 switch (gimple_assign_rhs_class (stmt
))
1713 case GIMPLE_SINGLE_RHS
:
1714 if (is_gimple_ip_invariant (rhs1
))
1716 agg_value
->pass_through
.operand
= rhs1
;
1722 case GIMPLE_UNARY_RHS
:
1723 /* NOTE: A GIMPLE_UNARY_RHS operation might not be tcc_unary
1724 (truth_not_expr is example), GIMPLE_BINARY_RHS does not imply
1725 tcc_binary, this subtleness is somewhat misleading.
1727 Since tcc_unary is widely used in IPA-CP code to check an operation
1728 with one operand, here we only allow tc_unary operation to avoid
1729 possible problem. Then we can use (opclass == tc_unary) or not to
1730 distinguish unary and binary. */
1731 if (TREE_CODE_CLASS (code
) != tcc_unary
|| CONVERT_EXPR_CODE_P (code
))
1734 rhs1
= get_ssa_def_if_simple_copy (rhs1
, &stmt
);
1737 case GIMPLE_BINARY_RHS
:
1739 gimple
*rhs1_stmt
= stmt
;
1740 gimple
*rhs2_stmt
= stmt
;
1741 tree rhs2
= gimple_assign_rhs2 (stmt
);
1743 rhs1
= get_ssa_def_if_simple_copy (rhs1
, &rhs1_stmt
);
1744 rhs2
= get_ssa_def_if_simple_copy (rhs2
, &rhs2_stmt
);
1746 if (is_gimple_ip_invariant (rhs2
))
1748 agg_value
->pass_through
.operand
= rhs2
;
1751 else if (is_gimple_ip_invariant (rhs1
))
1753 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1754 code
= swap_tree_comparison (code
);
1755 else if (!commutative_tree_code (code
))
1758 agg_value
->pass_through
.operand
= rhs1
;
1765 if (TREE_CODE_CLASS (code
) != tcc_comparison
1766 && !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs1
)))
1775 if (TREE_CODE (rhs1
) != SSA_NAME
)
1776 index
= load_from_unmodified_param_or_agg (fbi
, fbi
->info
, stmt
,
1778 &agg_value
->by_ref
);
1779 else if (SSA_NAME_IS_DEFAULT_DEF (rhs1
))
1780 index
= ipa_get_param_decl_index (fbi
->info
, SSA_NAME_VAR (rhs1
));
1784 if (agg_value
->offset
>= 0)
1785 agg_value
->type
= TREE_TYPE (rhs1
);
1786 agg_value
->pass_through
.formal_id
= index
;
1787 agg_value
->pass_through
.operation
= code
;
1790 agg_value
->pass_through
.operand
= NULL_TREE
;
1793 /* If STMT is a memory store to the object whose address is BASE, extract
1794 information (offset, size, and value) into CONTENT, and return true,
1795 otherwise we conservatively assume the whole object is modified with
1796 unknown content, and return false. CHECK_REF means that access to object
1797 is expected to be in form of MEM_REF expression. */
1800 extract_mem_content (struct ipa_func_body_info
*fbi
,
1801 gimple
*stmt
, tree base
, bool check_ref
,
1802 struct ipa_known_agg_contents_list
*content
)
1804 HOST_WIDE_INT lhs_offset
, lhs_size
;
1807 if (!is_gimple_assign (stmt
))
1810 tree lhs
= gimple_assign_lhs (stmt
);
1811 tree lhs_base
= get_ref_base_and_extent_hwi (lhs
, &lhs_offset
, &lhs_size
,
1818 if (TREE_CODE (lhs_base
) != MEM_REF
1819 || TREE_OPERAND (lhs_base
, 0) != base
1820 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1823 else if (lhs_base
!= base
)
1826 content
->offset
= lhs_offset
;
1827 content
->size
= lhs_size
;
1828 content
->type
= TREE_TYPE (lhs
);
1829 content
->next
= NULL
;
1831 analyze_agg_content_value (fbi
, &content
->value
, stmt
);
1835 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1836 in ARG is filled in constants or values that are derived from caller's
1837 formal parameter in the way described by some kinds of jump functions. FBI
1838 is the context of the caller function for interprocedural analysis. ARG can
1839 either be an aggregate expression or a pointer to an aggregate. ARG_TYPE is
1840 the type of the aggregate, JFUNC is the jump function for the aggregate. */
1843 determine_known_aggregate_parts (struct ipa_func_body_info
*fbi
,
1844 gcall
*call
, tree arg
,
1846 struct ipa_jump_func
*jfunc
)
1848 struct ipa_known_agg_contents_list
*list
= NULL
, *all_list
= NULL
;
1849 bitmap visited
= NULL
;
1850 int item_count
= 0, value_count
= 0;
1851 HOST_WIDE_INT arg_offset
, arg_size
;
1853 bool check_ref
, by_ref
;
1856 if (param_ipa_max_agg_items
== 0)
1859 /* The function operates in three stages. First, we prepare check_ref, r,
1860 arg_base and arg_offset based on what is actually passed as an actual
1863 if (POINTER_TYPE_P (arg_type
))
1866 if (TREE_CODE (arg
) == SSA_NAME
)
1869 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
)))
1870 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
1875 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1876 arg_size
= tree_to_uhwi (type_size
);
1877 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1879 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1883 arg
= TREE_OPERAND (arg
, 0);
1884 arg_base
= get_ref_base_and_extent_hwi (arg
, &arg_offset
,
1885 &arg_size
, &reverse
);
1888 if (DECL_P (arg_base
))
1891 ao_ref_init (&r
, arg_base
);
1903 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1907 arg_base
= get_ref_base_and_extent_hwi (arg
, &arg_offset
,
1908 &arg_size
, &reverse
);
1912 ao_ref_init (&r
, arg
);
1915 /* Second stage traverses virtual SSA web backwards starting from the call
1916 statement, only looks at individual dominating virtual operand (its
1917 definition dominates the call), as long as it is confident that content
1918 of the aggregate is affected by definition of the virtual operand, it
1919 builds a sorted linked list of ipa_agg_jf_list describing that. */
1921 for (tree dom_vuse
= gimple_vuse (call
); dom_vuse
;)
1923 gimple
*stmt
= SSA_NAME_DEF_STMT (dom_vuse
);
1925 if (gimple_code (stmt
) == GIMPLE_PHI
)
1927 dom_vuse
= get_continuation_for_phi (stmt
, &r
, true,
1928 fbi
->aa_walk_budget
,
1929 &visited
, false, NULL
, NULL
);
1933 if (stmt_may_clobber_ref_p_1 (stmt
, &r
))
1935 struct ipa_known_agg_contents_list
*content
1936 = XALLOCA (struct ipa_known_agg_contents_list
);
1938 if (!extract_mem_content (fbi
, stmt
, arg_base
, check_ref
, content
))
1941 /* Now we get a dominating virtual operand, and need to check
1942 whether its value is clobbered any other dominating one. */
1943 if ((content
->value
.pass_through
.formal_id
>= 0
1944 || content
->value
.pass_through
.operand
)
1945 && !clobber_by_agg_contents_list_p (all_list
, content
))
1947 struct ipa_known_agg_contents_list
*copy
1948 = XALLOCA (struct ipa_known_agg_contents_list
);
1950 /* Add to the list consisting of only dominating virtual
1951 operands, whose definitions can finally reach the call. */
1952 add_to_agg_contents_list (&list
, (*copy
= *content
, copy
));
1954 if (++value_count
== param_ipa_max_agg_items
)
1958 /* Add to the list consisting of all dominating virtual operands. */
1959 add_to_agg_contents_list (&all_list
, content
);
1961 if (++item_count
== 2 * param_ipa_max_agg_items
)
1964 dom_vuse
= gimple_vuse (stmt
);
1968 BITMAP_FREE (visited
);
1970 /* Third stage just goes over the list and creates an appropriate vector of
1971 ipa_agg_jf_item structures out of it, of course only if there are
1972 any meaningful items to begin with. */
1976 jfunc
->agg
.by_ref
= by_ref
;
1977 build_agg_jump_func_from_list (list
, value_count
, arg_offset
, jfunc
);
1982 /* Return the Ith param type of callee associated with call graph
1986 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1989 tree type
= (e
->callee
1990 ? TREE_TYPE (e
->callee
->decl
)
1991 : gimple_call_fntype (e
->call_stmt
));
1992 tree t
= TYPE_ARG_TYPES (type
);
1994 for (n
= 0; n
< i
; n
++)
2001 return TREE_VALUE (t
);
2004 t
= DECL_ARGUMENTS (e
->callee
->decl
);
2005 for (n
= 0; n
< i
; n
++)
2012 return TREE_TYPE (t
);
2016 /* Return ipa_bits with VALUE and MASK values, which can be either a newly
2017 allocated structure or a previously existing one shared with other jump
2018 functions and/or transformation summaries. */
2021 ipa_get_ipa_bits_for_value (const widest_int
&value
, const widest_int
&mask
)
2027 ipa_bits
**slot
= ipa_bits_hash_table
->find_slot (&tmp
, INSERT
);
2031 ipa_bits
*res
= ggc_alloc
<ipa_bits
> ();
2039 /* Assign to JF a pointer to ipa_bits structure with VALUE and MASK. Use hash
2040 table in order to avoid creating multiple same ipa_bits structures. */
2043 ipa_set_jfunc_bits (ipa_jump_func
*jf
, const widest_int
&value
,
2044 const widest_int
&mask
)
2046 jf
->bits
= ipa_get_ipa_bits_for_value (value
, mask
);
2049 /* Return a pointer to a value_range just like *TMP, but either find it in
2050 ipa_vr_hash_table or allocate it in GC memory. TMP->equiv must be NULL. */
2052 static value_range
*
2053 ipa_get_value_range (value_range
*tmp
)
2055 value_range
**slot
= ipa_vr_hash_table
->find_slot (tmp
, INSERT
);
2059 value_range
*vr
= ggc_alloc
<value_range
> ();
2066 /* Return a pointer to a value range consisting of TYPE, MIN, MAX and an empty
2067 equiv set. Use hash table in order to avoid creating multiple same copies of
2070 static value_range
*
2071 ipa_get_value_range (enum value_range_kind kind
, tree min
, tree max
)
2073 value_range
tmp (min
, max
, kind
);
2074 return ipa_get_value_range (&tmp
);
2077 /* Assign to JF a pointer to a value_range structure with TYPE, MIN and MAX and
2078 a NULL equiv bitmap. Use hash table in order to avoid creating multiple
2079 same value_range structures. */
2082 ipa_set_jfunc_vr (ipa_jump_func
*jf
, enum value_range_kind type
,
2085 jf
->m_vr
= ipa_get_value_range (type
, min
, max
);
2088 /* Assign to JF a pointer to a value_range just like TMP but either fetch a
2089 copy from ipa_vr_hash_table or allocate a new on in GC memory. */
2092 ipa_set_jfunc_vr (ipa_jump_func
*jf
, value_range
*tmp
)
2094 jf
->m_vr
= ipa_get_value_range (tmp
);
2097 /* Compute jump function for all arguments of callsite CS and insert the
2098 information in the jump_functions array in the ipa_edge_args corresponding
2099 to this callsite. */
2102 ipa_compute_jump_functions_for_edge (struct ipa_func_body_info
*fbi
,
2103 struct cgraph_edge
*cs
)
2105 class ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
2106 class ipa_edge_args
*args
= IPA_EDGE_REF_GET_CREATE (cs
);
2107 gcall
*call
= cs
->call_stmt
;
2108 int n
, arg_num
= gimple_call_num_args (call
);
2109 bool useful_context
= false;
2111 if (arg_num
== 0 || args
->jump_functions
)
2113 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
2114 if (flag_devirtualize
)
2115 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, arg_num
);
2117 if (gimple_call_internal_p (call
))
2119 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
2122 for (n
= 0; n
< arg_num
; n
++)
2124 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
2125 tree arg
= gimple_call_arg (call
, n
);
2126 tree param_type
= ipa_get_callee_param_type (cs
, n
);
2127 if (flag_devirtualize
&& POINTER_TYPE_P (TREE_TYPE (arg
)))
2130 class ipa_polymorphic_call_context
context (cs
->caller
->decl
,
2133 context
.get_dynamic_type (instance
, arg
, NULL
, cs
->call_stmt
,
2134 &fbi
->aa_walk_budget
);
2135 *ipa_get_ith_polymorhic_call_context (args
, n
) = context
;
2136 if (!context
.useless_p ())
2137 useful_context
= true;
2140 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
2142 bool addr_nonzero
= false;
2143 bool strict_overflow
= false;
2145 if (TREE_CODE (arg
) == SSA_NAME
2147 && get_ptr_nonnull (arg
))
2148 addr_nonzero
= true;
2149 else if (tree_single_nonzero_warnv_p (arg
, &strict_overflow
))
2150 addr_nonzero
= true;
2154 tree z
= build_int_cst (TREE_TYPE (arg
), 0);
2155 ipa_set_jfunc_vr (jfunc
, VR_ANTI_RANGE
, z
, z
);
2158 gcc_assert (!jfunc
->m_vr
);
2163 value_range_kind kind
;
2164 if (TREE_CODE (arg
) == SSA_NAME
2166 && (kind
= get_range_info (arg
, &min
, &max
))
2167 && (kind
== VR_RANGE
|| kind
== VR_ANTI_RANGE
))
2170 value_range
tmpvr (wide_int_to_tree (TREE_TYPE (arg
), min
),
2171 wide_int_to_tree (TREE_TYPE (arg
), max
),
2173 range_fold_unary_expr (&resvr
, NOP_EXPR
, param_type
,
2174 &tmpvr
, TREE_TYPE (arg
));
2175 if (!resvr
.undefined_p () && !resvr
.varying_p ())
2176 ipa_set_jfunc_vr (jfunc
, &resvr
);
2178 gcc_assert (!jfunc
->m_vr
);
2181 gcc_assert (!jfunc
->m_vr
);
2184 if (INTEGRAL_TYPE_P (TREE_TYPE (arg
))
2185 && (TREE_CODE (arg
) == SSA_NAME
|| TREE_CODE (arg
) == INTEGER_CST
))
2187 if (TREE_CODE (arg
) == SSA_NAME
)
2188 ipa_set_jfunc_bits (jfunc
, 0,
2189 widest_int::from (get_nonzero_bits (arg
),
2190 TYPE_SIGN (TREE_TYPE (arg
))));
2192 ipa_set_jfunc_bits (jfunc
, wi::to_widest (arg
), 0);
2194 else if (POINTER_TYPE_P (TREE_TYPE (arg
)))
2196 unsigned HOST_WIDE_INT bitpos
;
2199 get_pointer_alignment_1 (arg
, &align
, &bitpos
);
2200 widest_int mask
= wi::bit_and_not
2201 (wi::mask
<widest_int
> (TYPE_PRECISION (TREE_TYPE (arg
)), false),
2202 align
/ BITS_PER_UNIT
- 1);
2203 widest_int value
= bitpos
/ BITS_PER_UNIT
;
2204 ipa_set_jfunc_bits (jfunc
, value
, mask
);
2207 gcc_assert (!jfunc
->bits
);
2209 if (is_gimple_ip_invariant (arg
)
2211 && is_global_var (arg
)
2212 && TREE_READONLY (arg
)))
2213 ipa_set_jf_constant (jfunc
, arg
, cs
);
2214 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
2215 && TREE_CODE (arg
) == PARM_DECL
)
2217 int index
= ipa_get_param_decl_index (info
, arg
);
2219 gcc_assert (index
>=0);
2220 /* Aggregate passed by value, check for pass-through, otherwise we
2221 will attempt to fill in aggregate contents later in this
2223 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
2225 ipa_set_jf_simple_pass_through (jfunc
, index
, false);
2229 else if (TREE_CODE (arg
) == SSA_NAME
)
2231 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
2233 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
2237 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
2238 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
2243 gimple
*stmt
= SSA_NAME_DEF_STMT (arg
);
2244 if (is_gimple_assign (stmt
))
2245 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
2246 call
, stmt
, arg
, param_type
);
2247 else if (gimple_code (stmt
) == GIMPLE_PHI
)
2248 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
2250 as_a
<gphi
*> (stmt
));
2254 /* If ARG is pointer, we cannot use its type to determine the type of aggregate
2255 passed (because type conversions are ignored in gimple). Usually we can
2256 safely get type from function declaration, but in case of K&R prototypes or
2257 variadic functions we can try our luck with type of the pointer passed.
2258 TODO: Since we look for actual initialization of the memory object, we may better
2259 work out the type based on the memory stores we find. */
2261 param_type
= TREE_TYPE (arg
);
2263 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
2264 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
2265 && (jfunc
->type
!= IPA_JF_ANCESTOR
2266 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
2267 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
2268 || POINTER_TYPE_P (param_type
)))
2269 determine_known_aggregate_parts (fbi
, call
, arg
, param_type
, jfunc
);
2271 if (!useful_context
)
2272 vec_free (args
->polymorphic_call_contexts
);
2275 /* Compute jump functions for all edges - both direct and indirect - outgoing
2279 ipa_compute_jump_functions_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2281 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
2283 struct cgraph_edge
*cs
;
2285 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
2287 struct cgraph_node
*callee
= cs
->callee
;
2291 callee
= callee
->ultimate_alias_target ();
2292 /* We do not need to bother analyzing calls to unknown functions
2293 unless they may become known during lto/whopr. */
2294 if (!callee
->definition
&& !flag_lto
)
2297 ipa_compute_jump_functions_for_edge (fbi
, cs
);
2301 /* If STMT looks like a statement loading a value from a member pointer formal
2302 parameter, return that parameter and store the offset of the field to
2303 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
2304 might be clobbered). If USE_DELTA, then we look for a use of the delta
2305 field rather than the pfn. */
2308 ipa_get_stmt_member_ptr_load_param (gimple
*stmt
, bool use_delta
,
2309 HOST_WIDE_INT
*offset_p
)
2311 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
2313 if (!gimple_assign_single_p (stmt
))
2316 rhs
= gimple_assign_rhs1 (stmt
);
2317 if (TREE_CODE (rhs
) == COMPONENT_REF
)
2319 ref_field
= TREE_OPERAND (rhs
, 1);
2320 rhs
= TREE_OPERAND (rhs
, 0);
2323 ref_field
= NULL_TREE
;
2324 if (TREE_CODE (rhs
) != MEM_REF
)
2326 rec
= TREE_OPERAND (rhs
, 0);
2327 if (TREE_CODE (rec
) != ADDR_EXPR
)
2329 rec
= TREE_OPERAND (rec
, 0);
2330 if (TREE_CODE (rec
) != PARM_DECL
2331 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
2333 ref_offset
= TREE_OPERAND (rhs
, 1);
2340 *offset_p
= int_bit_position (fld
);
2344 if (integer_nonzerop (ref_offset
))
2346 return ref_field
== fld
? rec
: NULL_TREE
;
2349 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
2353 /* Returns true iff T is an SSA_NAME defined by a statement. */
2356 ipa_is_ssa_with_stmt_def (tree t
)
2358 if (TREE_CODE (t
) == SSA_NAME
2359 && !SSA_NAME_IS_DEFAULT_DEF (t
))
2365 /* Find the indirect call graph edge corresponding to STMT and mark it as a
2366 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
2367 indirect call graph edge.
2368 If POLYMORPHIC is true record is as a destination of polymorphic call. */
2370 static struct cgraph_edge
*
2371 ipa_note_param_call (struct cgraph_node
*node
, int param_index
,
2372 gcall
*stmt
, bool polymorphic
)
2374 struct cgraph_edge
*cs
;
2376 cs
= node
->get_edge (stmt
);
2377 cs
->indirect_info
->param_index
= param_index
;
2378 cs
->indirect_info
->agg_contents
= 0;
2379 cs
->indirect_info
->member_ptr
= 0;
2380 cs
->indirect_info
->guaranteed_unmodified
= 0;
2381 ipa_set_param_used_by_indirect_call (IPA_NODE_REF (node
),
2383 if (cs
->indirect_info
->polymorphic
|| polymorphic
)
2384 ipa_set_param_used_by_polymorphic_call
2385 (IPA_NODE_REF (node
), param_index
, true);
2389 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
2390 (described by INFO). PARMS_AINFO is a pointer to a vector containing
2391 intermediate information about each formal parameter. Currently it checks
2392 whether the call calls a pointer that is a formal parameter and if so, the
2393 parameter is marked with the called flag and an indirect call graph edge
2394 describing the call is created. This is very simple for ordinary pointers
2395 represented in SSA but not-so-nice when it comes to member pointers. The
2396 ugly part of this function does nothing more than trying to match the
2397 pattern of such a call. An example of such a pattern is the gimple dump
2398 below, the call is on the last line:
2401 f$__delta_5 = f.__delta;
2402 f$__pfn_24 = f.__pfn;
2406 f$__delta_5 = MEM[(struct *)&f];
2407 f$__pfn_24 = MEM[(struct *)&f + 4B];
2409 and a few lines below:
2412 D.2496_3 = (int) f$__pfn_24;
2413 D.2497_4 = D.2496_3 & 1;
2420 D.2500_7 = (unsigned int) f$__delta_5;
2421 D.2501_8 = &S + D.2500_7;
2422 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
2423 D.2503_10 = *D.2502_9;
2424 D.2504_12 = f$__pfn_24 + -1;
2425 D.2505_13 = (unsigned int) D.2504_12;
2426 D.2506_14 = D.2503_10 + D.2505_13;
2427 D.2507_15 = *D.2506_14;
2428 iftmp.11_16 = (String:: *) D.2507_15;
2431 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
2432 D.2500_19 = (unsigned int) f$__delta_5;
2433 D.2508_20 = &S + D.2500_19;
2434 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
2436 Such patterns are results of simple calls to a member pointer:
2438 int doprinting (int (MyString::* f)(int) const)
2440 MyString S ("somestring");
2445 Moreover, the function also looks for called pointers loaded from aggregates
2446 passed by value or reference. */
2449 ipa_analyze_indirect_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
,
2452 class ipa_node_params
*info
= fbi
->info
;
2453 HOST_WIDE_INT offset
;
2456 if (SSA_NAME_IS_DEFAULT_DEF (target
))
2458 tree var
= SSA_NAME_VAR (target
);
2459 int index
= ipa_get_param_decl_index (info
, var
);
2461 ipa_note_param_call (fbi
->node
, index
, call
, false);
2466 gimple
*def
= SSA_NAME_DEF_STMT (target
);
2467 bool guaranteed_unmodified
;
2468 if (gimple_assign_single_p (def
)
2469 && ipa_load_from_parm_agg (fbi
, info
->descriptors
, def
,
2470 gimple_assign_rhs1 (def
), &index
, &offset
,
2471 NULL
, &by_ref
, &guaranteed_unmodified
))
2473 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
,
2475 cs
->indirect_info
->offset
= offset
;
2476 cs
->indirect_info
->agg_contents
= 1;
2477 cs
->indirect_info
->by_ref
= by_ref
;
2478 cs
->indirect_info
->guaranteed_unmodified
= guaranteed_unmodified
;
2482 /* Now we need to try to match the complex pattern of calling a member
2484 if (gimple_code (def
) != GIMPLE_PHI
2485 || gimple_phi_num_args (def
) != 2
2486 || !POINTER_TYPE_P (TREE_TYPE (target
))
2487 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2490 /* First, we need to check whether one of these is a load from a member
2491 pointer that is a parameter to this function. */
2492 tree n1
= PHI_ARG_DEF (def
, 0);
2493 tree n2
= PHI_ARG_DEF (def
, 1);
2494 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2496 gimple
*d1
= SSA_NAME_DEF_STMT (n1
);
2497 gimple
*d2
= SSA_NAME_DEF_STMT (n2
);
2500 basic_block bb
, virt_bb
;
2501 basic_block join
= gimple_bb (def
);
2502 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2504 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2507 bb
= EDGE_PRED (join
, 0)->src
;
2508 virt_bb
= gimple_bb (d2
);
2510 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2512 bb
= EDGE_PRED (join
, 1)->src
;
2513 virt_bb
= gimple_bb (d1
);
2518 /* Second, we need to check that the basic blocks are laid out in the way
2519 corresponding to the pattern. */
2521 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2522 || single_pred (virt_bb
) != bb
2523 || single_succ (virt_bb
) != join
)
2526 /* Third, let's see that the branching is done depending on the least
2527 significant bit of the pfn. */
2529 gimple
*branch
= last_stmt (bb
);
2530 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2533 if ((gimple_cond_code (branch
) != NE_EXPR
2534 && gimple_cond_code (branch
) != EQ_EXPR
)
2535 || !integer_zerop (gimple_cond_rhs (branch
)))
2538 tree cond
= gimple_cond_lhs (branch
);
2539 if (!ipa_is_ssa_with_stmt_def (cond
))
2542 def
= SSA_NAME_DEF_STMT (cond
);
2543 if (!is_gimple_assign (def
)
2544 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2545 || !integer_onep (gimple_assign_rhs2 (def
)))
2548 cond
= gimple_assign_rhs1 (def
);
2549 if (!ipa_is_ssa_with_stmt_def (cond
))
2552 def
= SSA_NAME_DEF_STMT (cond
);
2554 if (is_gimple_assign (def
)
2555 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2557 cond
= gimple_assign_rhs1 (def
);
2558 if (!ipa_is_ssa_with_stmt_def (cond
))
2560 def
= SSA_NAME_DEF_STMT (cond
);
2564 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2565 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2566 == ptrmemfunc_vbit_in_delta
),
2571 index
= ipa_get_param_decl_index (info
, rec
);
2573 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2575 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
,
2577 cs
->indirect_info
->offset
= offset
;
2578 cs
->indirect_info
->agg_contents
= 1;
2579 cs
->indirect_info
->member_ptr
= 1;
2580 cs
->indirect_info
->guaranteed_unmodified
= 1;
2586 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2587 object referenced in the expression is a formal parameter of the caller
2588 FBI->node (described by FBI->info), create a call note for the
2592 ipa_analyze_virtual_call_uses (struct ipa_func_body_info
*fbi
,
2593 gcall
*call
, tree target
)
2595 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2597 HOST_WIDE_INT anc_offset
;
2599 if (!flag_devirtualize
)
2602 if (TREE_CODE (obj
) != SSA_NAME
)
2605 class ipa_node_params
*info
= fbi
->info
;
2606 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2608 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2612 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2613 gcc_assert (index
>= 0);
2614 if (detect_type_change_ssa (fbi
, obj
, obj_type_ref_class (target
),
2620 gimple
*stmt
= SSA_NAME_DEF_STMT (obj
);
2623 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2626 index
= ipa_get_param_decl_index (info
,
2627 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2628 gcc_assert (index
>= 0);
2629 if (detect_type_change (fbi
, obj
, expr
, obj_type_ref_class (target
),
2634 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
,
2636 class cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2637 ii
->offset
= anc_offset
;
2638 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2639 ii
->otr_type
= obj_type_ref_class (target
);
2640 ii
->polymorphic
= 1;
2643 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2644 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2645 containing intermediate information about each formal parameter. */
2648 ipa_analyze_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
)
2650 tree target
= gimple_call_fn (call
);
2653 || (TREE_CODE (target
) != SSA_NAME
2654 && !virtual_method_call_p (target
)))
2657 struct cgraph_edge
*cs
= fbi
->node
->get_edge (call
);
2658 /* If we previously turned the call into a direct call, there is
2659 no need to analyze. */
2660 if (cs
&& !cs
->indirect_unknown_callee
)
2663 if (cs
->indirect_info
->polymorphic
&& flag_devirtualize
)
2666 tree target
= gimple_call_fn (call
);
2667 ipa_polymorphic_call_context
context (current_function_decl
,
2668 target
, call
, &instance
);
2670 gcc_checking_assert (cs
->indirect_info
->otr_type
2671 == obj_type_ref_class (target
));
2672 gcc_checking_assert (cs
->indirect_info
->otr_token
2673 == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target
)));
2675 cs
->indirect_info
->vptr_changed
2676 = !context
.get_dynamic_type (instance
,
2677 OBJ_TYPE_REF_OBJECT (target
),
2678 obj_type_ref_class (target
), call
,
2679 &fbi
->aa_walk_budget
);
2680 cs
->indirect_info
->context
= context
;
2683 if (TREE_CODE (target
) == SSA_NAME
)
2684 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2685 else if (virtual_method_call_p (target
))
2686 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2690 /* Analyze the call statement STMT with respect to formal parameters (described
2691 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2692 formal parameters are called. */
2695 ipa_analyze_stmt_uses (struct ipa_func_body_info
*fbi
, gimple
*stmt
)
2697 if (is_gimple_call (stmt
))
2698 ipa_analyze_call_uses (fbi
, as_a
<gcall
*> (stmt
));
2701 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2702 If OP is a parameter declaration, mark it as used in the info structure
2706 visit_ref_for_mod_analysis (gimple
*, tree op
, tree
, void *data
)
2708 class ipa_node_params
*info
= (class ipa_node_params
*) data
;
2710 op
= get_base_address (op
);
2712 && TREE_CODE (op
) == PARM_DECL
)
2714 int index
= ipa_get_param_decl_index (info
, op
);
2715 gcc_assert (index
>= 0);
2716 ipa_set_param_used (info
, index
, true);
2722 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2723 the findings in various structures of the associated ipa_node_params
2724 structure, such as parameter flags, notes etc. FBI holds various data about
2725 the function being analyzed. */
2728 ipa_analyze_params_uses_in_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2730 gimple_stmt_iterator gsi
;
2731 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2733 gimple
*stmt
= gsi_stmt (gsi
);
2735 if (is_gimple_debug (stmt
))
2738 ipa_analyze_stmt_uses (fbi
, stmt
);
2739 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2740 visit_ref_for_mod_analysis
,
2741 visit_ref_for_mod_analysis
,
2742 visit_ref_for_mod_analysis
);
2744 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2745 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2746 visit_ref_for_mod_analysis
,
2747 visit_ref_for_mod_analysis
,
2748 visit_ref_for_mod_analysis
);
2751 /* Calculate controlled uses of parameters of NODE. */
2754 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2756 class ipa_node_params
*info
= IPA_NODE_REF (node
);
2758 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2760 tree parm
= ipa_get_param (info
, i
);
2761 int controlled_uses
= 0;
2763 /* For SSA regs see if parameter is used. For non-SSA we compute
2764 the flag during modification analysis. */
2765 if (is_gimple_reg (parm
))
2767 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2769 if (ddef
&& !has_zero_uses (ddef
))
2771 imm_use_iterator imm_iter
;
2772 use_operand_p use_p
;
2774 ipa_set_param_used (info
, i
, true);
2775 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2776 if (!is_gimple_call (USE_STMT (use_p
)))
2778 if (!is_gimple_debug (USE_STMT (use_p
)))
2780 controlled_uses
= IPA_UNDESCRIBED_USE
;
2788 controlled_uses
= 0;
2791 controlled_uses
= IPA_UNDESCRIBED_USE
;
2792 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2796 /* Free stuff in BI. */
2799 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2801 bi
->cg_edges
.release ();
2802 bi
->param_aa_statuses
.release ();
2805 /* Dominator walker driving the analysis. */
2807 class analysis_dom_walker
: public dom_walker
2810 analysis_dom_walker (struct ipa_func_body_info
*fbi
)
2811 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2813 virtual edge
before_dom_children (basic_block
);
2816 struct ipa_func_body_info
*m_fbi
;
2820 analysis_dom_walker::before_dom_children (basic_block bb
)
2822 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2823 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2827 /* Release body info FBI. */
2830 ipa_release_body_info (struct ipa_func_body_info
*fbi
)
2833 struct ipa_bb_info
*bi
;
2835 FOR_EACH_VEC_ELT (fbi
->bb_infos
, i
, bi
)
2836 free_ipa_bb_info (bi
);
2837 fbi
->bb_infos
.release ();
2840 /* Initialize the array describing properties of formal parameters
2841 of NODE, analyze their uses and compute jump functions associated
2842 with actual arguments of calls from within NODE. */
2845 ipa_analyze_node (struct cgraph_node
*node
)
2847 struct ipa_func_body_info fbi
;
2848 class ipa_node_params
*info
;
2850 ipa_check_create_node_params ();
2851 ipa_check_create_edge_args ();
2852 info
= IPA_NODE_REF_GET_CREATE (node
);
2854 if (info
->analysis_done
)
2856 info
->analysis_done
= 1;
2858 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2860 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2862 ipa_set_param_used (info
, i
, true);
2863 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2868 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2870 calculate_dominance_info (CDI_DOMINATORS
);
2871 ipa_initialize_node_params (node
);
2872 ipa_analyze_controlled_uses (node
);
2875 fbi
.info
= IPA_NODE_REF (node
);
2876 fbi
.bb_infos
= vNULL
;
2877 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2878 fbi
.param_count
= ipa_get_param_count (info
);
2879 fbi
.aa_walk_budget
= param_ipa_max_aa_steps
;
2881 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2883 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2884 bi
->cg_edges
.safe_push (cs
);
2887 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2889 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2890 bi
->cg_edges
.safe_push (cs
);
2893 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2895 ipa_release_body_info (&fbi
);
2896 free_dominance_info (CDI_DOMINATORS
);
2900 /* Update the jump functions associated with call graph edge E when the call
2901 graph edge CS is being inlined, assuming that E->caller is already (possibly
2902 indirectly) inlined into CS->callee and that E has not been inlined. */
2905 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2906 struct cgraph_edge
*e
)
2908 class ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2909 class ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2912 int count
= ipa_get_cs_argument_count (args
);
2915 for (i
= 0; i
< count
; i
++)
2917 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2918 class ipa_polymorphic_call_context
*dst_ctx
2919 = ipa_get_ith_polymorhic_call_context (args
, i
);
2923 struct ipa_agg_jf_item
*item
;
2926 FOR_EACH_VEC_ELT (*dst
->agg
.items
, j
, item
)
2929 struct ipa_jump_func
*src
;
2931 if (item
->jftype
!= IPA_JF_PASS_THROUGH
2932 && item
->jftype
!= IPA_JF_LOAD_AGG
)
2935 dst_fid
= item
->value
.pass_through
.formal_id
;
2936 if (!top
|| dst_fid
>= ipa_get_cs_argument_count (top
))
2938 item
->jftype
= IPA_JF_UNKNOWN
;
2942 item
->value
.pass_through
.formal_id
= -1;
2943 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2944 if (src
->type
== IPA_JF_CONST
)
2946 if (item
->jftype
== IPA_JF_PASS_THROUGH
2947 && item
->value
.pass_through
.operation
== NOP_EXPR
)
2949 item
->jftype
= IPA_JF_CONST
;
2950 item
->value
.constant
= src
->value
.constant
.value
;
2954 else if (src
->type
== IPA_JF_PASS_THROUGH
2955 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2957 if (item
->jftype
== IPA_JF_PASS_THROUGH
2958 || !item
->value
.load_agg
.by_ref
2959 || src
->value
.pass_through
.agg_preserved
)
2960 item
->value
.pass_through
.formal_id
2961 = src
->value
.pass_through
.formal_id
;
2963 else if (src
->type
== IPA_JF_ANCESTOR
)
2965 if (item
->jftype
== IPA_JF_PASS_THROUGH
)
2967 if (!src
->value
.ancestor
.offset
)
2968 item
->value
.pass_through
.formal_id
2969 = src
->value
.ancestor
.formal_id
;
2971 else if (src
->value
.ancestor
.agg_preserved
)
2973 gcc_checking_assert (item
->value
.load_agg
.by_ref
);
2975 item
->value
.pass_through
.formal_id
2976 = src
->value
.ancestor
.formal_id
;
2977 item
->value
.load_agg
.offset
2978 += src
->value
.ancestor
.offset
;
2982 if (item
->value
.pass_through
.formal_id
< 0)
2983 item
->jftype
= IPA_JF_UNKNOWN
;
2989 ipa_set_jf_unknown (dst
);
2993 if (dst
->type
== IPA_JF_ANCESTOR
)
2995 struct ipa_jump_func
*src
;
2996 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2997 class ipa_polymorphic_call_context
*src_ctx
2998 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
3000 /* Variable number of arguments can cause havoc if we try to access
3001 one that does not exist in the inlined edge. So make sure we
3003 if (dst_fid
>= ipa_get_cs_argument_count (top
))
3005 ipa_set_jf_unknown (dst
);
3009 src
= ipa_get_ith_jump_func (top
, dst_fid
);
3011 if (src_ctx
&& !src_ctx
->useless_p ())
3013 class ipa_polymorphic_call_context ctx
= *src_ctx
;
3015 /* TODO: Make type preserved safe WRT contexts. */
3016 if (!ipa_get_jf_ancestor_type_preserved (dst
))
3017 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
3018 ctx
.offset_by (dst
->value
.ancestor
.offset
);
3019 if (!ctx
.useless_p ())
3023 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
3025 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
3028 dst_ctx
->combine_with (ctx
);
3032 /* Parameter and argument in ancestor jump function must be pointer
3033 type, which means access to aggregate must be by-reference. */
3034 gcc_assert (!src
->agg
.items
|| src
->agg
.by_ref
);
3036 if (src
->agg
.items
&& dst
->value
.ancestor
.agg_preserved
)
3038 struct ipa_agg_jf_item
*item
;
3041 /* Currently we do not produce clobber aggregate jump functions,
3042 replace with merging when we do. */
3043 gcc_assert (!dst
->agg
.items
);
3045 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
3046 dst
->agg
.by_ref
= src
->agg
.by_ref
;
3047 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
3048 item
->offset
-= dst
->value
.ancestor
.offset
;
3051 if (src
->type
== IPA_JF_PASS_THROUGH
3052 && src
->value
.pass_through
.operation
== NOP_EXPR
)
3054 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
3055 dst
->value
.ancestor
.agg_preserved
&=
3056 src
->value
.pass_through
.agg_preserved
;
3058 else if (src
->type
== IPA_JF_ANCESTOR
)
3060 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
3061 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
3062 dst
->value
.ancestor
.agg_preserved
&=
3063 src
->value
.ancestor
.agg_preserved
;
3066 ipa_set_jf_unknown (dst
);
3068 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
3070 struct ipa_jump_func
*src
;
3071 /* We must check range due to calls with variable number of arguments
3072 and we cannot combine jump functions with operations. */
3073 if (dst
->value
.pass_through
.operation
== NOP_EXPR
3074 && (top
&& dst
->value
.pass_through
.formal_id
3075 < ipa_get_cs_argument_count (top
)))
3077 int dst_fid
= dst
->value
.pass_through
.formal_id
;
3078 src
= ipa_get_ith_jump_func (top
, dst_fid
);
3079 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
3080 class ipa_polymorphic_call_context
*src_ctx
3081 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
3083 if (src_ctx
&& !src_ctx
->useless_p ())
3085 class ipa_polymorphic_call_context ctx
= *src_ctx
;
3087 /* TODO: Make type preserved safe WRT contexts. */
3088 if (!ipa_get_jf_pass_through_type_preserved (dst
))
3089 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
3090 if (!ctx
.useless_p ())
3094 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
3096 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
3098 dst_ctx
->combine_with (ctx
);
3103 case IPA_JF_UNKNOWN
:
3104 ipa_set_jf_unknown (dst
);
3107 ipa_set_jf_cst_copy (dst
, src
);
3110 case IPA_JF_PASS_THROUGH
:
3112 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
3113 enum tree_code operation
;
3114 operation
= ipa_get_jf_pass_through_operation (src
);
3116 if (operation
== NOP_EXPR
)
3120 && ipa_get_jf_pass_through_agg_preserved (src
);
3121 ipa_set_jf_simple_pass_through (dst
, formal_id
, agg_p
);
3123 else if (TREE_CODE_CLASS (operation
) == tcc_unary
)
3124 ipa_set_jf_unary_pass_through (dst
, formal_id
, operation
);
3127 tree operand
= ipa_get_jf_pass_through_operand (src
);
3128 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
3133 case IPA_JF_ANCESTOR
:
3137 && ipa_get_jf_ancestor_agg_preserved (src
);
3138 ipa_set_ancestor_jf (dst
,
3139 ipa_get_jf_ancestor_offset (src
),
3140 ipa_get_jf_ancestor_formal_id (src
),
3149 && (dst_agg_p
|| !src
->agg
.by_ref
))
3151 /* Currently we do not produce clobber aggregate jump
3152 functions, replace with merging when we do. */
3153 gcc_assert (!dst
->agg
.items
);
3155 dst
->agg
.by_ref
= src
->agg
.by_ref
;
3156 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
3160 ipa_set_jf_unknown (dst
);
3165 /* If TARGET is an addr_expr of a function declaration, make it the
3166 (SPECULATIVE)destination of an indirect edge IE and return the edge.
3167 Otherwise, return NULL. */
3169 struct cgraph_edge
*
3170 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
,
3173 struct cgraph_node
*callee
;
3174 bool unreachable
= false;
3176 if (TREE_CODE (target
) == ADDR_EXPR
)
3177 target
= TREE_OPERAND (target
, 0);
3178 if (TREE_CODE (target
) != FUNCTION_DECL
)
3180 target
= canonicalize_constructor_val (target
, NULL
);
3181 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
3183 /* Member pointer call that goes through a VMT lookup. */
3184 if (ie
->indirect_info
->member_ptr
3185 /* Or if target is not an invariant expression and we do not
3186 know if it will evaulate to function at runtime.
3187 This can happen when folding through &VAR, where &VAR
3188 is IP invariant, but VAR itself is not.
3190 TODO: Revisit this when GCC 5 is branched. It seems that
3191 member_ptr check is not needed and that we may try to fold
3192 the expression and see if VAR is readonly. */
3193 || !is_gimple_ip_invariant (target
))
3195 if (dump_enabled_p ())
3197 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
3198 "discovered direct call non-invariant %s\n",
3199 ie
->caller
->dump_name ());
3205 if (dump_enabled_p ())
3207 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
3208 "discovered direct call to non-function in %s, "
3209 "making it __builtin_unreachable\n",
3210 ie
->caller
->dump_name ());
3213 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
3214 callee
= cgraph_node::get_create (target
);
3218 callee
= cgraph_node::get (target
);
3221 callee
= cgraph_node::get (target
);
3223 /* Because may-edges are not explicitely represented and vtable may be external,
3224 we may create the first reference to the object in the unit. */
3225 if (!callee
|| callee
->inlined_to
)
3228 /* We are better to ensure we can refer to it.
3229 In the case of static functions we are out of luck, since we already
3230 removed its body. In the case of public functions we may or may
3231 not introduce the reference. */
3232 if (!canonicalize_constructor_val (target
, NULL
)
3233 || !TREE_PUBLIC (target
))
3236 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
3237 "(%s -> %s) but cannot refer to it. Giving up.\n",
3238 ie
->caller
->dump_name (),
3239 ie
->callee
->dump_name ());
3242 callee
= cgraph_node::get_create (target
);
3245 /* If the edge is already speculated. */
3246 if (speculative
&& ie
->speculative
)
3248 struct cgraph_edge
*e2
;
3249 struct ipa_ref
*ref
;
3250 ie
->speculative_call_info (e2
, ie
, ref
);
3251 if (e2
->callee
->ultimate_alias_target ()
3252 != callee
->ultimate_alias_target ())
3255 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative "
3256 "target (%s -> %s) but the call is already "
3257 "speculated to %s. Giving up.\n",
3258 ie
->caller
->dump_name (), callee
->dump_name (),
3259 e2
->callee
->dump_name ());
3264 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
3265 "(%s -> %s) this agree with previous speculation.\n",
3266 ie
->caller
->dump_name (), callee
->dump_name ());
3271 if (!dbg_cnt (devirt
))
3274 ipa_check_create_node_params ();
3276 /* We cannot make edges to inline clones. It is bug that someone removed
3277 the cgraph node too early. */
3278 gcc_assert (!callee
->inlined_to
);
3280 if (dump_file
&& !unreachable
)
3282 fprintf (dump_file
, "ipa-prop: Discovered %s call to a %s target "
3283 "(%s -> %s), for stmt ",
3284 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
3285 speculative
? "speculative" : "known",
3286 ie
->caller
->dump_name (),
3287 callee
->dump_name ());
3289 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
3291 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
3293 if (dump_enabled_p ())
3295 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, ie
->call_stmt
,
3296 "converting indirect call in %s to direct call to %s\n",
3297 ie
->caller
->name (), callee
->name ());
3301 struct cgraph_edge
*orig
= ie
;
3302 ie
= ie
->make_direct (callee
);
3303 /* If we resolved speculative edge the cost is already up to date
3304 for direct call (adjusted by inline_edge_duplication_hook). */
3307 ipa_call_summary
*es
= ipa_call_summaries
->get (ie
);
3308 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
3309 - eni_size_weights
.call_cost
);
3310 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
3311 - eni_time_weights
.call_cost
);
3316 if (!callee
->can_be_discarded_p ())
3319 alias
= dyn_cast
<cgraph_node
*> (callee
->noninterposable_alias ());
3323 /* make_speculative will update ie's cost to direct call cost. */
3324 ie
= ie
->make_speculative
3325 (callee
, ie
->count
.apply_scale (8, 10));
3331 /* Attempt to locate an interprocedural constant at a given REQ_OFFSET in
3332 CONSTRUCTOR and return it. Return NULL if the search fails for some
3336 find_constructor_constant_at_offset (tree constructor
, HOST_WIDE_INT req_offset
)
3338 tree type
= TREE_TYPE (constructor
);
3339 if (TREE_CODE (type
) != ARRAY_TYPE
3340 && TREE_CODE (type
) != RECORD_TYPE
)
3345 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (constructor
), ix
, index
, val
)
3347 HOST_WIDE_INT elt_offset
;
3348 if (TREE_CODE (type
) == ARRAY_TYPE
)
3351 tree unit_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
3352 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
3356 if (TREE_CODE (index
) == RANGE_EXPR
)
3357 off
= wi::to_offset (TREE_OPERAND (index
, 0));
3359 off
= wi::to_offset (index
);
3360 if (TYPE_DOMAIN (type
) && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)))
3362 tree low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
3363 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
3364 off
= wi::sext (off
- wi::to_offset (low_bound
),
3365 TYPE_PRECISION (TREE_TYPE (index
)));
3367 off
*= wi::to_offset (unit_size
);
3368 /* ??? Handle more than just the first index of a
3372 off
= wi::to_offset (unit_size
) * ix
;
3374 off
= wi::lshift (off
, LOG2_BITS_PER_UNIT
);
3375 if (!wi::fits_shwi_p (off
) || wi::neg_p (off
))
3377 elt_offset
= off
.to_shwi ();
3379 else if (TREE_CODE (type
) == RECORD_TYPE
)
3381 gcc_checking_assert (index
&& TREE_CODE (index
) == FIELD_DECL
);
3382 if (DECL_BIT_FIELD (index
))
3384 elt_offset
= int_bit_position (index
);
3389 if (elt_offset
> req_offset
)
3392 if (TREE_CODE (val
) == CONSTRUCTOR
)
3393 return find_constructor_constant_at_offset (val
,
3394 req_offset
- elt_offset
);
3396 if (elt_offset
== req_offset
3397 && is_gimple_reg_type (TREE_TYPE (val
))
3398 && is_gimple_ip_invariant (val
))
3404 /* Check whether SCALAR could be used to look up an aggregate interprocedural
3405 invariant from a static constructor and if so, return it. Otherwise return
3409 ipa_find_agg_cst_from_init (tree scalar
, HOST_WIDE_INT offset
, bool by_ref
)
3413 if (TREE_CODE (scalar
) != ADDR_EXPR
)
3415 scalar
= TREE_OPERAND (scalar
, 0);
3419 || !is_global_var (scalar
)
3420 || !TREE_READONLY (scalar
)
3421 || !DECL_INITIAL (scalar
)
3422 || TREE_CODE (DECL_INITIAL (scalar
)) != CONSTRUCTOR
)
3425 return find_constructor_constant_at_offset (DECL_INITIAL (scalar
), offset
);
3428 /* Retrieve value from AGG, a set of known offset/value for an aggregate or
3429 static initializer of SCALAR (which can be NULL) for the given OFFSET or
3430 return NULL if there is none. BY_REF specifies whether the value has to be
3431 passed by reference or by value. If FROM_GLOBAL_CONSTANT is non-NULL, then
3432 the boolean it points to is set to true if the value comes from an
3433 initializer of a constant. */
3436 ipa_find_agg_cst_for_param (struct ipa_agg_value_set
*agg
, tree scalar
,
3437 HOST_WIDE_INT offset
, bool by_ref
,
3438 bool *from_global_constant
)
3440 struct ipa_agg_value
*item
;
3445 tree res
= ipa_find_agg_cst_from_init (scalar
, offset
, by_ref
);
3448 if (from_global_constant
)
3449 *from_global_constant
= true;
3455 || by_ref
!= agg
->by_ref
)
3458 FOR_EACH_VEC_ELT (agg
->items
, i
, item
)
3459 if (item
->offset
== offset
)
3461 /* Currently we do not have clobber values, return NULL for them once
3463 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
3464 if (from_global_constant
)
3465 *from_global_constant
= false;
3471 /* Remove a reference to SYMBOL from the list of references of a node given by
3472 reference description RDESC. Return true if the reference has been
3473 successfully found and removed. */
3476 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
3478 struct ipa_ref
*to_del
;
3479 struct cgraph_edge
*origin
;
3484 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
3485 origin
->lto_stmt_uid
);
3489 to_del
->remove_reference ();
3491 fprintf (dump_file
, "ipa-prop: Removed a reference from %s to %s.\n",
3492 origin
->caller
->dump_name (), xstrdup_for_dump (symbol
->name ()));
3496 /* If JFUNC has a reference description with refcount different from
3497 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
3498 NULL. JFUNC must be a constant jump function. */
3500 static struct ipa_cst_ref_desc
*
3501 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
3503 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
3504 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
3510 /* If the value of constant jump function JFUNC is an address of a function
3511 declaration, return the associated call graph node. Otherwise return
3514 static cgraph_node
*
3515 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
3517 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
3518 tree cst
= ipa_get_jf_constant (jfunc
);
3519 if (TREE_CODE (cst
) != ADDR_EXPR
3520 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
3523 return cgraph_node::get (TREE_OPERAND (cst
, 0));
3527 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
3528 refcount and if it hits zero, remove reference to SYMBOL from the caller of
3529 the edge specified in the rdesc. Return false if either the symbol or the
3530 reference could not be found, otherwise return true. */
3533 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
3535 struct ipa_cst_ref_desc
*rdesc
;
3536 if (jfunc
->type
== IPA_JF_CONST
3537 && (rdesc
= jfunc_rdesc_usable (jfunc
))
3538 && --rdesc
->refcount
== 0)
3540 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
3544 return remove_described_reference (symbol
, rdesc
);
3549 /* Try to find a destination for indirect edge IE that corresponds to a simple
3550 call or a call of a member function pointer and where the destination is a
3551 pointer formal parameter described by jump function JFUNC. TARGET_TYPE is
3552 the type of the parameter to which the result of JFUNC is passed. If it can
3553 be determined, return the newly direct edge, otherwise return NULL.
3554 NEW_ROOT and NEW_ROOT_INFO is the node and its info that JFUNC lattices are
3557 static struct cgraph_edge
*
3558 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
3559 struct ipa_jump_func
*jfunc
, tree target_type
,
3560 struct cgraph_node
*new_root
,
3561 class ipa_node_params
*new_root_info
)
3563 struct cgraph_edge
*cs
;
3565 bool agg_contents
= ie
->indirect_info
->agg_contents
;
3566 tree scalar
= ipa_value_from_jfunc (new_root_info
, jfunc
, target_type
);
3569 bool from_global_constant
;
3570 ipa_agg_value_set agg
= ipa_agg_value_set_from_jfunc (new_root_info
,
3573 target
= ipa_find_agg_cst_for_param (&agg
, scalar
,
3574 ie
->indirect_info
->offset
,
3575 ie
->indirect_info
->by_ref
,
3576 &from_global_constant
);
3579 && !from_global_constant
3580 && !ie
->indirect_info
->guaranteed_unmodified
)
3587 cs
= ipa_make_edge_direct_to_target (ie
, target
);
3589 if (cs
&& !agg_contents
)
3592 gcc_checking_assert (cs
->callee
3594 || jfunc
->type
!= IPA_JF_CONST
3595 || !cgraph_node_for_jfunc (jfunc
)
3596 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
3597 ok
= try_decrement_rdesc_refcount (jfunc
);
3598 gcc_checking_assert (ok
);
3604 /* Return the target to be used in cases of impossible devirtualization. IE
3605 and target (the latter can be NULL) are dumped when dumping is enabled. */
3608 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
3614 "Type inconsistent devirtualization: %s->%s\n",
3615 ie
->caller
->dump_name (),
3616 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
3619 "No devirtualization target in %s\n",
3620 ie
->caller
->dump_name ());
3622 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
3623 cgraph_node::get_create (new_target
);
3627 /* Try to find a destination for indirect edge IE that corresponds to a virtual
3628 call based on a formal parameter which is described by jump function JFUNC
3629 and if it can be determined, make it direct and return the direct edge.
3630 Otherwise, return NULL. CTX describes the polymorphic context that the
3631 parameter the call is based on brings along with it. NEW_ROOT and
3632 NEW_ROOT_INFO is the node and its info that JFUNC lattices are relative
3635 static struct cgraph_edge
*
3636 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
3637 struct ipa_jump_func
*jfunc
,
3638 class ipa_polymorphic_call_context ctx
,
3639 struct cgraph_node
*new_root
,
3640 class ipa_node_params
*new_root_info
)
3643 bool speculative
= false;
3645 if (!opt_for_fn (ie
->caller
->decl
, flag_devirtualize
))
3648 gcc_assert (!ie
->indirect_info
->by_ref
);
3650 /* Try to do lookup via known virtual table pointer value. */
3651 if (!ie
->indirect_info
->vptr_changed
3652 || opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
))
3655 unsigned HOST_WIDE_INT offset
;
3656 tree scalar
= (jfunc
->type
== IPA_JF_CONST
) ? ipa_get_jf_constant (jfunc
)
3658 ipa_agg_value_set agg
= ipa_agg_value_set_from_jfunc (new_root_info
,
3661 tree t
= ipa_find_agg_cst_for_param (&agg
, scalar
,
3662 ie
->indirect_info
->offset
,
3665 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
3668 t
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
3669 vtable
, offset
, &can_refer
);
3673 || fndecl_built_in_p (t
, BUILT_IN_UNREACHABLE
)
3674 || !possible_polymorphic_call_target_p
3675 (ie
, cgraph_node::get (t
)))
3677 /* Do not speculate builtin_unreachable, it is stupid! */
3678 if (!ie
->indirect_info
->vptr_changed
)
3679 target
= ipa_impossible_devirt_target (ie
, target
);
3686 speculative
= ie
->indirect_info
->vptr_changed
;
3692 ipa_polymorphic_call_context
ie_context (ie
);
3693 vec
<cgraph_node
*>targets
;
3696 ctx
.offset_by (ie
->indirect_info
->offset
);
3697 if (ie
->indirect_info
->vptr_changed
)
3698 ctx
.possible_dynamic_type_change (ie
->in_polymorphic_cdtor
,
3699 ie
->indirect_info
->otr_type
);
3700 ctx
.combine_with (ie_context
, ie
->indirect_info
->otr_type
);
3701 targets
= possible_polymorphic_call_targets
3702 (ie
->indirect_info
->otr_type
,
3703 ie
->indirect_info
->otr_token
,
3705 if (final
&& targets
.length () <= 1)
3707 speculative
= false;
3708 if (targets
.length () == 1)
3709 target
= targets
[0]->decl
;
3711 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3713 else if (!target
&& opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
)
3714 && !ie
->speculative
&& ie
->maybe_hot_p ())
3717 n
= try_speculative_devirtualization (ie
->indirect_info
->otr_type
,
3718 ie
->indirect_info
->otr_token
,
3719 ie
->indirect_info
->context
);
3729 if (!possible_polymorphic_call_target_p
3730 (ie
, cgraph_node::get_create (target
)))
3734 target
= ipa_impossible_devirt_target (ie
, target
);
3736 return ipa_make_edge_direct_to_target (ie
, target
, speculative
);
3742 /* Update the param called notes associated with NODE when CS is being inlined,
3743 assuming NODE is (potentially indirectly) inlined into CS->callee.
3744 Moreover, if the callee is discovered to be constant, create a new cgraph
3745 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3746 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3749 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3750 struct cgraph_node
*node
,
3751 vec
<cgraph_edge
*> *new_edges
)
3753 class ipa_edge_args
*top
;
3754 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3755 struct cgraph_node
*new_root
;
3756 class ipa_node_params
*new_root_info
, *inlined_node_info
;
3759 ipa_check_create_edge_args ();
3760 top
= IPA_EDGE_REF (cs
);
3761 new_root
= cs
->caller
->inlined_to
3762 ? cs
->caller
->inlined_to
: cs
->caller
;
3763 new_root_info
= IPA_NODE_REF (new_root
);
3764 inlined_node_info
= IPA_NODE_REF (cs
->callee
->function_symbol ());
3766 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3768 class cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3769 struct ipa_jump_func
*jfunc
;
3771 cgraph_node
*spec_target
= NULL
;
3773 next_ie
= ie
->next_callee
;
3775 if (ici
->param_index
== -1)
3778 /* We must check range due to calls with variable number of arguments: */
3779 if (!top
|| ici
->param_index
>= ipa_get_cs_argument_count (top
))
3781 ici
->param_index
= -1;
3785 param_index
= ici
->param_index
;
3786 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3788 if (ie
->speculative
)
3790 struct cgraph_edge
*de
;
3791 struct ipa_ref
*ref
;
3792 ie
->speculative_call_info (de
, ie
, ref
);
3793 spec_target
= de
->callee
;
3796 if (!opt_for_fn (node
->decl
, flag_indirect_inlining
))
3797 new_direct_edge
= NULL
;
3798 else if (ici
->polymorphic
)
3800 ipa_polymorphic_call_context ctx
;
3801 ctx
= ipa_context_from_jfunc (new_root_info
, cs
, param_index
, jfunc
);
3802 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
, ctx
,
3808 tree target_type
= ipa_get_type (inlined_node_info
, param_index
);
3809 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3815 /* If speculation was removed, then we need to do nothing. */
3816 if (new_direct_edge
&& new_direct_edge
!= ie
3817 && new_direct_edge
->callee
== spec_target
)
3819 new_direct_edge
->indirect_inlining_edge
= 1;
3820 top
= IPA_EDGE_REF (cs
);
3822 if (!new_direct_edge
->speculative
)
3825 else if (new_direct_edge
)
3827 new_direct_edge
->indirect_inlining_edge
= 1;
3830 new_edges
->safe_push (new_direct_edge
);
3833 top
= IPA_EDGE_REF (cs
);
3834 /* If speculative edge was introduced we still need to update
3835 call info of the indirect edge. */
3836 if (!new_direct_edge
->speculative
)
3839 if (jfunc
->type
== IPA_JF_PASS_THROUGH
3840 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3842 if (ici
->agg_contents
3843 && !ipa_get_jf_pass_through_agg_preserved (jfunc
)
3844 && !ici
->polymorphic
)
3845 ici
->param_index
= -1;
3848 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3849 if (ici
->polymorphic
3850 && !ipa_get_jf_pass_through_type_preserved (jfunc
))
3851 ici
->vptr_changed
= true;
3852 ipa_set_param_used_by_indirect_call (new_root_info
,
3853 ici
->param_index
, true);
3854 if (ici
->polymorphic
)
3855 ipa_set_param_used_by_polymorphic_call (new_root_info
,
3856 ici
->param_index
, true);
3859 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3861 if (ici
->agg_contents
3862 && !ipa_get_jf_ancestor_agg_preserved (jfunc
)
3863 && !ici
->polymorphic
)
3864 ici
->param_index
= -1;
3867 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3868 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3869 if (ici
->polymorphic
3870 && !ipa_get_jf_ancestor_type_preserved (jfunc
))
3871 ici
->vptr_changed
= true;
3872 ipa_set_param_used_by_indirect_call (new_root_info
,
3873 ici
->param_index
, true);
3874 if (ici
->polymorphic
)
3875 ipa_set_param_used_by_polymorphic_call (new_root_info
,
3876 ici
->param_index
, true);
3880 /* Either we can find a destination for this edge now or never. */
3881 ici
->param_index
= -1;
3887 /* Recursively traverse subtree of NODE (including node) made of inlined
3888 cgraph_edges when CS has been inlined and invoke
3889 update_indirect_edges_after_inlining on all nodes and
3890 update_jump_functions_after_inlining on all non-inlined edges that lead out
3891 of this subtree. Newly discovered indirect edges will be added to
3892 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3896 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3897 struct cgraph_node
*node
,
3898 vec
<cgraph_edge
*> *new_edges
)
3900 struct cgraph_edge
*e
;
3903 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3905 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3906 if (!e
->inline_failed
)
3907 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3909 update_jump_functions_after_inlining (cs
, e
);
3910 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3911 update_jump_functions_after_inlining (cs
, e
);
3916 /* Combine two controlled uses counts as done during inlining. */
3919 combine_controlled_uses_counters (int c
, int d
)
3921 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3922 return IPA_UNDESCRIBED_USE
;
3927 /* Propagate number of controlled users from CS->caleee to the new root of the
3928 tree of inlined nodes. */
3931 propagate_controlled_uses (struct cgraph_edge
*cs
)
3933 class ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3936 struct cgraph_node
*new_root
= cs
->caller
->inlined_to
3937 ? cs
->caller
->inlined_to
: cs
->caller
;
3938 class ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3939 class ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3945 count
= MIN (ipa_get_cs_argument_count (args
),
3946 ipa_get_param_count (old_root_info
));
3947 for (i
= 0; i
< count
; i
++)
3949 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3950 struct ipa_cst_ref_desc
*rdesc
;
3952 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3955 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3956 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3957 d
= ipa_get_controlled_uses (old_root_info
, i
);
3959 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3960 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3961 c
= combine_controlled_uses_counters (c
, d
);
3962 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3963 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3965 struct cgraph_node
*n
;
3966 struct ipa_ref
*ref
;
3967 tree t
= new_root_info
->known_csts
[src_idx
];
3969 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3970 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3971 && (n
= cgraph_node::get (TREE_OPERAND (t
, 0)))
3972 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3975 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3976 "reference from %s to %s.\n",
3977 new_root
->dump_name (),
3979 ref
->remove_reference ();
3983 else if (jf
->type
== IPA_JF_CONST
3984 && (rdesc
= jfunc_rdesc_usable (jf
)))
3986 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3987 int c
= rdesc
->refcount
;
3988 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3989 if (rdesc
->refcount
== 0)
3991 tree cst
= ipa_get_jf_constant (jf
);
3992 struct cgraph_node
*n
;
3993 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3994 && TREE_CODE (TREE_OPERAND (cst
, 0))
3996 n
= cgraph_node::get (TREE_OPERAND (cst
, 0));
3999 struct cgraph_node
*clone
;
4001 ok
= remove_described_reference (n
, rdesc
);
4002 gcc_checking_assert (ok
);
4005 while (clone
->inlined_to
4006 && clone
->ipcp_clone
4007 && clone
!= rdesc
->cs
->caller
)
4009 struct ipa_ref
*ref
;
4010 ref
= clone
->find_reference (n
, NULL
, 0);
4014 fprintf (dump_file
, "ipa-prop: Removing "
4015 "cloning-created reference "
4017 clone
->dump_name (),
4019 ref
->remove_reference ();
4021 clone
= clone
->callers
->caller
;
4028 for (i
= ipa_get_param_count (old_root_info
);
4029 i
< ipa_get_cs_argument_count (args
);
4032 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
4034 if (jf
->type
== IPA_JF_CONST
)
4036 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
4038 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
4040 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
4041 ipa_set_controlled_uses (new_root_info
,
4042 jf
->value
.pass_through
.formal_id
,
4043 IPA_UNDESCRIBED_USE
);
4047 /* Update jump functions and call note functions on inlining the call site CS.
4048 CS is expected to lead to a node already cloned by
4049 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
4050 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
4054 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
4055 vec
<cgraph_edge
*> *new_edges
)
4058 /* Do nothing if the preparation phase has not been carried out yet
4059 (i.e. during early inlining). */
4060 if (!ipa_node_params_sum
)
4062 gcc_assert (ipa_edge_args_sum
);
4064 propagate_controlled_uses (cs
);
4065 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
4066 ipa_node_params_sum
->remove (cs
->callee
);
4068 class ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
4072 if (args
->jump_functions
)
4074 struct ipa_jump_func
*jf
;
4076 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
4077 if (jf
->type
== IPA_JF_CONST
4078 && ipa_get_jf_constant_rdesc (jf
))
4085 ipa_edge_args_sum
->remove (cs
);
4087 if (ipcp_transformation_sum
)
4088 ipcp_transformation_sum
->remove (cs
->callee
);
4093 /* Ensure that array of edge arguments infos is big enough to accommodate a
4094 structure for all edges and reallocates it if not. Also, allocate
4095 associated hash tables is they do not already exist. */
4098 ipa_check_create_edge_args (void)
4100 if (!ipa_edge_args_sum
)
4102 = (new (ggc_alloc_no_dtor
<ipa_edge_args_sum_t
> ())
4103 ipa_edge_args_sum_t (symtab
, true));
4104 if (!ipa_bits_hash_table
)
4105 ipa_bits_hash_table
= hash_table
<ipa_bit_ggc_hash_traits
>::create_ggc (37);
4106 if (!ipa_vr_hash_table
)
4107 ipa_vr_hash_table
= hash_table
<ipa_vr_ggc_hash_traits
>::create_ggc (37);
4110 /* Free all ipa_edge structures. */
4113 ipa_free_all_edge_args (void)
4115 if (!ipa_edge_args_sum
)
4118 ggc_delete (ipa_edge_args_sum
);
4119 ipa_edge_args_sum
= NULL
;
4122 /* Free all ipa_node_params structures. */
4125 ipa_free_all_node_params (void)
4127 ggc_delete (ipa_node_params_sum
);
4128 ipa_node_params_sum
= NULL
;
4131 /* Initialize IPA CP transformation summary and also allocate any necessary hash
4132 tables if they do not already exist. */
4135 ipcp_transformation_initialize (void)
4137 if (!ipa_bits_hash_table
)
4138 ipa_bits_hash_table
= hash_table
<ipa_bit_ggc_hash_traits
>::create_ggc (37);
4139 if (!ipa_vr_hash_table
)
4140 ipa_vr_hash_table
= hash_table
<ipa_vr_ggc_hash_traits
>::create_ggc (37);
4141 if (ipcp_transformation_sum
== NULL
)
4142 ipcp_transformation_sum
= ipcp_transformation_t::create_ggc (symtab
);
4145 /* Release the IPA CP transformation summary. */
4148 ipcp_free_transformation_sum (void)
4150 if (!ipcp_transformation_sum
)
4153 ipcp_transformation_sum
->~function_summary
<ipcp_transformation
*> ();
4154 ggc_free (ipcp_transformation_sum
);
4155 ipcp_transformation_sum
= NULL
;
4158 /* Set the aggregate replacements of NODE to be AGGVALS. */
4161 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
4162 struct ipa_agg_replacement_value
*aggvals
)
4164 ipcp_transformation_initialize ();
4165 ipcp_transformation
*s
= ipcp_transformation_sum
->get_create (node
);
4166 s
->agg_values
= aggvals
;
4169 /* Hook that is called by cgraph.c when an edge is removed. Adjust reference
4170 count data structures accordingly. */
4173 ipa_edge_args_sum_t::remove (cgraph_edge
*cs
, ipa_edge_args
*args
)
4175 if (args
->jump_functions
)
4177 struct ipa_jump_func
*jf
;
4179 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
4181 struct ipa_cst_ref_desc
*rdesc
;
4182 try_decrement_rdesc_refcount (jf
);
4183 if (jf
->type
== IPA_JF_CONST
4184 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
4191 /* Method invoked when an edge is duplicated. Copy ipa_edge_args and adjust
4192 reference count data strucutres accordingly. */
4195 ipa_edge_args_sum_t::duplicate (cgraph_edge
*src
, cgraph_edge
*dst
,
4196 ipa_edge_args
*old_args
, ipa_edge_args
*new_args
)
4200 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
4201 if (old_args
->polymorphic_call_contexts
)
4202 new_args
->polymorphic_call_contexts
4203 = vec_safe_copy (old_args
->polymorphic_call_contexts
);
4205 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
4207 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
4208 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
4210 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
4212 if (src_jf
->type
== IPA_JF_CONST
)
4214 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
4217 dst_jf
->value
.constant
.rdesc
= NULL
;
4218 else if (src
->caller
== dst
->caller
)
4220 struct ipa_ref
*ref
;
4221 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
4222 gcc_checking_assert (n
);
4223 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
4225 gcc_checking_assert (ref
);
4226 dst
->caller
->clone_reference (ref
, ref
->stmt
);
4228 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
4229 dst_rdesc
->cs
= dst
;
4230 dst_rdesc
->refcount
= src_rdesc
->refcount
;
4231 dst_rdesc
->next_duplicate
= NULL
;
4232 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
4234 else if (src_rdesc
->cs
== src
)
4236 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
4237 dst_rdesc
->cs
= dst
;
4238 dst_rdesc
->refcount
= src_rdesc
->refcount
;
4239 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
4240 src_rdesc
->next_duplicate
= dst_rdesc
;
4241 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
4245 struct ipa_cst_ref_desc
*dst_rdesc
;
4246 /* This can happen during inlining, when a JFUNC can refer to a
4247 reference taken in a function up in the tree of inline clones.
4248 We need to find the duplicate that refers to our tree of
4251 gcc_assert (dst
->caller
->inlined_to
);
4252 for (dst_rdesc
= src_rdesc
->next_duplicate
;
4254 dst_rdesc
= dst_rdesc
->next_duplicate
)
4256 struct cgraph_node
*top
;
4257 top
= dst_rdesc
->cs
->caller
->inlined_to
4258 ? dst_rdesc
->cs
->caller
->inlined_to
4259 : dst_rdesc
->cs
->caller
;
4260 if (dst
->caller
->inlined_to
== top
)
4263 gcc_assert (dst_rdesc
);
4264 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
4267 else if (dst_jf
->type
== IPA_JF_PASS_THROUGH
4268 && src
->caller
== dst
->caller
)
4270 struct cgraph_node
*inline_root
= dst
->caller
->inlined_to
4271 ? dst
->caller
->inlined_to
: dst
->caller
;
4272 class ipa_node_params
*root_info
= IPA_NODE_REF (inline_root
);
4273 int idx
= ipa_get_jf_pass_through_formal_id (dst_jf
);
4275 int c
= ipa_get_controlled_uses (root_info
, idx
);
4276 if (c
!= IPA_UNDESCRIBED_USE
)
4279 ipa_set_controlled_uses (root_info
, idx
, c
);
4285 /* Analyze newly added function into callgraph. */
4288 ipa_add_new_function (cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
4290 if (node
->has_gimple_body_p ())
4291 ipa_analyze_node (node
);
4294 /* Hook that is called by summary when a node is duplicated. */
4297 ipa_node_params_t::duplicate(cgraph_node
*src
, cgraph_node
*dst
,
4298 ipa_node_params
*old_info
,
4299 ipa_node_params
*new_info
)
4301 ipa_agg_replacement_value
*old_av
, *new_av
;
4303 new_info
->descriptors
= vec_safe_copy (old_info
->descriptors
);
4304 new_info
->lattices
= NULL
;
4305 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
4306 new_info
->known_csts
= old_info
->known_csts
.copy ();
4307 new_info
->known_contexts
= old_info
->known_contexts
.copy ();
4309 new_info
->analysis_done
= old_info
->analysis_done
;
4310 new_info
->node_enqueued
= old_info
->node_enqueued
;
4311 new_info
->versionable
= old_info
->versionable
;
4313 old_av
= ipa_get_agg_replacements_for_node (src
);
4319 struct ipa_agg_replacement_value
*v
;
4321 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
4322 memcpy (v
, old_av
, sizeof (*v
));
4325 old_av
= old_av
->next
;
4327 ipa_set_node_agg_value_chain (dst
, new_av
);
4331 /* Duplication of ipcp transformation summaries. */
4334 ipcp_transformation_t::duplicate(cgraph_node
*, cgraph_node
*dst
,
4335 ipcp_transformation
*src_trans
,
4336 ipcp_transformation
*dst_trans
)
4338 /* Avoid redundant work of duplicating vectors we will never use. */
4339 if (dst
->inlined_to
)
4341 dst_trans
->bits
= vec_safe_copy (src_trans
->bits
);
4342 dst_trans
->m_vr
= vec_safe_copy (src_trans
->m_vr
);
4343 ipa_agg_replacement_value
*agg
= src_trans
->agg_values
,
4344 **aggptr
= &dst_trans
->agg_values
;
4347 *aggptr
= ggc_alloc
<ipa_agg_replacement_value
> ();
4350 aggptr
= &(*aggptr
)->next
;
4354 /* Register our cgraph hooks if they are not already there. */
4357 ipa_register_cgraph_hooks (void)
4359 ipa_check_create_node_params ();
4360 ipa_check_create_edge_args ();
4362 function_insertion_hook_holder
=
4363 symtab
->add_cgraph_insertion_hook (&ipa_add_new_function
, NULL
);
4366 /* Unregister our cgraph hooks if they are not already there. */
4369 ipa_unregister_cgraph_hooks (void)
4371 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
4372 function_insertion_hook_holder
= NULL
;
4375 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
4376 longer needed after ipa-cp. */
4379 ipa_free_all_structures_after_ipa_cp (void)
4381 if (!optimize
&& !in_lto_p
)
4383 ipa_free_all_edge_args ();
4384 ipa_free_all_node_params ();
4385 ipcp_sources_pool
.release ();
4386 ipcp_cst_values_pool
.release ();
4387 ipcp_poly_ctx_values_pool
.release ();
4388 ipcp_agg_lattice_pool
.release ();
4389 ipa_unregister_cgraph_hooks ();
4390 ipa_refdesc_pool
.release ();
4394 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
4395 longer needed after indirect inlining. */
4398 ipa_free_all_structures_after_iinln (void)
4400 ipa_free_all_edge_args ();
4401 ipa_free_all_node_params ();
4402 ipa_unregister_cgraph_hooks ();
4403 ipcp_sources_pool
.release ();
4404 ipcp_cst_values_pool
.release ();
4405 ipcp_poly_ctx_values_pool
.release ();
4406 ipcp_agg_lattice_pool
.release ();
4407 ipa_refdesc_pool
.release ();
4410 /* Print ipa_tree_map data structures of all functions in the
4414 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
4417 class ipa_node_params
*info
;
4419 if (!node
->definition
)
4421 info
= IPA_NODE_REF (node
);
4422 fprintf (f
, " function %s parameter descriptors:\n", node
->dump_name ());
4425 fprintf (f
, " no params return\n");
4428 count
= ipa_get_param_count (info
);
4429 for (i
= 0; i
< count
; i
++)
4434 ipa_dump_param (f
, info
, i
);
4435 if (ipa_is_param_used (info
, i
))
4436 fprintf (f
, " used");
4437 if (ipa_is_param_used_by_ipa_predicates (info
, i
))
4438 fprintf (f
, " used_by_ipa_predicates");
4439 if (ipa_is_param_used_by_indirect_call (info
, i
))
4440 fprintf (f
, " used_by_indirect_call");
4441 if (ipa_is_param_used_by_polymorphic_call (info
, i
))
4442 fprintf (f
, " used_by_polymorphic_call");
4443 c
= ipa_get_controlled_uses (info
, i
);
4444 if (c
== IPA_UNDESCRIBED_USE
)
4445 fprintf (f
, " undescribed_use");
4447 fprintf (f
, " controlled_uses=%i", c
);
4452 /* Print ipa_tree_map data structures of all functions in the
4456 ipa_print_all_params (FILE * f
)
4458 struct cgraph_node
*node
;
4460 fprintf (f
, "\nFunction parameters:\n");
4461 FOR_EACH_FUNCTION (node
)
4462 ipa_print_node_params (f
, node
);
4465 /* Dump the AV linked list. */
4468 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4471 fprintf (f
, " Aggregate replacements:");
4472 for (; av
; av
= av
->next
)
4474 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4475 av
->index
, av
->offset
);
4476 print_generic_expr (f
, av
->value
);
4482 /* Stream out jump function JUMP_FUNC to OB. */
4485 ipa_write_jump_function (struct output_block
*ob
,
4486 struct ipa_jump_func
*jump_func
)
4488 struct ipa_agg_jf_item
*item
;
4489 struct bitpack_d bp
;
4493 /* ADDR_EXPRs are very comon IP invariants; save some streamer data
4494 as well as WPA memory by handling them specially. */
4495 if (jump_func
->type
== IPA_JF_CONST
4496 && TREE_CODE (jump_func
->value
.constant
.value
) == ADDR_EXPR
)
4499 streamer_write_uhwi (ob
, jump_func
->type
* 2 + flag
);
4500 switch (jump_func
->type
)
4502 case IPA_JF_UNKNOWN
:
4506 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4507 stream_write_tree (ob
,
4509 ? TREE_OPERAND (jump_func
->value
.constant
.value
, 0)
4510 : jump_func
->value
.constant
.value
, true);
4512 case IPA_JF_PASS_THROUGH
:
4513 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4514 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4516 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4517 bp
= bitpack_create (ob
->main_stream
);
4518 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4519 streamer_write_bitpack (&bp
);
4521 else if (TREE_CODE_CLASS (jump_func
->value
.pass_through
.operation
)
4523 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4526 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4527 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4530 case IPA_JF_ANCESTOR
:
4531 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4532 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4533 bp
= bitpack_create (ob
->main_stream
);
4534 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4535 streamer_write_bitpack (&bp
);
4538 fatal_error (UNKNOWN_LOCATION
, "invalid jump function in LTO stream");
4541 count
= vec_safe_length (jump_func
->agg
.items
);
4542 streamer_write_uhwi (ob
, count
);
4545 bp
= bitpack_create (ob
->main_stream
);
4546 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4547 streamer_write_bitpack (&bp
);
4550 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4552 stream_write_tree (ob
, item
->type
, true);
4553 streamer_write_uhwi (ob
, item
->offset
);
4554 streamer_write_uhwi (ob
, item
->jftype
);
4555 switch (item
->jftype
)
4557 case IPA_JF_UNKNOWN
:
4560 stream_write_tree (ob
, item
->value
.constant
, true);
4562 case IPA_JF_PASS_THROUGH
:
4563 case IPA_JF_LOAD_AGG
:
4564 streamer_write_uhwi (ob
, item
->value
.pass_through
.operation
);
4565 streamer_write_uhwi (ob
, item
->value
.pass_through
.formal_id
);
4566 if (TREE_CODE_CLASS (item
->value
.pass_through
.operation
)
4568 stream_write_tree (ob
, item
->value
.pass_through
.operand
, true);
4569 if (item
->jftype
== IPA_JF_LOAD_AGG
)
4571 stream_write_tree (ob
, item
->value
.load_agg
.type
, true);
4572 streamer_write_uhwi (ob
, item
->value
.load_agg
.offset
);
4573 bp
= bitpack_create (ob
->main_stream
);
4574 bp_pack_value (&bp
, item
->value
.load_agg
.by_ref
, 1);
4575 streamer_write_bitpack (&bp
);
4579 fatal_error (UNKNOWN_LOCATION
,
4580 "invalid jump function in LTO stream");
4584 bp
= bitpack_create (ob
->main_stream
);
4585 bp_pack_value (&bp
, !!jump_func
->bits
, 1);
4586 streamer_write_bitpack (&bp
);
4587 if (jump_func
->bits
)
4589 streamer_write_widest_int (ob
, jump_func
->bits
->value
);
4590 streamer_write_widest_int (ob
, jump_func
->bits
->mask
);
4592 bp_pack_value (&bp
, !!jump_func
->m_vr
, 1);
4593 streamer_write_bitpack (&bp
);
4594 if (jump_func
->m_vr
)
4596 streamer_write_enum (ob
->main_stream
, value_rang_type
,
4597 VR_LAST
, jump_func
->m_vr
->kind ());
4598 stream_write_tree (ob
, jump_func
->m_vr
->min (), true);
4599 stream_write_tree (ob
, jump_func
->m_vr
->max (), true);
4603 /* Read in jump function JUMP_FUNC from IB. */
4606 ipa_read_jump_function (class lto_input_block
*ib
,
4607 struct ipa_jump_func
*jump_func
,
4608 struct cgraph_edge
*cs
,
4609 class data_in
*data_in
,
4612 enum jump_func_type jftype
;
4613 enum tree_code operation
;
4615 int val
= streamer_read_uhwi (ib
);
4616 bool flag
= val
& 1;
4618 jftype
= (enum jump_func_type
) (val
/ 2);
4621 case IPA_JF_UNKNOWN
:
4622 ipa_set_jf_unknown (jump_func
);
4626 tree t
= stream_read_tree (ib
, data_in
);
4627 if (flag
&& prevails
)
4628 t
= build_fold_addr_expr (t
);
4629 ipa_set_jf_constant (jump_func
, t
, cs
);
4632 case IPA_JF_PASS_THROUGH
:
4633 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4634 if (operation
== NOP_EXPR
)
4636 int formal_id
= streamer_read_uhwi (ib
);
4637 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4638 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4639 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
);
4641 else if (TREE_CODE_CLASS (operation
) == tcc_unary
)
4643 int formal_id
= streamer_read_uhwi (ib
);
4644 ipa_set_jf_unary_pass_through (jump_func
, formal_id
, operation
);
4648 tree operand
= stream_read_tree (ib
, data_in
);
4649 int formal_id
= streamer_read_uhwi (ib
);
4650 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4654 case IPA_JF_ANCESTOR
:
4656 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4657 int formal_id
= streamer_read_uhwi (ib
);
4658 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4659 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4660 ipa_set_ancestor_jf (jump_func
, offset
, formal_id
, agg_preserved
);
4664 fatal_error (UNKNOWN_LOCATION
, "invalid jump function in LTO stream");
4667 count
= streamer_read_uhwi (ib
);
4669 vec_alloc (jump_func
->agg
.items
, count
);
4672 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4673 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4675 for (i
= 0; i
< count
; i
++)
4677 struct ipa_agg_jf_item item
;
4678 item
.type
= stream_read_tree (ib
, data_in
);
4679 item
.offset
= streamer_read_uhwi (ib
);
4680 item
.jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4682 switch (item
.jftype
)
4684 case IPA_JF_UNKNOWN
:
4687 item
.value
.constant
= stream_read_tree (ib
, data_in
);
4689 case IPA_JF_PASS_THROUGH
:
4690 case IPA_JF_LOAD_AGG
:
4691 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4692 item
.value
.pass_through
.operation
= operation
;
4693 item
.value
.pass_through
.formal_id
= streamer_read_uhwi (ib
);
4694 if (TREE_CODE_CLASS (operation
) == tcc_unary
)
4695 item
.value
.pass_through
.operand
= NULL_TREE
;
4697 item
.value
.pass_through
.operand
= stream_read_tree (ib
, data_in
);
4698 if (item
.jftype
== IPA_JF_LOAD_AGG
)
4700 struct bitpack_d bp
;
4701 item
.value
.load_agg
.type
= stream_read_tree (ib
, data_in
);
4702 item
.value
.load_agg
.offset
= streamer_read_uhwi (ib
);
4703 bp
= streamer_read_bitpack (ib
);
4704 item
.value
.load_agg
.by_ref
= bp_unpack_value (&bp
, 1);
4708 fatal_error (UNKNOWN_LOCATION
,
4709 "invalid jump function in LTO stream");
4712 jump_func
->agg
.items
->quick_push (item
);
4715 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4716 bool bits_known
= bp_unpack_value (&bp
, 1);
4719 widest_int value
= streamer_read_widest_int (ib
);
4720 widest_int mask
= streamer_read_widest_int (ib
);
4722 ipa_set_jfunc_bits (jump_func
, value
, mask
);
4725 jump_func
->bits
= NULL
;
4727 struct bitpack_d vr_bp
= streamer_read_bitpack (ib
);
4728 bool vr_known
= bp_unpack_value (&vr_bp
, 1);
4731 enum value_range_kind type
= streamer_read_enum (ib
, value_range_kind
,
4733 tree min
= stream_read_tree (ib
, data_in
);
4734 tree max
= stream_read_tree (ib
, data_in
);
4736 ipa_set_jfunc_vr (jump_func
, type
, min
, max
);
4739 jump_func
->m_vr
= NULL
;
4742 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4743 relevant to indirect inlining to OB. */
4746 ipa_write_indirect_edge_info (struct output_block
*ob
,
4747 struct cgraph_edge
*cs
)
4749 class cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4750 struct bitpack_d bp
;
4752 streamer_write_hwi (ob
, ii
->param_index
);
4753 bp
= bitpack_create (ob
->main_stream
);
4754 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4755 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4756 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4757 bp_pack_value (&bp
, ii
->by_ref
, 1);
4758 bp_pack_value (&bp
, ii
->guaranteed_unmodified
, 1);
4759 bp_pack_value (&bp
, ii
->vptr_changed
, 1);
4760 streamer_write_bitpack (&bp
);
4761 if (ii
->agg_contents
|| ii
->polymorphic
)
4762 streamer_write_hwi (ob
, ii
->offset
);
4764 gcc_assert (ii
->offset
== 0);
4766 if (ii
->polymorphic
)
4768 streamer_write_hwi (ob
, ii
->otr_token
);
4769 stream_write_tree (ob
, ii
->otr_type
, true);
4770 ii
->context
.stream_out (ob
);
4774 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4775 relevant to indirect inlining from IB. */
4778 ipa_read_indirect_edge_info (class lto_input_block
*ib
,
4779 class data_in
*data_in
,
4780 struct cgraph_edge
*cs
,
4781 class ipa_node_params
*info
)
4783 class cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4784 struct bitpack_d bp
;
4786 ii
->param_index
= (int) streamer_read_hwi (ib
);
4787 bp
= streamer_read_bitpack (ib
);
4788 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4789 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4790 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4791 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4792 ii
->guaranteed_unmodified
= bp_unpack_value (&bp
, 1);
4793 ii
->vptr_changed
= bp_unpack_value (&bp
, 1);
4794 if (ii
->agg_contents
|| ii
->polymorphic
)
4795 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4798 if (ii
->polymorphic
)
4800 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4801 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4802 ii
->context
.stream_in (ib
, data_in
);
4804 if (info
&& ii
->param_index
>= 0)
4806 if (ii
->polymorphic
)
4807 ipa_set_param_used_by_polymorphic_call (info
,
4808 ii
->param_index
, true);
4809 ipa_set_param_used_by_indirect_call (info
,
4810 ii
->param_index
, true);
4814 /* Stream out NODE info to OB. */
4817 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4820 lto_symtab_encoder_t encoder
;
4821 class ipa_node_params
*info
= IPA_NODE_REF (node
);
4823 struct cgraph_edge
*e
;
4824 struct bitpack_d bp
;
4826 encoder
= ob
->decl_state
->symtab_node_encoder
;
4827 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4828 streamer_write_uhwi (ob
, node_ref
);
4830 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4831 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4832 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4833 bp
= bitpack_create (ob
->main_stream
);
4834 gcc_assert (info
->analysis_done
4835 || ipa_get_param_count (info
) == 0);
4836 gcc_assert (!info
->node_enqueued
);
4837 gcc_assert (!info
->ipcp_orig_node
);
4838 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4839 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4840 streamer_write_bitpack (&bp
);
4841 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4843 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4844 stream_write_tree (ob
, ipa_get_type (info
, j
), true);
4846 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4848 class ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4852 streamer_write_uhwi (ob
, 0);
4856 streamer_write_uhwi (ob
,
4857 ipa_get_cs_argument_count (args
) * 2
4858 + (args
->polymorphic_call_contexts
!= NULL
));
4859 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4861 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4862 if (args
->polymorphic_call_contexts
!= NULL
)
4863 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4866 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4868 class ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4870 streamer_write_uhwi (ob
, 0);
4873 streamer_write_uhwi (ob
,
4874 ipa_get_cs_argument_count (args
) * 2
4875 + (args
->polymorphic_call_contexts
!= NULL
));
4876 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4878 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4879 if (args
->polymorphic_call_contexts
!= NULL
)
4880 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4883 ipa_write_indirect_edge_info (ob
, e
);
4887 /* Stream in edge E from IB. */
4890 ipa_read_edge_info (class lto_input_block
*ib
,
4891 class data_in
*data_in
,
4892 struct cgraph_edge
*e
, bool prevails
)
4894 int count
= streamer_read_uhwi (ib
);
4895 bool contexts_computed
= count
& 1;
4900 if (prevails
&& e
->possibly_call_in_translation_unit_p ())
4902 class ipa_edge_args
*args
= IPA_EDGE_REF_GET_CREATE (e
);
4903 vec_safe_grow_cleared (args
->jump_functions
, count
);
4904 if (contexts_computed
)
4905 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4906 for (int k
= 0; k
< count
; k
++)
4908 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4910 if (contexts_computed
)
4911 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in
4917 for (int k
= 0; k
< count
; k
++)
4919 struct ipa_jump_func dummy
;
4920 ipa_read_jump_function (ib
, &dummy
, e
,
4922 if (contexts_computed
)
4924 class ipa_polymorphic_call_context ctx
;
4925 ctx
.stream_in (ib
, data_in
);
4931 /* Stream in NODE info from IB. */
4934 ipa_read_node_info (class lto_input_block
*ib
, struct cgraph_node
*node
,
4935 class data_in
*data_in
)
4938 struct cgraph_edge
*e
;
4939 struct bitpack_d bp
;
4940 bool prevails
= node
->prevailing_p ();
4941 class ipa_node_params
*info
= prevails
4942 ? IPA_NODE_REF_GET_CREATE (node
) : NULL
;
4944 int param_count
= streamer_read_uhwi (ib
);
4947 ipa_alloc_node_params (node
, param_count
);
4948 for (k
= 0; k
< param_count
; k
++)
4949 (*info
->descriptors
)[k
].move_cost
= streamer_read_uhwi (ib
);
4950 if (ipa_get_param_count (info
) != 0)
4951 info
->analysis_done
= true;
4952 info
->node_enqueued
= false;
4955 for (k
= 0; k
< param_count
; k
++)
4956 streamer_read_uhwi (ib
);
4958 bp
= streamer_read_bitpack (ib
);
4959 for (k
= 0; k
< param_count
; k
++)
4961 bool used
= bp_unpack_value (&bp
, 1);
4964 ipa_set_param_used (info
, k
, used
);
4966 for (k
= 0; k
< param_count
; k
++)
4968 int nuses
= streamer_read_hwi (ib
);
4969 tree type
= stream_read_tree (ib
, data_in
);
4973 ipa_set_controlled_uses (info
, k
, nuses
);
4974 (*info
->descriptors
)[k
].decl_or_type
= type
;
4977 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4978 ipa_read_edge_info (ib
, data_in
, e
, prevails
);
4979 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4981 ipa_read_edge_info (ib
, data_in
, e
, prevails
);
4982 ipa_read_indirect_edge_info (ib
, data_in
, e
, info
);
4986 /* Write jump functions for nodes in SET. */
4989 ipa_prop_write_jump_functions (void)
4991 struct cgraph_node
*node
;
4992 struct output_block
*ob
;
4993 unsigned int count
= 0;
4994 lto_symtab_encoder_iterator lsei
;
4995 lto_symtab_encoder_t encoder
;
4997 if (!ipa_node_params_sum
|| !ipa_edge_args_sum
)
5000 ob
= create_output_block (LTO_section_jump_functions
);
5001 encoder
= ob
->decl_state
->symtab_node_encoder
;
5003 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5004 lsei_next_function_in_partition (&lsei
))
5006 node
= lsei_cgraph_node (lsei
);
5007 if (node
->has_gimple_body_p ()
5008 && IPA_NODE_REF (node
) != NULL
)
5012 streamer_write_uhwi (ob
, count
);
5014 /* Process all of the functions. */
5015 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5016 lsei_next_function_in_partition (&lsei
))
5018 node
= lsei_cgraph_node (lsei
);
5019 if (node
->has_gimple_body_p ()
5020 && IPA_NODE_REF (node
) != NULL
)
5021 ipa_write_node_info (ob
, node
);
5023 streamer_write_char_stream (ob
->main_stream
, 0);
5024 produce_asm (ob
, NULL
);
5025 destroy_output_block (ob
);
5028 /* Read section in file FILE_DATA of length LEN with data DATA. */
5031 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
5034 const struct lto_function_header
*header
=
5035 (const struct lto_function_header
*) data
;
5036 const int cfg_offset
= sizeof (struct lto_function_header
);
5037 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5038 const int string_offset
= main_offset
+ header
->main_size
;
5039 class data_in
*data_in
;
5043 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5044 header
->main_size
, file_data
->mode_table
);
5047 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5048 header
->string_size
, vNULL
);
5049 count
= streamer_read_uhwi (&ib_main
);
5051 for (i
= 0; i
< count
; i
++)
5054 struct cgraph_node
*node
;
5055 lto_symtab_encoder_t encoder
;
5057 index
= streamer_read_uhwi (&ib_main
);
5058 encoder
= file_data
->symtab_node_encoder
;
5059 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5061 gcc_assert (node
->definition
);
5062 ipa_read_node_info (&ib_main
, node
, data_in
);
5064 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5066 lto_data_in_delete (data_in
);
5069 /* Read ipcp jump functions. */
5072 ipa_prop_read_jump_functions (void)
5074 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5075 struct lto_file_decl_data
*file_data
;
5078 ipa_check_create_node_params ();
5079 ipa_check_create_edge_args ();
5080 ipa_register_cgraph_hooks ();
5082 while ((file_data
= file_data_vec
[j
++]))
5086 = lto_get_summary_section_data (file_data
, LTO_section_jump_functions
,
5089 ipa_prop_read_section (file_data
, data
, len
);
5094 write_ipcp_transformation_info (output_block
*ob
, cgraph_node
*node
)
5097 unsigned int count
= 0;
5098 lto_symtab_encoder_t encoder
;
5099 struct ipa_agg_replacement_value
*aggvals
, *av
;
5101 aggvals
= ipa_get_agg_replacements_for_node (node
);
5102 encoder
= ob
->decl_state
->symtab_node_encoder
;
5103 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
5104 streamer_write_uhwi (ob
, node_ref
);
5106 for (av
= aggvals
; av
; av
= av
->next
)
5108 streamer_write_uhwi (ob
, count
);
5110 for (av
= aggvals
; av
; av
= av
->next
)
5112 struct bitpack_d bp
;
5114 streamer_write_uhwi (ob
, av
->offset
);
5115 streamer_write_uhwi (ob
, av
->index
);
5116 stream_write_tree (ob
, av
->value
, true);
5118 bp
= bitpack_create (ob
->main_stream
);
5119 bp_pack_value (&bp
, av
->by_ref
, 1);
5120 streamer_write_bitpack (&bp
);
5123 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
5124 if (ts
&& vec_safe_length (ts
->m_vr
) > 0)
5126 count
= ts
->m_vr
->length ();
5127 streamer_write_uhwi (ob
, count
);
5128 for (unsigned i
= 0; i
< count
; ++i
)
5130 struct bitpack_d bp
;
5131 ipa_vr
*parm_vr
= &(*ts
->m_vr
)[i
];
5132 bp
= bitpack_create (ob
->main_stream
);
5133 bp_pack_value (&bp
, parm_vr
->known
, 1);
5134 streamer_write_bitpack (&bp
);
5137 streamer_write_enum (ob
->main_stream
, value_rang_type
,
5138 VR_LAST
, parm_vr
->type
);
5139 streamer_write_wide_int (ob
, parm_vr
->min
);
5140 streamer_write_wide_int (ob
, parm_vr
->max
);
5145 streamer_write_uhwi (ob
, 0);
5147 if (ts
&& vec_safe_length (ts
->bits
) > 0)
5149 count
= ts
->bits
->length ();
5150 streamer_write_uhwi (ob
, count
);
5152 for (unsigned i
= 0; i
< count
; ++i
)
5154 const ipa_bits
*bits_jfunc
= (*ts
->bits
)[i
];
5155 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
5156 bp_pack_value (&bp
, !!bits_jfunc
, 1);
5157 streamer_write_bitpack (&bp
);
5160 streamer_write_widest_int (ob
, bits_jfunc
->value
);
5161 streamer_write_widest_int (ob
, bits_jfunc
->mask
);
5166 streamer_write_uhwi (ob
, 0);
5169 /* Stream in the aggregate value replacement chain for NODE from IB. */
5172 read_ipcp_transformation_info (lto_input_block
*ib
, cgraph_node
*node
,
5175 struct ipa_agg_replacement_value
*aggvals
= NULL
;
5176 unsigned int count
, i
;
5178 count
= streamer_read_uhwi (ib
);
5179 for (i
= 0; i
<count
; i
++)
5181 struct ipa_agg_replacement_value
*av
;
5182 struct bitpack_d bp
;
5184 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
5185 av
->offset
= streamer_read_uhwi (ib
);
5186 av
->index
= streamer_read_uhwi (ib
);
5187 av
->value
= stream_read_tree (ib
, data_in
);
5188 bp
= streamer_read_bitpack (ib
);
5189 av
->by_ref
= bp_unpack_value (&bp
, 1);
5193 ipa_set_node_agg_value_chain (node
, aggvals
);
5195 count
= streamer_read_uhwi (ib
);
5198 ipcp_transformation_initialize ();
5199 ipcp_transformation
*ts
= ipcp_transformation_sum
->get_create (node
);
5200 vec_safe_grow_cleared (ts
->m_vr
, count
);
5201 for (i
= 0; i
< count
; i
++)
5204 parm_vr
= &(*ts
->m_vr
)[i
];
5205 struct bitpack_d bp
;
5206 bp
= streamer_read_bitpack (ib
);
5207 parm_vr
->known
= bp_unpack_value (&bp
, 1);
5210 parm_vr
->type
= streamer_read_enum (ib
, value_range_kind
,
5212 parm_vr
->min
= streamer_read_wide_int (ib
);
5213 parm_vr
->max
= streamer_read_wide_int (ib
);
5217 count
= streamer_read_uhwi (ib
);
5220 ipcp_transformation_initialize ();
5221 ipcp_transformation
*ts
= ipcp_transformation_sum
->get_create (node
);
5222 vec_safe_grow_cleared (ts
->bits
, count
);
5224 for (i
= 0; i
< count
; i
++)
5226 struct bitpack_d bp
= streamer_read_bitpack (ib
);
5227 bool known
= bp_unpack_value (&bp
, 1);
5230 const widest_int value
= streamer_read_widest_int (ib
);
5231 const widest_int mask
= streamer_read_widest_int (ib
);
5233 = ipa_get_ipa_bits_for_value (value
, mask
);
5234 (*ts
->bits
)[i
] = bits
;
5240 /* Write all aggregate replacement for nodes in set. */
5243 ipcp_write_transformation_summaries (void)
5245 struct cgraph_node
*node
;
5246 struct output_block
*ob
;
5247 unsigned int count
= 0;
5248 lto_symtab_encoder_iterator lsei
;
5249 lto_symtab_encoder_t encoder
;
5251 ob
= create_output_block (LTO_section_ipcp_transform
);
5252 encoder
= ob
->decl_state
->symtab_node_encoder
;
5254 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5255 lsei_next_function_in_partition (&lsei
))
5257 node
= lsei_cgraph_node (lsei
);
5258 if (node
->has_gimple_body_p ())
5262 streamer_write_uhwi (ob
, count
);
5264 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5265 lsei_next_function_in_partition (&lsei
))
5267 node
= lsei_cgraph_node (lsei
);
5268 if (node
->has_gimple_body_p ())
5269 write_ipcp_transformation_info (ob
, node
);
5271 streamer_write_char_stream (ob
->main_stream
, 0);
5272 produce_asm (ob
, NULL
);
5273 destroy_output_block (ob
);
5276 /* Read replacements section in file FILE_DATA of length LEN with data
5280 read_replacements_section (struct lto_file_decl_data
*file_data
,
5284 const struct lto_function_header
*header
=
5285 (const struct lto_function_header
*) data
;
5286 const int cfg_offset
= sizeof (struct lto_function_header
);
5287 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5288 const int string_offset
= main_offset
+ header
->main_size
;
5289 class data_in
*data_in
;
5293 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5294 header
->main_size
, file_data
->mode_table
);
5296 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5297 header
->string_size
, vNULL
);
5298 count
= streamer_read_uhwi (&ib_main
);
5300 for (i
= 0; i
< count
; i
++)
5303 struct cgraph_node
*node
;
5304 lto_symtab_encoder_t encoder
;
5306 index
= streamer_read_uhwi (&ib_main
);
5307 encoder
= file_data
->symtab_node_encoder
;
5308 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5310 gcc_assert (node
->definition
);
5311 read_ipcp_transformation_info (&ib_main
, node
, data_in
);
5313 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5315 lto_data_in_delete (data_in
);
5318 /* Read IPA-CP aggregate replacements. */
5321 ipcp_read_transformation_summaries (void)
5323 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5324 struct lto_file_decl_data
*file_data
;
5327 while ((file_data
= file_data_vec
[j
++]))
5331 = lto_get_summary_section_data (file_data
, LTO_section_ipcp_transform
,
5334 read_replacements_section (file_data
, data
, len
);
5338 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5342 adjust_agg_replacement_values (struct cgraph_node
*node
,
5343 struct ipa_agg_replacement_value
*aggval
)
5345 struct ipa_agg_replacement_value
*v
;
5347 if (!node
->clone
.param_adjustments
)
5350 auto_vec
<int, 16> new_indices
;
5351 node
->clone
.param_adjustments
->get_updated_indices (&new_indices
);
5352 for (v
= aggval
; v
; v
= v
->next
)
5354 gcc_checking_assert (v
->index
>= 0);
5356 if ((unsigned) v
->index
< new_indices
.length ())
5357 v
->index
= new_indices
[v
->index
];
5359 /* This can happen if we know about a constant passed by reference by
5360 an argument which is never actually used for anything, let alone
5361 loading that constant. */
5366 /* Dominator walker driving the ipcp modification phase. */
5368 class ipcp_modif_dom_walker
: public dom_walker
5371 ipcp_modif_dom_walker (struct ipa_func_body_info
*fbi
,
5372 vec
<ipa_param_descriptor
, va_gc
> *descs
,
5373 struct ipa_agg_replacement_value
*av
,
5375 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5376 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5378 virtual edge
before_dom_children (basic_block
);
5381 struct ipa_func_body_info
*m_fbi
;
5382 vec
<ipa_param_descriptor
, va_gc
> *m_descriptors
;
5383 struct ipa_agg_replacement_value
*m_aggval
;
5384 bool *m_something_changed
, *m_cfg_changed
;
5388 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5390 gimple_stmt_iterator gsi
;
5391 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5393 struct ipa_agg_replacement_value
*v
;
5394 gimple
*stmt
= gsi_stmt (gsi
);
5396 HOST_WIDE_INT offset
;
5401 if (!gimple_assign_load_p (stmt
))
5403 rhs
= gimple_assign_rhs1 (stmt
);
5404 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5409 while (handled_component_p (t
))
5411 /* V_C_E can do things like convert an array of integers to one
5412 bigger integer and similar things we do not handle below. */
5413 if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
5418 t
= TREE_OPERAND (t
, 0);
5423 if (!ipa_load_from_parm_agg (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5424 &offset
, &size
, &by_ref
))
5426 for (v
= m_aggval
; v
; v
= v
->next
)
5427 if (v
->index
== index
5428 && v
->offset
== offset
)
5431 || v
->by_ref
!= by_ref
5432 || maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (v
->value
))),
5436 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5437 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5439 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5440 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5441 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5442 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5443 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5448 fprintf (dump_file
, " const ");
5449 print_generic_expr (dump_file
, v
->value
);
5450 fprintf (dump_file
, " can't be converted to type of ");
5451 print_generic_expr (dump_file
, rhs
);
5452 fprintf (dump_file
, "\n");
5460 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5462 fprintf (dump_file
, "Modifying stmt:\n ");
5463 print_gimple_stmt (dump_file
, stmt
, 0);
5465 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5468 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5470 fprintf (dump_file
, "into:\n ");
5471 print_gimple_stmt (dump_file
, stmt
, 0);
5472 fprintf (dump_file
, "\n");
5475 *m_something_changed
= true;
5476 if (maybe_clean_eh_stmt (stmt
)
5477 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5478 *m_cfg_changed
= true;
5483 /* Return true if we have recorded VALUE and MASK about PARM.
5484 Set VALUE and MASk accordingly. */
5487 ipcp_get_parm_bits (tree parm
, tree
*value
, widest_int
*mask
)
5489 cgraph_node
*cnode
= cgraph_node::get (current_function_decl
);
5490 ipcp_transformation
*ts
= ipcp_get_transformation_summary (cnode
);
5491 if (!ts
|| vec_safe_length (ts
->bits
) == 0)
5495 for (tree p
= DECL_ARGUMENTS (current_function_decl
);
5496 p
!= parm
; p
= DECL_CHAIN (p
))
5499 /* Ignore static chain. */
5504 if (cnode
->clone
.param_adjustments
)
5506 i
= cnode
->clone
.param_adjustments
->get_original_index (i
);
5511 vec
<ipa_bits
*, va_gc
> &bits
= *ts
->bits
;
5514 *mask
= bits
[i
]->mask
;
5515 *value
= wide_int_to_tree (TREE_TYPE (parm
), bits
[i
]->value
);
5520 /* Update bits info of formal parameters as described in
5521 ipcp_transformation. */
5524 ipcp_update_bits (struct cgraph_node
*node
)
5526 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
5528 if (!ts
|| vec_safe_length (ts
->bits
) == 0)
5530 vec
<ipa_bits
*, va_gc
> &bits
= *ts
->bits
;
5531 unsigned count
= bits
.length ();
5535 auto_vec
<int, 16> new_indices
;
5536 bool need_remapping
= false;
5537 if (node
->clone
.param_adjustments
)
5539 node
->clone
.param_adjustments
->get_updated_indices (&new_indices
);
5540 need_remapping
= true;
5542 auto_vec
<tree
, 16> parm_decls
;
5543 push_function_arg_decls (&parm_decls
, node
->decl
);
5545 for (unsigned i
= 0; i
< count
; ++i
)
5550 if (i
>= new_indices
.length ())
5552 int idx
= new_indices
[i
];
5555 parm
= parm_decls
[idx
];
5558 parm
= parm_decls
[i
];
5559 gcc_checking_assert (parm
);
5563 || !(INTEGRAL_TYPE_P (TREE_TYPE (parm
))
5564 || POINTER_TYPE_P (TREE_TYPE (parm
)))
5565 || !is_gimple_reg (parm
))
5568 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5574 fprintf (dump_file
, "Adjusting mask for param %u to ", i
);
5575 print_hex (bits
[i
]->mask
, dump_file
);
5576 fprintf (dump_file
, "\n");
5579 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5581 unsigned prec
= TYPE_PRECISION (TREE_TYPE (ddef
));
5582 signop sgn
= TYPE_SIGN (TREE_TYPE (ddef
));
5584 wide_int nonzero_bits
= wide_int::from (bits
[i
]->mask
, prec
, UNSIGNED
)
5585 | wide_int::from (bits
[i
]->value
, prec
, sgn
);
5586 set_nonzero_bits (ddef
, nonzero_bits
);
5590 unsigned tem
= bits
[i
]->mask
.to_uhwi ();
5591 unsigned HOST_WIDE_INT bitpos
= bits
[i
]->value
.to_uhwi ();
5592 unsigned align
= tem
& -tem
;
5593 unsigned misalign
= bitpos
& (align
- 1);
5598 fprintf (dump_file
, "Adjusting align: %u, misalign: %u\n", align
, misalign
);
5600 unsigned old_align
, old_misalign
;
5601 struct ptr_info_def
*pi
= get_ptr_info (ddef
);
5602 bool old_known
= get_ptr_info_alignment (pi
, &old_align
, &old_misalign
);
5605 && old_align
> align
)
5609 fprintf (dump_file
, "But alignment was already %u.\n", old_align
);
5610 if ((old_misalign
& (align
- 1)) != misalign
)
5611 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5612 old_misalign
, misalign
);
5618 && ((misalign
& (old_align
- 1)) != old_misalign
)
5620 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5621 old_misalign
, misalign
);
5623 set_ptr_info_alignment (pi
, align
, misalign
);
5630 ipa_vr::nonzero_p (tree expr_type
) const
5632 if (type
== VR_ANTI_RANGE
&& wi::eq_p (min
, 0) && wi::eq_p (max
, 0))
5635 unsigned prec
= TYPE_PRECISION (expr_type
);
5636 return (type
== VR_RANGE
5637 && TYPE_UNSIGNED (expr_type
)
5638 && wi::eq_p (min
, wi::one (prec
))
5639 && wi::eq_p (max
, wi::max_value (prec
, TYPE_SIGN (expr_type
))));
5642 /* Update value range of formal parameters as described in
5643 ipcp_transformation. */
5646 ipcp_update_vr (struct cgraph_node
*node
)
5648 ipcp_transformation
*ts
= ipcp_get_transformation_summary (node
);
5649 if (!ts
|| vec_safe_length (ts
->m_vr
) == 0)
5651 const vec
<ipa_vr
, va_gc
> &vr
= *ts
->m_vr
;
5652 unsigned count
= vr
.length ();
5656 auto_vec
<int, 16> new_indices
;
5657 bool need_remapping
= false;
5658 if (node
->clone
.param_adjustments
)
5660 node
->clone
.param_adjustments
->get_updated_indices (&new_indices
);
5661 need_remapping
= true;
5663 auto_vec
<tree
, 16> parm_decls
;
5664 push_function_arg_decls (&parm_decls
, node
->decl
);
5666 for (unsigned i
= 0; i
< count
; ++i
)
5672 if (i
>= new_indices
.length ())
5674 remapped_idx
= new_indices
[i
];
5675 if (remapped_idx
< 0)
5681 parm
= parm_decls
[remapped_idx
];
5683 gcc_checking_assert (parm
);
5684 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5686 if (!ddef
|| !is_gimple_reg (parm
))
5690 && (vr
[i
].type
== VR_RANGE
|| vr
[i
].type
== VR_ANTI_RANGE
))
5692 tree type
= TREE_TYPE (ddef
);
5693 unsigned prec
= TYPE_PRECISION (type
);
5694 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5698 fprintf (dump_file
, "Setting value range of param %u "
5699 "(now %i) ", i
, remapped_idx
);
5700 fprintf (dump_file
, "%s[",
5701 (vr
[i
].type
== VR_ANTI_RANGE
) ? "~" : "");
5702 print_decs (vr
[i
].min
, dump_file
);
5703 fprintf (dump_file
, ", ");
5704 print_decs (vr
[i
].max
, dump_file
);
5705 fprintf (dump_file
, "]\n");
5707 set_range_info (ddef
, vr
[i
].type
,
5708 wide_int_storage::from (vr
[i
].min
, prec
,
5710 wide_int_storage::from (vr
[i
].max
, prec
,
5713 else if (POINTER_TYPE_P (TREE_TYPE (ddef
))
5714 && vr
[i
].nonzero_p (TREE_TYPE (ddef
)))
5717 fprintf (dump_file
, "Setting nonnull for %u\n", i
);
5718 set_ptr_nonnull (ddef
);
5724 /* IPCP transformation phase doing propagation of aggregate values. */
5727 ipcp_transform_function (struct cgraph_node
*node
)
5729 vec
<ipa_param_descriptor
, va_gc
> *descriptors
= NULL
;
5730 struct ipa_func_body_info fbi
;
5731 struct ipa_agg_replacement_value
*aggval
;
5733 bool cfg_changed
= false, something_changed
= false;
5735 gcc_checking_assert (cfun
);
5736 gcc_checking_assert (current_function_decl
);
5739 fprintf (dump_file
, "Modification phase of node %s\n",
5740 node
->dump_name ());
5742 ipcp_update_bits (node
);
5743 ipcp_update_vr (node
);
5744 aggval
= ipa_get_agg_replacements_for_node (node
);
5747 param_count
= count_formal_params (node
->decl
);
5748 if (param_count
== 0)
5750 adjust_agg_replacement_values (node
, aggval
);
5752 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5756 fbi
.bb_infos
= vNULL
;
5757 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5758 fbi
.param_count
= param_count
;
5759 fbi
.aa_walk_budget
= param_ipa_max_aa_steps
;
5761 vec_safe_grow_cleared (descriptors
, param_count
);
5762 ipa_populate_param_decls (node
, *descriptors
);
5763 calculate_dominance_info (CDI_DOMINATORS
);
5764 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5765 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5768 struct ipa_bb_info
*bi
;
5769 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5770 free_ipa_bb_info (bi
);
5771 fbi
.bb_infos
.release ();
5772 free_dominance_info (CDI_DOMINATORS
);
5774 ipcp_transformation
*s
= ipcp_transformation_sum
->get (node
);
5775 s
->agg_values
= NULL
;
5779 vec_free (descriptors
);
5781 if (!something_changed
)
5785 delete_unreachable_blocks_update_callgraph (node
, false);
5787 return TODO_update_ssa_only_virtuals
;
5791 /* Return true if OTHER describes same agg value. */
5793 ipa_agg_value::equal_to (const ipa_agg_value
&other
)
5795 return offset
== other
.offset
5796 && operand_equal_p (value
, other
.value
, 0);
5798 #include "gt-ipa-prop.h"