1 /* Interprocedural analyses.
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "alloc-pool.h"
28 #include "tree-pass.h"
30 #include "tree-streamer.h"
32 #include "diagnostic.h"
33 #include "fold-const.h"
34 #include "gimple-fold.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
40 #include "gimple-iterator.h"
41 #include "gimplify-me.h"
42 #include "gimple-walk.h"
43 #include "symbol-summary.h"
47 #include "tree-inline.h"
48 #include "ipa-inline.h"
49 #include "gimple-pretty-print.h"
51 #include "ipa-utils.h"
56 /* Function summary where the parameter infos are actually stored. */
57 ipa_node_params_t
*ipa_node_params_sum
= NULL
;
58 /* Vector of IPA-CP transformation data for each clone. */
59 vec
<ipcp_transformation_summary
, va_gc
> *ipcp_transformations
;
60 /* Vector where the parameter infos are actually stored. */
61 vec
<ipa_edge_args
, va_gc
> *ipa_edge_args_vector
;
63 /* Holders of ipa cgraph hooks: */
64 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
65 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
66 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
68 /* Description of a reference to an IPA constant. */
69 struct ipa_cst_ref_desc
71 /* Edge that corresponds to the statement which took the reference. */
72 struct cgraph_edge
*cs
;
73 /* Linked list of duplicates created when call graph edges are cloned. */
74 struct ipa_cst_ref_desc
*next_duplicate
;
75 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
80 /* Allocation pool for reference descriptions. */
82 static object_allocator
<ipa_cst_ref_desc
> ipa_refdesc_pool
83 ("IPA-PROP ref descriptions");
85 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
86 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
89 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
91 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
95 return !opt_for_fn (node
->decl
, optimize
) || !opt_for_fn (node
->decl
, flag_ipa_cp
);
98 /* Return index of the formal whose tree is PTREE in function which corresponds
102 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
> descriptors
, tree ptree
)
106 count
= descriptors
.length ();
107 for (i
= 0; i
< count
; i
++)
108 if (descriptors
[i
].decl_or_type
== ptree
)
114 /* Return index of the formal whose tree is PTREE in function which corresponds
118 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
120 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
123 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
127 ipa_populate_param_decls (struct cgraph_node
*node
,
128 vec
<ipa_param_descriptor
> &descriptors
)
136 gcc_assert (gimple_has_body_p (fndecl
));
137 fnargs
= DECL_ARGUMENTS (fndecl
);
139 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
141 descriptors
[param_num
].decl_or_type
= parm
;
142 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
),
148 /* Return how many formal parameters FNDECL has. */
151 count_formal_params (tree fndecl
)
155 gcc_assert (gimple_has_body_p (fndecl
));
157 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
163 /* Return the declaration of Ith formal parameter of the function corresponding
164 to INFO. Note there is no setter function as this array is built just once
165 using ipa_initialize_node_params. */
168 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
170 fprintf (file
, "param #%i", i
);
171 if (info
->descriptors
[i
].decl_or_type
)
174 print_generic_expr (file
, info
->descriptors
[i
].decl_or_type
, 0);
178 /* Initialize the ipa_node_params structure associated with NODE
179 to hold PARAM_COUNT parameters. */
182 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
184 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
186 if (!info
->descriptors
.exists () && param_count
)
187 info
->descriptors
.safe_grow_cleared (param_count
);
190 /* Initialize the ipa_node_params structure associated with NODE by counting
191 the function parameters, creating the descriptors and populating their
195 ipa_initialize_node_params (struct cgraph_node
*node
)
197 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
199 if (!info
->descriptors
.exists ())
201 ipa_alloc_node_params (node
, count_formal_params (node
->decl
));
202 ipa_populate_param_decls (node
, info
->descriptors
);
206 /* Print the jump functions associated with call graph edge CS to file F. */
209 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
213 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
214 for (i
= 0; i
< count
; i
++)
216 struct ipa_jump_func
*jump_func
;
217 enum jump_func_type type
;
219 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
220 type
= jump_func
->type
;
222 fprintf (f
, " param %d: ", i
);
223 if (type
== IPA_JF_UNKNOWN
)
224 fprintf (f
, "UNKNOWN\n");
225 else if (type
== IPA_JF_CONST
)
227 tree val
= jump_func
->value
.constant
.value
;
228 fprintf (f
, "CONST: ");
229 print_generic_expr (f
, val
, 0);
230 if (TREE_CODE (val
) == ADDR_EXPR
231 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
234 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
239 else if (type
== IPA_JF_PASS_THROUGH
)
241 fprintf (f
, "PASS THROUGH: ");
242 fprintf (f
, "%d, op %s",
243 jump_func
->value
.pass_through
.formal_id
,
244 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
245 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
248 print_generic_expr (f
,
249 jump_func
->value
.pass_through
.operand
, 0);
251 if (jump_func
->value
.pass_through
.agg_preserved
)
252 fprintf (f
, ", agg_preserved");
255 else if (type
== IPA_JF_ANCESTOR
)
257 fprintf (f
, "ANCESTOR: ");
258 fprintf (f
, "%d, offset " HOST_WIDE_INT_PRINT_DEC
,
259 jump_func
->value
.ancestor
.formal_id
,
260 jump_func
->value
.ancestor
.offset
);
261 if (jump_func
->value
.ancestor
.agg_preserved
)
262 fprintf (f
, ", agg_preserved");
266 if (jump_func
->agg
.items
)
268 struct ipa_agg_jf_item
*item
;
271 fprintf (f
, " Aggregate passed by %s:\n",
272 jump_func
->agg
.by_ref
? "reference" : "value");
273 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
275 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
277 if (TYPE_P (item
->value
))
278 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
279 tree_to_uhwi (TYPE_SIZE (item
->value
)));
282 fprintf (f
, "cst: ");
283 print_generic_expr (f
, item
->value
, 0);
289 struct ipa_polymorphic_call_context
*ctx
290 = ipa_get_ith_polymorhic_call_context (IPA_EDGE_REF (cs
), i
);
291 if (ctx
&& !ctx
->useless_p ())
293 fprintf (f
, " Context: ");
294 ctx
->dump (dump_file
);
297 if (jump_func
->bits
.known
)
299 fprintf (f
, " value: "); print_hex (jump_func
->bits
.value
, f
);
300 fprintf (f
, ", mask: "); print_hex (jump_func
->bits
.mask
, f
);
304 fprintf (f
, " Unknown bits\n");
306 if (jump_func
->vr_known
)
310 (jump_func
->m_vr
.type
== VR_ANTI_RANGE
) ? "~" : "");
311 print_decs (jump_func
->m_vr
.min
, f
);
313 print_decs (jump_func
->m_vr
.max
, f
);
317 fprintf (f
, " Unknown VR\n");
322 /* Print the jump functions of all arguments on all call graph edges going from
326 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
328 struct cgraph_edge
*cs
;
330 fprintf (f
, " Jump functions of caller %s/%i:\n", node
->name (),
332 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
334 if (!ipa_edge_args_info_available_for_edge_p (cs
))
337 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
338 xstrdup_for_dump (node
->name ()), node
->order
,
339 xstrdup_for_dump (cs
->callee
->name ()),
341 ipa_print_node_jump_functions_for_edge (f
, cs
);
344 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
346 struct cgraph_indirect_call_info
*ii
;
347 if (!ipa_edge_args_info_available_for_edge_p (cs
))
350 ii
= cs
->indirect_info
;
351 if (ii
->agg_contents
)
352 fprintf (f
, " indirect %s callsite, calling param %i, "
353 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
354 ii
->member_ptr
? "member ptr" : "aggregate",
355 ii
->param_index
, ii
->offset
,
356 ii
->by_ref
? "by reference" : "by_value");
358 fprintf (f
, " indirect %s callsite, calling param %i, "
359 "offset " HOST_WIDE_INT_PRINT_DEC
,
360 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
365 fprintf (f
, ", for stmt ");
366 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
371 ii
->context
.dump (f
);
372 ipa_print_node_jump_functions_for_edge (f
, cs
);
376 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
379 ipa_print_all_jump_functions (FILE *f
)
381 struct cgraph_node
*node
;
383 fprintf (f
, "\nJump functions:\n");
384 FOR_EACH_FUNCTION (node
)
386 ipa_print_node_jump_functions (f
, node
);
390 /* Set jfunc to be a know-really nothing jump function. */
393 ipa_set_jf_unknown (struct ipa_jump_func
*jfunc
)
395 jfunc
->type
= IPA_JF_UNKNOWN
;
396 jfunc
->bits
.known
= false;
397 jfunc
->vr_known
= false;
400 /* Set JFUNC to be a copy of another jmp (to be used by jump function
401 combination code). The two functions will share their rdesc. */
404 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
405 struct ipa_jump_func
*src
)
408 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
409 dst
->type
= IPA_JF_CONST
;
410 dst
->value
.constant
= src
->value
.constant
;
413 /* Set JFUNC to be a constant jmp function. */
416 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
417 struct cgraph_edge
*cs
)
419 jfunc
->type
= IPA_JF_CONST
;
420 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
422 if (TREE_CODE (constant
) == ADDR_EXPR
423 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
425 struct ipa_cst_ref_desc
*rdesc
;
427 rdesc
= ipa_refdesc_pool
.allocate ();
429 rdesc
->next_duplicate
= NULL
;
431 jfunc
->value
.constant
.rdesc
= rdesc
;
434 jfunc
->value
.constant
.rdesc
= NULL
;
437 /* Set JFUNC to be a simple pass-through jump function. */
439 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
442 jfunc
->type
= IPA_JF_PASS_THROUGH
;
443 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
444 jfunc
->value
.pass_through
.formal_id
= formal_id
;
445 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
446 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
449 /* Set JFUNC to be an arithmetic pass through jump function. */
452 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
453 tree operand
, enum tree_code operation
)
455 jfunc
->type
= IPA_JF_PASS_THROUGH
;
456 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
457 jfunc
->value
.pass_through
.formal_id
= formal_id
;
458 jfunc
->value
.pass_through
.operation
= operation
;
459 jfunc
->value
.pass_through
.agg_preserved
= false;
462 /* Set JFUNC to be an ancestor jump function. */
465 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
466 int formal_id
, bool agg_preserved
)
468 jfunc
->type
= IPA_JF_ANCESTOR
;
469 jfunc
->value
.ancestor
.formal_id
= formal_id
;
470 jfunc
->value
.ancestor
.offset
= offset
;
471 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
474 /* Get IPA BB information about the given BB. FBI is the context of analyzis
475 of this function body. */
477 static struct ipa_bb_info
*
478 ipa_get_bb_info (struct ipa_func_body_info
*fbi
, basic_block bb
)
480 gcc_checking_assert (fbi
);
481 return &fbi
->bb_infos
[bb
->index
];
484 /* Structure to be passed in between detect_type_change and
485 check_stmt_for_type_change. */
487 struct prop_type_change_info
489 /* Offset into the object where there is the virtual method pointer we are
491 HOST_WIDE_INT offset
;
492 /* The declaration or SSA_NAME pointer of the base that we are checking for
495 /* Set to true if dynamic type change has been detected. */
496 bool type_maybe_changed
;
499 /* Return true if STMT can modify a virtual method table pointer.
501 This function makes special assumptions about both constructors and
502 destructors which are all the functions that are allowed to alter the VMT
503 pointers. It assumes that destructors begin with assignment into all VMT
504 pointers and that constructors essentially look in the following way:
506 1) The very first thing they do is that they call constructors of ancestor
507 sub-objects that have them.
509 2) Then VMT pointers of this and all its ancestors is set to new values
510 corresponding to the type corresponding to the constructor.
512 3) Only afterwards, other stuff such as constructor of member sub-objects
513 and the code written by the user is run. Only this may include calling
514 virtual functions, directly or indirectly.
516 There is no way to call a constructor of an ancestor sub-object in any
519 This means that we do not have to care whether constructors get the correct
520 type information because they will always change it (in fact, if we define
521 the type to be given by the VMT pointer, it is undefined).
523 The most important fact to derive from the above is that if, for some
524 statement in the section 3, we try to detect whether the dynamic type has
525 changed, we can safely ignore all calls as we examine the function body
526 backwards until we reach statements in section 2 because these calls cannot
527 be ancestor constructors or destructors (if the input is not bogus) and so
528 do not change the dynamic type (this holds true only for automatically
529 allocated objects but at the moment we devirtualize only these). We then
530 must detect that statements in section 2 change the dynamic type and can try
531 to derive the new type. That is enough and we can stop, we will never see
532 the calls into constructors of sub-objects in this code. Therefore we can
533 safely ignore all call statements that we traverse.
537 stmt_may_be_vtbl_ptr_store (gimple
*stmt
)
539 if (is_gimple_call (stmt
))
541 if (gimple_clobber_p (stmt
))
543 else if (is_gimple_assign (stmt
))
545 tree lhs
= gimple_assign_lhs (stmt
);
547 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
549 if (flag_strict_aliasing
550 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
553 if (TREE_CODE (lhs
) == COMPONENT_REF
554 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
556 /* In the future we might want to use get_base_ref_and_offset to find
557 if there is a field corresponding to the offset and if so, proceed
558 almost like if it was a component ref. */
564 /* Callback of walk_aliased_vdefs and a helper function for detect_type_change
565 to check whether a particular statement may modify the virtual table
566 pointerIt stores its result into DATA, which points to a
567 prop_type_change_info structure. */
570 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
572 gimple
*stmt
= SSA_NAME_DEF_STMT (vdef
);
573 struct prop_type_change_info
*tci
= (struct prop_type_change_info
*) data
;
575 if (stmt_may_be_vtbl_ptr_store (stmt
))
577 tci
->type_maybe_changed
= true;
584 /* See if ARG is PARAM_DECl describing instance passed by pointer
585 or reference in FUNCTION. Return false if the dynamic type may change
586 in between beggining of the function until CALL is invoked.
588 Generally functions are not allowed to change type of such instances,
589 but they call destructors. We assume that methods can not destroy the THIS
590 pointer. Also as a special cases, constructor and destructors may change
591 type of the THIS pointer. */
594 param_type_may_change_p (tree function
, tree arg
, gimple
*call
)
596 /* Pure functions can not do any changes on the dynamic type;
597 that require writting to memory. */
598 if (flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
600 /* We need to check if we are within inlined consturctor
601 or destructor (ideally we would have way to check that the
602 inline cdtor is actually working on ARG, but we don't have
603 easy tie on this, so punt on all non-pure cdtors.
604 We may also record the types of cdtors and once we know type
605 of the instance match them.
607 Also code unification optimizations may merge calls from
608 different blocks making return values unreliable. So
609 do nothing during late optimization. */
610 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
612 if (TREE_CODE (arg
) == SSA_NAME
613 && SSA_NAME_IS_DEFAULT_DEF (arg
)
614 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
)
616 /* Normal (non-THIS) argument. */
617 if ((SSA_NAME_VAR (arg
) != DECL_ARGUMENTS (function
)
618 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
)
619 /* THIS pointer of an method - here we want to watch constructors
620 and destructors as those definitely may change the dynamic
622 || (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
623 && !DECL_CXX_CONSTRUCTOR_P (function
)
624 && !DECL_CXX_DESTRUCTOR_P (function
)
625 && (SSA_NAME_VAR (arg
) == DECL_ARGUMENTS (function
))))
627 /* Walk the inline stack and watch out for ctors/dtors. */
628 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
629 block
= BLOCK_SUPERCONTEXT (block
))
630 if (inlined_polymorphic_ctor_dtor_block_p (block
, false))
638 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
639 callsite CALL) by looking for assignments to its virtual table pointer. If
640 it is, return true and fill in the jump function JFUNC with relevant type
641 information or set it to unknown. ARG is the object itself (not a pointer
642 to it, unless dereferenced). BASE is the base of the memory access as
643 returned by get_ref_base_and_extent, as is the offset.
645 This is helper function for detect_type_change and detect_type_change_ssa
646 that does the heavy work which is usually unnecesary. */
649 detect_type_change_from_memory_writes (tree arg
, tree base
, tree comp_type
,
650 gcall
*call
, struct ipa_jump_func
*jfunc
,
651 HOST_WIDE_INT offset
)
653 struct prop_type_change_info tci
;
655 bool entry_reached
= false;
657 gcc_checking_assert (DECL_P (arg
)
658 || TREE_CODE (arg
) == MEM_REF
659 || handled_component_p (arg
));
661 comp_type
= TYPE_MAIN_VARIANT (comp_type
);
663 /* Const calls cannot call virtual methods through VMT and so type changes do
665 if (!flag_devirtualize
|| !gimple_vuse (call
)
666 /* Be sure expected_type is polymorphic. */
668 || TREE_CODE (comp_type
) != RECORD_TYPE
669 || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))
670 || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))))
673 ao_ref_init (&ao
, arg
);
676 ao
.size
= POINTER_SIZE
;
677 ao
.max_size
= ao
.size
;
680 tci
.object
= get_base_address (arg
);
681 tci
.type_maybe_changed
= false;
683 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
684 &tci
, NULL
, &entry_reached
);
685 if (!tci
.type_maybe_changed
)
688 ipa_set_jf_unknown (jfunc
);
692 /* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
693 If it is, return true and fill in the jump function JFUNC with relevant type
694 information or set it to unknown. ARG is the object itself (not a pointer
695 to it, unless dereferenced). BASE is the base of the memory access as
696 returned by get_ref_base_and_extent, as is the offset. */
699 detect_type_change (tree arg
, tree base
, tree comp_type
, gcall
*call
,
700 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
702 if (!flag_devirtualize
)
705 if (TREE_CODE (base
) == MEM_REF
706 && !param_type_may_change_p (current_function_decl
,
707 TREE_OPERAND (base
, 0),
710 return detect_type_change_from_memory_writes (arg
, base
, comp_type
,
711 call
, jfunc
, offset
);
714 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
715 SSA name (its dereference will become the base and the offset is assumed to
719 detect_type_change_ssa (tree arg
, tree comp_type
,
720 gcall
*call
, struct ipa_jump_func
*jfunc
)
722 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
723 if (!flag_devirtualize
724 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
727 if (!param_type_may_change_p (current_function_decl
, arg
, call
))
730 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
731 build_int_cst (ptr_type_node
, 0));
733 return detect_type_change_from_memory_writes (arg
, arg
, comp_type
,
737 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
738 boolean variable pointed to by DATA. */
741 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
744 bool *b
= (bool *) data
;
749 /* Return true if we have already walked so many statements in AA that we
750 should really just start giving up. */
753 aa_overwalked (struct ipa_func_body_info
*fbi
)
755 gcc_checking_assert (fbi
);
756 return fbi
->aa_walked
> (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS
);
759 /* Find the nearest valid aa status for parameter specified by INDEX that
762 static struct ipa_param_aa_status
*
763 find_dominating_aa_status (struct ipa_func_body_info
*fbi
, basic_block bb
,
768 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
771 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
772 if (!bi
->param_aa_statuses
.is_empty ()
773 && bi
->param_aa_statuses
[index
].valid
)
774 return &bi
->param_aa_statuses
[index
];
778 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
779 structures and/or intialize the result with a dominating description as
782 static struct ipa_param_aa_status
*
783 parm_bb_aa_status_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
,
786 gcc_checking_assert (fbi
);
787 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
788 if (bi
->param_aa_statuses
.is_empty ())
789 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
790 struct ipa_param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
793 gcc_checking_assert (!paa
->parm_modified
794 && !paa
->ref_modified
795 && !paa
->pt_modified
);
796 struct ipa_param_aa_status
*dom_paa
;
797 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
807 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
808 a value known not to be modified in this function before reaching the
809 statement STMT. FBI holds information about the function we have so far
810 gathered but do not survive the summary building stage. */
813 parm_preserved_before_stmt_p (struct ipa_func_body_info
*fbi
, int index
,
814 gimple
*stmt
, tree parm_load
)
816 struct ipa_param_aa_status
*paa
;
817 bool modified
= false;
820 tree base
= get_base_address (parm_load
);
821 gcc_assert (TREE_CODE (base
) == PARM_DECL
);
822 if (TREE_READONLY (base
))
825 /* FIXME: FBI can be NULL if we are being called from outside
826 ipa_node_analysis or ipcp_transform_function, which currently happens
827 during inlining analysis. It would be great to extend fbi's lifetime and
828 always have it. Currently, we are just not afraid of too much walking in
832 if (aa_overwalked (fbi
))
834 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
835 if (paa
->parm_modified
)
841 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
842 ao_ref_init (&refd
, parm_load
);
843 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
846 fbi
->aa_walked
+= walked
;
848 paa
->parm_modified
= true;
852 /* If STMT is an assignment that loads a value from an parameter declaration,
853 return the index of the parameter in ipa_node_params which has not been
854 modified. Otherwise return -1. */
857 load_from_unmodified_param (struct ipa_func_body_info
*fbi
,
858 vec
<ipa_param_descriptor
> descriptors
,
864 if (!gimple_assign_single_p (stmt
))
867 op1
= gimple_assign_rhs1 (stmt
);
868 if (TREE_CODE (op1
) != PARM_DECL
)
871 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
873 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
879 /* Return true if memory reference REF (which must be a load through parameter
880 with INDEX) loads data that are known to be unmodified in this function
881 before reaching statement STMT. */
884 parm_ref_data_preserved_p (struct ipa_func_body_info
*fbi
,
885 int index
, gimple
*stmt
, tree ref
)
887 struct ipa_param_aa_status
*paa
;
888 bool modified
= false;
891 /* FIXME: FBI can be NULL if we are being called from outside
892 ipa_node_analysis or ipcp_transform_function, which currently happens
893 during inlining analysis. It would be great to extend fbi's lifetime and
894 always have it. Currently, we are just not afraid of too much walking in
898 if (aa_overwalked (fbi
))
900 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
901 if (paa
->ref_modified
)
907 gcc_checking_assert (gimple_vuse (stmt
));
908 ao_ref_init (&refd
, ref
);
909 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
912 fbi
->aa_walked
+= walked
;
914 paa
->ref_modified
= true;
918 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
919 is known to be unmodified in this function before reaching call statement
920 CALL into which it is passed. FBI describes the function body. */
923 parm_ref_data_pass_through_p (struct ipa_func_body_info
*fbi
, int index
,
924 gimple
*call
, tree parm
)
926 bool modified
= false;
929 /* It's unnecessary to calculate anything about memory contnets for a const
930 function because it is not goin to use it. But do not cache the result
931 either. Also, no such calculations for non-pointers. */
932 if (!gimple_vuse (call
)
933 || !POINTER_TYPE_P (TREE_TYPE (parm
))
934 || aa_overwalked (fbi
))
937 struct ipa_param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
,
940 if (paa
->pt_modified
)
943 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
944 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
946 fbi
->aa_walked
+= walked
;
948 paa
->pt_modified
= true;
952 /* Return true if we can prove that OP is a memory reference loading
953 data from an aggregate passed as a parameter.
955 The function works in two modes. If GUARANTEED_UNMODIFIED is NULL, it return
956 false if it cannot prove that the value has not been modified before the
957 load in STMT. If GUARANTEED_UNMODIFIED is not NULL, it will return true even
958 if it cannot prove the value has not been modified, in that case it will
959 store false to *GUARANTEED_UNMODIFIED, otherwise it will store true there.
961 INFO and PARMS_AINFO describe parameters of the current function (but the
962 latter can be NULL), STMT is the load statement. If function returns true,
963 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
964 within the aggregate and whether it is a load from a value passed by
965 reference respectively. */
968 ipa_load_from_parm_agg (struct ipa_func_body_info
*fbi
,
969 vec
<ipa_param_descriptor
> descriptors
,
970 gimple
*stmt
, tree op
, int *index_p
,
971 HOST_WIDE_INT
*offset_p
, HOST_WIDE_INT
*size_p
,
972 bool *by_ref_p
, bool *guaranteed_unmodified
)
975 HOST_WIDE_INT size
, max_size
;
978 = get_ref_base_and_extent (op
, offset_p
, &size
, &max_size
, &reverse
);
980 if (max_size
== -1 || max_size
!= size
|| *offset_p
< 0)
985 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
987 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
993 if (guaranteed_unmodified
)
994 *guaranteed_unmodified
= true;
1000 if (TREE_CODE (base
) != MEM_REF
1001 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1002 || !integer_zerop (TREE_OPERAND (base
, 1)))
1005 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1007 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1008 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1012 /* This branch catches situations where a pointer parameter is not a
1013 gimple register, for example:
1015 void hip7(S*) (struct S * p)
1017 void (*<T2e4>) (struct S *) D.1867;
1022 D.1867_2 = p.1_1->f;
1027 gimple
*def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1028 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1033 bool data_preserved
= parm_ref_data_preserved_p (fbi
, index
, stmt
, op
);
1034 if (!data_preserved
&& !guaranteed_unmodified
)
1041 if (guaranteed_unmodified
)
1042 *guaranteed_unmodified
= data_preserved
;
1048 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1049 of an assignment statement STMT, try to determine whether we are actually
1050 handling any of the following cases and construct an appropriate jump
1051 function into JFUNC if so:
1053 1) The passed value is loaded from a formal parameter which is not a gimple
1054 register (most probably because it is addressable, the value has to be
1055 scalar) and we can guarantee the value has not changed. This case can
1056 therefore be described by a simple pass-through jump function. For example:
1065 2) The passed value can be described by a simple arithmetic pass-through
1072 D.2064_4 = a.1(D) + 4;
1075 This case can also occur in combination of the previous one, e.g.:
1083 D.2064_4 = a.0_3 + 4;
1086 3) The passed value is an address of an object within another one (which
1087 also passed by reference). Such situations are described by an ancestor
1088 jump function and describe situations such as:
1090 B::foo() (struct B * const this)
1094 D.1845_2 = &this_1(D)->D.1748;
1097 INFO is the structure describing individual parameters access different
1098 stages of IPA optimizations. PARMS_AINFO contains the information that is
1099 only needed for intraprocedural analysis. */
1102 compute_complex_assign_jump_func (struct ipa_func_body_info
*fbi
,
1103 struct ipa_node_params
*info
,
1104 struct ipa_jump_func
*jfunc
,
1105 gcall
*call
, gimple
*stmt
, tree name
,
1108 HOST_WIDE_INT offset
, size
, max_size
;
1109 tree op1
, tc_ssa
, base
, ssa
;
1113 op1
= gimple_assign_rhs1 (stmt
);
1115 if (TREE_CODE (op1
) == SSA_NAME
)
1117 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1118 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1120 index
= load_from_unmodified_param (fbi
, info
->descriptors
,
1121 SSA_NAME_DEF_STMT (op1
));
1126 index
= load_from_unmodified_param (fbi
, info
->descriptors
, stmt
);
1127 tc_ssa
= gimple_assign_lhs (stmt
);
1132 tree op2
= gimple_assign_rhs2 (stmt
);
1136 if (!is_gimple_ip_invariant (op2
)
1137 || (TREE_CODE_CLASS (gimple_expr_code (stmt
)) != tcc_comparison
1138 && !useless_type_conversion_p (TREE_TYPE (name
),
1142 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1143 gimple_assign_rhs_code (stmt
));
1145 else if (gimple_assign_single_p (stmt
))
1147 bool agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, tc_ssa
);
1148 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1153 if (TREE_CODE (op1
) != ADDR_EXPR
)
1155 op1
= TREE_OPERAND (op1
, 0);
1156 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1158 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
, &reverse
);
1159 if (TREE_CODE (base
) != MEM_REF
1160 /* If this is a varying address, punt. */
1162 || max_size
!= size
)
1164 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1165 ssa
= TREE_OPERAND (base
, 0);
1166 if (TREE_CODE (ssa
) != SSA_NAME
1167 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1171 /* Dynamic types are changed in constructors and destructors. */
1172 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1173 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1174 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1175 parm_ref_data_pass_through_p (fbi
, index
, call
, ssa
));
1178 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1181 iftmp.1_3 = &obj_2(D)->D.1762;
1183 The base of the MEM_REF must be a default definition SSA NAME of a
1184 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1185 whole MEM_REF expression is returned and the offset calculated from any
1186 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1187 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1190 get_ancestor_addr_info (gimple
*assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1192 HOST_WIDE_INT size
, max_size
;
1193 tree expr
, parm
, obj
;
1196 if (!gimple_assign_single_p (assign
))
1198 expr
= gimple_assign_rhs1 (assign
);
1200 if (TREE_CODE (expr
) != ADDR_EXPR
)
1202 expr
= TREE_OPERAND (expr
, 0);
1204 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
, &reverse
);
1206 if (TREE_CODE (expr
) != MEM_REF
1207 /* If this is a varying address, punt. */
1212 parm
= TREE_OPERAND (expr
, 0);
1213 if (TREE_CODE (parm
) != SSA_NAME
1214 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1215 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1218 *offset
+= mem_ref_offset (expr
).to_short_addr () * BITS_PER_UNIT
;
1224 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1225 statement PHI, try to find out whether NAME is in fact a
1226 multiple-inheritance typecast from a descendant into an ancestor of a formal
1227 parameter and thus can be described by an ancestor jump function and if so,
1228 write the appropriate function into JFUNC.
1230 Essentially we want to match the following pattern:
1238 iftmp.1_3 = &obj_2(D)->D.1762;
1241 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1242 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1246 compute_complex_ancestor_jump_func (struct ipa_func_body_info
*fbi
,
1247 struct ipa_node_params
*info
,
1248 struct ipa_jump_func
*jfunc
,
1249 gcall
*call
, gphi
*phi
)
1251 HOST_WIDE_INT offset
;
1252 gimple
*assign
, *cond
;
1253 basic_block phi_bb
, assign_bb
, cond_bb
;
1254 tree tmp
, parm
, expr
, obj
;
1257 if (gimple_phi_num_args (phi
) != 2)
1260 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1261 tmp
= PHI_ARG_DEF (phi
, 0);
1262 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1263 tmp
= PHI_ARG_DEF (phi
, 1);
1266 if (TREE_CODE (tmp
) != SSA_NAME
1267 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1268 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1269 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1272 assign
= SSA_NAME_DEF_STMT (tmp
);
1273 assign_bb
= gimple_bb (assign
);
1274 if (!single_pred_p (assign_bb
))
1276 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1279 parm
= TREE_OPERAND (expr
, 0);
1280 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1284 cond_bb
= single_pred (assign_bb
);
1285 cond
= last_stmt (cond_bb
);
1287 || gimple_code (cond
) != GIMPLE_COND
1288 || gimple_cond_code (cond
) != NE_EXPR
1289 || gimple_cond_lhs (cond
) != parm
1290 || !integer_zerop (gimple_cond_rhs (cond
)))
1293 phi_bb
= gimple_bb (phi
);
1294 for (i
= 0; i
< 2; i
++)
1296 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1297 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1301 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1302 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
));
1305 /* Inspect the given TYPE and return true iff it has the same structure (the
1306 same number of fields of the same types) as a C++ member pointer. If
1307 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1308 corresponding fields there. */
1311 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1315 if (TREE_CODE (type
) != RECORD_TYPE
)
1318 fld
= TYPE_FIELDS (type
);
1319 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1320 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1321 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1327 fld
= DECL_CHAIN (fld
);
1328 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1329 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1334 if (DECL_CHAIN (fld
))
1340 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1341 return the rhs of its defining statement. Otherwise return RHS as it
1345 get_ssa_def_if_simple_copy (tree rhs
)
1347 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1349 gimple
*def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1351 if (gimple_assign_single_p (def_stmt
))
1352 rhs
= gimple_assign_rhs1 (def_stmt
);
1359 /* Simple linked list, describing known contents of an aggregate beforere
1362 struct ipa_known_agg_contents_list
1364 /* Offset and size of the described part of the aggregate. */
1365 HOST_WIDE_INT offset
, size
;
1366 /* Known constant value or NULL if the contents is known to be unknown. */
1368 /* Pointer to the next structure in the list. */
1369 struct ipa_known_agg_contents_list
*next
;
1372 /* Find the proper place in linked list of ipa_known_agg_contents_list
1373 structures where to put a new one with the given LHS_OFFSET and LHS_SIZE,
1374 unless there is a partial overlap, in which case return NULL, or such
1375 element is already there, in which case set *ALREADY_THERE to true. */
1377 static struct ipa_known_agg_contents_list
**
1378 get_place_in_agg_contents_list (struct ipa_known_agg_contents_list
**list
,
1379 HOST_WIDE_INT lhs_offset
,
1380 HOST_WIDE_INT lhs_size
,
1381 bool *already_there
)
1383 struct ipa_known_agg_contents_list
**p
= list
;
1384 while (*p
&& (*p
)->offset
< lhs_offset
)
1386 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1391 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1393 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1394 /* We already know this value is subsequently overwritten with
1396 *already_there
= true;
1398 /* Otherwise this is a partial overlap which we cannot
1405 /* Build aggregate jump function from LIST, assuming there are exactly
1406 CONST_COUNT constant entries there and that th offset of the passed argument
1407 is ARG_OFFSET and store it into JFUNC. */
1410 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1411 int const_count
, HOST_WIDE_INT arg_offset
,
1412 struct ipa_jump_func
*jfunc
)
1414 vec_alloc (jfunc
->agg
.items
, const_count
);
1419 struct ipa_agg_jf_item item
;
1420 item
.offset
= list
->offset
- arg_offset
;
1421 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1422 item
.value
= unshare_expr_without_location (list
->constant
);
1423 jfunc
->agg
.items
->quick_push (item
);
1429 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1430 in ARG is filled in with constant values. ARG can either be an aggregate
1431 expression or a pointer to an aggregate. ARG_TYPE is the type of the
1432 aggregate. JFUNC is the jump function into which the constants are
1433 subsequently stored. */
1436 determine_locally_known_aggregate_parts (gcall
*call
, tree arg
,
1438 struct ipa_jump_func
*jfunc
)
1440 struct ipa_known_agg_contents_list
*list
= NULL
;
1441 int item_count
= 0, const_count
= 0;
1442 HOST_WIDE_INT arg_offset
, arg_size
;
1443 gimple_stmt_iterator gsi
;
1445 bool check_ref
, by_ref
;
1448 if (PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
) == 0)
1451 /* The function operates in three stages. First, we prepare check_ref, r,
1452 arg_base and arg_offset based on what is actually passed as an actual
1455 if (POINTER_TYPE_P (arg_type
))
1458 if (TREE_CODE (arg
) == SSA_NAME
)
1461 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
))))
1466 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1467 arg_size
= tree_to_uhwi (type_size
);
1468 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1470 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1472 HOST_WIDE_INT arg_max_size
;
1475 arg
= TREE_OPERAND (arg
, 0);
1476 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1477 &arg_max_size
, &reverse
);
1478 if (arg_max_size
== -1
1479 || arg_max_size
!= arg_size
1482 if (DECL_P (arg_base
))
1485 ao_ref_init (&r
, arg_base
);
1495 HOST_WIDE_INT arg_max_size
;
1498 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1502 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1503 &arg_max_size
, &reverse
);
1504 if (arg_max_size
== -1
1505 || arg_max_size
!= arg_size
1509 ao_ref_init (&r
, arg
);
1512 /* Second stage walks back the BB, looks at individual statements and as long
1513 as it is confident of how the statements affect contents of the
1514 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1516 gsi
= gsi_for_stmt (call
);
1518 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1520 struct ipa_known_agg_contents_list
*n
, **p
;
1521 gimple
*stmt
= gsi_stmt (gsi
);
1522 HOST_WIDE_INT lhs_offset
, lhs_size
, lhs_max_size
;
1523 tree lhs
, rhs
, lhs_base
;
1526 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1528 if (!gimple_assign_single_p (stmt
))
1531 lhs
= gimple_assign_lhs (stmt
);
1532 rhs
= gimple_assign_rhs1 (stmt
);
1533 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1534 || TREE_CODE (lhs
) == BIT_FIELD_REF
1535 || contains_bitfld_component_ref_p (lhs
))
1538 lhs_base
= get_ref_base_and_extent (lhs
, &lhs_offset
, &lhs_size
,
1539 &lhs_max_size
, &reverse
);
1540 if (lhs_max_size
== -1
1541 || lhs_max_size
!= lhs_size
)
1546 if (TREE_CODE (lhs_base
) != MEM_REF
1547 || TREE_OPERAND (lhs_base
, 0) != arg_base
1548 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1551 else if (lhs_base
!= arg_base
)
1553 if (DECL_P (lhs_base
))
1559 bool already_there
= false;
1560 p
= get_place_in_agg_contents_list (&list
, lhs_offset
, lhs_size
,
1567 rhs
= get_ssa_def_if_simple_copy (rhs
);
1568 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1570 n
->offset
= lhs_offset
;
1571 if (is_gimple_ip_invariant (rhs
))
1577 n
->constant
= NULL_TREE
;
1582 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1583 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1587 /* Third stage just goes over the list and creates an appropriate vector of
1588 ipa_agg_jf_item structures out of it, of sourse only if there are
1589 any known constants to begin with. */
1593 jfunc
->agg
.by_ref
= by_ref
;
1594 build_agg_jump_func_from_list (list
, const_count
, arg_offset
, jfunc
);
1598 /* Return the Ith param type of callee associated with call graph
1602 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1605 tree type
= (e
->callee
1606 ? TREE_TYPE (e
->callee
->decl
)
1607 : gimple_call_fntype (e
->call_stmt
));
1608 tree t
= TYPE_ARG_TYPES (type
);
1610 for (n
= 0; n
< i
; n
++)
1617 return TREE_VALUE (t
);
1620 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1621 for (n
= 0; n
< i
; n
++)
1628 return TREE_TYPE (t
);
1632 /* Compute jump function for all arguments of callsite CS and insert the
1633 information in the jump_functions array in the ipa_edge_args corresponding
1634 to this callsite. */
1637 ipa_compute_jump_functions_for_edge (struct ipa_func_body_info
*fbi
,
1638 struct cgraph_edge
*cs
)
1640 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1641 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1642 gcall
*call
= cs
->call_stmt
;
1643 int n
, arg_num
= gimple_call_num_args (call
);
1644 bool useful_context
= false;
1646 if (arg_num
== 0 || args
->jump_functions
)
1648 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1649 if (flag_devirtualize
)
1650 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, arg_num
);
1652 if (gimple_call_internal_p (call
))
1654 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1657 for (n
= 0; n
< arg_num
; n
++)
1659 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1660 tree arg
= gimple_call_arg (call
, n
);
1661 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1662 if (flag_devirtualize
&& POINTER_TYPE_P (TREE_TYPE (arg
)))
1665 struct ipa_polymorphic_call_context
context (cs
->caller
->decl
,
1668 context
.get_dynamic_type (instance
, arg
, NULL
, cs
->call_stmt
);
1669 *ipa_get_ith_polymorhic_call_context (args
, n
) = context
;
1670 if (!context
.useless_p ())
1671 useful_context
= true;
1674 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1676 bool addr_nonzero
= false;
1677 bool strict_overflow
= false;
1679 if (TREE_CODE (arg
) == SSA_NAME
1681 && get_ptr_nonnull (arg
))
1682 addr_nonzero
= true;
1683 else if (tree_single_nonzero_warnv_p (arg
, &strict_overflow
))
1684 addr_nonzero
= true;
1688 jfunc
->vr_known
= true;
1689 jfunc
->m_vr
.type
= VR_ANTI_RANGE
;
1690 jfunc
->m_vr
.min
= build_int_cst (TREE_TYPE (arg
), 0);
1691 jfunc
->m_vr
.max
= build_int_cst (TREE_TYPE (arg
), 0);
1692 jfunc
->m_vr
.equiv
= NULL
;
1695 gcc_assert (!jfunc
->vr_known
);
1700 value_range_type type
;
1701 if (TREE_CODE (arg
) == SSA_NAME
1703 && (type
= get_range_info (arg
, &min
, &max
))
1704 && (type
== VR_RANGE
|| type
== VR_ANTI_RANGE
))
1709 vr
.min
= wide_int_to_tree (TREE_TYPE (arg
), min
);
1710 vr
.max
= wide_int_to_tree (TREE_TYPE (arg
), max
);
1712 extract_range_from_unary_expr (&jfunc
->m_vr
,
1715 &vr
, TREE_TYPE (arg
));
1716 if (jfunc
->m_vr
.type
== VR_RANGE
1717 || jfunc
->m_vr
.type
== VR_ANTI_RANGE
)
1718 jfunc
->vr_known
= true;
1720 jfunc
->vr_known
= false;
1723 gcc_assert (!jfunc
->vr_known
);
1726 if (INTEGRAL_TYPE_P (TREE_TYPE (arg
))
1727 && (TREE_CODE (arg
) == SSA_NAME
|| TREE_CODE (arg
) == INTEGER_CST
))
1729 jfunc
->bits
.known
= true;
1731 if (TREE_CODE (arg
) == SSA_NAME
)
1733 jfunc
->bits
.value
= 0;
1734 jfunc
->bits
.mask
= widest_int::from (get_nonzero_bits (arg
),
1735 TYPE_SIGN (TREE_TYPE (arg
)));
1739 jfunc
->bits
.value
= wi::to_widest (arg
);
1740 jfunc
->bits
.mask
= 0;
1743 else if (POINTER_TYPE_P (TREE_TYPE (arg
)))
1745 unsigned HOST_WIDE_INT bitpos
;
1748 jfunc
->bits
.known
= true;
1749 get_pointer_alignment_1 (arg
, &align
, &bitpos
);
1750 jfunc
->bits
.mask
= wi::mask
<widest_int
>(TYPE_PRECISION (TREE_TYPE (arg
)), false)
1751 .and_not (align
/ BITS_PER_UNIT
- 1);
1752 jfunc
->bits
.value
= bitpos
/ BITS_PER_UNIT
;
1755 gcc_assert (!jfunc
->bits
.known
);
1757 if (is_gimple_ip_invariant (arg
)
1759 && is_global_var (arg
)
1760 && TREE_READONLY (arg
)))
1761 ipa_set_jf_constant (jfunc
, arg
, cs
);
1762 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1763 && TREE_CODE (arg
) == PARM_DECL
)
1765 int index
= ipa_get_param_decl_index (info
, arg
);
1767 gcc_assert (index
>=0);
1768 /* Aggregate passed by value, check for pass-through, otherwise we
1769 will attempt to fill in aggregate contents later in this
1771 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
1773 ipa_set_jf_simple_pass_through (jfunc
, index
, false);
1777 else if (TREE_CODE (arg
) == SSA_NAME
)
1779 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1781 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1785 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
1786 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1791 gimple
*stmt
= SSA_NAME_DEF_STMT (arg
);
1792 if (is_gimple_assign (stmt
))
1793 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
1794 call
, stmt
, arg
, param_type
);
1795 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1796 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
1798 as_a
<gphi
*> (stmt
));
1802 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1803 passed (because type conversions are ignored in gimple). Usually we can
1804 safely get type from function declaration, but in case of K&R prototypes or
1805 variadic functions we can try our luck with type of the pointer passed.
1806 TODO: Since we look for actual initialization of the memory object, we may better
1807 work out the type based on the memory stores we find. */
1809 param_type
= TREE_TYPE (arg
);
1811 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1812 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1813 && (jfunc
->type
!= IPA_JF_ANCESTOR
1814 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1815 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1816 || POINTER_TYPE_P (param_type
)))
1817 determine_locally_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1819 if (!useful_context
)
1820 vec_free (args
->polymorphic_call_contexts
);
1823 /* Compute jump functions for all edges - both direct and indirect - outgoing
1827 ipa_compute_jump_functions_for_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
1829 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
1831 struct cgraph_edge
*cs
;
1833 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
1835 struct cgraph_node
*callee
= cs
->callee
;
1839 callee
->ultimate_alias_target ();
1840 /* We do not need to bother analyzing calls to unknown functions
1841 unless they may become known during lto/whopr. */
1842 if (!callee
->definition
&& !flag_lto
)
1845 ipa_compute_jump_functions_for_edge (fbi
, cs
);
1849 /* If STMT looks like a statement loading a value from a member pointer formal
1850 parameter, return that parameter and store the offset of the field to
1851 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1852 might be clobbered). If USE_DELTA, then we look for a use of the delta
1853 field rather than the pfn. */
1856 ipa_get_stmt_member_ptr_load_param (gimple
*stmt
, bool use_delta
,
1857 HOST_WIDE_INT
*offset_p
)
1859 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
1861 if (!gimple_assign_single_p (stmt
))
1864 rhs
= gimple_assign_rhs1 (stmt
);
1865 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1867 ref_field
= TREE_OPERAND (rhs
, 1);
1868 rhs
= TREE_OPERAND (rhs
, 0);
1871 ref_field
= NULL_TREE
;
1872 if (TREE_CODE (rhs
) != MEM_REF
)
1874 rec
= TREE_OPERAND (rhs
, 0);
1875 if (TREE_CODE (rec
) != ADDR_EXPR
)
1877 rec
= TREE_OPERAND (rec
, 0);
1878 if (TREE_CODE (rec
) != PARM_DECL
1879 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1881 ref_offset
= TREE_OPERAND (rhs
, 1);
1888 *offset_p
= int_bit_position (fld
);
1892 if (integer_nonzerop (ref_offset
))
1894 return ref_field
== fld
? rec
: NULL_TREE
;
1897 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
1901 /* Returns true iff T is an SSA_NAME defined by a statement. */
1904 ipa_is_ssa_with_stmt_def (tree t
)
1906 if (TREE_CODE (t
) == SSA_NAME
1907 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1913 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1914 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1915 indirect call graph edge. */
1917 static struct cgraph_edge
*
1918 ipa_note_param_call (struct cgraph_node
*node
, int param_index
,
1921 struct cgraph_edge
*cs
;
1923 cs
= node
->get_edge (stmt
);
1924 cs
->indirect_info
->param_index
= param_index
;
1925 cs
->indirect_info
->agg_contents
= 0;
1926 cs
->indirect_info
->member_ptr
= 0;
1927 cs
->indirect_info
->guaranteed_unmodified
= 0;
1931 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1932 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1933 intermediate information about each formal parameter. Currently it checks
1934 whether the call calls a pointer that is a formal parameter and if so, the
1935 parameter is marked with the called flag and an indirect call graph edge
1936 describing the call is created. This is very simple for ordinary pointers
1937 represented in SSA but not-so-nice when it comes to member pointers. The
1938 ugly part of this function does nothing more than trying to match the
1939 pattern of such a call. An example of such a pattern is the gimple dump
1940 below, the call is on the last line:
1943 f$__delta_5 = f.__delta;
1944 f$__pfn_24 = f.__pfn;
1948 f$__delta_5 = MEM[(struct *)&f];
1949 f$__pfn_24 = MEM[(struct *)&f + 4B];
1951 and a few lines below:
1954 D.2496_3 = (int) f$__pfn_24;
1955 D.2497_4 = D.2496_3 & 1;
1962 D.2500_7 = (unsigned int) f$__delta_5;
1963 D.2501_8 = &S + D.2500_7;
1964 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1965 D.2503_10 = *D.2502_9;
1966 D.2504_12 = f$__pfn_24 + -1;
1967 D.2505_13 = (unsigned int) D.2504_12;
1968 D.2506_14 = D.2503_10 + D.2505_13;
1969 D.2507_15 = *D.2506_14;
1970 iftmp.11_16 = (String:: *) D.2507_15;
1973 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1974 D.2500_19 = (unsigned int) f$__delta_5;
1975 D.2508_20 = &S + D.2500_19;
1976 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1978 Such patterns are results of simple calls to a member pointer:
1980 int doprinting (int (MyString::* f)(int) const)
1982 MyString S ("somestring");
1987 Moreover, the function also looks for called pointers loaded from aggregates
1988 passed by value or reference. */
1991 ipa_analyze_indirect_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
,
1994 struct ipa_node_params
*info
= fbi
->info
;
1995 HOST_WIDE_INT offset
;
1998 if (SSA_NAME_IS_DEFAULT_DEF (target
))
2000 tree var
= SSA_NAME_VAR (target
);
2001 int index
= ipa_get_param_decl_index (info
, var
);
2003 ipa_note_param_call (fbi
->node
, index
, call
);
2008 gimple
*def
= SSA_NAME_DEF_STMT (target
);
2009 bool guaranteed_unmodified
;
2010 if (gimple_assign_single_p (def
)
2011 && ipa_load_from_parm_agg (fbi
, info
->descriptors
, def
,
2012 gimple_assign_rhs1 (def
), &index
, &offset
,
2013 NULL
, &by_ref
, &guaranteed_unmodified
))
2015 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2016 cs
->indirect_info
->offset
= offset
;
2017 cs
->indirect_info
->agg_contents
= 1;
2018 cs
->indirect_info
->by_ref
= by_ref
;
2019 cs
->indirect_info
->guaranteed_unmodified
= guaranteed_unmodified
;
2023 /* Now we need to try to match the complex pattern of calling a member
2025 if (gimple_code (def
) != GIMPLE_PHI
2026 || gimple_phi_num_args (def
) != 2
2027 || !POINTER_TYPE_P (TREE_TYPE (target
))
2028 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2031 /* First, we need to check whether one of these is a load from a member
2032 pointer that is a parameter to this function. */
2033 tree n1
= PHI_ARG_DEF (def
, 0);
2034 tree n2
= PHI_ARG_DEF (def
, 1);
2035 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2037 gimple
*d1
= SSA_NAME_DEF_STMT (n1
);
2038 gimple
*d2
= SSA_NAME_DEF_STMT (n2
);
2041 basic_block bb
, virt_bb
;
2042 basic_block join
= gimple_bb (def
);
2043 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2045 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2048 bb
= EDGE_PRED (join
, 0)->src
;
2049 virt_bb
= gimple_bb (d2
);
2051 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2053 bb
= EDGE_PRED (join
, 1)->src
;
2054 virt_bb
= gimple_bb (d1
);
2059 /* Second, we need to check that the basic blocks are laid out in the way
2060 corresponding to the pattern. */
2062 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2063 || single_pred (virt_bb
) != bb
2064 || single_succ (virt_bb
) != join
)
2067 /* Third, let's see that the branching is done depending on the least
2068 significant bit of the pfn. */
2070 gimple
*branch
= last_stmt (bb
);
2071 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2074 if ((gimple_cond_code (branch
) != NE_EXPR
2075 && gimple_cond_code (branch
) != EQ_EXPR
)
2076 || !integer_zerop (gimple_cond_rhs (branch
)))
2079 tree cond
= gimple_cond_lhs (branch
);
2080 if (!ipa_is_ssa_with_stmt_def (cond
))
2083 def
= SSA_NAME_DEF_STMT (cond
);
2084 if (!is_gimple_assign (def
)
2085 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2086 || !integer_onep (gimple_assign_rhs2 (def
)))
2089 cond
= gimple_assign_rhs1 (def
);
2090 if (!ipa_is_ssa_with_stmt_def (cond
))
2093 def
= SSA_NAME_DEF_STMT (cond
);
2095 if (is_gimple_assign (def
)
2096 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2098 cond
= gimple_assign_rhs1 (def
);
2099 if (!ipa_is_ssa_with_stmt_def (cond
))
2101 def
= SSA_NAME_DEF_STMT (cond
);
2105 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2106 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2107 == ptrmemfunc_vbit_in_delta
),
2112 index
= ipa_get_param_decl_index (info
, rec
);
2114 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2116 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2117 cs
->indirect_info
->offset
= offset
;
2118 cs
->indirect_info
->agg_contents
= 1;
2119 cs
->indirect_info
->member_ptr
= 1;
2120 cs
->indirect_info
->guaranteed_unmodified
= 1;
2126 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2127 object referenced in the expression is a formal parameter of the caller
2128 FBI->node (described by FBI->info), create a call note for the
2132 ipa_analyze_virtual_call_uses (struct ipa_func_body_info
*fbi
,
2133 gcall
*call
, tree target
)
2135 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2137 HOST_WIDE_INT anc_offset
;
2139 if (!flag_devirtualize
)
2142 if (TREE_CODE (obj
) != SSA_NAME
)
2145 struct ipa_node_params
*info
= fbi
->info
;
2146 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2148 struct ipa_jump_func jfunc
;
2149 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2153 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2154 gcc_assert (index
>= 0);
2155 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2161 struct ipa_jump_func jfunc
;
2162 gimple
*stmt
= SSA_NAME_DEF_STMT (obj
);
2165 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2168 index
= ipa_get_param_decl_index (info
,
2169 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2170 gcc_assert (index
>= 0);
2171 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2172 call
, &jfunc
, anc_offset
))
2176 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2177 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2178 ii
->offset
= anc_offset
;
2179 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2180 ii
->otr_type
= obj_type_ref_class (target
);
2181 ii
->polymorphic
= 1;
2184 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2185 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2186 containing intermediate information about each formal parameter. */
2189 ipa_analyze_call_uses (struct ipa_func_body_info
*fbi
, gcall
*call
)
2191 tree target
= gimple_call_fn (call
);
2194 || (TREE_CODE (target
) != SSA_NAME
2195 && !virtual_method_call_p (target
)))
2198 struct cgraph_edge
*cs
= fbi
->node
->get_edge (call
);
2199 /* If we previously turned the call into a direct call, there is
2200 no need to analyze. */
2201 if (cs
&& !cs
->indirect_unknown_callee
)
2204 if (cs
->indirect_info
->polymorphic
&& flag_devirtualize
)
2207 tree target
= gimple_call_fn (call
);
2208 ipa_polymorphic_call_context
context (current_function_decl
,
2209 target
, call
, &instance
);
2211 gcc_checking_assert (cs
->indirect_info
->otr_type
2212 == obj_type_ref_class (target
));
2213 gcc_checking_assert (cs
->indirect_info
->otr_token
2214 == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target
)));
2216 cs
->indirect_info
->vptr_changed
2217 = !context
.get_dynamic_type (instance
,
2218 OBJ_TYPE_REF_OBJECT (target
),
2219 obj_type_ref_class (target
), call
);
2220 cs
->indirect_info
->context
= context
;
2223 if (TREE_CODE (target
) == SSA_NAME
)
2224 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2225 else if (virtual_method_call_p (target
))
2226 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2230 /* Analyze the call statement STMT with respect to formal parameters (described
2231 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2232 formal parameters are called. */
2235 ipa_analyze_stmt_uses (struct ipa_func_body_info
*fbi
, gimple
*stmt
)
2237 if (is_gimple_call (stmt
))
2238 ipa_analyze_call_uses (fbi
, as_a
<gcall
*> (stmt
));
2241 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2242 If OP is a parameter declaration, mark it as used in the info structure
2246 visit_ref_for_mod_analysis (gimple
*, tree op
, tree
, void *data
)
2248 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2250 op
= get_base_address (op
);
2252 && TREE_CODE (op
) == PARM_DECL
)
2254 int index
= ipa_get_param_decl_index (info
, op
);
2255 gcc_assert (index
>= 0);
2256 ipa_set_param_used (info
, index
, true);
2262 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2263 the findings in various structures of the associated ipa_node_params
2264 structure, such as parameter flags, notes etc. FBI holds various data about
2265 the function being analyzed. */
2268 ipa_analyze_params_uses_in_bb (struct ipa_func_body_info
*fbi
, basic_block bb
)
2270 gimple_stmt_iterator gsi
;
2271 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2273 gimple
*stmt
= gsi_stmt (gsi
);
2275 if (is_gimple_debug (stmt
))
2278 ipa_analyze_stmt_uses (fbi
, stmt
);
2279 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2280 visit_ref_for_mod_analysis
,
2281 visit_ref_for_mod_analysis
,
2282 visit_ref_for_mod_analysis
);
2284 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2285 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2286 visit_ref_for_mod_analysis
,
2287 visit_ref_for_mod_analysis
,
2288 visit_ref_for_mod_analysis
);
2291 /* Calculate controlled uses of parameters of NODE. */
2294 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2296 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2298 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2300 tree parm
= ipa_get_param (info
, i
);
2301 int controlled_uses
= 0;
2303 /* For SSA regs see if parameter is used. For non-SSA we compute
2304 the flag during modification analysis. */
2305 if (is_gimple_reg (parm
))
2307 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2309 if (ddef
&& !has_zero_uses (ddef
))
2311 imm_use_iterator imm_iter
;
2312 use_operand_p use_p
;
2314 ipa_set_param_used (info
, i
, true);
2315 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2316 if (!is_gimple_call (USE_STMT (use_p
)))
2318 if (!is_gimple_debug (USE_STMT (use_p
)))
2320 controlled_uses
= IPA_UNDESCRIBED_USE
;
2328 controlled_uses
= 0;
2331 controlled_uses
= IPA_UNDESCRIBED_USE
;
2332 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2336 /* Free stuff in BI. */
2339 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2341 bi
->cg_edges
.release ();
2342 bi
->param_aa_statuses
.release ();
2345 /* Dominator walker driving the analysis. */
2347 class analysis_dom_walker
: public dom_walker
2350 analysis_dom_walker (struct ipa_func_body_info
*fbi
)
2351 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2353 virtual edge
before_dom_children (basic_block
);
2356 struct ipa_func_body_info
*m_fbi
;
2360 analysis_dom_walker::before_dom_children (basic_block bb
)
2362 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2363 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2367 /* Release body info FBI. */
2370 ipa_release_body_info (struct ipa_func_body_info
*fbi
)
2373 struct ipa_bb_info
*bi
;
2375 FOR_EACH_VEC_ELT (fbi
->bb_infos
, i
, bi
)
2376 free_ipa_bb_info (bi
);
2377 fbi
->bb_infos
.release ();
2380 /* Initialize the array describing properties of formal parameters
2381 of NODE, analyze their uses and compute jump functions associated
2382 with actual arguments of calls from within NODE. */
2385 ipa_analyze_node (struct cgraph_node
*node
)
2387 struct ipa_func_body_info fbi
;
2388 struct ipa_node_params
*info
;
2390 ipa_check_create_node_params ();
2391 ipa_check_create_edge_args ();
2392 info
= IPA_NODE_REF (node
);
2394 if (info
->analysis_done
)
2396 info
->analysis_done
= 1;
2398 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2400 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2402 ipa_set_param_used (info
, i
, true);
2403 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2408 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2410 calculate_dominance_info (CDI_DOMINATORS
);
2411 ipa_initialize_node_params (node
);
2412 ipa_analyze_controlled_uses (node
);
2415 fbi
.info
= IPA_NODE_REF (node
);
2416 fbi
.bb_infos
= vNULL
;
2417 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2418 fbi
.param_count
= ipa_get_param_count (info
);
2421 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2423 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2424 bi
->cg_edges
.safe_push (cs
);
2427 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2429 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2430 bi
->cg_edges
.safe_push (cs
);
2433 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2435 ipa_release_body_info (&fbi
);
2436 free_dominance_info (CDI_DOMINATORS
);
2440 /* Update the jump functions associated with call graph edge E when the call
2441 graph edge CS is being inlined, assuming that E->caller is already (possibly
2442 indirectly) inlined into CS->callee and that E has not been inlined. */
2445 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2446 struct cgraph_edge
*e
)
2448 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2449 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2450 int count
= ipa_get_cs_argument_count (args
);
2453 for (i
= 0; i
< count
; i
++)
2455 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2456 struct ipa_polymorphic_call_context
*dst_ctx
2457 = ipa_get_ith_polymorhic_call_context (args
, i
);
2459 if (dst
->type
== IPA_JF_ANCESTOR
)
2461 struct ipa_jump_func
*src
;
2462 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2463 struct ipa_polymorphic_call_context
*src_ctx
2464 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2466 /* Variable number of arguments can cause havoc if we try to access
2467 one that does not exist in the inlined edge. So make sure we
2469 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2471 ipa_set_jf_unknown (dst
);
2475 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2477 if (src_ctx
&& !src_ctx
->useless_p ())
2479 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2481 /* TODO: Make type preserved safe WRT contexts. */
2482 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2483 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2484 ctx
.offset_by (dst
->value
.ancestor
.offset
);
2485 if (!ctx
.useless_p ())
2489 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2491 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2494 dst_ctx
->combine_with (ctx
);
2499 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2501 struct ipa_agg_jf_item
*item
;
2504 /* Currently we do not produce clobber aggregate jump functions,
2505 replace with merging when we do. */
2506 gcc_assert (!dst
->agg
.items
);
2508 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2509 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2510 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2511 item
->offset
-= dst
->value
.ancestor
.offset
;
2514 if (src
->type
== IPA_JF_PASS_THROUGH
2515 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2517 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2518 dst
->value
.ancestor
.agg_preserved
&=
2519 src
->value
.pass_through
.agg_preserved
;
2521 else if (src
->type
== IPA_JF_ANCESTOR
)
2523 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2524 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2525 dst
->value
.ancestor
.agg_preserved
&=
2526 src
->value
.ancestor
.agg_preserved
;
2529 ipa_set_jf_unknown (dst
);
2531 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2533 struct ipa_jump_func
*src
;
2534 /* We must check range due to calls with variable number of arguments
2535 and we cannot combine jump functions with operations. */
2536 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2537 && (dst
->value
.pass_through
.formal_id
2538 < ipa_get_cs_argument_count (top
)))
2540 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2541 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2542 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2543 struct ipa_polymorphic_call_context
*src_ctx
2544 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2546 if (src_ctx
&& !src_ctx
->useless_p ())
2548 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2550 /* TODO: Make type preserved safe WRT contexts. */
2551 if (!ipa_get_jf_pass_through_type_preserved (dst
))
2552 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2553 if (!ctx
.useless_p ())
2557 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2559 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2561 dst_ctx
->combine_with (ctx
);
2566 case IPA_JF_UNKNOWN
:
2567 ipa_set_jf_unknown (dst
);
2570 ipa_set_jf_cst_copy (dst
, src
);
2573 case IPA_JF_PASS_THROUGH
:
2575 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2576 enum tree_code operation
;
2577 operation
= ipa_get_jf_pass_through_operation (src
);
2579 if (operation
== NOP_EXPR
)
2583 && ipa_get_jf_pass_through_agg_preserved (src
);
2584 ipa_set_jf_simple_pass_through (dst
, formal_id
, agg_p
);
2588 tree operand
= ipa_get_jf_pass_through_operand (src
);
2589 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2594 case IPA_JF_ANCESTOR
:
2598 && ipa_get_jf_ancestor_agg_preserved (src
);
2599 ipa_set_ancestor_jf (dst
,
2600 ipa_get_jf_ancestor_offset (src
),
2601 ipa_get_jf_ancestor_formal_id (src
),
2610 && (dst_agg_p
|| !src
->agg
.by_ref
))
2612 /* Currently we do not produce clobber aggregate jump
2613 functions, replace with merging when we do. */
2614 gcc_assert (!dst
->agg
.items
);
2616 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2617 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2621 ipa_set_jf_unknown (dst
);
2626 /* If TARGET is an addr_expr of a function declaration, make it the
2627 (SPECULATIVE)destination of an indirect edge IE and return the edge.
2628 Otherwise, return NULL. */
2630 struct cgraph_edge
*
2631 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
,
2634 struct cgraph_node
*callee
;
2635 struct inline_edge_summary
*es
= inline_edge_summary (ie
);
2636 bool unreachable
= false;
2638 if (TREE_CODE (target
) == ADDR_EXPR
)
2639 target
= TREE_OPERAND (target
, 0);
2640 if (TREE_CODE (target
) != FUNCTION_DECL
)
2642 target
= canonicalize_constructor_val (target
, NULL
);
2643 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2645 /* Member pointer call that goes through a VMT lookup. */
2646 if (ie
->indirect_info
->member_ptr
2647 /* Or if target is not an invariant expression and we do not
2648 know if it will evaulate to function at runtime.
2649 This can happen when folding through &VAR, where &VAR
2650 is IP invariant, but VAR itself is not.
2652 TODO: Revisit this when GCC 5 is branched. It seems that
2653 member_ptr check is not needed and that we may try to fold
2654 the expression and see if VAR is readonly. */
2655 || !is_gimple_ip_invariant (target
))
2657 if (dump_enabled_p ())
2659 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2660 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2661 "discovered direct call non-invariant "
2663 ie
->caller
->name (), ie
->caller
->order
);
2669 if (dump_enabled_p ())
2671 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2672 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2673 "discovered direct call to non-function in %s/%i, "
2674 "making it __builtin_unreachable\n",
2675 ie
->caller
->name (), ie
->caller
->order
);
2678 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2679 callee
= cgraph_node::get_create (target
);
2683 callee
= cgraph_node::get (target
);
2686 callee
= cgraph_node::get (target
);
2688 /* Because may-edges are not explicitely represented and vtable may be external,
2689 we may create the first reference to the object in the unit. */
2690 if (!callee
|| callee
->global
.inlined_to
)
2693 /* We are better to ensure we can refer to it.
2694 In the case of static functions we are out of luck, since we already
2695 removed its body. In the case of public functions we may or may
2696 not introduce the reference. */
2697 if (!canonicalize_constructor_val (target
, NULL
)
2698 || !TREE_PUBLIC (target
))
2701 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2702 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2703 xstrdup_for_dump (ie
->caller
->name ()),
2705 xstrdup_for_dump (ie
->callee
->name ()),
2709 callee
= cgraph_node::get_create (target
);
2712 /* If the edge is already speculated. */
2713 if (speculative
&& ie
->speculative
)
2715 struct cgraph_edge
*e2
;
2716 struct ipa_ref
*ref
;
2717 ie
->speculative_call_info (e2
, ie
, ref
);
2718 if (e2
->callee
->ultimate_alias_target ()
2719 != callee
->ultimate_alias_target ())
2722 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2723 "(%s/%i -> %s/%i) but the call is already speculated to %s/%i. Giving up.\n",
2724 xstrdup_for_dump (ie
->caller
->name ()),
2726 xstrdup_for_dump (callee
->name ()),
2728 xstrdup_for_dump (e2
->callee
->name ()),
2734 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2735 "(%s/%i -> %s/%i) this agree with previous speculation.\n",
2736 xstrdup_for_dump (ie
->caller
->name ()),
2738 xstrdup_for_dump (callee
->name ()),
2744 if (!dbg_cnt (devirt
))
2747 ipa_check_create_node_params ();
2749 /* We can not make edges to inline clones. It is bug that someone removed
2750 the cgraph node too early. */
2751 gcc_assert (!callee
->global
.inlined_to
);
2753 if (dump_file
&& !unreachable
)
2755 fprintf (dump_file
, "ipa-prop: Discovered %s call to a %s target "
2756 "(%s/%i -> %s/%i), for stmt ",
2757 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2758 speculative
? "speculative" : "known",
2759 xstrdup_for_dump (ie
->caller
->name ()),
2761 xstrdup_for_dump (callee
->name ()),
2764 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2766 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2768 if (dump_enabled_p ())
2770 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2772 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2773 "converting indirect call in %s to direct call to %s\n",
2774 ie
->caller
->name (), callee
->name ());
2778 struct cgraph_edge
*orig
= ie
;
2779 ie
= ie
->make_direct (callee
);
2780 /* If we resolved speculative edge the cost is already up to date
2781 for direct call (adjusted by inline_edge_duplication_hook). */
2784 es
= inline_edge_summary (ie
);
2785 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2786 - eni_size_weights
.call_cost
);
2787 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2788 - eni_time_weights
.call_cost
);
2793 if (!callee
->can_be_discarded_p ())
2796 alias
= dyn_cast
<cgraph_node
*> (callee
->noninterposable_alias ());
2800 /* make_speculative will update ie's cost to direct call cost. */
2801 ie
= ie
->make_speculative
2802 (callee
, ie
->count
* 8 / 10, ie
->frequency
* 8 / 10);
2808 /* Attempt to locate an interprocedural constant at a given REQ_OFFSET in
2809 CONSTRUCTOR and return it. Return NULL if the search fails for some
2813 find_constructor_constant_at_offset (tree constructor
, HOST_WIDE_INT req_offset
)
2815 tree type
= TREE_TYPE (constructor
);
2816 if (TREE_CODE (type
) != ARRAY_TYPE
2817 && TREE_CODE (type
) != RECORD_TYPE
)
2822 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (constructor
), ix
, index
, val
)
2824 HOST_WIDE_INT elt_offset
;
2825 if (TREE_CODE (type
) == ARRAY_TYPE
)
2828 tree unit_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
2829 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
2833 off
= wi::to_offset (index
);
2834 if (TYPE_DOMAIN (type
) && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)))
2836 tree low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
2837 gcc_assert (TREE_CODE (unit_size
) == INTEGER_CST
);
2838 off
= wi::sext (off
- wi::to_offset (low_bound
),
2839 TYPE_PRECISION (TREE_TYPE (index
)));
2841 off
*= wi::to_offset (unit_size
);
2844 off
= wi::to_offset (unit_size
) * ix
;
2846 off
= wi::lshift (off
, LOG2_BITS_PER_UNIT
);
2847 if (!wi::fits_shwi_p (off
) || wi::neg_p (off
))
2849 elt_offset
= off
.to_shwi ();
2851 else if (TREE_CODE (type
) == RECORD_TYPE
)
2853 gcc_checking_assert (index
&& TREE_CODE (index
) == FIELD_DECL
);
2854 if (DECL_BIT_FIELD (index
))
2856 elt_offset
= int_bit_position (index
);
2861 if (elt_offset
> req_offset
)
2864 if (TREE_CODE (val
) == CONSTRUCTOR
)
2865 return find_constructor_constant_at_offset (val
,
2866 req_offset
- elt_offset
);
2868 if (elt_offset
== req_offset
2869 && is_gimple_reg_type (TREE_TYPE (val
))
2870 && is_gimple_ip_invariant (val
))
2876 /* Check whether SCALAR could be used to look up an aggregate interprocedural
2877 invariant from a static constructor and if so, return it. Otherwise return
2881 ipa_find_agg_cst_from_init (tree scalar
, HOST_WIDE_INT offset
, bool by_ref
)
2885 if (TREE_CODE (scalar
) != ADDR_EXPR
)
2887 scalar
= TREE_OPERAND (scalar
, 0);
2891 || !is_global_var (scalar
)
2892 || !TREE_READONLY (scalar
)
2893 || !DECL_INITIAL (scalar
)
2894 || TREE_CODE (DECL_INITIAL (scalar
)) != CONSTRUCTOR
)
2897 return find_constructor_constant_at_offset (DECL_INITIAL (scalar
), offset
);
2900 /* Retrieve value from aggregate jump function AGG or static initializer of
2901 SCALAR (which can be NULL) for the given OFFSET or return NULL if there is
2902 none. BY_REF specifies whether the value has to be passed by reference or
2903 by value. If FROM_GLOBAL_CONSTANT is non-NULL, then the boolean it points
2904 to is set to true if the value comes from an initializer of a constant. */
2907 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
, tree scalar
,
2908 HOST_WIDE_INT offset
, bool by_ref
,
2909 bool *from_global_constant
)
2911 struct ipa_agg_jf_item
*item
;
2916 tree res
= ipa_find_agg_cst_from_init (scalar
, offset
, by_ref
);
2919 if (from_global_constant
)
2920 *from_global_constant
= true;
2926 || by_ref
!= agg
->by_ref
)
2929 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2930 if (item
->offset
== offset
)
2932 /* Currently we do not have clobber values, return NULL for them once
2934 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2935 if (from_global_constant
)
2936 *from_global_constant
= false;
2942 /* Remove a reference to SYMBOL from the list of references of a node given by
2943 reference description RDESC. Return true if the reference has been
2944 successfully found and removed. */
2947 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
2949 struct ipa_ref
*to_del
;
2950 struct cgraph_edge
*origin
;
2955 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
2956 origin
->lto_stmt_uid
);
2960 to_del
->remove_reference ();
2962 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
2963 xstrdup_for_dump (origin
->caller
->name ()),
2964 origin
->caller
->order
, xstrdup_for_dump (symbol
->name ()));
2968 /* If JFUNC has a reference description with refcount different from
2969 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
2970 NULL. JFUNC must be a constant jump function. */
2972 static struct ipa_cst_ref_desc
*
2973 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
2975 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
2976 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
2982 /* If the value of constant jump function JFUNC is an address of a function
2983 declaration, return the associated call graph node. Otherwise return
2986 static cgraph_node
*
2987 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
2989 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
2990 tree cst
= ipa_get_jf_constant (jfunc
);
2991 if (TREE_CODE (cst
) != ADDR_EXPR
2992 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
2995 return cgraph_node::get (TREE_OPERAND (cst
, 0));
2999 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
3000 refcount and if it hits zero, remove reference to SYMBOL from the caller of
3001 the edge specified in the rdesc. Return false if either the symbol or the
3002 reference could not be found, otherwise return true. */
3005 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
3007 struct ipa_cst_ref_desc
*rdesc
;
3008 if (jfunc
->type
== IPA_JF_CONST
3009 && (rdesc
= jfunc_rdesc_usable (jfunc
))
3010 && --rdesc
->refcount
== 0)
3012 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
3016 return remove_described_reference (symbol
, rdesc
);
3021 /* Try to find a destination for indirect edge IE that corresponds to a simple
3022 call or a call of a member function pointer and where the destination is a
3023 pointer formal parameter described by jump function JFUNC. If it can be
3024 determined, return the newly direct edge, otherwise return NULL.
3025 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
3027 static struct cgraph_edge
*
3028 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
3029 struct ipa_jump_func
*jfunc
,
3030 struct ipa_node_params
*new_root_info
)
3032 struct cgraph_edge
*cs
;
3034 bool agg_contents
= ie
->indirect_info
->agg_contents
;
3035 tree scalar
= ipa_value_from_jfunc (new_root_info
, jfunc
);
3038 bool from_global_constant
;
3039 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3040 ie
->indirect_info
->offset
,
3041 ie
->indirect_info
->by_ref
,
3042 &from_global_constant
);
3044 && !from_global_constant
3045 && !ie
->indirect_info
->guaranteed_unmodified
)
3052 cs
= ipa_make_edge_direct_to_target (ie
, target
);
3054 if (cs
&& !agg_contents
)
3057 gcc_checking_assert (cs
->callee
3059 || jfunc
->type
!= IPA_JF_CONST
3060 || !cgraph_node_for_jfunc (jfunc
)
3061 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
3062 ok
= try_decrement_rdesc_refcount (jfunc
);
3063 gcc_checking_assert (ok
);
3069 /* Return the target to be used in cases of impossible devirtualization. IE
3070 and target (the latter can be NULL) are dumped when dumping is enabled. */
3073 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
3079 "Type inconsistent devirtualization: %s/%i->%s\n",
3080 ie
->caller
->name (), ie
->caller
->order
,
3081 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
3084 "No devirtualization target in %s/%i\n",
3085 ie
->caller
->name (), ie
->caller
->order
);
3087 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
3088 cgraph_node::get_create (new_target
);
3092 /* Try to find a destination for indirect edge IE that corresponds to a virtual
3093 call based on a formal parameter which is described by jump function JFUNC
3094 and if it can be determined, make it direct and return the direct edge.
3095 Otherwise, return NULL. CTX describes the polymorphic context that the
3096 parameter the call is based on brings along with it. */
3098 static struct cgraph_edge
*
3099 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
3100 struct ipa_jump_func
*jfunc
,
3101 struct ipa_polymorphic_call_context ctx
)
3104 bool speculative
= false;
3106 if (!opt_for_fn (ie
->caller
->decl
, flag_devirtualize
))
3109 gcc_assert (!ie
->indirect_info
->by_ref
);
3111 /* Try to do lookup via known virtual table pointer value. */
3112 if (!ie
->indirect_info
->vptr_changed
3113 || opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
))
3116 unsigned HOST_WIDE_INT offset
;
3117 tree scalar
= (jfunc
->type
== IPA_JF_CONST
) ? ipa_get_jf_constant (jfunc
)
3119 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
, scalar
,
3120 ie
->indirect_info
->offset
,
3122 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
3125 t
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
3126 vtable
, offset
, &can_refer
);
3130 || (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
3131 && DECL_FUNCTION_CODE (t
) == BUILT_IN_UNREACHABLE
)
3132 || !possible_polymorphic_call_target_p
3133 (ie
, cgraph_node::get (t
)))
3135 /* Do not speculate builtin_unreachable, it is stupid! */
3136 if (!ie
->indirect_info
->vptr_changed
)
3137 target
= ipa_impossible_devirt_target (ie
, target
);
3144 speculative
= ie
->indirect_info
->vptr_changed
;
3150 ipa_polymorphic_call_context
ie_context (ie
);
3151 vec
<cgraph_node
*>targets
;
3154 ctx
.offset_by (ie
->indirect_info
->offset
);
3155 if (ie
->indirect_info
->vptr_changed
)
3156 ctx
.possible_dynamic_type_change (ie
->in_polymorphic_cdtor
,
3157 ie
->indirect_info
->otr_type
);
3158 ctx
.combine_with (ie_context
, ie
->indirect_info
->otr_type
);
3159 targets
= possible_polymorphic_call_targets
3160 (ie
->indirect_info
->otr_type
,
3161 ie
->indirect_info
->otr_token
,
3163 if (final
&& targets
.length () <= 1)
3165 speculative
= false;
3166 if (targets
.length () == 1)
3167 target
= targets
[0]->decl
;
3169 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3171 else if (!target
&& opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
)
3172 && !ie
->speculative
&& ie
->maybe_hot_p ())
3175 n
= try_speculative_devirtualization (ie
->indirect_info
->otr_type
,
3176 ie
->indirect_info
->otr_token
,
3177 ie
->indirect_info
->context
);
3187 if (!possible_polymorphic_call_target_p
3188 (ie
, cgraph_node::get_create (target
)))
3192 target
= ipa_impossible_devirt_target (ie
, target
);
3194 return ipa_make_edge_direct_to_target (ie
, target
, speculative
);
3200 /* Update the param called notes associated with NODE when CS is being inlined,
3201 assuming NODE is (potentially indirectly) inlined into CS->callee.
3202 Moreover, if the callee is discovered to be constant, create a new cgraph
3203 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3204 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3207 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3208 struct cgraph_node
*node
,
3209 vec
<cgraph_edge
*> *new_edges
)
3211 struct ipa_edge_args
*top
;
3212 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3213 struct ipa_node_params
*new_root_info
;
3216 ipa_check_create_edge_args ();
3217 top
= IPA_EDGE_REF (cs
);
3218 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3219 ? cs
->caller
->global
.inlined_to
3222 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3224 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3225 struct ipa_jump_func
*jfunc
;
3227 cgraph_node
*spec_target
= NULL
;
3229 next_ie
= ie
->next_callee
;
3231 if (ici
->param_index
== -1)
3234 /* We must check range due to calls with variable number of arguments: */
3235 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3237 ici
->param_index
= -1;
3241 param_index
= ici
->param_index
;
3242 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3244 if (ie
->speculative
)
3246 struct cgraph_edge
*de
;
3247 struct ipa_ref
*ref
;
3248 ie
->speculative_call_info (de
, ie
, ref
);
3249 spec_target
= de
->callee
;
3252 if (!opt_for_fn (node
->decl
, flag_indirect_inlining
))
3253 new_direct_edge
= NULL
;
3254 else if (ici
->polymorphic
)
3256 ipa_polymorphic_call_context ctx
;
3257 ctx
= ipa_context_from_jfunc (new_root_info
, cs
, param_index
, jfunc
);
3258 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
, ctx
);
3261 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3263 /* If speculation was removed, then we need to do nothing. */
3264 if (new_direct_edge
&& new_direct_edge
!= ie
3265 && new_direct_edge
->callee
== spec_target
)
3267 new_direct_edge
->indirect_inlining_edge
= 1;
3268 top
= IPA_EDGE_REF (cs
);
3270 if (!new_direct_edge
->speculative
)
3273 else if (new_direct_edge
)
3275 new_direct_edge
->indirect_inlining_edge
= 1;
3276 if (new_direct_edge
->call_stmt
)
3277 new_direct_edge
->call_stmt_cannot_inline_p
3278 = !gimple_check_call_matching_types (
3279 new_direct_edge
->call_stmt
,
3280 new_direct_edge
->callee
->decl
, false);
3283 new_edges
->safe_push (new_direct_edge
);
3286 top
= IPA_EDGE_REF (cs
);
3287 /* If speculative edge was introduced we still need to update
3288 call info of the indirect edge. */
3289 if (!new_direct_edge
->speculative
)
3292 if (jfunc
->type
== IPA_JF_PASS_THROUGH
3293 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3295 if (ici
->agg_contents
3296 && !ipa_get_jf_pass_through_agg_preserved (jfunc
)
3297 && !ici
->polymorphic
)
3298 ici
->param_index
= -1;
3301 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3302 if (ici
->polymorphic
3303 && !ipa_get_jf_pass_through_type_preserved (jfunc
))
3304 ici
->vptr_changed
= true;
3307 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3309 if (ici
->agg_contents
3310 && !ipa_get_jf_ancestor_agg_preserved (jfunc
)
3311 && !ici
->polymorphic
)
3312 ici
->param_index
= -1;
3315 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3316 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3317 if (ici
->polymorphic
3318 && !ipa_get_jf_ancestor_type_preserved (jfunc
))
3319 ici
->vptr_changed
= true;
3323 /* Either we can find a destination for this edge now or never. */
3324 ici
->param_index
= -1;
3330 /* Recursively traverse subtree of NODE (including node) made of inlined
3331 cgraph_edges when CS has been inlined and invoke
3332 update_indirect_edges_after_inlining on all nodes and
3333 update_jump_functions_after_inlining on all non-inlined edges that lead out
3334 of this subtree. Newly discovered indirect edges will be added to
3335 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3339 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3340 struct cgraph_node
*node
,
3341 vec
<cgraph_edge
*> *new_edges
)
3343 struct cgraph_edge
*e
;
3346 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3348 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3349 if (!e
->inline_failed
)
3350 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3352 update_jump_functions_after_inlining (cs
, e
);
3353 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3354 update_jump_functions_after_inlining (cs
, e
);
3359 /* Combine two controlled uses counts as done during inlining. */
3362 combine_controlled_uses_counters (int c
, int d
)
3364 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3365 return IPA_UNDESCRIBED_USE
;
3370 /* Propagate number of controlled users from CS->caleee to the new root of the
3371 tree of inlined nodes. */
3374 propagate_controlled_uses (struct cgraph_edge
*cs
)
3376 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3377 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3378 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3379 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3380 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3383 count
= MIN (ipa_get_cs_argument_count (args
),
3384 ipa_get_param_count (old_root_info
));
3385 for (i
= 0; i
< count
; i
++)
3387 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3388 struct ipa_cst_ref_desc
*rdesc
;
3390 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3393 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3394 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3395 d
= ipa_get_controlled_uses (old_root_info
, i
);
3397 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3398 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3399 c
= combine_controlled_uses_counters (c
, d
);
3400 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3401 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3403 struct cgraph_node
*n
;
3404 struct ipa_ref
*ref
;
3405 tree t
= new_root_info
->known_csts
[src_idx
];
3407 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3408 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3409 && (n
= cgraph_node::get (TREE_OPERAND (t
, 0)))
3410 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3413 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3414 "reference from %s/%i to %s/%i.\n",
3415 xstrdup_for_dump (new_root
->name ()),
3417 xstrdup_for_dump (n
->name ()), n
->order
);
3418 ref
->remove_reference ();
3422 else if (jf
->type
== IPA_JF_CONST
3423 && (rdesc
= jfunc_rdesc_usable (jf
)))
3425 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3426 int c
= rdesc
->refcount
;
3427 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3428 if (rdesc
->refcount
== 0)
3430 tree cst
= ipa_get_jf_constant (jf
);
3431 struct cgraph_node
*n
;
3432 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3433 && TREE_CODE (TREE_OPERAND (cst
, 0))
3435 n
= cgraph_node::get (TREE_OPERAND (cst
, 0));
3438 struct cgraph_node
*clone
;
3440 ok
= remove_described_reference (n
, rdesc
);
3441 gcc_checking_assert (ok
);
3444 while (clone
->global
.inlined_to
3445 && clone
!= rdesc
->cs
->caller
3446 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3448 struct ipa_ref
*ref
;
3449 ref
= clone
->find_reference (n
, NULL
, 0);
3453 fprintf (dump_file
, "ipa-prop: Removing "
3454 "cloning-created reference "
3455 "from %s/%i to %s/%i.\n",
3456 xstrdup_for_dump (clone
->name ()),
3458 xstrdup_for_dump (n
->name ()),
3460 ref
->remove_reference ();
3462 clone
= clone
->callers
->caller
;
3469 for (i
= ipa_get_param_count (old_root_info
);
3470 i
< ipa_get_cs_argument_count (args
);
3473 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3475 if (jf
->type
== IPA_JF_CONST
)
3477 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3479 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3481 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3482 ipa_set_controlled_uses (new_root_info
,
3483 jf
->value
.pass_through
.formal_id
,
3484 IPA_UNDESCRIBED_USE
);
3488 /* Update jump functions and call note functions on inlining the call site CS.
3489 CS is expected to lead to a node already cloned by
3490 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3491 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3495 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3496 vec
<cgraph_edge
*> *new_edges
)
3499 /* Do nothing if the preparation phase has not been carried out yet
3500 (i.e. during early inlining). */
3501 if (!ipa_node_params_sum
)
3503 gcc_assert (ipa_edge_args_vector
);
3505 propagate_controlled_uses (cs
);
3506 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3511 /* Frees all dynamically allocated structures that the argument info points
3515 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3517 vec_free (args
->jump_functions
);
3518 memset (args
, 0, sizeof (*args
));
3521 /* Free all ipa_edge structures. */
3524 ipa_free_all_edge_args (void)
3527 struct ipa_edge_args
*args
;
3529 if (!ipa_edge_args_vector
)
3532 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3533 ipa_free_edge_args_substructures (args
);
3535 vec_free (ipa_edge_args_vector
);
3538 /* Frees all dynamically allocated structures that the param info points
3541 ipa_node_params::~ipa_node_params ()
3543 descriptors
.release ();
3545 /* Lattice values and their sources are deallocated with their alocation
3547 known_csts
.release ();
3548 known_contexts
.release ();
3551 ipcp_orig_node
= NULL
;
3554 do_clone_for_all_contexts
= 0;
3555 is_all_contexts_clone
= 0;
3559 /* Free all ipa_node_params structures. */
3562 ipa_free_all_node_params (void)
3564 delete ipa_node_params_sum
;
3565 ipa_node_params_sum
= NULL
;
3568 /* Grow ipcp_transformations if necessary. */
3571 ipcp_grow_transformations_if_necessary (void)
3573 if (vec_safe_length (ipcp_transformations
)
3574 <= (unsigned) symtab
->cgraph_max_uid
)
3575 vec_safe_grow_cleared (ipcp_transformations
, symtab
->cgraph_max_uid
+ 1);
3578 /* Set the aggregate replacements of NODE to be AGGVALS. */
3581 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3582 struct ipa_agg_replacement_value
*aggvals
)
3584 ipcp_grow_transformations_if_necessary ();
3585 (*ipcp_transformations
)[node
->uid
].agg_values
= aggvals
;
3588 /* Hook that is called by cgraph.c when an edge is removed. */
3591 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3593 struct ipa_edge_args
*args
;
3595 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3596 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3599 args
= IPA_EDGE_REF (cs
);
3600 if (args
->jump_functions
)
3602 struct ipa_jump_func
*jf
;
3604 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3606 struct ipa_cst_ref_desc
*rdesc
;
3607 try_decrement_rdesc_refcount (jf
);
3608 if (jf
->type
== IPA_JF_CONST
3609 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3615 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3618 /* Hook that is called by cgraph.c when an edge is duplicated. */
3621 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3624 struct ipa_edge_args
*old_args
, *new_args
;
3627 ipa_check_create_edge_args ();
3629 old_args
= IPA_EDGE_REF (src
);
3630 new_args
= IPA_EDGE_REF (dst
);
3632 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3633 if (old_args
->polymorphic_call_contexts
)
3634 new_args
->polymorphic_call_contexts
3635 = vec_safe_copy (old_args
->polymorphic_call_contexts
);
3637 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3639 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3640 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3642 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3644 if (src_jf
->type
== IPA_JF_CONST
)
3646 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3649 dst_jf
->value
.constant
.rdesc
= NULL
;
3650 else if (src
->caller
== dst
->caller
)
3652 struct ipa_ref
*ref
;
3653 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3654 gcc_checking_assert (n
);
3655 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3657 gcc_checking_assert (ref
);
3658 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3660 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3661 dst_rdesc
->cs
= dst
;
3662 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3663 dst_rdesc
->next_duplicate
= NULL
;
3664 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3666 else if (src_rdesc
->cs
== src
)
3668 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3669 dst_rdesc
->cs
= dst
;
3670 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3671 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3672 src_rdesc
->next_duplicate
= dst_rdesc
;
3673 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3677 struct ipa_cst_ref_desc
*dst_rdesc
;
3678 /* This can happen during inlining, when a JFUNC can refer to a
3679 reference taken in a function up in the tree of inline clones.
3680 We need to find the duplicate that refers to our tree of
3683 gcc_assert (dst
->caller
->global
.inlined_to
);
3684 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3686 dst_rdesc
= dst_rdesc
->next_duplicate
)
3688 struct cgraph_node
*top
;
3689 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3690 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3691 : dst_rdesc
->cs
->caller
;
3692 if (dst
->caller
->global
.inlined_to
== top
)
3695 gcc_assert (dst_rdesc
);
3696 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3699 else if (dst_jf
->type
== IPA_JF_PASS_THROUGH
3700 && src
->caller
== dst
->caller
)
3702 struct cgraph_node
*inline_root
= dst
->caller
->global
.inlined_to
3703 ? dst
->caller
->global
.inlined_to
: dst
->caller
;
3704 struct ipa_node_params
*root_info
= IPA_NODE_REF (inline_root
);
3705 int idx
= ipa_get_jf_pass_through_formal_id (dst_jf
);
3707 int c
= ipa_get_controlled_uses (root_info
, idx
);
3708 if (c
!= IPA_UNDESCRIBED_USE
)
3711 ipa_set_controlled_uses (root_info
, idx
, c
);
3717 /* Analyze newly added function into callgraph. */
3720 ipa_add_new_function (cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3722 if (node
->has_gimple_body_p ())
3723 ipa_analyze_node (node
);
3726 /* Hook that is called by summary when a node is duplicated. */
3729 ipa_node_params_t::duplicate(cgraph_node
*src
, cgraph_node
*dst
,
3730 ipa_node_params
*old_info
,
3731 ipa_node_params
*new_info
)
3733 ipa_agg_replacement_value
*old_av
, *new_av
;
3735 new_info
->descriptors
= old_info
->descriptors
.copy ();
3736 new_info
->lattices
= NULL
;
3737 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3739 new_info
->analysis_done
= old_info
->analysis_done
;
3740 new_info
->node_enqueued
= old_info
->node_enqueued
;
3741 new_info
->versionable
= old_info
->versionable
;
3743 old_av
= ipa_get_agg_replacements_for_node (src
);
3749 struct ipa_agg_replacement_value
*v
;
3751 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3752 memcpy (v
, old_av
, sizeof (*v
));
3755 old_av
= old_av
->next
;
3757 ipa_set_node_agg_value_chain (dst
, new_av
);
3760 ipcp_transformation_summary
*src_trans
= ipcp_get_transformation_summary (src
);
3764 ipcp_grow_transformations_if_necessary ();
3765 src_trans
= ipcp_get_transformation_summary (src
);
3766 const vec
<ipa_vr
, va_gc
> *src_vr
= src_trans
->m_vr
;
3767 vec
<ipa_vr
, va_gc
> *&dst_vr
3768 = ipcp_get_transformation_summary (dst
)->m_vr
;
3769 if (vec_safe_length (src_trans
->m_vr
) > 0)
3771 vec_safe_reserve_exact (dst_vr
, src_vr
->length ());
3772 for (unsigned i
= 0; i
< src_vr
->length (); ++i
)
3773 dst_vr
->quick_push ((*src_vr
)[i
]);
3777 if (src_trans
&& vec_safe_length (src_trans
->bits
) > 0)
3779 ipcp_grow_transformations_if_necessary ();
3780 src_trans
= ipcp_get_transformation_summary (src
);
3781 const vec
<ipa_bits
, va_gc
> *src_bits
= src_trans
->bits
;
3782 vec
<ipa_bits
, va_gc
> *&dst_bits
3783 = ipcp_get_transformation_summary (dst
)->bits
;
3784 vec_safe_reserve_exact (dst_bits
, src_bits
->length ());
3785 for (unsigned i
= 0; i
< src_bits
->length (); ++i
)
3786 dst_bits
->quick_push ((*src_bits
)[i
]);
3790 /* Register our cgraph hooks if they are not already there. */
3793 ipa_register_cgraph_hooks (void)
3795 ipa_check_create_node_params ();
3797 if (!edge_removal_hook_holder
)
3798 edge_removal_hook_holder
=
3799 symtab
->add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3800 if (!edge_duplication_hook_holder
)
3801 edge_duplication_hook_holder
=
3802 symtab
->add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3803 function_insertion_hook_holder
=
3804 symtab
->add_cgraph_insertion_hook (&ipa_add_new_function
, NULL
);
3807 /* Unregister our cgraph hooks if they are not already there. */
3810 ipa_unregister_cgraph_hooks (void)
3812 symtab
->remove_edge_removal_hook (edge_removal_hook_holder
);
3813 edge_removal_hook_holder
= NULL
;
3814 symtab
->remove_edge_duplication_hook (edge_duplication_hook_holder
);
3815 edge_duplication_hook_holder
= NULL
;
3816 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
3817 function_insertion_hook_holder
= NULL
;
3820 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3821 longer needed after ipa-cp. */
3824 ipa_free_all_structures_after_ipa_cp (void)
3826 if (!optimize
&& !in_lto_p
)
3828 ipa_free_all_edge_args ();
3829 ipa_free_all_node_params ();
3830 ipcp_sources_pool
.release ();
3831 ipcp_cst_values_pool
.release ();
3832 ipcp_poly_ctx_values_pool
.release ();
3833 ipcp_agg_lattice_pool
.release ();
3834 ipa_unregister_cgraph_hooks ();
3835 ipa_refdesc_pool
.release ();
3839 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3840 longer needed after indirect inlining. */
3843 ipa_free_all_structures_after_iinln (void)
3845 ipa_free_all_edge_args ();
3846 ipa_free_all_node_params ();
3847 ipa_unregister_cgraph_hooks ();
3848 ipcp_sources_pool
.release ();
3849 ipcp_cst_values_pool
.release ();
3850 ipcp_poly_ctx_values_pool
.release ();
3851 ipcp_agg_lattice_pool
.release ();
3852 ipa_refdesc_pool
.release ();
3855 /* Print ipa_tree_map data structures of all functions in the
3859 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3862 struct ipa_node_params
*info
;
3864 if (!node
->definition
)
3866 info
= IPA_NODE_REF (node
);
3867 fprintf (f
, " function %s/%i parameter descriptors:\n",
3868 node
->name (), node
->order
);
3869 count
= ipa_get_param_count (info
);
3870 for (i
= 0; i
< count
; i
++)
3875 ipa_dump_param (f
, info
, i
);
3876 if (ipa_is_param_used (info
, i
))
3877 fprintf (f
, " used");
3878 c
= ipa_get_controlled_uses (info
, i
);
3879 if (c
== IPA_UNDESCRIBED_USE
)
3880 fprintf (f
, " undescribed_use");
3882 fprintf (f
, " controlled_uses=%i", c
);
3887 /* Print ipa_tree_map data structures of all functions in the
3891 ipa_print_all_params (FILE * f
)
3893 struct cgraph_node
*node
;
3895 fprintf (f
, "\nFunction parameters:\n");
3896 FOR_EACH_FUNCTION (node
)
3897 ipa_print_node_params (f
, node
);
3900 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3903 ipa_get_vector_of_formal_parms (tree fndecl
)
3909 gcc_assert (!flag_wpa
);
3910 count
= count_formal_params (fndecl
);
3911 args
.create (count
);
3912 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3913 args
.quick_push (parm
);
3918 /* Return a heap allocated vector containing types of formal parameters of
3919 function type FNTYPE. */
3922 ipa_get_vector_of_formal_parm_types (tree fntype
)
3928 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3931 types
.create (count
);
3932 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3933 types
.quick_push (TREE_VALUE (t
));
3938 /* Modify the function declaration FNDECL and its type according to the plan in
3939 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3940 to reflect the actual parameters being modified which are determined by the
3941 base_index field. */
3944 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
3946 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
3947 tree orig_type
= TREE_TYPE (fndecl
);
3948 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
3950 /* The following test is an ugly hack, some functions simply don't have any
3951 arguments in their type. This is probably a bug but well... */
3952 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
3953 bool last_parm_void
;
3957 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
3959 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
3961 gcc_assert (oparms
.length () + 1 == otypes
.length ());
3963 gcc_assert (oparms
.length () == otypes
.length ());
3967 last_parm_void
= false;
3971 int len
= adjustments
.length ();
3972 tree
*link
= &DECL_ARGUMENTS (fndecl
);
3973 tree new_arg_types
= NULL
;
3974 for (int i
= 0; i
< len
; i
++)
3976 struct ipa_parm_adjustment
*adj
;
3979 adj
= &adjustments
[i
];
3981 if (adj
->op
== IPA_PARM_OP_NEW
)
3984 parm
= oparms
[adj
->base_index
];
3987 if (adj
->op
== IPA_PARM_OP_COPY
)
3990 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
3993 link
= &DECL_CHAIN (parm
);
3995 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
4001 ptype
= build_pointer_type (adj
->type
);
4005 if (is_gimple_reg_type (ptype
))
4007 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
4008 if (TYPE_ALIGN (ptype
) != malign
)
4009 ptype
= build_aligned_type (ptype
, malign
);
4014 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
4016 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
4018 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
4019 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
4020 DECL_ARTIFICIAL (new_parm
) = 1;
4021 DECL_ARG_TYPE (new_parm
) = ptype
;
4022 DECL_CONTEXT (new_parm
) = fndecl
;
4023 TREE_USED (new_parm
) = 1;
4024 DECL_IGNORED_P (new_parm
) = 1;
4025 layout_decl (new_parm
, 0);
4027 if (adj
->op
== IPA_PARM_OP_NEW
)
4031 adj
->new_decl
= new_parm
;
4034 link
= &DECL_CHAIN (new_parm
);
4040 tree new_reversed
= NULL
;
4043 new_reversed
= nreverse (new_arg_types
);
4047 TREE_CHAIN (new_arg_types
) = void_list_node
;
4049 new_reversed
= void_list_node
;
4053 /* Use copy_node to preserve as much as possible from original type
4054 (debug info, attribute lists etc.)
4055 Exception is METHOD_TYPEs must have THIS argument.
4056 When we are asked to remove it, we need to build new FUNCTION_TYPE
4058 tree new_type
= NULL
;
4059 if (TREE_CODE (orig_type
) != METHOD_TYPE
4060 || (adjustments
[0].op
== IPA_PARM_OP_COPY
4061 && adjustments
[0].base_index
== 0))
4063 new_type
= build_distinct_type_copy (orig_type
);
4064 TYPE_ARG_TYPES (new_type
) = new_reversed
;
4069 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
4071 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
4072 DECL_VINDEX (fndecl
) = NULL_TREE
;
4075 /* When signature changes, we need to clear builtin info. */
4076 if (DECL_BUILT_IN (fndecl
))
4078 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
4079 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
4082 TREE_TYPE (fndecl
) = new_type
;
4083 DECL_VIRTUAL_P (fndecl
) = 0;
4084 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
4089 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
4090 If this is a directly recursive call, CS must be NULL. Otherwise it must
4091 contain the corresponding call graph edge. */
4094 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gcall
*stmt
,
4095 ipa_parm_adjustment_vec adjustments
)
4097 struct cgraph_node
*current_node
= cgraph_node::get (current_function_decl
);
4099 vec
<tree
, va_gc
> **debug_args
= NULL
;
4101 gimple_stmt_iterator gsi
, prev_gsi
;
4105 len
= adjustments
.length ();
4107 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
4108 current_node
->remove_stmt_references (stmt
);
4110 gsi
= gsi_for_stmt (stmt
);
4112 gsi_prev (&prev_gsi
);
4113 for (i
= 0; i
< len
; i
++)
4115 struct ipa_parm_adjustment
*adj
;
4117 adj
= &adjustments
[i
];
4119 if (adj
->op
== IPA_PARM_OP_COPY
)
4121 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
4123 vargs
.quick_push (arg
);
4125 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
4127 tree expr
, base
, off
;
4129 unsigned int deref_align
= 0;
4130 bool deref_base
= false;
4132 /* We create a new parameter out of the value of the old one, we can
4133 do the following kind of transformations:
4135 - A scalar passed by reference is converted to a scalar passed by
4136 value. (adj->by_ref is false and the type of the original
4137 actual argument is a pointer to a scalar).
4139 - A part of an aggregate is passed instead of the whole aggregate.
4140 The part can be passed either by value or by reference, this is
4141 determined by value of adj->by_ref. Moreover, the code below
4142 handles both situations when the original aggregate is passed by
4143 value (its type is not a pointer) and when it is passed by
4144 reference (it is a pointer to an aggregate).
4146 When the new argument is passed by reference (adj->by_ref is true)
4147 it must be a part of an aggregate and therefore we form it by
4148 simply taking the address of a reference inside the original
4151 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
4152 base
= gimple_call_arg (stmt
, adj
->base_index
);
4153 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
4154 : EXPR_LOCATION (base
);
4156 if (TREE_CODE (base
) != ADDR_EXPR
4157 && POINTER_TYPE_P (TREE_TYPE (base
)))
4158 off
= build_int_cst (adj
->alias_ptr_type
,
4159 adj
->offset
/ BITS_PER_UNIT
);
4162 HOST_WIDE_INT base_offset
;
4166 if (TREE_CODE (base
) == ADDR_EXPR
)
4168 base
= TREE_OPERAND (base
, 0);
4174 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
4175 /* Aggregate arguments can have non-invariant addresses. */
4178 base
= build_fold_addr_expr (prev_base
);
4179 off
= build_int_cst (adj
->alias_ptr_type
,
4180 adj
->offset
/ BITS_PER_UNIT
);
4182 else if (TREE_CODE (base
) == MEM_REF
)
4187 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
4189 off
= build_int_cst (adj
->alias_ptr_type
,
4191 + adj
->offset
/ BITS_PER_UNIT
);
4192 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
4194 base
= TREE_OPERAND (base
, 0);
4198 off
= build_int_cst (adj
->alias_ptr_type
,
4200 + adj
->offset
/ BITS_PER_UNIT
);
4201 base
= build_fold_addr_expr (base
);
4207 tree type
= adj
->type
;
4209 unsigned HOST_WIDE_INT misalign
;
4213 align
= deref_align
;
4218 get_pointer_alignment_1 (base
, &align
, &misalign
);
4219 if (TYPE_ALIGN (type
) > align
)
4220 align
= TYPE_ALIGN (type
);
4222 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
4224 misalign
= misalign
& (align
- 1);
4226 align
= least_bit_hwi (misalign
);
4227 if (align
< TYPE_ALIGN (type
))
4228 type
= build_aligned_type (type
, align
);
4229 base
= force_gimple_operand_gsi (&gsi
, base
,
4230 true, NULL
, true, GSI_SAME_STMT
);
4231 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
4232 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4233 /* If expr is not a valid gimple call argument emit
4234 a load into a temporary. */
4235 if (is_gimple_reg_type (TREE_TYPE (expr
)))
4237 gimple
*tem
= gimple_build_assign (NULL_TREE
, expr
);
4238 if (gimple_in_ssa_p (cfun
))
4240 gimple_set_vuse (tem
, gimple_vuse (stmt
));
4241 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
4244 expr
= create_tmp_reg (TREE_TYPE (expr
));
4245 gimple_assign_set_lhs (tem
, expr
);
4246 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
4251 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
4252 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4253 expr
= build_fold_addr_expr (expr
);
4254 expr
= force_gimple_operand_gsi (&gsi
, expr
,
4255 true, NULL
, true, GSI_SAME_STMT
);
4257 vargs
.quick_push (expr
);
4259 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
4262 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
4265 arg
= gimple_call_arg (stmt
, adj
->base_index
);
4266 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
4268 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
4270 arg
= fold_convert_loc (gimple_location (stmt
),
4271 TREE_TYPE (origin
), arg
);
4273 if (debug_args
== NULL
)
4274 debug_args
= decl_debug_args_insert (callee_decl
);
4275 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
4276 if (ddecl
== origin
)
4278 ddecl
= (**debug_args
)[ix
+ 1];
4283 ddecl
= make_node (DEBUG_EXPR_DECL
);
4284 DECL_ARTIFICIAL (ddecl
) = 1;
4285 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
4286 DECL_MODE (ddecl
) = DECL_MODE (origin
);
4288 vec_safe_push (*debug_args
, origin
);
4289 vec_safe_push (*debug_args
, ddecl
);
4291 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
4292 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
4296 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4298 fprintf (dump_file
, "replacing stmt:");
4299 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
4302 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
4304 if (gimple_call_lhs (stmt
))
4305 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
4307 gimple_set_block (new_stmt
, gimple_block (stmt
));
4308 if (gimple_has_location (stmt
))
4309 gimple_set_location (new_stmt
, gimple_location (stmt
));
4310 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
4311 gimple_call_copy_flags (new_stmt
, stmt
);
4312 if (gimple_in_ssa_p (cfun
))
4314 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4315 if (gimple_vdef (stmt
))
4317 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4318 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
4322 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4324 fprintf (dump_file
, "with stmt:");
4325 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
4326 fprintf (dump_file
, "\n");
4328 gsi_replace (&gsi
, new_stmt
, true);
4330 cs
->set_call_stmt (new_stmt
);
4333 current_node
->record_stmt_references (gsi_stmt (gsi
));
4336 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
4339 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
4340 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
4341 specifies whether the function should care about type incompatibility the
4342 current and new expressions. If it is false, the function will leave
4343 incompatibility issues to the caller. Return true iff the expression
4347 ipa_modify_expr (tree
*expr
, bool convert
,
4348 ipa_parm_adjustment_vec adjustments
)
4350 struct ipa_parm_adjustment
*cand
4351 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
4358 src
= build_simple_mem_ref (cand
->new_decl
);
4359 REF_REVERSE_STORAGE_ORDER (src
) = cand
->reverse
;
4362 src
= cand
->new_decl
;
4364 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4366 fprintf (dump_file
, "About to replace expr ");
4367 print_generic_expr (dump_file
, *expr
, 0);
4368 fprintf (dump_file
, " with ");
4369 print_generic_expr (dump_file
, src
, 0);
4370 fprintf (dump_file
, "\n");
4373 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
4375 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
4383 /* If T is an SSA_NAME, return NULL if it is not a default def or
4384 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
4385 the base variable is always returned, regardless if it is a default
4386 def. Return T if it is not an SSA_NAME. */
4389 get_ssa_base_param (tree t
, bool ignore_default_def
)
4391 if (TREE_CODE (t
) == SSA_NAME
)
4393 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
4394 return SSA_NAME_VAR (t
);
4401 /* Given an expression, return an adjustment entry specifying the
4402 transformation to be done on EXPR. If no suitable adjustment entry
4403 was found, returns NULL.
4405 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
4406 default def, otherwise bail on them.
4408 If CONVERT is non-NULL, this function will set *CONVERT if the
4409 expression provided is a component reference. ADJUSTMENTS is the
4410 adjustments vector. */
4412 ipa_parm_adjustment
*
4413 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
4414 ipa_parm_adjustment_vec adjustments
,
4415 bool ignore_default_def
)
4417 if (TREE_CODE (**expr
) == BIT_FIELD_REF
4418 || TREE_CODE (**expr
) == IMAGPART_EXPR
4419 || TREE_CODE (**expr
) == REALPART_EXPR
)
4421 *expr
= &TREE_OPERAND (**expr
, 0);
4426 HOST_WIDE_INT offset
, size
, max_size
;
4429 = get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
, &reverse
);
4430 if (!base
|| size
== -1 || max_size
== -1)
4433 if (TREE_CODE (base
) == MEM_REF
)
4435 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
4436 base
= TREE_OPERAND (base
, 0);
4439 base
= get_ssa_base_param (base
, ignore_default_def
);
4440 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4443 struct ipa_parm_adjustment
*cand
= NULL
;
4444 unsigned int len
= adjustments
.length ();
4445 for (unsigned i
= 0; i
< len
; i
++)
4447 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4449 if (adj
->base
== base
4450 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4457 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4462 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4465 index_in_adjustments_multiple_times_p (int base_index
,
4466 ipa_parm_adjustment_vec adjustments
)
4468 int i
, len
= adjustments
.length ();
4471 for (i
= 0; i
< len
; i
++)
4473 struct ipa_parm_adjustment
*adj
;
4474 adj
= &adjustments
[i
];
4476 if (adj
->base_index
== base_index
)
4488 /* Return adjustments that should have the same effect on function parameters
4489 and call arguments as if they were first changed according to adjustments in
4490 INNER and then by adjustments in OUTER. */
4492 ipa_parm_adjustment_vec
4493 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4494 ipa_parm_adjustment_vec outer
)
4496 int i
, outlen
= outer
.length ();
4497 int inlen
= inner
.length ();
4499 ipa_parm_adjustment_vec adjustments
, tmp
;
4502 for (i
= 0; i
< inlen
; i
++)
4504 struct ipa_parm_adjustment
*n
;
4507 if (n
->op
== IPA_PARM_OP_REMOVE
)
4511 /* FIXME: Handling of new arguments are not implemented yet. */
4512 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4513 tmp
.quick_push (*n
);
4517 adjustments
.create (outlen
+ removals
);
4518 for (i
= 0; i
< outlen
; i
++)
4520 struct ipa_parm_adjustment r
;
4521 struct ipa_parm_adjustment
*out
= &outer
[i
];
4522 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4524 memset (&r
, 0, sizeof (r
));
4525 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4526 if (out
->op
== IPA_PARM_OP_REMOVE
)
4528 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4530 r
.op
= IPA_PARM_OP_REMOVE
;
4531 adjustments
.quick_push (r
);
4537 /* FIXME: Handling of new arguments are not implemented yet. */
4538 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4541 r
.base_index
= in
->base_index
;
4544 /* FIXME: Create nonlocal value too. */
4546 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4547 r
.op
= IPA_PARM_OP_COPY
;
4548 else if (in
->op
== IPA_PARM_OP_COPY
)
4549 r
.offset
= out
->offset
;
4550 else if (out
->op
== IPA_PARM_OP_COPY
)
4551 r
.offset
= in
->offset
;
4553 r
.offset
= in
->offset
+ out
->offset
;
4554 adjustments
.quick_push (r
);
4557 for (i
= 0; i
< inlen
; i
++)
4559 struct ipa_parm_adjustment
*n
= &inner
[i
];
4561 if (n
->op
== IPA_PARM_OP_REMOVE
)
4562 adjustments
.quick_push (*n
);
4569 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4570 friendly way, assuming they are meant to be applied to FNDECL. */
4573 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4576 int i
, len
= adjustments
.length ();
4578 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4580 fprintf (file
, "IPA param adjustments: ");
4581 for (i
= 0; i
< len
; i
++)
4583 struct ipa_parm_adjustment
*adj
;
4584 adj
= &adjustments
[i
];
4587 fprintf (file
, " ");
4591 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4592 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4595 fprintf (file
, ", base: ");
4596 print_generic_expr (file
, adj
->base
, 0);
4600 fprintf (file
, ", new_decl: ");
4601 print_generic_expr (file
, adj
->new_decl
, 0);
4603 if (adj
->new_ssa_base
)
4605 fprintf (file
, ", new_ssa_base: ");
4606 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4609 if (adj
->op
== IPA_PARM_OP_COPY
)
4610 fprintf (file
, ", copy_param");
4611 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4612 fprintf (file
, ", remove_param");
4614 fprintf (file
, ", offset %li", (long) adj
->offset
);
4616 fprintf (file
, ", by_ref");
4617 print_node_brief (file
, ", type: ", adj
->type
, 0);
4618 fprintf (file
, "\n");
4623 /* Dump the AV linked list. */
4626 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4629 fprintf (f
, " Aggregate replacements:");
4630 for (; av
; av
= av
->next
)
4632 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4633 av
->index
, av
->offset
);
4634 print_generic_expr (f
, av
->value
, 0);
4640 /* Stream out jump function JUMP_FUNC to OB. */
4643 ipa_write_jump_function (struct output_block
*ob
,
4644 struct ipa_jump_func
*jump_func
)
4646 struct ipa_agg_jf_item
*item
;
4647 struct bitpack_d bp
;
4650 streamer_write_uhwi (ob
, jump_func
->type
);
4651 switch (jump_func
->type
)
4653 case IPA_JF_UNKNOWN
:
4657 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4658 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4660 case IPA_JF_PASS_THROUGH
:
4661 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4662 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4664 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4665 bp
= bitpack_create (ob
->main_stream
);
4666 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4667 streamer_write_bitpack (&bp
);
4671 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4672 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4675 case IPA_JF_ANCESTOR
:
4676 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4677 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4678 bp
= bitpack_create (ob
->main_stream
);
4679 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4680 streamer_write_bitpack (&bp
);
4684 count
= vec_safe_length (jump_func
->agg
.items
);
4685 streamer_write_uhwi (ob
, count
);
4688 bp
= bitpack_create (ob
->main_stream
);
4689 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4690 streamer_write_bitpack (&bp
);
4693 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4695 streamer_write_uhwi (ob
, item
->offset
);
4696 stream_write_tree (ob
, item
->value
, true);
4699 bp
= bitpack_create (ob
->main_stream
);
4700 bp_pack_value (&bp
, jump_func
->bits
.known
, 1);
4701 streamer_write_bitpack (&bp
);
4702 if (jump_func
->bits
.known
)
4704 streamer_write_widest_int (ob
, jump_func
->bits
.value
);
4705 streamer_write_widest_int (ob
, jump_func
->bits
.mask
);
4707 bp_pack_value (&bp
, jump_func
->vr_known
, 1);
4708 streamer_write_bitpack (&bp
);
4709 if (jump_func
->vr_known
)
4711 streamer_write_enum (ob
->main_stream
, value_rang_type
,
4712 VR_LAST
, jump_func
->m_vr
.type
);
4713 stream_write_tree (ob
, jump_func
->m_vr
.min
, true);
4714 stream_write_tree (ob
, jump_func
->m_vr
.max
, true);
4718 /* Read in jump function JUMP_FUNC from IB. */
4721 ipa_read_jump_function (struct lto_input_block
*ib
,
4722 struct ipa_jump_func
*jump_func
,
4723 struct cgraph_edge
*cs
,
4724 struct data_in
*data_in
)
4726 enum jump_func_type jftype
;
4727 enum tree_code operation
;
4730 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4733 case IPA_JF_UNKNOWN
:
4734 ipa_set_jf_unknown (jump_func
);
4737 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4739 case IPA_JF_PASS_THROUGH
:
4740 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4741 if (operation
== NOP_EXPR
)
4743 int formal_id
= streamer_read_uhwi (ib
);
4744 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4745 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4746 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
);
4750 tree operand
= stream_read_tree (ib
, data_in
);
4751 int formal_id
= streamer_read_uhwi (ib
);
4752 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4756 case IPA_JF_ANCESTOR
:
4758 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4759 int formal_id
= streamer_read_uhwi (ib
);
4760 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4761 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4762 ipa_set_ancestor_jf (jump_func
, offset
, formal_id
, agg_preserved
);
4767 count
= streamer_read_uhwi (ib
);
4768 vec_alloc (jump_func
->agg
.items
, count
);
4771 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4772 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4774 for (i
= 0; i
< count
; i
++)
4776 struct ipa_agg_jf_item item
;
4777 item
.offset
= streamer_read_uhwi (ib
);
4778 item
.value
= stream_read_tree (ib
, data_in
);
4779 jump_func
->agg
.items
->quick_push (item
);
4782 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4783 bool bits_known
= bp_unpack_value (&bp
, 1);
4786 jump_func
->bits
.known
= true;
4787 jump_func
->bits
.value
= streamer_read_widest_int (ib
);
4788 jump_func
->bits
.mask
= streamer_read_widest_int (ib
);
4791 jump_func
->bits
.known
= false;
4793 struct bitpack_d vr_bp
= streamer_read_bitpack (ib
);
4794 bool vr_known
= bp_unpack_value (&vr_bp
, 1);
4797 jump_func
->vr_known
= true;
4798 jump_func
->m_vr
.type
= streamer_read_enum (ib
,
4801 jump_func
->m_vr
.min
= stream_read_tree (ib
, data_in
);
4802 jump_func
->m_vr
.max
= stream_read_tree (ib
, data_in
);
4805 jump_func
->vr_known
= false;
4808 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4809 relevant to indirect inlining to OB. */
4812 ipa_write_indirect_edge_info (struct output_block
*ob
,
4813 struct cgraph_edge
*cs
)
4815 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4816 struct bitpack_d bp
;
4818 streamer_write_hwi (ob
, ii
->param_index
);
4819 bp
= bitpack_create (ob
->main_stream
);
4820 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4821 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4822 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4823 bp_pack_value (&bp
, ii
->by_ref
, 1);
4824 bp_pack_value (&bp
, ii
->guaranteed_unmodified
, 1);
4825 bp_pack_value (&bp
, ii
->vptr_changed
, 1);
4826 streamer_write_bitpack (&bp
);
4827 if (ii
->agg_contents
|| ii
->polymorphic
)
4828 streamer_write_hwi (ob
, ii
->offset
);
4830 gcc_assert (ii
->offset
== 0);
4832 if (ii
->polymorphic
)
4834 streamer_write_hwi (ob
, ii
->otr_token
);
4835 stream_write_tree (ob
, ii
->otr_type
, true);
4836 ii
->context
.stream_out (ob
);
4840 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4841 relevant to indirect inlining from IB. */
4844 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4845 struct data_in
*data_in
,
4846 struct cgraph_edge
*cs
)
4848 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4849 struct bitpack_d bp
;
4851 ii
->param_index
= (int) streamer_read_hwi (ib
);
4852 bp
= streamer_read_bitpack (ib
);
4853 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4854 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4855 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4856 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4857 ii
->guaranteed_unmodified
= bp_unpack_value (&bp
, 1);
4858 ii
->vptr_changed
= bp_unpack_value (&bp
, 1);
4859 if (ii
->agg_contents
|| ii
->polymorphic
)
4860 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4863 if (ii
->polymorphic
)
4865 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4866 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4867 ii
->context
.stream_in (ib
, data_in
);
4871 /* Stream out NODE info to OB. */
4874 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4877 lto_symtab_encoder_t encoder
;
4878 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4880 struct cgraph_edge
*e
;
4881 struct bitpack_d bp
;
4883 encoder
= ob
->decl_state
->symtab_node_encoder
;
4884 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4885 streamer_write_uhwi (ob
, node_ref
);
4887 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4888 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4889 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4890 bp
= bitpack_create (ob
->main_stream
);
4891 gcc_assert (info
->analysis_done
4892 || ipa_get_param_count (info
) == 0);
4893 gcc_assert (!info
->node_enqueued
);
4894 gcc_assert (!info
->ipcp_orig_node
);
4895 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4896 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4897 streamer_write_bitpack (&bp
);
4898 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4899 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4900 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4902 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4904 streamer_write_uhwi (ob
,
4905 ipa_get_cs_argument_count (args
) * 2
4906 + (args
->polymorphic_call_contexts
!= NULL
));
4907 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4909 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4910 if (args
->polymorphic_call_contexts
!= NULL
)
4911 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4914 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4916 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4918 streamer_write_uhwi (ob
,
4919 ipa_get_cs_argument_count (args
) * 2
4920 + (args
->polymorphic_call_contexts
!= NULL
));
4921 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4923 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4924 if (args
->polymorphic_call_contexts
!= NULL
)
4925 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4927 ipa_write_indirect_edge_info (ob
, e
);
4931 /* Stream in NODE info from IB. */
4934 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4935 struct data_in
*data_in
)
4937 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4939 struct cgraph_edge
*e
;
4940 struct bitpack_d bp
;
4942 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
4944 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4945 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
4947 bp
= streamer_read_bitpack (ib
);
4948 if (ipa_get_param_count (info
) != 0)
4949 info
->analysis_done
= true;
4950 info
->node_enqueued
= false;
4951 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4952 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
4953 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4954 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
4955 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4957 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4958 int count
= streamer_read_uhwi (ib
);
4959 bool contexts_computed
= count
& 1;
4964 vec_safe_grow_cleared (args
->jump_functions
, count
);
4965 if (contexts_computed
)
4966 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4968 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4970 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4972 if (contexts_computed
)
4973 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
4976 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4978 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4979 int count
= streamer_read_uhwi (ib
);
4980 bool contexts_computed
= count
& 1;
4985 vec_safe_grow_cleared (args
->jump_functions
, count
);
4986 if (contexts_computed
)
4987 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4988 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4990 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4992 if (contexts_computed
)
4993 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
4996 ipa_read_indirect_edge_info (ib
, data_in
, e
);
5000 /* Write jump functions for nodes in SET. */
5003 ipa_prop_write_jump_functions (void)
5005 struct cgraph_node
*node
;
5006 struct output_block
*ob
;
5007 unsigned int count
= 0;
5008 lto_symtab_encoder_iterator lsei
;
5009 lto_symtab_encoder_t encoder
;
5011 if (!ipa_node_params_sum
)
5014 ob
= create_output_block (LTO_section_jump_functions
);
5015 encoder
= ob
->decl_state
->symtab_node_encoder
;
5017 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5018 lsei_next_function_in_partition (&lsei
))
5020 node
= lsei_cgraph_node (lsei
);
5021 if (node
->has_gimple_body_p ()
5022 && IPA_NODE_REF (node
) != NULL
)
5026 streamer_write_uhwi (ob
, count
);
5028 /* Process all of the functions. */
5029 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5030 lsei_next_function_in_partition (&lsei
))
5032 node
= lsei_cgraph_node (lsei
);
5033 if (node
->has_gimple_body_p ()
5034 && IPA_NODE_REF (node
) != NULL
)
5035 ipa_write_node_info (ob
, node
);
5037 streamer_write_char_stream (ob
->main_stream
, 0);
5038 produce_asm (ob
, NULL
);
5039 destroy_output_block (ob
);
5042 /* Read section in file FILE_DATA of length LEN with data DATA. */
5045 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
5048 const struct lto_function_header
*header
=
5049 (const struct lto_function_header
*) data
;
5050 const int cfg_offset
= sizeof (struct lto_function_header
);
5051 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5052 const int string_offset
= main_offset
+ header
->main_size
;
5053 struct data_in
*data_in
;
5057 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5058 header
->main_size
, file_data
->mode_table
);
5061 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5062 header
->string_size
, vNULL
);
5063 count
= streamer_read_uhwi (&ib_main
);
5065 for (i
= 0; i
< count
; i
++)
5068 struct cgraph_node
*node
;
5069 lto_symtab_encoder_t encoder
;
5071 index
= streamer_read_uhwi (&ib_main
);
5072 encoder
= file_data
->symtab_node_encoder
;
5073 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5075 gcc_assert (node
->definition
);
5076 ipa_read_node_info (&ib_main
, node
, data_in
);
5078 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5080 lto_data_in_delete (data_in
);
5083 /* Read ipcp jump functions. */
5086 ipa_prop_read_jump_functions (void)
5088 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5089 struct lto_file_decl_data
*file_data
;
5092 ipa_check_create_node_params ();
5093 ipa_check_create_edge_args ();
5094 ipa_register_cgraph_hooks ();
5096 while ((file_data
= file_data_vec
[j
++]))
5099 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
5102 ipa_prop_read_section (file_data
, data
, len
);
5106 /* After merging units, we can get mismatch in argument counts.
5107 Also decl merging might've rendered parameter lists obsolete.
5108 Also compute called_with_variable_arg info. */
5111 ipa_update_after_lto_read (void)
5113 ipa_check_create_node_params ();
5114 ipa_check_create_edge_args ();
5118 write_ipcp_transformation_info (output_block
*ob
, cgraph_node
*node
)
5121 unsigned int count
= 0;
5122 lto_symtab_encoder_t encoder
;
5123 struct ipa_agg_replacement_value
*aggvals
, *av
;
5125 aggvals
= ipa_get_agg_replacements_for_node (node
);
5126 encoder
= ob
->decl_state
->symtab_node_encoder
;
5127 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
5128 streamer_write_uhwi (ob
, node_ref
);
5130 for (av
= aggvals
; av
; av
= av
->next
)
5132 streamer_write_uhwi (ob
, count
);
5134 for (av
= aggvals
; av
; av
= av
->next
)
5136 struct bitpack_d bp
;
5138 streamer_write_uhwi (ob
, av
->offset
);
5139 streamer_write_uhwi (ob
, av
->index
);
5140 stream_write_tree (ob
, av
->value
, true);
5142 bp
= bitpack_create (ob
->main_stream
);
5143 bp_pack_value (&bp
, av
->by_ref
, 1);
5144 streamer_write_bitpack (&bp
);
5147 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5148 if (ts
&& vec_safe_length (ts
->m_vr
) > 0)
5150 count
= ts
->m_vr
->length ();
5151 streamer_write_uhwi (ob
, count
);
5152 for (unsigned i
= 0; i
< count
; ++i
)
5154 struct bitpack_d bp
;
5155 ipa_vr
*parm_vr
= &(*ts
->m_vr
)[i
];
5156 bp
= bitpack_create (ob
->main_stream
);
5157 bp_pack_value (&bp
, parm_vr
->known
, 1);
5158 streamer_write_bitpack (&bp
);
5161 streamer_write_enum (ob
->main_stream
, value_rang_type
,
5162 VR_LAST
, parm_vr
->type
);
5163 streamer_write_wide_int (ob
, parm_vr
->min
);
5164 streamer_write_wide_int (ob
, parm_vr
->max
);
5169 streamer_write_uhwi (ob
, 0);
5171 if (ts
&& vec_safe_length (ts
->bits
) > 0)
5173 count
= ts
->bits
->length ();
5174 streamer_write_uhwi (ob
, count
);
5176 for (unsigned i
= 0; i
< count
; ++i
)
5178 const ipa_bits
& bits_jfunc
= (*ts
->bits
)[i
];
5179 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
5180 bp_pack_value (&bp
, bits_jfunc
.known
, 1);
5181 streamer_write_bitpack (&bp
);
5182 if (bits_jfunc
.known
)
5184 streamer_write_widest_int (ob
, bits_jfunc
.value
);
5185 streamer_write_widest_int (ob
, bits_jfunc
.mask
);
5190 streamer_write_uhwi (ob
, 0);
5193 /* Stream in the aggregate value replacement chain for NODE from IB. */
5196 read_ipcp_transformation_info (lto_input_block
*ib
, cgraph_node
*node
,
5199 struct ipa_agg_replacement_value
*aggvals
= NULL
;
5200 unsigned int count
, i
;
5202 count
= streamer_read_uhwi (ib
);
5203 for (i
= 0; i
<count
; i
++)
5205 struct ipa_agg_replacement_value
*av
;
5206 struct bitpack_d bp
;
5208 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
5209 av
->offset
= streamer_read_uhwi (ib
);
5210 av
->index
= streamer_read_uhwi (ib
);
5211 av
->value
= stream_read_tree (ib
, data_in
);
5212 bp
= streamer_read_bitpack (ib
);
5213 av
->by_ref
= bp_unpack_value (&bp
, 1);
5217 ipa_set_node_agg_value_chain (node
, aggvals
);
5219 count
= streamer_read_uhwi (ib
);
5222 ipcp_grow_transformations_if_necessary ();
5224 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5225 vec_safe_grow_cleared (ts
->m_vr
, count
);
5226 for (i
= 0; i
< count
; i
++)
5229 parm_vr
= &(*ts
->m_vr
)[i
];
5230 struct bitpack_d bp
;
5231 bp
= streamer_read_bitpack (ib
);
5232 parm_vr
->known
= bp_unpack_value (&bp
, 1);
5235 parm_vr
->type
= streamer_read_enum (ib
, value_range_type
,
5237 parm_vr
->min
= streamer_read_wide_int (ib
);
5238 parm_vr
->max
= streamer_read_wide_int (ib
);
5242 count
= streamer_read_uhwi (ib
);
5245 ipcp_grow_transformations_if_necessary ();
5247 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5248 vec_safe_grow_cleared (ts
->bits
, count
);
5250 for (i
= 0; i
< count
; i
++)
5252 ipa_bits
& bits_jfunc
= (*ts
->bits
)[i
];
5253 struct bitpack_d bp
= streamer_read_bitpack (ib
);
5254 bits_jfunc
.known
= bp_unpack_value (&bp
, 1);
5255 if (bits_jfunc
.known
)
5257 bits_jfunc
.value
= streamer_read_widest_int (ib
);
5258 bits_jfunc
.mask
= streamer_read_widest_int (ib
);
5264 /* Write all aggregate replacement for nodes in set. */
5267 ipcp_write_transformation_summaries (void)
5269 struct cgraph_node
*node
;
5270 struct output_block
*ob
;
5271 unsigned int count
= 0;
5272 lto_symtab_encoder_iterator lsei
;
5273 lto_symtab_encoder_t encoder
;
5275 ob
= create_output_block (LTO_section_ipcp_transform
);
5276 encoder
= ob
->decl_state
->symtab_node_encoder
;
5278 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5279 lsei_next_function_in_partition (&lsei
))
5281 node
= lsei_cgraph_node (lsei
);
5282 if (node
->has_gimple_body_p ())
5286 streamer_write_uhwi (ob
, count
);
5288 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5289 lsei_next_function_in_partition (&lsei
))
5291 node
= lsei_cgraph_node (lsei
);
5292 if (node
->has_gimple_body_p ())
5293 write_ipcp_transformation_info (ob
, node
);
5295 streamer_write_char_stream (ob
->main_stream
, 0);
5296 produce_asm (ob
, NULL
);
5297 destroy_output_block (ob
);
5300 /* Read replacements section in file FILE_DATA of length LEN with data
5304 read_replacements_section (struct lto_file_decl_data
*file_data
,
5308 const struct lto_function_header
*header
=
5309 (const struct lto_function_header
*) data
;
5310 const int cfg_offset
= sizeof (struct lto_function_header
);
5311 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5312 const int string_offset
= main_offset
+ header
->main_size
;
5313 struct data_in
*data_in
;
5317 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5318 header
->main_size
, file_data
->mode_table
);
5320 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5321 header
->string_size
, vNULL
);
5322 count
= streamer_read_uhwi (&ib_main
);
5324 for (i
= 0; i
< count
; i
++)
5327 struct cgraph_node
*node
;
5328 lto_symtab_encoder_t encoder
;
5330 index
= streamer_read_uhwi (&ib_main
);
5331 encoder
= file_data
->symtab_node_encoder
;
5332 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5334 gcc_assert (node
->definition
);
5335 read_ipcp_transformation_info (&ib_main
, node
, data_in
);
5337 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5339 lto_data_in_delete (data_in
);
5342 /* Read IPA-CP aggregate replacements. */
5345 ipcp_read_transformation_summaries (void)
5347 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5348 struct lto_file_decl_data
*file_data
;
5351 while ((file_data
= file_data_vec
[j
++]))
5354 const char *data
= lto_get_section_data (file_data
,
5355 LTO_section_ipcp_transform
,
5358 read_replacements_section (file_data
, data
, len
);
5362 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5366 adjust_agg_replacement_values (struct cgraph_node
*node
,
5367 struct ipa_agg_replacement_value
*aggval
)
5369 struct ipa_agg_replacement_value
*v
;
5370 int i
, c
= 0, d
= 0, *adj
;
5372 if (!node
->clone
.combined_args_to_skip
)
5375 for (v
= aggval
; v
; v
= v
->next
)
5377 gcc_assert (v
->index
>= 0);
5383 adj
= XALLOCAVEC (int, c
);
5384 for (i
= 0; i
< c
; i
++)
5385 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5393 for (v
= aggval
; v
; v
= v
->next
)
5394 v
->index
= adj
[v
->index
];
5397 /* Dominator walker driving the ipcp modification phase. */
5399 class ipcp_modif_dom_walker
: public dom_walker
5402 ipcp_modif_dom_walker (struct ipa_func_body_info
*fbi
,
5403 vec
<ipa_param_descriptor
> descs
,
5404 struct ipa_agg_replacement_value
*av
,
5406 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5407 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5409 virtual edge
before_dom_children (basic_block
);
5412 struct ipa_func_body_info
*m_fbi
;
5413 vec
<ipa_param_descriptor
> m_descriptors
;
5414 struct ipa_agg_replacement_value
*m_aggval
;
5415 bool *m_something_changed
, *m_cfg_changed
;
5419 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5421 gimple_stmt_iterator gsi
;
5422 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5424 struct ipa_agg_replacement_value
*v
;
5425 gimple
*stmt
= gsi_stmt (gsi
);
5427 HOST_WIDE_INT offset
, size
;
5431 if (!gimple_assign_load_p (stmt
))
5433 rhs
= gimple_assign_rhs1 (stmt
);
5434 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5439 while (handled_component_p (t
))
5441 /* V_C_E can do things like convert an array of integers to one
5442 bigger integer and similar things we do not handle below. */
5443 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
5448 t
= TREE_OPERAND (t
, 0);
5453 if (!ipa_load_from_parm_agg (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5454 &offset
, &size
, &by_ref
))
5456 for (v
= m_aggval
; v
; v
= v
->next
)
5457 if (v
->index
== index
5458 && v
->offset
== offset
)
5461 || v
->by_ref
!= by_ref
5462 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
5465 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5466 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5468 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5469 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5470 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5471 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5472 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5477 fprintf (dump_file
, " const ");
5478 print_generic_expr (dump_file
, v
->value
, 0);
5479 fprintf (dump_file
, " can't be converted to type of ");
5480 print_generic_expr (dump_file
, rhs
, 0);
5481 fprintf (dump_file
, "\n");
5489 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5491 fprintf (dump_file
, "Modifying stmt:\n ");
5492 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5494 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5497 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5499 fprintf (dump_file
, "into:\n ");
5500 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5501 fprintf (dump_file
, "\n");
5504 *m_something_changed
= true;
5505 if (maybe_clean_eh_stmt (stmt
)
5506 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5507 *m_cfg_changed
= true;
5512 /* Update bits info of formal parameters as described in
5513 ipcp_transformation_summary. */
5516 ipcp_update_bits (struct cgraph_node
*node
)
5518 tree parm
= DECL_ARGUMENTS (node
->decl
);
5519 tree next_parm
= parm
;
5520 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5522 if (!ts
|| vec_safe_length (ts
->bits
) == 0)
5525 vec
<ipa_bits
, va_gc
> &bits
= *ts
->bits
;
5526 unsigned count
= bits
.length ();
5528 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5530 if (node
->clone
.combined_args_to_skip
5531 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5534 gcc_checking_assert (parm
);
5535 next_parm
= DECL_CHAIN (parm
);
5538 || !(INTEGRAL_TYPE_P (TREE_TYPE (parm
)) || POINTER_TYPE_P (TREE_TYPE (parm
)))
5539 || !is_gimple_reg (parm
))
5542 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5548 fprintf (dump_file
, "Adjusting mask for param %u to ", i
);
5549 print_hex (bits
[i
].mask
, dump_file
);
5550 fprintf (dump_file
, "\n");
5553 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5555 unsigned prec
= TYPE_PRECISION (TREE_TYPE (ddef
));
5556 signop sgn
= TYPE_SIGN (TREE_TYPE (ddef
));
5558 wide_int nonzero_bits
= wide_int::from (bits
[i
].mask
, prec
, UNSIGNED
)
5559 | wide_int::from (bits
[i
].value
, prec
, sgn
);
5560 set_nonzero_bits (ddef
, nonzero_bits
);
5564 unsigned tem
= bits
[i
].mask
.to_uhwi ();
5565 unsigned HOST_WIDE_INT bitpos
= bits
[i
].value
.to_uhwi ();
5566 unsigned align
= tem
& -tem
;
5567 unsigned misalign
= bitpos
& (align
- 1);
5572 fprintf (dump_file
, "Adjusting align: %u, misalign: %u\n", align
, misalign
);
5574 unsigned old_align
, old_misalign
;
5575 struct ptr_info_def
*pi
= get_ptr_info (ddef
);
5576 bool old_known
= get_ptr_info_alignment (pi
, &old_align
, &old_misalign
);
5579 && old_align
> align
)
5583 fprintf (dump_file
, "But alignment was already %u.\n", old_align
);
5584 if ((old_misalign
& (align
- 1)) != misalign
)
5585 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5586 old_misalign
, misalign
);
5592 && ((misalign
& (old_align
- 1)) != old_misalign
)
5594 fprintf (dump_file
, "old_misalign (%u) and misalign (%u) mismatch\n",
5595 old_misalign
, misalign
);
5597 set_ptr_info_alignment (pi
, align
, misalign
);
5603 /* Update value range of formal parameters as described in
5604 ipcp_transformation_summary. */
5607 ipcp_update_vr (struct cgraph_node
*node
)
5609 tree fndecl
= node
->decl
;
5610 tree parm
= DECL_ARGUMENTS (fndecl
);
5611 tree next_parm
= parm
;
5612 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5613 if (!ts
|| vec_safe_length (ts
->m_vr
) == 0)
5615 const vec
<ipa_vr
, va_gc
> &vr
= *ts
->m_vr
;
5616 unsigned count
= vr
.length ();
5618 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5620 if (node
->clone
.combined_args_to_skip
5621 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5623 gcc_checking_assert (parm
);
5624 next_parm
= DECL_CHAIN (parm
);
5625 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5627 if (!ddef
|| !is_gimple_reg (parm
))
5631 && (vr
[i
].type
== VR_RANGE
|| vr
[i
].type
== VR_ANTI_RANGE
))
5633 tree type
= TREE_TYPE (ddef
);
5634 unsigned prec
= TYPE_PRECISION (type
);
5635 if (INTEGRAL_TYPE_P (TREE_TYPE (ddef
)))
5639 fprintf (dump_file
, "Setting value range of param %u ", i
);
5640 fprintf (dump_file
, "%s[",
5641 (vr
[i
].type
== VR_ANTI_RANGE
) ? "~" : "");
5642 print_decs (vr
[i
].min
, dump_file
);
5643 fprintf (dump_file
, ", ");
5644 print_decs (vr
[i
].max
, dump_file
);
5645 fprintf (dump_file
, "]\n");
5647 set_range_info (ddef
, vr
[i
].type
,
5648 wide_int_storage::from (vr
[i
].min
, prec
,
5650 wide_int_storage::from (vr
[i
].max
, prec
,
5653 else if (POINTER_TYPE_P (TREE_TYPE (ddef
))
5654 && vr
[i
].type
== VR_ANTI_RANGE
5655 && wi::eq_p (vr
[i
].min
, 0)
5656 && wi::eq_p (vr
[i
].max
, 0))
5659 fprintf (dump_file
, "Setting nonnull for %u\n", i
);
5660 set_ptr_nonnull (ddef
);
5666 /* IPCP transformation phase doing propagation of aggregate values. */
5669 ipcp_transform_function (struct cgraph_node
*node
)
5671 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
5672 struct ipa_func_body_info fbi
;
5673 struct ipa_agg_replacement_value
*aggval
;
5675 bool cfg_changed
= false, something_changed
= false;
5677 gcc_checking_assert (cfun
);
5678 gcc_checking_assert (current_function_decl
);
5681 fprintf (dump_file
, "Modification phase of node %s/%i\n",
5682 node
->name (), node
->order
);
5684 ipcp_update_bits (node
);
5685 ipcp_update_vr (node
);
5686 aggval
= ipa_get_agg_replacements_for_node (node
);
5689 param_count
= count_formal_params (node
->decl
);
5690 if (param_count
== 0)
5692 adjust_agg_replacement_values (node
, aggval
);
5694 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5698 fbi
.bb_infos
= vNULL
;
5699 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5700 fbi
.param_count
= param_count
;
5703 descriptors
.safe_grow_cleared (param_count
);
5704 ipa_populate_param_decls (node
, descriptors
);
5705 calculate_dominance_info (CDI_DOMINATORS
);
5706 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5707 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5710 struct ipa_bb_info
*bi
;
5711 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5712 free_ipa_bb_info (bi
);
5713 fbi
.bb_infos
.release ();
5714 free_dominance_info (CDI_DOMINATORS
);
5715 (*ipcp_transformations
)[node
->uid
].agg_values
= NULL
;
5716 (*ipcp_transformations
)[node
->uid
].bits
= NULL
;
5717 (*ipcp_transformations
)[node
->uid
].m_vr
= NULL
;
5719 descriptors
.release ();
5721 if (!something_changed
)
5723 else if (cfg_changed
)
5724 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5726 return TODO_update_ssa_only_virtuals
;