1 /* Interprocedural analyses.
2 Copyright (C) 2005-2015 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"
28 #include "fold-const.h"
31 #include "hard-reg-set.h"
33 #include "dominance.h"
35 #include "basic-block.h"
36 #include "tree-ssa-alias.h"
37 #include "internal-fn.h"
38 #include "gimple-fold.h"
40 #include "gimple-expr.h"
45 #include "insn-config.h"
54 #include "stor-layout.h"
55 #include "print-tree.h"
57 #include "gimple-iterator.h"
58 #include "gimplify-me.h"
59 #include "gimple-walk.h"
60 #include "langhooks.h"
62 #include "plugin-api.h"
65 #include "alloc-pool.h"
66 #include "symbol-summary.h"
69 #include "gimple-ssa.h"
71 #include "tree-phinodes.h"
72 #include "ssa-iterators.h"
73 #include "tree-into-ssa.h"
75 #include "tree-pass.h"
76 #include "tree-inline.h"
77 #include "ipa-inline.h"
78 #include "diagnostic.h"
79 #include "gimple-pretty-print.h"
80 #include "lto-streamer.h"
81 #include "data-streamer.h"
82 #include "tree-streamer.h"
84 #include "ipa-utils.h"
85 #include "stringpool.h"
86 #include "tree-ssanames.h"
91 /* Intermediate information that we get from alias analysis about a particular
92 parameter in a particular basic_block. When a parameter or the memory it
93 references is marked modified, we use that information in all dominatd
94 blocks without cosulting alias analysis oracle. */
96 struct param_aa_status
98 /* Set when this structure contains meaningful information. If not, the
99 structure describing a dominating BB should be used instead. */
102 /* Whether we have seen something which might have modified the data in
103 question. PARM is for the parameter itself, REF is for data it points to
104 but using the alias type of individual accesses and PT is the same thing
105 but for computing aggregate pass-through functions using a very inclusive
107 bool parm_modified
, ref_modified
, pt_modified
;
110 /* Information related to a given BB that used only when looking at function
115 /* Call graph edges going out of this BB. */
116 vec
<cgraph_edge
*> cg_edges
;
117 /* Alias analysis statuses of each formal parameter at this bb. */
118 vec
<param_aa_status
> param_aa_statuses
;
121 /* Structure with global information that is only used when looking at function
124 struct func_body_info
126 /* The node that is being analyzed. */
130 struct ipa_node_params
*info
;
132 /* Information about individual BBs. */
133 vec
<ipa_bb_info
> bb_infos
;
135 /* Number of parameters. */
138 /* Number of statements already walked by when analyzing this function. */
139 unsigned int aa_walked
;
142 /* Function summary where the parameter infos are actually stored. */
143 ipa_node_params_t
*ipa_node_params_sum
= NULL
;
144 /* Vector of IPA-CP transformation data for each clone. */
145 vec
<ipcp_transformation_summary
, va_gc
> *ipcp_transformations
;
146 /* Vector where the parameter infos are actually stored. */
147 vec
<ipa_edge_args
, va_gc
> *ipa_edge_args_vector
;
149 /* Holders of ipa cgraph hooks: */
150 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
151 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
152 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
154 /* Description of a reference to an IPA constant. */
155 struct ipa_cst_ref_desc
157 /* Edge that corresponds to the statement which took the reference. */
158 struct cgraph_edge
*cs
;
159 /* Linked list of duplicates created when call graph edges are cloned. */
160 struct ipa_cst_ref_desc
*next_duplicate
;
161 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
162 if out of control. */
166 /* Allocation pool for reference descriptions. */
168 static pool_allocator
<ipa_cst_ref_desc
> ipa_refdesc_pool
169 ("IPA-PROP ref descriptions", 32);
171 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
172 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
175 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
177 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
181 return !opt_for_fn (node
->decl
, optimize
) || !opt_for_fn (node
->decl
, flag_ipa_cp
);
184 /* Return index of the formal whose tree is PTREE in function which corresponds
188 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
> descriptors
, tree ptree
)
192 count
= descriptors
.length ();
193 for (i
= 0; i
< count
; i
++)
194 if (descriptors
[i
].decl
== ptree
)
200 /* Return index of the formal whose tree is PTREE in function which corresponds
204 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
206 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
209 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
213 ipa_populate_param_decls (struct cgraph_node
*node
,
214 vec
<ipa_param_descriptor
> &descriptors
)
222 gcc_assert (gimple_has_body_p (fndecl
));
223 fnargs
= DECL_ARGUMENTS (fndecl
);
225 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
227 descriptors
[param_num
].decl
= parm
;
228 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
),
234 /* Return how many formal parameters FNDECL has. */
237 count_formal_params (tree fndecl
)
241 gcc_assert (gimple_has_body_p (fndecl
));
243 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
249 /* Return the declaration of Ith formal parameter of the function corresponding
250 to INFO. Note there is no setter function as this array is built just once
251 using ipa_initialize_node_params. */
254 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
256 fprintf (file
, "param #%i", i
);
257 if (info
->descriptors
[i
].decl
)
260 print_generic_expr (file
, info
->descriptors
[i
].decl
, 0);
264 /* Initialize the ipa_node_params structure associated with NODE
265 to hold PARAM_COUNT parameters. */
268 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
270 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
272 if (!info
->descriptors
.exists () && param_count
)
273 info
->descriptors
.safe_grow_cleared (param_count
);
276 /* Initialize the ipa_node_params structure associated with NODE by counting
277 the function parameters, creating the descriptors and populating their
281 ipa_initialize_node_params (struct cgraph_node
*node
)
283 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
285 if (!info
->descriptors
.exists ())
287 ipa_alloc_node_params (node
, count_formal_params (node
->decl
));
288 ipa_populate_param_decls (node
, info
->descriptors
);
292 /* Print the jump functions associated with call graph edge CS to file F. */
295 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
299 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
300 for (i
= 0; i
< count
; i
++)
302 struct ipa_jump_func
*jump_func
;
303 enum jump_func_type type
;
305 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
306 type
= jump_func
->type
;
308 fprintf (f
, " param %d: ", i
);
309 if (type
== IPA_JF_UNKNOWN
)
310 fprintf (f
, "UNKNOWN\n");
311 else if (type
== IPA_JF_CONST
)
313 tree val
= jump_func
->value
.constant
.value
;
314 fprintf (f
, "CONST: ");
315 print_generic_expr (f
, val
, 0);
316 if (TREE_CODE (val
) == ADDR_EXPR
317 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
320 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
325 else if (type
== IPA_JF_PASS_THROUGH
)
327 fprintf (f
, "PASS THROUGH: ");
328 fprintf (f
, "%d, op %s",
329 jump_func
->value
.pass_through
.formal_id
,
330 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
331 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
334 print_generic_expr (f
,
335 jump_func
->value
.pass_through
.operand
, 0);
337 if (jump_func
->value
.pass_through
.agg_preserved
)
338 fprintf (f
, ", agg_preserved");
341 else if (type
== IPA_JF_ANCESTOR
)
343 fprintf (f
, "ANCESTOR: ");
344 fprintf (f
, "%d, offset " HOST_WIDE_INT_PRINT_DEC
,
345 jump_func
->value
.ancestor
.formal_id
,
346 jump_func
->value
.ancestor
.offset
);
347 if (jump_func
->value
.ancestor
.agg_preserved
)
348 fprintf (f
, ", agg_preserved");
352 if (jump_func
->agg
.items
)
354 struct ipa_agg_jf_item
*item
;
357 fprintf (f
, " Aggregate passed by %s:\n",
358 jump_func
->agg
.by_ref
? "reference" : "value");
359 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
361 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
363 if (TYPE_P (item
->value
))
364 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
365 tree_to_uhwi (TYPE_SIZE (item
->value
)));
368 fprintf (f
, "cst: ");
369 print_generic_expr (f
, item
->value
, 0);
375 struct ipa_polymorphic_call_context
*ctx
376 = ipa_get_ith_polymorhic_call_context (IPA_EDGE_REF (cs
), i
);
377 if (ctx
&& !ctx
->useless_p ())
379 fprintf (f
, " Context: ");
380 ctx
->dump (dump_file
);
383 if (jump_func
->alignment
.known
)
385 fprintf (f
, " Alignment: %u, misalignment: %u\n",
386 jump_func
->alignment
.align
,
387 jump_func
->alignment
.misalign
);
390 fprintf (f
, " Unknown alignment\n");
395 /* Print the jump functions of all arguments on all call graph edges going from
399 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
401 struct cgraph_edge
*cs
;
403 fprintf (f
, " Jump functions of caller %s/%i:\n", node
->name (),
405 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
407 if (!ipa_edge_args_info_available_for_edge_p (cs
))
410 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
411 xstrdup_for_dump (node
->name ()), node
->order
,
412 xstrdup_for_dump (cs
->callee
->name ()),
414 ipa_print_node_jump_functions_for_edge (f
, cs
);
417 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
419 struct cgraph_indirect_call_info
*ii
;
420 if (!ipa_edge_args_info_available_for_edge_p (cs
))
423 ii
= cs
->indirect_info
;
424 if (ii
->agg_contents
)
425 fprintf (f
, " indirect %s callsite, calling param %i, "
426 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
427 ii
->member_ptr
? "member ptr" : "aggregate",
428 ii
->param_index
, ii
->offset
,
429 ii
->by_ref
? "by reference" : "by_value");
431 fprintf (f
, " indirect %s callsite, calling param %i, "
432 "offset " HOST_WIDE_INT_PRINT_DEC
,
433 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
438 fprintf (f
, ", for stmt ");
439 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
444 ii
->context
.dump (f
);
445 ipa_print_node_jump_functions_for_edge (f
, cs
);
449 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
452 ipa_print_all_jump_functions (FILE *f
)
454 struct cgraph_node
*node
;
456 fprintf (f
, "\nJump functions:\n");
457 FOR_EACH_FUNCTION (node
)
459 ipa_print_node_jump_functions (f
, node
);
463 /* Set jfunc to be a know-really nothing jump function. */
466 ipa_set_jf_unknown (struct ipa_jump_func
*jfunc
)
468 jfunc
->type
= IPA_JF_UNKNOWN
;
469 jfunc
->alignment
.known
= false;
472 /* Set JFUNC to be a copy of another jmp (to be used by jump function
473 combination code). The two functions will share their rdesc. */
476 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
477 struct ipa_jump_func
*src
)
480 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
481 dst
->type
= IPA_JF_CONST
;
482 dst
->value
.constant
= src
->value
.constant
;
485 /* Set JFUNC to be a constant jmp function. */
488 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
489 struct cgraph_edge
*cs
)
491 constant
= unshare_expr (constant
);
492 if (constant
&& EXPR_P (constant
))
493 SET_EXPR_LOCATION (constant
, UNKNOWN_LOCATION
);
494 jfunc
->type
= IPA_JF_CONST
;
495 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
497 if (TREE_CODE (constant
) == ADDR_EXPR
498 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
500 struct ipa_cst_ref_desc
*rdesc
;
502 rdesc
= ipa_refdesc_pool
.allocate ();
504 rdesc
->next_duplicate
= NULL
;
506 jfunc
->value
.constant
.rdesc
= rdesc
;
509 jfunc
->value
.constant
.rdesc
= NULL
;
512 /* Set JFUNC to be a simple pass-through jump function. */
514 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
517 jfunc
->type
= IPA_JF_PASS_THROUGH
;
518 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
519 jfunc
->value
.pass_through
.formal_id
= formal_id
;
520 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
521 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
524 /* Set JFUNC to be an arithmetic pass through jump function. */
527 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
528 tree operand
, enum tree_code operation
)
530 jfunc
->type
= IPA_JF_PASS_THROUGH
;
531 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
532 jfunc
->value
.pass_through
.formal_id
= formal_id
;
533 jfunc
->value
.pass_through
.operation
= operation
;
534 jfunc
->value
.pass_through
.agg_preserved
= false;
537 /* Set JFUNC to be an ancestor jump function. */
540 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
541 int formal_id
, bool agg_preserved
)
543 jfunc
->type
= IPA_JF_ANCESTOR
;
544 jfunc
->value
.ancestor
.formal_id
= formal_id
;
545 jfunc
->value
.ancestor
.offset
= offset
;
546 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
549 /* Get IPA BB information about the given BB. FBI is the context of analyzis
550 of this function body. */
552 static struct ipa_bb_info
*
553 ipa_get_bb_info (struct func_body_info
*fbi
, basic_block bb
)
555 gcc_checking_assert (fbi
);
556 return &fbi
->bb_infos
[bb
->index
];
559 /* Structure to be passed in between detect_type_change and
560 check_stmt_for_type_change. */
562 struct prop_type_change_info
564 /* Offset into the object where there is the virtual method pointer we are
566 HOST_WIDE_INT offset
;
567 /* The declaration or SSA_NAME pointer of the base that we are checking for
570 /* Set to true if dynamic type change has been detected. */
571 bool type_maybe_changed
;
574 /* Return true if STMT can modify a virtual method table pointer.
576 This function makes special assumptions about both constructors and
577 destructors which are all the functions that are allowed to alter the VMT
578 pointers. It assumes that destructors begin with assignment into all VMT
579 pointers and that constructors essentially look in the following way:
581 1) The very first thing they do is that they call constructors of ancestor
582 sub-objects that have them.
584 2) Then VMT pointers of this and all its ancestors is set to new values
585 corresponding to the type corresponding to the constructor.
587 3) Only afterwards, other stuff such as constructor of member sub-objects
588 and the code written by the user is run. Only this may include calling
589 virtual functions, directly or indirectly.
591 There is no way to call a constructor of an ancestor sub-object in any
594 This means that we do not have to care whether constructors get the correct
595 type information because they will always change it (in fact, if we define
596 the type to be given by the VMT pointer, it is undefined).
598 The most important fact to derive from the above is that if, for some
599 statement in the section 3, we try to detect whether the dynamic type has
600 changed, we can safely ignore all calls as we examine the function body
601 backwards until we reach statements in section 2 because these calls cannot
602 be ancestor constructors or destructors (if the input is not bogus) and so
603 do not change the dynamic type (this holds true only for automatically
604 allocated objects but at the moment we devirtualize only these). We then
605 must detect that statements in section 2 change the dynamic type and can try
606 to derive the new type. That is enough and we can stop, we will never see
607 the calls into constructors of sub-objects in this code. Therefore we can
608 safely ignore all call statements that we traverse.
612 stmt_may_be_vtbl_ptr_store (gimple stmt
)
614 if (is_gimple_call (stmt
))
616 if (gimple_clobber_p (stmt
))
618 else if (is_gimple_assign (stmt
))
620 tree lhs
= gimple_assign_lhs (stmt
);
622 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
624 if (flag_strict_aliasing
625 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
628 if (TREE_CODE (lhs
) == COMPONENT_REF
629 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
631 /* In the future we might want to use get_base_ref_and_offset to find
632 if there is a field corresponding to the offset and if so, proceed
633 almost like if it was a component ref. */
639 /* Callback of walk_aliased_vdefs and a helper function for detect_type_change
640 to check whether a particular statement may modify the virtual table
641 pointerIt stores its result into DATA, which points to a
642 prop_type_change_info structure. */
645 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
647 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
648 struct prop_type_change_info
*tci
= (struct prop_type_change_info
*) data
;
650 if (stmt_may_be_vtbl_ptr_store (stmt
))
652 tci
->type_maybe_changed
= true;
659 /* See if ARG is PARAM_DECl describing instance passed by pointer
660 or reference in FUNCTION. Return false if the dynamic type may change
661 in between beggining of the function until CALL is invoked.
663 Generally functions are not allowed to change type of such instances,
664 but they call destructors. We assume that methods can not destroy the THIS
665 pointer. Also as a special cases, constructor and destructors may change
666 type of the THIS pointer. */
669 param_type_may_change_p (tree function
, tree arg
, gimple call
)
671 /* Pure functions can not do any changes on the dynamic type;
672 that require writting to memory. */
673 if (flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
675 /* We need to check if we are within inlined consturctor
676 or destructor (ideally we would have way to check that the
677 inline cdtor is actually working on ARG, but we don't have
678 easy tie on this, so punt on all non-pure cdtors.
679 We may also record the types of cdtors and once we know type
680 of the instance match them.
682 Also code unification optimizations may merge calls from
683 different blocks making return values unreliable. So
684 do nothing during late optimization. */
685 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
687 if (TREE_CODE (arg
) == SSA_NAME
688 && SSA_NAME_IS_DEFAULT_DEF (arg
)
689 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
)
691 /* Normal (non-THIS) argument. */
692 if ((SSA_NAME_VAR (arg
) != DECL_ARGUMENTS (function
)
693 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
)
694 /* THIS pointer of an method - here we we want to watch constructors
695 and destructors as those definitely may change the dynamic
697 || (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
698 && !DECL_CXX_CONSTRUCTOR_P (function
)
699 && !DECL_CXX_DESTRUCTOR_P (function
)
700 && (SSA_NAME_VAR (arg
) == DECL_ARGUMENTS (function
))))
702 /* Walk the inline stack and watch out for ctors/dtors. */
703 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
704 block
= BLOCK_SUPERCONTEXT (block
))
705 if (inlined_polymorphic_ctor_dtor_block_p (block
, false))
713 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
714 callsite CALL) by looking for assignments to its virtual table pointer. If
715 it is, return true and fill in the jump function JFUNC with relevant type
716 information or set it to unknown. ARG is the object itself (not a pointer
717 to it, unless dereferenced). BASE is the base of the memory access as
718 returned by get_ref_base_and_extent, as is the offset.
720 This is helper function for detect_type_change and detect_type_change_ssa
721 that does the heavy work which is usually unnecesary. */
724 detect_type_change_from_memory_writes (tree arg
, tree base
, tree comp_type
,
725 gcall
*call
, struct ipa_jump_func
*jfunc
,
726 HOST_WIDE_INT offset
)
728 struct prop_type_change_info tci
;
730 bool entry_reached
= false;
732 gcc_checking_assert (DECL_P (arg
)
733 || TREE_CODE (arg
) == MEM_REF
734 || handled_component_p (arg
));
736 comp_type
= TYPE_MAIN_VARIANT (comp_type
);
738 /* Const calls cannot call virtual methods through VMT and so type changes do
740 if (!flag_devirtualize
|| !gimple_vuse (call
)
741 /* Be sure expected_type is polymorphic. */
743 || TREE_CODE (comp_type
) != RECORD_TYPE
744 || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))
745 || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type
))))
748 ao_ref_init (&ao
, arg
);
751 ao
.size
= POINTER_SIZE
;
752 ao
.max_size
= ao
.size
;
755 tci
.object
= get_base_address (arg
);
756 tci
.type_maybe_changed
= false;
758 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
759 &tci
, NULL
, &entry_reached
);
760 if (!tci
.type_maybe_changed
)
763 ipa_set_jf_unknown (jfunc
);
767 /* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
768 If it is, return true and fill in the jump function JFUNC with relevant type
769 information or set it to unknown. ARG is the object itself (not a pointer
770 to it, unless dereferenced). BASE is the base of the memory access as
771 returned by get_ref_base_and_extent, as is the offset. */
774 detect_type_change (tree arg
, tree base
, tree comp_type
, gcall
*call
,
775 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
777 if (!flag_devirtualize
)
780 if (TREE_CODE (base
) == MEM_REF
781 && !param_type_may_change_p (current_function_decl
,
782 TREE_OPERAND (base
, 0),
785 return detect_type_change_from_memory_writes (arg
, base
, comp_type
,
786 call
, jfunc
, offset
);
789 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
790 SSA name (its dereference will become the base and the offset is assumed to
794 detect_type_change_ssa (tree arg
, tree comp_type
,
795 gcall
*call
, struct ipa_jump_func
*jfunc
)
797 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
798 if (!flag_devirtualize
799 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
802 if (!param_type_may_change_p (current_function_decl
, arg
, call
))
805 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
806 build_int_cst (ptr_type_node
, 0));
808 return detect_type_change_from_memory_writes (arg
, arg
, comp_type
,
812 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
813 boolean variable pointed to by DATA. */
816 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
819 bool *b
= (bool *) data
;
824 /* Return true if we have already walked so many statements in AA that we
825 should really just start giving up. */
828 aa_overwalked (struct func_body_info
*fbi
)
830 gcc_checking_assert (fbi
);
831 return fbi
->aa_walked
> (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS
);
834 /* Find the nearest valid aa status for parameter specified by INDEX that
837 static struct param_aa_status
*
838 find_dominating_aa_status (struct func_body_info
*fbi
, basic_block bb
,
843 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
846 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
847 if (!bi
->param_aa_statuses
.is_empty ()
848 && bi
->param_aa_statuses
[index
].valid
)
849 return &bi
->param_aa_statuses
[index
];
853 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
854 structures and/or intialize the result with a dominating description as
857 static struct param_aa_status
*
858 parm_bb_aa_status_for_bb (struct func_body_info
*fbi
, basic_block bb
,
861 gcc_checking_assert (fbi
);
862 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
863 if (bi
->param_aa_statuses
.is_empty ())
864 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
865 struct param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
868 gcc_checking_assert (!paa
->parm_modified
869 && !paa
->ref_modified
870 && !paa
->pt_modified
);
871 struct param_aa_status
*dom_paa
;
872 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
882 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
883 a value known not to be modified in this function before reaching the
884 statement STMT. FBI holds information about the function we have so far
885 gathered but do not survive the summary building stage. */
888 parm_preserved_before_stmt_p (struct func_body_info
*fbi
, int index
,
889 gimple stmt
, tree parm_load
)
891 struct param_aa_status
*paa
;
892 bool modified
= false;
895 /* FIXME: FBI can be NULL if we are being called from outside
896 ipa_node_analysis or ipcp_transform_function, which currently happens
897 during inlining analysis. It would be great to extend fbi's lifetime and
898 always have it. Currently, we are just not afraid of too much walking in
902 if (aa_overwalked (fbi
))
904 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
905 if (paa
->parm_modified
)
911 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
912 ao_ref_init (&refd
, parm_load
);
913 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
916 fbi
->aa_walked
+= walked
;
918 paa
->parm_modified
= true;
922 /* If STMT is an assignment that loads a value from an parameter declaration,
923 return the index of the parameter in ipa_node_params which has not been
924 modified. Otherwise return -1. */
927 load_from_unmodified_param (struct func_body_info
*fbi
,
928 vec
<ipa_param_descriptor
> descriptors
,
934 if (!gimple_assign_single_p (stmt
))
937 op1
= gimple_assign_rhs1 (stmt
);
938 if (TREE_CODE (op1
) != PARM_DECL
)
941 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
943 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
949 /* Return true if memory reference REF (which must be a load through parameter
950 with INDEX) loads data that are known to be unmodified in this function
951 before reaching statement STMT. */
954 parm_ref_data_preserved_p (struct func_body_info
*fbi
,
955 int index
, gimple stmt
, tree ref
)
957 struct param_aa_status
*paa
;
958 bool modified
= false;
961 /* FIXME: FBI can be NULL if we are being called from outside
962 ipa_node_analysis or ipcp_transform_function, which currently happens
963 during inlining analysis. It would be great to extend fbi's lifetime and
964 always have it. Currently, we are just not afraid of too much walking in
968 if (aa_overwalked (fbi
))
970 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
971 if (paa
->ref_modified
)
977 gcc_checking_assert (gimple_vuse (stmt
));
978 ao_ref_init (&refd
, ref
);
979 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
982 fbi
->aa_walked
+= walked
;
984 paa
->ref_modified
= true;
988 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
989 is known to be unmodified in this function before reaching call statement
990 CALL into which it is passed. FBI describes the function body. */
993 parm_ref_data_pass_through_p (struct func_body_info
*fbi
, int index
,
994 gimple call
, tree parm
)
996 bool modified
= false;
999 /* It's unnecessary to calculate anything about memory contnets for a const
1000 function because it is not goin to use it. But do not cache the result
1001 either. Also, no such calculations for non-pointers. */
1002 if (!gimple_vuse (call
)
1003 || !POINTER_TYPE_P (TREE_TYPE (parm
))
1004 || aa_overwalked (fbi
))
1007 struct param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (call
),
1009 if (paa
->pt_modified
)
1012 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
1013 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
1015 fbi
->aa_walked
+= walked
;
1017 paa
->pt_modified
= true;
1021 /* Return true if we can prove that OP is a memory reference loading unmodified
1022 data from an aggregate passed as a parameter and if the aggregate is passed
1023 by reference, that the alias type of the load corresponds to the type of the
1024 formal parameter (so that we can rely on this type for TBAA in callers).
1025 INFO and PARMS_AINFO describe parameters of the current function (but the
1026 latter can be NULL), STMT is the load statement. If function returns true,
1027 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
1028 within the aggregate and whether it is a load from a value passed by
1029 reference respectively. */
1032 ipa_load_from_parm_agg_1 (struct func_body_info
*fbi
,
1033 vec
<ipa_param_descriptor
> descriptors
,
1034 gimple stmt
, tree op
, int *index_p
,
1035 HOST_WIDE_INT
*offset_p
, HOST_WIDE_INT
*size_p
,
1039 HOST_WIDE_INT size
, max_size
;
1042 = get_ref_base_and_extent (op
, offset_p
, &size
, &max_size
, &reverse
);
1044 if (max_size
== -1 || max_size
!= size
|| *offset_p
< 0)
1049 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
1051 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
1062 if (TREE_CODE (base
) != MEM_REF
1063 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1064 || !integer_zerop (TREE_OPERAND (base
, 1)))
1067 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1069 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1070 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1074 /* This branch catches situations where a pointer parameter is not a
1075 gimple register, for example:
1077 void hip7(S*) (struct S * p)
1079 void (*<T2e4>) (struct S *) D.1867;
1084 D.1867_2 = p.1_1->f;
1089 gimple def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1090 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1094 && parm_ref_data_preserved_p (fbi
, index
, stmt
, op
))
1105 /* Just like the previous function, just without the param_analysis_info
1106 pointer, for users outside of this file. */
1109 ipa_load_from_parm_agg (struct ipa_node_params
*info
, gimple stmt
,
1110 tree op
, int *index_p
, HOST_WIDE_INT
*offset_p
,
1113 return ipa_load_from_parm_agg_1 (NULL
, info
->descriptors
, stmt
, op
, index_p
,
1114 offset_p
, NULL
, by_ref_p
);
1117 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1118 of an assignment statement STMT, try to determine whether we are actually
1119 handling any of the following cases and construct an appropriate jump
1120 function into JFUNC if so:
1122 1) The passed value is loaded from a formal parameter which is not a gimple
1123 register (most probably because it is addressable, the value has to be
1124 scalar) and we can guarantee the value has not changed. This case can
1125 therefore be described by a simple pass-through jump function. For example:
1134 2) The passed value can be described by a simple arithmetic pass-through
1141 D.2064_4 = a.1(D) + 4;
1144 This case can also occur in combination of the previous one, e.g.:
1152 D.2064_4 = a.0_3 + 4;
1155 3) The passed value is an address of an object within another one (which
1156 also passed by reference). Such situations are described by an ancestor
1157 jump function and describe situations such as:
1159 B::foo() (struct B * const this)
1163 D.1845_2 = &this_1(D)->D.1748;
1166 INFO is the structure describing individual parameters access different
1167 stages of IPA optimizations. PARMS_AINFO contains the information that is
1168 only needed for intraprocedural analysis. */
1171 compute_complex_assign_jump_func (struct func_body_info
*fbi
,
1172 struct ipa_node_params
*info
,
1173 struct ipa_jump_func
*jfunc
,
1174 gcall
*call
, gimple stmt
, tree name
,
1177 HOST_WIDE_INT offset
, size
, max_size
;
1178 tree op1
, tc_ssa
, base
, ssa
;
1182 op1
= gimple_assign_rhs1 (stmt
);
1184 if (TREE_CODE (op1
) == SSA_NAME
)
1186 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1187 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1189 index
= load_from_unmodified_param (fbi
, info
->descriptors
,
1190 SSA_NAME_DEF_STMT (op1
));
1195 index
= load_from_unmodified_param (fbi
, info
->descriptors
, stmt
);
1196 tc_ssa
= gimple_assign_lhs (stmt
);
1201 tree op2
= gimple_assign_rhs2 (stmt
);
1205 if (!is_gimple_ip_invariant (op2
)
1206 || (TREE_CODE_CLASS (gimple_expr_code (stmt
)) != tcc_comparison
1207 && !useless_type_conversion_p (TREE_TYPE (name
),
1211 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1212 gimple_assign_rhs_code (stmt
));
1214 else if (gimple_assign_single_p (stmt
))
1216 bool agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, tc_ssa
);
1217 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1222 if (TREE_CODE (op1
) != ADDR_EXPR
)
1224 op1
= TREE_OPERAND (op1
, 0);
1225 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1227 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
, &reverse
);
1228 if (TREE_CODE (base
) != MEM_REF
1229 /* If this is a varying address, punt. */
1231 || max_size
!= size
)
1233 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1234 ssa
= TREE_OPERAND (base
, 0);
1235 if (TREE_CODE (ssa
) != SSA_NAME
1236 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1240 /* Dynamic types are changed in constructors and destructors. */
1241 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1242 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1243 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1244 parm_ref_data_pass_through_p (fbi
, index
, call
, ssa
));
1247 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1250 iftmp.1_3 = &obj_2(D)->D.1762;
1252 The base of the MEM_REF must be a default definition SSA NAME of a
1253 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1254 whole MEM_REF expression is returned and the offset calculated from any
1255 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1256 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1259 get_ancestor_addr_info (gimple assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1261 HOST_WIDE_INT size
, max_size
;
1262 tree expr
, parm
, obj
;
1265 if (!gimple_assign_single_p (assign
))
1267 expr
= gimple_assign_rhs1 (assign
);
1269 if (TREE_CODE (expr
) != ADDR_EXPR
)
1271 expr
= TREE_OPERAND (expr
, 0);
1273 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
, &reverse
);
1275 if (TREE_CODE (expr
) != MEM_REF
1276 /* If this is a varying address, punt. */
1281 parm
= TREE_OPERAND (expr
, 0);
1282 if (TREE_CODE (parm
) != SSA_NAME
1283 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1284 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1287 *offset
+= mem_ref_offset (expr
).to_short_addr () * BITS_PER_UNIT
;
1293 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1294 statement PHI, try to find out whether NAME is in fact a
1295 multiple-inheritance typecast from a descendant into an ancestor of a formal
1296 parameter and thus can be described by an ancestor jump function and if so,
1297 write the appropriate function into JFUNC.
1299 Essentially we want to match the following pattern:
1307 iftmp.1_3 = &obj_2(D)->D.1762;
1310 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1311 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1315 compute_complex_ancestor_jump_func (struct func_body_info
*fbi
,
1316 struct ipa_node_params
*info
,
1317 struct ipa_jump_func
*jfunc
,
1318 gcall
*call
, gphi
*phi
)
1320 HOST_WIDE_INT offset
;
1321 gimple assign
, cond
;
1322 basic_block phi_bb
, assign_bb
, cond_bb
;
1323 tree tmp
, parm
, expr
, obj
;
1326 if (gimple_phi_num_args (phi
) != 2)
1329 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1330 tmp
= PHI_ARG_DEF (phi
, 0);
1331 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1332 tmp
= PHI_ARG_DEF (phi
, 1);
1335 if (TREE_CODE (tmp
) != SSA_NAME
1336 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1337 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1338 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1341 assign
= SSA_NAME_DEF_STMT (tmp
);
1342 assign_bb
= gimple_bb (assign
);
1343 if (!single_pred_p (assign_bb
))
1345 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1348 parm
= TREE_OPERAND (expr
, 0);
1349 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1353 cond_bb
= single_pred (assign_bb
);
1354 cond
= last_stmt (cond_bb
);
1356 || gimple_code (cond
) != GIMPLE_COND
1357 || gimple_cond_code (cond
) != NE_EXPR
1358 || gimple_cond_lhs (cond
) != parm
1359 || !integer_zerop (gimple_cond_rhs (cond
)))
1362 phi_bb
= gimple_bb (phi
);
1363 for (i
= 0; i
< 2; i
++)
1365 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1366 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1370 ipa_set_ancestor_jf (jfunc
, offset
, index
,
1371 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
));
1374 /* Inspect the given TYPE and return true iff it has the same structure (the
1375 same number of fields of the same types) as a C++ member pointer. If
1376 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1377 corresponding fields there. */
1380 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1384 if (TREE_CODE (type
) != RECORD_TYPE
)
1387 fld
= TYPE_FIELDS (type
);
1388 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1389 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1390 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1396 fld
= DECL_CHAIN (fld
);
1397 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1398 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1403 if (DECL_CHAIN (fld
))
1409 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1410 return the rhs of its defining statement. Otherwise return RHS as it
1414 get_ssa_def_if_simple_copy (tree rhs
)
1416 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1418 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1420 if (gimple_assign_single_p (def_stmt
))
1421 rhs
= gimple_assign_rhs1 (def_stmt
);
1428 /* Simple linked list, describing known contents of an aggregate beforere
1431 struct ipa_known_agg_contents_list
1433 /* Offset and size of the described part of the aggregate. */
1434 HOST_WIDE_INT offset
, size
;
1435 /* Known constant value or NULL if the contents is known to be unknown. */
1437 /* Pointer to the next structure in the list. */
1438 struct ipa_known_agg_contents_list
*next
;
1441 /* Find the proper place in linked list of ipa_known_agg_contents_list
1442 structures where to put a new one with the given LHS_OFFSET and LHS_SIZE,
1443 unless there is a partial overlap, in which case return NULL, or such
1444 element is already there, in which case set *ALREADY_THERE to true. */
1446 static struct ipa_known_agg_contents_list
**
1447 get_place_in_agg_contents_list (struct ipa_known_agg_contents_list
**list
,
1448 HOST_WIDE_INT lhs_offset
,
1449 HOST_WIDE_INT lhs_size
,
1450 bool *already_there
)
1452 struct ipa_known_agg_contents_list
**p
= list
;
1453 while (*p
&& (*p
)->offset
< lhs_offset
)
1455 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1460 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1462 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1463 /* We already know this value is subsequently overwritten with
1465 *already_there
= true;
1467 /* Otherwise this is a partial overlap which we cannot
1474 /* Build aggregate jump function from LIST, assuming there are exactly
1475 CONST_COUNT constant entries there and that th offset of the passed argument
1476 is ARG_OFFSET and store it into JFUNC. */
1479 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1480 int const_count
, HOST_WIDE_INT arg_offset
,
1481 struct ipa_jump_func
*jfunc
)
1483 vec_alloc (jfunc
->agg
.items
, const_count
);
1488 struct ipa_agg_jf_item item
;
1489 item
.offset
= list
->offset
- arg_offset
;
1490 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1491 item
.value
= unshare_expr_without_location (list
->constant
);
1492 jfunc
->agg
.items
->quick_push (item
);
1498 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1499 in ARG is filled in with constant values. ARG can either be an aggregate
1500 expression or a pointer to an aggregate. ARG_TYPE is the type of the
1501 aggregate. JFUNC is the jump function into which the constants are
1502 subsequently stored. */
1505 determine_locally_known_aggregate_parts (gcall
*call
, tree arg
,
1507 struct ipa_jump_func
*jfunc
)
1509 struct ipa_known_agg_contents_list
*list
= NULL
;
1510 int item_count
= 0, const_count
= 0;
1511 HOST_WIDE_INT arg_offset
, arg_size
;
1512 gimple_stmt_iterator gsi
;
1514 bool check_ref
, by_ref
;
1517 /* The function operates in three stages. First, we prepare check_ref, r,
1518 arg_base and arg_offset based on what is actually passed as an actual
1521 if (POINTER_TYPE_P (arg_type
))
1524 if (TREE_CODE (arg
) == SSA_NAME
)
1527 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
))))
1532 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1533 arg_size
= tree_to_uhwi (type_size
);
1534 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1536 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1538 HOST_WIDE_INT arg_max_size
;
1541 arg
= TREE_OPERAND (arg
, 0);
1542 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1543 &arg_max_size
, &reverse
);
1544 if (arg_max_size
== -1
1545 || arg_max_size
!= arg_size
1548 if (DECL_P (arg_base
))
1551 ao_ref_init (&r
, arg_base
);
1561 HOST_WIDE_INT arg_max_size
;
1564 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1568 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1569 &arg_max_size
, &reverse
);
1570 if (arg_max_size
== -1
1571 || arg_max_size
!= arg_size
1575 ao_ref_init (&r
, arg
);
1578 /* Second stage walks back the BB, looks at individual statements and as long
1579 as it is confident of how the statements affect contents of the
1580 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1582 gsi
= gsi_for_stmt (call
);
1584 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1586 struct ipa_known_agg_contents_list
*n
, **p
;
1587 gimple stmt
= gsi_stmt (gsi
);
1588 HOST_WIDE_INT lhs_offset
, lhs_size
, lhs_max_size
;
1589 tree lhs
, rhs
, lhs_base
;
1592 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1594 if (!gimple_assign_single_p (stmt
))
1597 lhs
= gimple_assign_lhs (stmt
);
1598 rhs
= gimple_assign_rhs1 (stmt
);
1599 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1600 || TREE_CODE (lhs
) == BIT_FIELD_REF
1601 || contains_bitfld_component_ref_p (lhs
))
1604 lhs_base
= get_ref_base_and_extent (lhs
, &lhs_offset
, &lhs_size
,
1605 &lhs_max_size
, &reverse
);
1606 if (lhs_max_size
== -1
1607 || lhs_max_size
!= lhs_size
)
1612 if (TREE_CODE (lhs_base
) != MEM_REF
1613 || TREE_OPERAND (lhs_base
, 0) != arg_base
1614 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1617 else if (lhs_base
!= arg_base
)
1619 if (DECL_P (lhs_base
))
1625 bool already_there
= false;
1626 p
= get_place_in_agg_contents_list (&list
, lhs_offset
, lhs_size
,
1633 rhs
= get_ssa_def_if_simple_copy (rhs
);
1634 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1636 n
->offset
= lhs_offset
;
1637 if (is_gimple_ip_invariant (rhs
))
1643 n
->constant
= NULL_TREE
;
1648 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1649 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1653 /* Third stage just goes over the list and creates an appropriate vector of
1654 ipa_agg_jf_item structures out of it, of sourse only if there are
1655 any known constants to begin with. */
1659 jfunc
->agg
.by_ref
= by_ref
;
1660 build_agg_jump_func_from_list (list
, const_count
, arg_offset
, jfunc
);
1665 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1668 tree type
= (e
->callee
1669 ? TREE_TYPE (e
->callee
->decl
)
1670 : gimple_call_fntype (e
->call_stmt
));
1671 tree t
= TYPE_ARG_TYPES (type
);
1673 for (n
= 0; n
< i
; n
++)
1680 return TREE_VALUE (t
);
1683 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1684 for (n
= 0; n
< i
; n
++)
1691 return TREE_TYPE (t
);
1695 /* Compute jump function for all arguments of callsite CS and insert the
1696 information in the jump_functions array in the ipa_edge_args corresponding
1697 to this callsite. */
1700 ipa_compute_jump_functions_for_edge (struct func_body_info
*fbi
,
1701 struct cgraph_edge
*cs
)
1703 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1704 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1705 gcall
*call
= cs
->call_stmt
;
1706 int n
, arg_num
= gimple_call_num_args (call
);
1707 bool useful_context
= false;
1709 if (arg_num
== 0 || args
->jump_functions
)
1711 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1712 if (flag_devirtualize
)
1713 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, arg_num
);
1715 if (gimple_call_internal_p (call
))
1717 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1720 for (n
= 0; n
< arg_num
; n
++)
1722 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1723 tree arg
= gimple_call_arg (call
, n
);
1724 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1725 if (flag_devirtualize
&& POINTER_TYPE_P (TREE_TYPE (arg
)))
1728 struct ipa_polymorphic_call_context
context (cs
->caller
->decl
,
1731 context
.get_dynamic_type (instance
, arg
, NULL
, cs
->call_stmt
);
1732 *ipa_get_ith_polymorhic_call_context (args
, n
) = context
;
1733 if (!context
.useless_p ())
1734 useful_context
= true;
1737 if (POINTER_TYPE_P (TREE_TYPE(arg
)))
1739 unsigned HOST_WIDE_INT hwi_bitpos
;
1742 if (get_pointer_alignment_1 (arg
, &align
, &hwi_bitpos
)
1743 && align
% BITS_PER_UNIT
== 0
1744 && hwi_bitpos
% BITS_PER_UNIT
== 0)
1746 jfunc
->alignment
.known
= true;
1747 jfunc
->alignment
.align
= align
/ BITS_PER_UNIT
;
1748 jfunc
->alignment
.misalign
= hwi_bitpos
/ BITS_PER_UNIT
;
1751 gcc_assert (!jfunc
->alignment
.known
);
1754 gcc_assert (!jfunc
->alignment
.known
);
1756 if (is_gimple_ip_invariant (arg
))
1757 ipa_set_jf_constant (jfunc
, arg
, cs
);
1758 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1759 && TREE_CODE (arg
) == PARM_DECL
)
1761 int index
= ipa_get_param_decl_index (info
, arg
);
1763 gcc_assert (index
>=0);
1764 /* Aggregate passed by value, check for pass-through, otherwise we
1765 will attempt to fill in aggregate contents later in this
1767 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
1769 ipa_set_jf_simple_pass_through (jfunc
, index
, false);
1773 else if (TREE_CODE (arg
) == SSA_NAME
)
1775 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1777 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1781 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
1782 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
);
1787 gimple stmt
= SSA_NAME_DEF_STMT (arg
);
1788 if (is_gimple_assign (stmt
))
1789 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
1790 call
, stmt
, arg
, param_type
);
1791 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1792 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
1794 as_a
<gphi
*> (stmt
));
1798 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1799 passed (because type conversions are ignored in gimple). Usually we can
1800 safely get type from function declaration, but in case of K&R prototypes or
1801 variadic functions we can try our luck with type of the pointer passed.
1802 TODO: Since we look for actual initialization of the memory object, we may better
1803 work out the type based on the memory stores we find. */
1805 param_type
= TREE_TYPE (arg
);
1807 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1808 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1809 && (jfunc
->type
!= IPA_JF_ANCESTOR
1810 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1811 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1812 || POINTER_TYPE_P (param_type
)))
1813 determine_locally_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1815 if (!useful_context
)
1816 vec_free (args
->polymorphic_call_contexts
);
1819 /* Compute jump functions for all edges - both direct and indirect - outgoing
1823 ipa_compute_jump_functions_for_bb (struct func_body_info
*fbi
, basic_block bb
)
1825 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
1827 struct cgraph_edge
*cs
;
1829 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
1831 struct cgraph_node
*callee
= cs
->callee
;
1835 callee
->ultimate_alias_target ();
1836 /* We do not need to bother analyzing calls to unknown functions
1837 unless they may become known during lto/whopr. */
1838 if (!callee
->definition
&& !flag_lto
)
1841 ipa_compute_jump_functions_for_edge (fbi
, cs
);
1845 /* If STMT looks like a statement loading a value from a member pointer formal
1846 parameter, return that parameter and store the offset of the field to
1847 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1848 might be clobbered). If USE_DELTA, then we look for a use of the delta
1849 field rather than the pfn. */
1852 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
,
1853 HOST_WIDE_INT
*offset_p
)
1855 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
1857 if (!gimple_assign_single_p (stmt
))
1860 rhs
= gimple_assign_rhs1 (stmt
);
1861 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1863 ref_field
= TREE_OPERAND (rhs
, 1);
1864 rhs
= TREE_OPERAND (rhs
, 0);
1867 ref_field
= NULL_TREE
;
1868 if (TREE_CODE (rhs
) != MEM_REF
)
1870 rec
= TREE_OPERAND (rhs
, 0);
1871 if (TREE_CODE (rec
) != ADDR_EXPR
)
1873 rec
= TREE_OPERAND (rec
, 0);
1874 if (TREE_CODE (rec
) != PARM_DECL
1875 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1877 ref_offset
= TREE_OPERAND (rhs
, 1);
1884 *offset_p
= int_bit_position (fld
);
1888 if (integer_nonzerop (ref_offset
))
1890 return ref_field
== fld
? rec
: NULL_TREE
;
1893 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
1897 /* Returns true iff T is an SSA_NAME defined by a statement. */
1900 ipa_is_ssa_with_stmt_def (tree t
)
1902 if (TREE_CODE (t
) == SSA_NAME
1903 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1909 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1910 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1911 indirect call graph edge. */
1913 static struct cgraph_edge
*
1914 ipa_note_param_call (struct cgraph_node
*node
, int param_index
,
1917 struct cgraph_edge
*cs
;
1919 cs
= node
->get_edge (stmt
);
1920 cs
->indirect_info
->param_index
= param_index
;
1921 cs
->indirect_info
->agg_contents
= 0;
1922 cs
->indirect_info
->member_ptr
= 0;
1926 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1927 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1928 intermediate information about each formal parameter. Currently it checks
1929 whether the call calls a pointer that is a formal parameter and if so, the
1930 parameter is marked with the called flag and an indirect call graph edge
1931 describing the call is created. This is very simple for ordinary pointers
1932 represented in SSA but not-so-nice when it comes to member pointers. The
1933 ugly part of this function does nothing more than trying to match the
1934 pattern of such a call. An example of such a pattern is the gimple dump
1935 below, the call is on the last line:
1938 f$__delta_5 = f.__delta;
1939 f$__pfn_24 = f.__pfn;
1943 f$__delta_5 = MEM[(struct *)&f];
1944 f$__pfn_24 = MEM[(struct *)&f + 4B];
1946 and a few lines below:
1949 D.2496_3 = (int) f$__pfn_24;
1950 D.2497_4 = D.2496_3 & 1;
1957 D.2500_7 = (unsigned int) f$__delta_5;
1958 D.2501_8 = &S + D.2500_7;
1959 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1960 D.2503_10 = *D.2502_9;
1961 D.2504_12 = f$__pfn_24 + -1;
1962 D.2505_13 = (unsigned int) D.2504_12;
1963 D.2506_14 = D.2503_10 + D.2505_13;
1964 D.2507_15 = *D.2506_14;
1965 iftmp.11_16 = (String:: *) D.2507_15;
1968 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1969 D.2500_19 = (unsigned int) f$__delta_5;
1970 D.2508_20 = &S + D.2500_19;
1971 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1973 Such patterns are results of simple calls to a member pointer:
1975 int doprinting (int (MyString::* f)(int) const)
1977 MyString S ("somestring");
1982 Moreover, the function also looks for called pointers loaded from aggregates
1983 passed by value or reference. */
1986 ipa_analyze_indirect_call_uses (struct func_body_info
*fbi
, gcall
*call
,
1989 struct ipa_node_params
*info
= fbi
->info
;
1990 HOST_WIDE_INT offset
;
1993 if (SSA_NAME_IS_DEFAULT_DEF (target
))
1995 tree var
= SSA_NAME_VAR (target
);
1996 int index
= ipa_get_param_decl_index (info
, var
);
1998 ipa_note_param_call (fbi
->node
, index
, call
);
2003 gimple def
= SSA_NAME_DEF_STMT (target
);
2004 if (gimple_assign_single_p (def
)
2005 && ipa_load_from_parm_agg_1 (fbi
, info
->descriptors
, def
,
2006 gimple_assign_rhs1 (def
), &index
, &offset
,
2009 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2010 cs
->indirect_info
->offset
= offset
;
2011 cs
->indirect_info
->agg_contents
= 1;
2012 cs
->indirect_info
->by_ref
= by_ref
;
2016 /* Now we need to try to match the complex pattern of calling a member
2018 if (gimple_code (def
) != GIMPLE_PHI
2019 || gimple_phi_num_args (def
) != 2
2020 || !POINTER_TYPE_P (TREE_TYPE (target
))
2021 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2024 /* First, we need to check whether one of these is a load from a member
2025 pointer that is a parameter to this function. */
2026 tree n1
= PHI_ARG_DEF (def
, 0);
2027 tree n2
= PHI_ARG_DEF (def
, 1);
2028 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2030 gimple d1
= SSA_NAME_DEF_STMT (n1
);
2031 gimple d2
= SSA_NAME_DEF_STMT (n2
);
2034 basic_block bb
, virt_bb
;
2035 basic_block join
= gimple_bb (def
);
2036 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2038 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2041 bb
= EDGE_PRED (join
, 0)->src
;
2042 virt_bb
= gimple_bb (d2
);
2044 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2046 bb
= EDGE_PRED (join
, 1)->src
;
2047 virt_bb
= gimple_bb (d1
);
2052 /* Second, we need to check that the basic blocks are laid out in the way
2053 corresponding to the pattern. */
2055 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2056 || single_pred (virt_bb
) != bb
2057 || single_succ (virt_bb
) != join
)
2060 /* Third, let's see that the branching is done depending on the least
2061 significant bit of the pfn. */
2063 gimple branch
= last_stmt (bb
);
2064 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2067 if ((gimple_cond_code (branch
) != NE_EXPR
2068 && gimple_cond_code (branch
) != EQ_EXPR
)
2069 || !integer_zerop (gimple_cond_rhs (branch
)))
2072 tree cond
= gimple_cond_lhs (branch
);
2073 if (!ipa_is_ssa_with_stmt_def (cond
))
2076 def
= SSA_NAME_DEF_STMT (cond
);
2077 if (!is_gimple_assign (def
)
2078 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2079 || !integer_onep (gimple_assign_rhs2 (def
)))
2082 cond
= gimple_assign_rhs1 (def
);
2083 if (!ipa_is_ssa_with_stmt_def (cond
))
2086 def
= SSA_NAME_DEF_STMT (cond
);
2088 if (is_gimple_assign (def
)
2089 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2091 cond
= gimple_assign_rhs1 (def
);
2092 if (!ipa_is_ssa_with_stmt_def (cond
))
2094 def
= SSA_NAME_DEF_STMT (cond
);
2098 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2099 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2100 == ptrmemfunc_vbit_in_delta
),
2105 index
= ipa_get_param_decl_index (info
, rec
);
2107 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2109 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2110 cs
->indirect_info
->offset
= offset
;
2111 cs
->indirect_info
->agg_contents
= 1;
2112 cs
->indirect_info
->member_ptr
= 1;
2118 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2119 object referenced in the expression is a formal parameter of the caller
2120 FBI->node (described by FBI->info), create a call note for the
2124 ipa_analyze_virtual_call_uses (struct func_body_info
*fbi
,
2125 gcall
*call
, tree target
)
2127 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2129 HOST_WIDE_INT anc_offset
;
2131 if (!flag_devirtualize
)
2134 if (TREE_CODE (obj
) != SSA_NAME
)
2137 struct ipa_node_params
*info
= fbi
->info
;
2138 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2140 struct ipa_jump_func jfunc
;
2141 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2145 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2146 gcc_assert (index
>= 0);
2147 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2153 struct ipa_jump_func jfunc
;
2154 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
2157 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2160 index
= ipa_get_param_decl_index (info
,
2161 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2162 gcc_assert (index
>= 0);
2163 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2164 call
, &jfunc
, anc_offset
))
2168 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2169 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2170 ii
->offset
= anc_offset
;
2171 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2172 ii
->otr_type
= obj_type_ref_class (target
);
2173 ii
->polymorphic
= 1;
2176 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2177 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2178 containing intermediate information about each formal parameter. */
2181 ipa_analyze_call_uses (struct func_body_info
*fbi
, gcall
*call
)
2183 tree target
= gimple_call_fn (call
);
2186 || (TREE_CODE (target
) != SSA_NAME
2187 && !virtual_method_call_p (target
)))
2190 struct cgraph_edge
*cs
= fbi
->node
->get_edge (call
);
2191 /* If we previously turned the call into a direct call, there is
2192 no need to analyze. */
2193 if (cs
&& !cs
->indirect_unknown_callee
)
2196 if (cs
->indirect_info
->polymorphic
&& flag_devirtualize
)
2199 tree target
= gimple_call_fn (call
);
2200 ipa_polymorphic_call_context
context (current_function_decl
,
2201 target
, call
, &instance
);
2203 gcc_checking_assert (cs
->indirect_info
->otr_type
2204 == obj_type_ref_class (target
));
2205 gcc_checking_assert (cs
->indirect_info
->otr_token
2206 == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target
)));
2208 cs
->indirect_info
->vptr_changed
2209 = !context
.get_dynamic_type (instance
,
2210 OBJ_TYPE_REF_OBJECT (target
),
2211 obj_type_ref_class (target
), call
);
2212 cs
->indirect_info
->context
= context
;
2215 if (TREE_CODE (target
) == SSA_NAME
)
2216 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2217 else if (virtual_method_call_p (target
))
2218 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2222 /* Analyze the call statement STMT with respect to formal parameters (described
2223 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2224 formal parameters are called. */
2227 ipa_analyze_stmt_uses (struct func_body_info
*fbi
, gimple stmt
)
2229 if (is_gimple_call (stmt
))
2230 ipa_analyze_call_uses (fbi
, as_a
<gcall
*> (stmt
));
2233 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2234 If OP is a parameter declaration, mark it as used in the info structure
2238 visit_ref_for_mod_analysis (gimple
, tree op
, tree
, void *data
)
2240 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2242 op
= get_base_address (op
);
2244 && TREE_CODE (op
) == PARM_DECL
)
2246 int index
= ipa_get_param_decl_index (info
, op
);
2247 gcc_assert (index
>= 0);
2248 ipa_set_param_used (info
, index
, true);
2254 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2255 the findings in various structures of the associated ipa_node_params
2256 structure, such as parameter flags, notes etc. FBI holds various data about
2257 the function being analyzed. */
2260 ipa_analyze_params_uses_in_bb (struct func_body_info
*fbi
, basic_block bb
)
2262 gimple_stmt_iterator gsi
;
2263 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2265 gimple stmt
= gsi_stmt (gsi
);
2267 if (is_gimple_debug (stmt
))
2270 ipa_analyze_stmt_uses (fbi
, stmt
);
2271 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2272 visit_ref_for_mod_analysis
,
2273 visit_ref_for_mod_analysis
,
2274 visit_ref_for_mod_analysis
);
2276 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2277 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2278 visit_ref_for_mod_analysis
,
2279 visit_ref_for_mod_analysis
,
2280 visit_ref_for_mod_analysis
);
2283 /* Calculate controlled uses of parameters of NODE. */
2286 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2288 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2290 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2292 tree parm
= ipa_get_param (info
, i
);
2293 int controlled_uses
= 0;
2295 /* For SSA regs see if parameter is used. For non-SSA we compute
2296 the flag during modification analysis. */
2297 if (is_gimple_reg (parm
))
2299 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2301 if (ddef
&& !has_zero_uses (ddef
))
2303 imm_use_iterator imm_iter
;
2304 use_operand_p use_p
;
2306 ipa_set_param_used (info
, i
, true);
2307 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2308 if (!is_gimple_call (USE_STMT (use_p
)))
2310 if (!is_gimple_debug (USE_STMT (use_p
)))
2312 controlled_uses
= IPA_UNDESCRIBED_USE
;
2320 controlled_uses
= 0;
2323 controlled_uses
= IPA_UNDESCRIBED_USE
;
2324 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2328 /* Free stuff in BI. */
2331 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2333 bi
->cg_edges
.release ();
2334 bi
->param_aa_statuses
.release ();
2337 /* Dominator walker driving the analysis. */
2339 class analysis_dom_walker
: public dom_walker
2342 analysis_dom_walker (struct func_body_info
*fbi
)
2343 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2345 virtual void before_dom_children (basic_block
);
2348 struct func_body_info
*m_fbi
;
2352 analysis_dom_walker::before_dom_children (basic_block bb
)
2354 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2355 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2358 /* Initialize the array describing properties of of formal parameters
2359 of NODE, analyze their uses and compute jump functions associated
2360 with actual arguments of calls from within NODE. */
2363 ipa_analyze_node (struct cgraph_node
*node
)
2365 struct func_body_info fbi
;
2366 struct ipa_node_params
*info
;
2368 ipa_check_create_node_params ();
2369 ipa_check_create_edge_args ();
2370 info
= IPA_NODE_REF (node
);
2372 if (info
->analysis_done
)
2374 info
->analysis_done
= 1;
2376 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2378 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2380 ipa_set_param_used (info
, i
, true);
2381 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2386 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2388 calculate_dominance_info (CDI_DOMINATORS
);
2389 ipa_initialize_node_params (node
);
2390 ipa_analyze_controlled_uses (node
);
2393 fbi
.info
= IPA_NODE_REF (node
);
2394 fbi
.bb_infos
= vNULL
;
2395 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2396 fbi
.param_count
= ipa_get_param_count (info
);
2399 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2401 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2402 bi
->cg_edges
.safe_push (cs
);
2405 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2407 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2408 bi
->cg_edges
.safe_push (cs
);
2411 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2414 struct ipa_bb_info
*bi
;
2415 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
2416 free_ipa_bb_info (bi
);
2417 fbi
.bb_infos
.release ();
2418 free_dominance_info (CDI_DOMINATORS
);
2422 /* Update the jump functions associated with call graph edge E when the call
2423 graph edge CS is being inlined, assuming that E->caller is already (possibly
2424 indirectly) inlined into CS->callee and that E has not been inlined. */
2427 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2428 struct cgraph_edge
*e
)
2430 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2431 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2432 int count
= ipa_get_cs_argument_count (args
);
2435 for (i
= 0; i
< count
; i
++)
2437 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2438 struct ipa_polymorphic_call_context
*dst_ctx
2439 = ipa_get_ith_polymorhic_call_context (args
, i
);
2441 if (dst
->type
== IPA_JF_ANCESTOR
)
2443 struct ipa_jump_func
*src
;
2444 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2445 struct ipa_polymorphic_call_context
*src_ctx
2446 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2448 /* Variable number of arguments can cause havoc if we try to access
2449 one that does not exist in the inlined edge. So make sure we
2451 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2453 ipa_set_jf_unknown (dst
);
2457 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2459 if (src_ctx
&& !src_ctx
->useless_p ())
2461 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2463 /* TODO: Make type preserved safe WRT contexts. */
2464 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2465 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2466 ctx
.offset_by (dst
->value
.ancestor
.offset
);
2467 if (!ctx
.useless_p ())
2469 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2471 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2473 dst_ctx
->combine_with (ctx
);
2477 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2479 struct ipa_agg_jf_item
*item
;
2482 /* Currently we do not produce clobber aggregate jump functions,
2483 replace with merging when we do. */
2484 gcc_assert (!dst
->agg
.items
);
2486 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2487 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2488 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2489 item
->offset
-= dst
->value
.ancestor
.offset
;
2492 if (src
->type
== IPA_JF_PASS_THROUGH
2493 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2495 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2496 dst
->value
.ancestor
.agg_preserved
&=
2497 src
->value
.pass_through
.agg_preserved
;
2499 else if (src
->type
== IPA_JF_ANCESTOR
)
2501 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2502 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2503 dst
->value
.ancestor
.agg_preserved
&=
2504 src
->value
.ancestor
.agg_preserved
;
2507 ipa_set_jf_unknown (dst
);
2509 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2511 struct ipa_jump_func
*src
;
2512 /* We must check range due to calls with variable number of arguments
2513 and we cannot combine jump functions with operations. */
2514 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2515 && (dst
->value
.pass_through
.formal_id
2516 < ipa_get_cs_argument_count (top
)))
2518 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2519 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2520 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2521 struct ipa_polymorphic_call_context
*src_ctx
2522 = ipa_get_ith_polymorhic_call_context (top
, dst_fid
);
2524 if (src_ctx
&& !src_ctx
->useless_p ())
2526 struct ipa_polymorphic_call_context ctx
= *src_ctx
;
2528 /* TODO: Make type preserved safe WRT contexts. */
2529 if (!ipa_get_jf_pass_through_type_preserved (dst
))
2530 ctx
.possible_dynamic_type_change (e
->in_polymorphic_cdtor
);
2531 if (!ctx
.useless_p ())
2535 vec_safe_grow_cleared (args
->polymorphic_call_contexts
,
2537 dst_ctx
= ipa_get_ith_polymorhic_call_context (args
, i
);
2539 dst_ctx
->combine_with (ctx
);
2544 case IPA_JF_UNKNOWN
:
2545 ipa_set_jf_unknown (dst
);
2548 ipa_set_jf_cst_copy (dst
, src
);
2551 case IPA_JF_PASS_THROUGH
:
2553 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2554 enum tree_code operation
;
2555 operation
= ipa_get_jf_pass_through_operation (src
);
2557 if (operation
== NOP_EXPR
)
2561 && ipa_get_jf_pass_through_agg_preserved (src
);
2562 ipa_set_jf_simple_pass_through (dst
, formal_id
, agg_p
);
2566 tree operand
= ipa_get_jf_pass_through_operand (src
);
2567 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2572 case IPA_JF_ANCESTOR
:
2576 && ipa_get_jf_ancestor_agg_preserved (src
);
2577 ipa_set_ancestor_jf (dst
,
2578 ipa_get_jf_ancestor_offset (src
),
2579 ipa_get_jf_ancestor_formal_id (src
),
2588 && (dst_agg_p
|| !src
->agg
.by_ref
))
2590 /* Currently we do not produce clobber aggregate jump
2591 functions, replace with merging when we do. */
2592 gcc_assert (!dst
->agg
.items
);
2594 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2595 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2599 ipa_set_jf_unknown (dst
);
2604 /* If TARGET is an addr_expr of a function declaration, make it the
2605 (SPECULATIVE)destination of an indirect edge IE and return the edge.
2606 Otherwise, return NULL. */
2608 struct cgraph_edge
*
2609 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
,
2612 struct cgraph_node
*callee
;
2613 struct inline_edge_summary
*es
= inline_edge_summary (ie
);
2614 bool unreachable
= false;
2616 if (TREE_CODE (target
) == ADDR_EXPR
)
2617 target
= TREE_OPERAND (target
, 0);
2618 if (TREE_CODE (target
) != FUNCTION_DECL
)
2620 target
= canonicalize_constructor_val (target
, NULL
);
2621 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2623 /* Member pointer call that goes through a VMT lookup. */
2624 if (ie
->indirect_info
->member_ptr
2625 /* Or if target is not an invariant expression and we do not
2626 know if it will evaulate to function at runtime.
2627 This can happen when folding through &VAR, where &VAR
2628 is IP invariant, but VAR itself is not.
2630 TODO: Revisit this when GCC 5 is branched. It seems that
2631 member_ptr check is not needed and that we may try to fold
2632 the expression and see if VAR is readonly. */
2633 || !is_gimple_ip_invariant (target
))
2635 if (dump_enabled_p ())
2637 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2638 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2639 "discovered direct call non-invariant "
2641 ie
->caller
->name (), ie
->caller
->order
);
2647 if (dump_enabled_p ())
2649 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2650 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2651 "discovered direct call to non-function in %s/%i, "
2652 "making it __builtin_unreachable\n",
2653 ie
->caller
->name (), ie
->caller
->order
);
2656 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2657 callee
= cgraph_node::get_create (target
);
2661 callee
= cgraph_node::get (target
);
2664 callee
= cgraph_node::get (target
);
2666 /* Because may-edges are not explicitely represented and vtable may be external,
2667 we may create the first reference to the object in the unit. */
2668 if (!callee
|| callee
->global
.inlined_to
)
2671 /* We are better to ensure we can refer to it.
2672 In the case of static functions we are out of luck, since we already
2673 removed its body. In the case of public functions we may or may
2674 not introduce the reference. */
2675 if (!canonicalize_constructor_val (target
, NULL
)
2676 || !TREE_PUBLIC (target
))
2679 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2680 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2681 xstrdup_for_dump (ie
->caller
->name ()),
2683 xstrdup_for_dump (ie
->callee
->name ()),
2687 callee
= cgraph_node::get_create (target
);
2690 /* If the edge is already speculated. */
2691 if (speculative
&& ie
->speculative
)
2693 struct cgraph_edge
*e2
;
2694 struct ipa_ref
*ref
;
2695 ie
->speculative_call_info (e2
, ie
, ref
);
2696 if (e2
->callee
->ultimate_alias_target ()
2697 != callee
->ultimate_alias_target ())
2700 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2701 "(%s/%i -> %s/%i) but the call is already speculated to %s/%i. Giving up.\n",
2702 xstrdup_for_dump (ie
->caller
->name ()),
2704 xstrdup_for_dump (callee
->name ()),
2706 xstrdup_for_dump (e2
->callee
->name ()),
2712 fprintf (dump_file
, "ipa-prop: Discovered call to a speculative target "
2713 "(%s/%i -> %s/%i) this agree with previous speculation.\n",
2714 xstrdup_for_dump (ie
->caller
->name ()),
2716 xstrdup_for_dump (callee
->name ()),
2722 if (!dbg_cnt (devirt
))
2725 ipa_check_create_node_params ();
2727 /* We can not make edges to inline clones. It is bug that someone removed
2728 the cgraph node too early. */
2729 gcc_assert (!callee
->global
.inlined_to
);
2731 if (dump_file
&& !unreachable
)
2733 fprintf (dump_file
, "ipa-prop: Discovered %s call to a %s target "
2734 "(%s/%i -> %s/%i), for stmt ",
2735 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2736 speculative
? "speculative" : "known",
2737 xstrdup_for_dump (ie
->caller
->name ()),
2739 xstrdup_for_dump (callee
->name ()),
2742 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2744 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2746 if (dump_enabled_p ())
2748 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2750 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2751 "converting indirect call in %s to direct call to %s\n",
2752 ie
->caller
->name (), callee
->name ());
2756 struct cgraph_edge
*orig
= ie
;
2757 ie
= ie
->make_direct (callee
);
2758 /* If we resolved speculative edge the cost is already up to date
2759 for direct call (adjusted by inline_edge_duplication_hook). */
2762 es
= inline_edge_summary (ie
);
2763 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2764 - eni_size_weights
.call_cost
);
2765 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2766 - eni_time_weights
.call_cost
);
2771 if (!callee
->can_be_discarded_p ())
2774 alias
= dyn_cast
<cgraph_node
*> (callee
->noninterposable_alias ());
2778 /* make_speculative will update ie's cost to direct call cost. */
2779 ie
= ie
->make_speculative
2780 (callee
, ie
->count
* 8 / 10, ie
->frequency
* 8 / 10);
2786 /* Retrieve value from aggregate jump function AGG for the given OFFSET or
2787 return NULL if there is not any. BY_REF specifies whether the value has to
2788 be passed by reference or by value. */
2791 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
,
2792 HOST_WIDE_INT offset
, bool by_ref
)
2794 struct ipa_agg_jf_item
*item
;
2797 if (by_ref
!= agg
->by_ref
)
2800 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2801 if (item
->offset
== offset
)
2803 /* Currently we do not have clobber values, return NULL for them once
2805 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2811 /* Remove a reference to SYMBOL from the list of references of a node given by
2812 reference description RDESC. Return true if the reference has been
2813 successfully found and removed. */
2816 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
2818 struct ipa_ref
*to_del
;
2819 struct cgraph_edge
*origin
;
2824 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
2825 origin
->lto_stmt_uid
);
2829 to_del
->remove_reference ();
2831 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
2832 xstrdup_for_dump (origin
->caller
->name ()),
2833 origin
->caller
->order
, xstrdup_for_dump (symbol
->name ()));
2837 /* If JFUNC has a reference description with refcount different from
2838 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
2839 NULL. JFUNC must be a constant jump function. */
2841 static struct ipa_cst_ref_desc
*
2842 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
2844 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
2845 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
2851 /* If the value of constant jump function JFUNC is an address of a function
2852 declaration, return the associated call graph node. Otherwise return
2855 static cgraph_node
*
2856 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
2858 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
2859 tree cst
= ipa_get_jf_constant (jfunc
);
2860 if (TREE_CODE (cst
) != ADDR_EXPR
2861 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
2864 return cgraph_node::get (TREE_OPERAND (cst
, 0));
2868 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
2869 refcount and if it hits zero, remove reference to SYMBOL from the caller of
2870 the edge specified in the rdesc. Return false if either the symbol or the
2871 reference could not be found, otherwise return true. */
2874 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
2876 struct ipa_cst_ref_desc
*rdesc
;
2877 if (jfunc
->type
== IPA_JF_CONST
2878 && (rdesc
= jfunc_rdesc_usable (jfunc
))
2879 && --rdesc
->refcount
== 0)
2881 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
2885 return remove_described_reference (symbol
, rdesc
);
2890 /* Try to find a destination for indirect edge IE that corresponds to a simple
2891 call or a call of a member function pointer and where the destination is a
2892 pointer formal parameter described by jump function JFUNC. If it can be
2893 determined, return the newly direct edge, otherwise return NULL.
2894 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
2896 static struct cgraph_edge
*
2897 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
2898 struct ipa_jump_func
*jfunc
,
2899 struct ipa_node_params
*new_root_info
)
2901 struct cgraph_edge
*cs
;
2903 bool agg_contents
= ie
->indirect_info
->agg_contents
;
2905 if (ie
->indirect_info
->agg_contents
)
2906 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2907 ie
->indirect_info
->offset
,
2908 ie
->indirect_info
->by_ref
);
2910 target
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2913 cs
= ipa_make_edge_direct_to_target (ie
, target
);
2915 if (cs
&& !agg_contents
)
2918 gcc_checking_assert (cs
->callee
2920 || jfunc
->type
!= IPA_JF_CONST
2921 || !cgraph_node_for_jfunc (jfunc
)
2922 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
2923 ok
= try_decrement_rdesc_refcount (jfunc
);
2924 gcc_checking_assert (ok
);
2930 /* Return the target to be used in cases of impossible devirtualization. IE
2931 and target (the latter can be NULL) are dumped when dumping is enabled. */
2934 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
2940 "Type inconsistent devirtualization: %s/%i->%s\n",
2941 ie
->caller
->name (), ie
->caller
->order
,
2942 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
2945 "No devirtualization target in %s/%i\n",
2946 ie
->caller
->name (), ie
->caller
->order
);
2948 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2949 cgraph_node::get_create (new_target
);
2953 /* Try to find a destination for indirect edge IE that corresponds to a virtual
2954 call based on a formal parameter which is described by jump function JFUNC
2955 and if it can be determined, make it direct and return the direct edge.
2956 Otherwise, return NULL. CTX describes the polymorphic context that the
2957 parameter the call is based on brings along with it. */
2959 static struct cgraph_edge
*
2960 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
2961 struct ipa_jump_func
*jfunc
,
2962 struct ipa_polymorphic_call_context ctx
)
2965 bool speculative
= false;
2967 if (!opt_for_fn (ie
->caller
->decl
, flag_devirtualize
))
2970 gcc_assert (!ie
->indirect_info
->by_ref
);
2972 /* Try to do lookup via known virtual table pointer value. */
2973 if (!ie
->indirect_info
->vptr_changed
2974 || opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
))
2977 unsigned HOST_WIDE_INT offset
;
2978 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2979 ie
->indirect_info
->offset
,
2981 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2983 t
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
2987 if ((TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
2988 && DECL_FUNCTION_CODE (t
) == BUILT_IN_UNREACHABLE
)
2989 || !possible_polymorphic_call_target_p
2990 (ie
, cgraph_node::get (t
)))
2992 /* Do not speculate builtin_unreachable, it is stupid! */
2993 if (!ie
->indirect_info
->vptr_changed
)
2994 target
= ipa_impossible_devirt_target (ie
, target
);
2999 speculative
= ie
->indirect_info
->vptr_changed
;
3005 ipa_polymorphic_call_context
ie_context (ie
);
3006 vec
<cgraph_node
*>targets
;
3009 ctx
.offset_by (ie
->indirect_info
->offset
);
3010 if (ie
->indirect_info
->vptr_changed
)
3011 ctx
.possible_dynamic_type_change (ie
->in_polymorphic_cdtor
,
3012 ie
->indirect_info
->otr_type
);
3013 ctx
.combine_with (ie_context
, ie
->indirect_info
->otr_type
);
3014 targets
= possible_polymorphic_call_targets
3015 (ie
->indirect_info
->otr_type
,
3016 ie
->indirect_info
->otr_token
,
3018 if (final
&& targets
.length () <= 1)
3020 speculative
= false;
3021 if (targets
.length () == 1)
3022 target
= targets
[0]->decl
;
3024 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3026 else if (!target
&& opt_for_fn (ie
->caller
->decl
, flag_devirtualize_speculatively
)
3027 && !ie
->speculative
&& ie
->maybe_hot_p ())
3030 n
= try_speculative_devirtualization (ie
->indirect_info
->otr_type
,
3031 ie
->indirect_info
->otr_token
,
3032 ie
->indirect_info
->context
);
3042 if (!possible_polymorphic_call_target_p
3043 (ie
, cgraph_node::get_create (target
)))
3047 target
= ipa_impossible_devirt_target (ie
, target
);
3049 return ipa_make_edge_direct_to_target (ie
, target
, speculative
);
3055 /* Update the param called notes associated with NODE when CS is being inlined,
3056 assuming NODE is (potentially indirectly) inlined into CS->callee.
3057 Moreover, if the callee is discovered to be constant, create a new cgraph
3058 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3059 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3062 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3063 struct cgraph_node
*node
,
3064 vec
<cgraph_edge
*> *new_edges
)
3066 struct ipa_edge_args
*top
;
3067 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3068 struct ipa_node_params
*new_root_info
;
3071 ipa_check_create_edge_args ();
3072 top
= IPA_EDGE_REF (cs
);
3073 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3074 ? cs
->caller
->global
.inlined_to
3077 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3079 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3080 struct ipa_jump_func
*jfunc
;
3082 cgraph_node
*spec_target
= NULL
;
3084 next_ie
= ie
->next_callee
;
3086 if (ici
->param_index
== -1)
3089 /* We must check range due to calls with variable number of arguments: */
3090 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3092 ici
->param_index
= -1;
3096 param_index
= ici
->param_index
;
3097 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3099 if (ie
->speculative
)
3101 struct cgraph_edge
*de
;
3102 struct ipa_ref
*ref
;
3103 ie
->speculative_call_info (de
, ie
, ref
);
3104 spec_target
= de
->callee
;
3107 if (!opt_for_fn (node
->decl
, flag_indirect_inlining
))
3108 new_direct_edge
= NULL
;
3109 else if (ici
->polymorphic
)
3111 ipa_polymorphic_call_context ctx
;
3112 ctx
= ipa_context_from_jfunc (new_root_info
, cs
, param_index
, jfunc
);
3113 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
, ctx
);
3116 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3118 /* If speculation was removed, then we need to do nothing. */
3119 if (new_direct_edge
&& new_direct_edge
!= ie
3120 && new_direct_edge
->callee
== spec_target
)
3122 new_direct_edge
->indirect_inlining_edge
= 1;
3123 top
= IPA_EDGE_REF (cs
);
3125 if (!new_direct_edge
->speculative
)
3128 else if (new_direct_edge
)
3130 new_direct_edge
->indirect_inlining_edge
= 1;
3131 if (new_direct_edge
->call_stmt
)
3132 new_direct_edge
->call_stmt_cannot_inline_p
3133 = !gimple_check_call_matching_types (
3134 new_direct_edge
->call_stmt
,
3135 new_direct_edge
->callee
->decl
, false);
3138 new_edges
->safe_push (new_direct_edge
);
3141 top
= IPA_EDGE_REF (cs
);
3142 /* If speculative edge was introduced we still need to update
3143 call info of the indirect edge. */
3144 if (!new_direct_edge
->speculative
)
3147 if (jfunc
->type
== IPA_JF_PASS_THROUGH
3148 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3150 if (ici
->agg_contents
3151 && !ipa_get_jf_pass_through_agg_preserved (jfunc
)
3152 && !ici
->polymorphic
)
3153 ici
->param_index
= -1;
3156 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3157 if (ici
->polymorphic
3158 && !ipa_get_jf_pass_through_type_preserved (jfunc
))
3159 ici
->vptr_changed
= true;
3162 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3164 if (ici
->agg_contents
3165 && !ipa_get_jf_ancestor_agg_preserved (jfunc
)
3166 && !ici
->polymorphic
)
3167 ici
->param_index
= -1;
3170 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3171 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3172 if (ici
->polymorphic
3173 && !ipa_get_jf_ancestor_type_preserved (jfunc
))
3174 ici
->vptr_changed
= true;
3178 /* Either we can find a destination for this edge now or never. */
3179 ici
->param_index
= -1;
3185 /* Recursively traverse subtree of NODE (including node) made of inlined
3186 cgraph_edges when CS has been inlined and invoke
3187 update_indirect_edges_after_inlining on all nodes and
3188 update_jump_functions_after_inlining on all non-inlined edges that lead out
3189 of this subtree. Newly discovered indirect edges will be added to
3190 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3194 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3195 struct cgraph_node
*node
,
3196 vec
<cgraph_edge
*> *new_edges
)
3198 struct cgraph_edge
*e
;
3201 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3203 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3204 if (!e
->inline_failed
)
3205 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3207 update_jump_functions_after_inlining (cs
, e
);
3208 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3209 update_jump_functions_after_inlining (cs
, e
);
3214 /* Combine two controlled uses counts as done during inlining. */
3217 combine_controlled_uses_counters (int c
, int d
)
3219 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3220 return IPA_UNDESCRIBED_USE
;
3225 /* Propagate number of controlled users from CS->caleee to the new root of the
3226 tree of inlined nodes. */
3229 propagate_controlled_uses (struct cgraph_edge
*cs
)
3231 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3232 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3233 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3234 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3235 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3238 count
= MIN (ipa_get_cs_argument_count (args
),
3239 ipa_get_param_count (old_root_info
));
3240 for (i
= 0; i
< count
; i
++)
3242 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3243 struct ipa_cst_ref_desc
*rdesc
;
3245 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3248 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3249 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3250 d
= ipa_get_controlled_uses (old_root_info
, i
);
3252 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3253 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3254 c
= combine_controlled_uses_counters (c
, d
);
3255 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3256 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3258 struct cgraph_node
*n
;
3259 struct ipa_ref
*ref
;
3260 tree t
= new_root_info
->known_csts
[src_idx
];
3262 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3263 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3264 && (n
= cgraph_node::get (TREE_OPERAND (t
, 0)))
3265 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3268 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3269 "reference from %s/%i to %s/%i.\n",
3270 xstrdup_for_dump (new_root
->name ()),
3272 xstrdup_for_dump (n
->name ()), n
->order
);
3273 ref
->remove_reference ();
3277 else if (jf
->type
== IPA_JF_CONST
3278 && (rdesc
= jfunc_rdesc_usable (jf
)))
3280 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3281 int c
= rdesc
->refcount
;
3282 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3283 if (rdesc
->refcount
== 0)
3285 tree cst
= ipa_get_jf_constant (jf
);
3286 struct cgraph_node
*n
;
3287 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3288 && TREE_CODE (TREE_OPERAND (cst
, 0))
3290 n
= cgraph_node::get (TREE_OPERAND (cst
, 0));
3293 struct cgraph_node
*clone
;
3295 ok
= remove_described_reference (n
, rdesc
);
3296 gcc_checking_assert (ok
);
3299 while (clone
->global
.inlined_to
3300 && clone
!= rdesc
->cs
->caller
3301 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3303 struct ipa_ref
*ref
;
3304 ref
= clone
->find_reference (n
, NULL
, 0);
3308 fprintf (dump_file
, "ipa-prop: Removing "
3309 "cloning-created reference "
3310 "from %s/%i to %s/%i.\n",
3311 xstrdup_for_dump (clone
->name ()),
3313 xstrdup_for_dump (n
->name ()),
3315 ref
->remove_reference ();
3317 clone
= clone
->callers
->caller
;
3324 for (i
= ipa_get_param_count (old_root_info
);
3325 i
< ipa_get_cs_argument_count (args
);
3328 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3330 if (jf
->type
== IPA_JF_CONST
)
3332 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3334 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3336 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3337 ipa_set_controlled_uses (new_root_info
,
3338 jf
->value
.pass_through
.formal_id
,
3339 IPA_UNDESCRIBED_USE
);
3343 /* Update jump functions and call note functions on inlining the call site CS.
3344 CS is expected to lead to a node already cloned by
3345 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3346 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3350 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3351 vec
<cgraph_edge
*> *new_edges
)
3354 /* Do nothing if the preparation phase has not been carried out yet
3355 (i.e. during early inlining). */
3356 if (!ipa_node_params_sum
)
3358 gcc_assert (ipa_edge_args_vector
);
3360 propagate_controlled_uses (cs
);
3361 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3366 /* Frees all dynamically allocated structures that the argument info points
3370 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3372 vec_free (args
->jump_functions
);
3373 memset (args
, 0, sizeof (*args
));
3376 /* Free all ipa_edge structures. */
3379 ipa_free_all_edge_args (void)
3382 struct ipa_edge_args
*args
;
3384 if (!ipa_edge_args_vector
)
3387 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3388 ipa_free_edge_args_substructures (args
);
3390 vec_free (ipa_edge_args_vector
);
3393 /* Frees all dynamically allocated structures that the param info points
3396 ipa_node_params::~ipa_node_params ()
3398 descriptors
.release ();
3400 /* Lattice values and their sources are deallocated with their alocation
3402 known_contexts
.release ();
3405 ipcp_orig_node
= NULL
;
3408 do_clone_for_all_contexts
= 0;
3409 is_all_contexts_clone
= 0;
3413 /* Free all ipa_node_params structures. */
3416 ipa_free_all_node_params (void)
3418 delete ipa_node_params_sum
;
3419 ipa_node_params_sum
= NULL
;
3422 /* Grow ipcp_transformations if necessary. */
3425 ipcp_grow_transformations_if_necessary (void)
3427 if (vec_safe_length (ipcp_transformations
)
3428 <= (unsigned) symtab
->cgraph_max_uid
)
3429 vec_safe_grow_cleared (ipcp_transformations
, symtab
->cgraph_max_uid
+ 1);
3432 /* Set the aggregate replacements of NODE to be AGGVALS. */
3435 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3436 struct ipa_agg_replacement_value
*aggvals
)
3438 ipcp_grow_transformations_if_necessary ();
3439 (*ipcp_transformations
)[node
->uid
].agg_values
= aggvals
;
3442 /* Hook that is called by cgraph.c when an edge is removed. */
3445 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3447 struct ipa_edge_args
*args
;
3449 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3450 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3453 args
= IPA_EDGE_REF (cs
);
3454 if (args
->jump_functions
)
3456 struct ipa_jump_func
*jf
;
3458 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3460 struct ipa_cst_ref_desc
*rdesc
;
3461 try_decrement_rdesc_refcount (jf
);
3462 if (jf
->type
== IPA_JF_CONST
3463 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3469 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3472 /* Hook that is called by cgraph.c when an edge is duplicated. */
3475 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3478 struct ipa_edge_args
*old_args
, *new_args
;
3481 ipa_check_create_edge_args ();
3483 old_args
= IPA_EDGE_REF (src
);
3484 new_args
= IPA_EDGE_REF (dst
);
3486 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3487 if (old_args
->polymorphic_call_contexts
)
3488 new_args
->polymorphic_call_contexts
3489 = vec_safe_copy (old_args
->polymorphic_call_contexts
);
3491 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3493 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3494 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3496 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3498 if (src_jf
->type
== IPA_JF_CONST
)
3500 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3503 dst_jf
->value
.constant
.rdesc
= NULL
;
3504 else if (src
->caller
== dst
->caller
)
3506 struct ipa_ref
*ref
;
3507 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3508 gcc_checking_assert (n
);
3509 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3511 gcc_checking_assert (ref
);
3512 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3514 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3515 dst_rdesc
->cs
= dst
;
3516 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3517 dst_rdesc
->next_duplicate
= NULL
;
3518 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3520 else if (src_rdesc
->cs
== src
)
3522 struct ipa_cst_ref_desc
*dst_rdesc
= ipa_refdesc_pool
.allocate ();
3523 dst_rdesc
->cs
= dst
;
3524 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3525 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3526 src_rdesc
->next_duplicate
= dst_rdesc
;
3527 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3531 struct ipa_cst_ref_desc
*dst_rdesc
;
3532 /* This can happen during inlining, when a JFUNC can refer to a
3533 reference taken in a function up in the tree of inline clones.
3534 We need to find the duplicate that refers to our tree of
3537 gcc_assert (dst
->caller
->global
.inlined_to
);
3538 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3540 dst_rdesc
= dst_rdesc
->next_duplicate
)
3542 struct cgraph_node
*top
;
3543 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3544 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3545 : dst_rdesc
->cs
->caller
;
3546 if (dst
->caller
->global
.inlined_to
== top
)
3549 gcc_assert (dst_rdesc
);
3550 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3553 else if (dst_jf
->type
== IPA_JF_PASS_THROUGH
3554 && src
->caller
== dst
->caller
)
3556 struct cgraph_node
*inline_root
= dst
->caller
->global
.inlined_to
3557 ? dst
->caller
->global
.inlined_to
: dst
->caller
;
3558 struct ipa_node_params
*root_info
= IPA_NODE_REF (inline_root
);
3559 int idx
= ipa_get_jf_pass_through_formal_id (dst_jf
);
3561 int c
= ipa_get_controlled_uses (root_info
, idx
);
3562 if (c
!= IPA_UNDESCRIBED_USE
)
3565 ipa_set_controlled_uses (root_info
, idx
, c
);
3571 /* Analyze newly added function into callgraph. */
3574 ipa_add_new_function (cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3576 if (node
->has_gimple_body_p ())
3577 ipa_analyze_node (node
);
3580 /* Hook that is called by summary when a node is duplicated. */
3583 ipa_node_params_t::duplicate(cgraph_node
*src
, cgraph_node
*dst
,
3584 ipa_node_params
*old_info
,
3585 ipa_node_params
*new_info
)
3587 ipa_agg_replacement_value
*old_av
, *new_av
;
3589 new_info
->descriptors
= old_info
->descriptors
.copy ();
3590 new_info
->lattices
= NULL
;
3591 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3593 new_info
->analysis_done
= old_info
->analysis_done
;
3594 new_info
->node_enqueued
= old_info
->node_enqueued
;
3596 old_av
= ipa_get_agg_replacements_for_node (src
);
3602 struct ipa_agg_replacement_value
*v
;
3604 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3605 memcpy (v
, old_av
, sizeof (*v
));
3608 old_av
= old_av
->next
;
3610 ipa_set_node_agg_value_chain (dst
, new_av
);
3613 ipcp_transformation_summary
*src_trans
= ipcp_get_transformation_summary (src
);
3615 if (src_trans
&& vec_safe_length (src_trans
->alignments
) > 0)
3617 ipcp_grow_transformations_if_necessary ();
3618 src_trans
= ipcp_get_transformation_summary (src
);
3619 const vec
<ipa_alignment
, va_gc
> *src_alignments
= src_trans
->alignments
;
3620 vec
<ipa_alignment
, va_gc
> *&dst_alignments
3621 = ipcp_get_transformation_summary (dst
)->alignments
;
3622 vec_safe_reserve_exact (dst_alignments
, src_alignments
->length ());
3623 for (unsigned i
= 0; i
< src_alignments
->length (); ++i
)
3624 dst_alignments
->quick_push ((*src_alignments
)[i
]);
3628 /* Register our cgraph hooks if they are not already there. */
3631 ipa_register_cgraph_hooks (void)
3633 ipa_check_create_node_params ();
3635 if (!edge_removal_hook_holder
)
3636 edge_removal_hook_holder
=
3637 symtab
->add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3638 if (!edge_duplication_hook_holder
)
3639 edge_duplication_hook_holder
=
3640 symtab
->add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3641 function_insertion_hook_holder
=
3642 symtab
->add_cgraph_insertion_hook (&ipa_add_new_function
, NULL
);
3645 /* Unregister our cgraph hooks if they are not already there. */
3648 ipa_unregister_cgraph_hooks (void)
3650 symtab
->remove_edge_removal_hook (edge_removal_hook_holder
);
3651 edge_removal_hook_holder
= NULL
;
3652 symtab
->remove_edge_duplication_hook (edge_duplication_hook_holder
);
3653 edge_duplication_hook_holder
= NULL
;
3654 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
3655 function_insertion_hook_holder
= NULL
;
3658 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3659 longer needed after ipa-cp. */
3662 ipa_free_all_structures_after_ipa_cp (void)
3664 if (!optimize
&& !in_lto_p
)
3666 ipa_free_all_edge_args ();
3667 ipa_free_all_node_params ();
3668 ipcp_sources_pool
.release ();
3669 ipcp_cst_values_pool
.release ();
3670 ipcp_poly_ctx_values_pool
.release ();
3671 ipcp_agg_lattice_pool
.release ();
3672 ipa_unregister_cgraph_hooks ();
3673 ipa_refdesc_pool
.release ();
3677 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3678 longer needed after indirect inlining. */
3681 ipa_free_all_structures_after_iinln (void)
3683 ipa_free_all_edge_args ();
3684 ipa_free_all_node_params ();
3685 ipa_unregister_cgraph_hooks ();
3686 ipcp_sources_pool
.release ();
3687 ipcp_cst_values_pool
.release ();
3688 ipcp_poly_ctx_values_pool
.release ();
3689 ipcp_agg_lattice_pool
.release ();
3690 ipa_refdesc_pool
.release ();
3693 /* Print ipa_tree_map data structures of all functions in the
3697 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3700 struct ipa_node_params
*info
;
3702 if (!node
->definition
)
3704 info
= IPA_NODE_REF (node
);
3705 fprintf (f
, " function %s/%i parameter descriptors:\n",
3706 node
->name (), node
->order
);
3707 count
= ipa_get_param_count (info
);
3708 for (i
= 0; i
< count
; i
++)
3713 ipa_dump_param (f
, info
, i
);
3714 if (ipa_is_param_used (info
, i
))
3715 fprintf (f
, " used");
3716 c
= ipa_get_controlled_uses (info
, i
);
3717 if (c
== IPA_UNDESCRIBED_USE
)
3718 fprintf (f
, " undescribed_use");
3720 fprintf (f
, " controlled_uses=%i", c
);
3725 /* Print ipa_tree_map data structures of all functions in the
3729 ipa_print_all_params (FILE * f
)
3731 struct cgraph_node
*node
;
3733 fprintf (f
, "\nFunction parameters:\n");
3734 FOR_EACH_FUNCTION (node
)
3735 ipa_print_node_params (f
, node
);
3738 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3741 ipa_get_vector_of_formal_parms (tree fndecl
)
3747 gcc_assert (!flag_wpa
);
3748 count
= count_formal_params (fndecl
);
3749 args
.create (count
);
3750 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3751 args
.quick_push (parm
);
3756 /* Return a heap allocated vector containing types of formal parameters of
3757 function type FNTYPE. */
3760 ipa_get_vector_of_formal_parm_types (tree fntype
)
3766 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3769 types
.create (count
);
3770 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3771 types
.quick_push (TREE_VALUE (t
));
3776 /* Modify the function declaration FNDECL and its type according to the plan in
3777 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3778 to reflect the actual parameters being modified which are determined by the
3779 base_index field. */
3782 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
3784 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
3785 tree orig_type
= TREE_TYPE (fndecl
);
3786 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
3788 /* The following test is an ugly hack, some functions simply don't have any
3789 arguments in their type. This is probably a bug but well... */
3790 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
3791 bool last_parm_void
;
3795 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
3797 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
3799 gcc_assert (oparms
.length () + 1 == otypes
.length ());
3801 gcc_assert (oparms
.length () == otypes
.length ());
3805 last_parm_void
= false;
3809 int len
= adjustments
.length ();
3810 tree
*link
= &DECL_ARGUMENTS (fndecl
);
3811 tree new_arg_types
= NULL
;
3812 for (int i
= 0; i
< len
; i
++)
3814 struct ipa_parm_adjustment
*adj
;
3817 adj
= &adjustments
[i
];
3819 if (adj
->op
== IPA_PARM_OP_NEW
)
3822 parm
= oparms
[adj
->base_index
];
3825 if (adj
->op
== IPA_PARM_OP_COPY
)
3828 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
3831 link
= &DECL_CHAIN (parm
);
3833 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3839 ptype
= build_pointer_type (adj
->type
);
3843 if (is_gimple_reg_type (ptype
))
3845 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
3846 if (TYPE_ALIGN (ptype
) < malign
)
3847 ptype
= build_aligned_type (ptype
, malign
);
3852 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
3854 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
3856 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
3857 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
3858 DECL_ARTIFICIAL (new_parm
) = 1;
3859 DECL_ARG_TYPE (new_parm
) = ptype
;
3860 DECL_CONTEXT (new_parm
) = fndecl
;
3861 TREE_USED (new_parm
) = 1;
3862 DECL_IGNORED_P (new_parm
) = 1;
3863 layout_decl (new_parm
, 0);
3865 if (adj
->op
== IPA_PARM_OP_NEW
)
3869 adj
->new_decl
= new_parm
;
3872 link
= &DECL_CHAIN (new_parm
);
3878 tree new_reversed
= NULL
;
3881 new_reversed
= nreverse (new_arg_types
);
3885 TREE_CHAIN (new_arg_types
) = void_list_node
;
3887 new_reversed
= void_list_node
;
3891 /* Use copy_node to preserve as much as possible from original type
3892 (debug info, attribute lists etc.)
3893 Exception is METHOD_TYPEs must have THIS argument.
3894 When we are asked to remove it, we need to build new FUNCTION_TYPE
3896 tree new_type
= NULL
;
3897 if (TREE_CODE (orig_type
) != METHOD_TYPE
3898 || (adjustments
[0].op
== IPA_PARM_OP_COPY
3899 && adjustments
[0].base_index
== 0))
3901 new_type
= build_distinct_type_copy (orig_type
);
3902 TYPE_ARG_TYPES (new_type
) = new_reversed
;
3907 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
3909 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
3910 DECL_VINDEX (fndecl
) = NULL_TREE
;
3913 /* When signature changes, we need to clear builtin info. */
3914 if (DECL_BUILT_IN (fndecl
))
3916 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
3917 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
3920 TREE_TYPE (fndecl
) = new_type
;
3921 DECL_VIRTUAL_P (fndecl
) = 0;
3922 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
3927 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
3928 If this is a directly recursive call, CS must be NULL. Otherwise it must
3929 contain the corresponding call graph edge. */
3932 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gcall
*stmt
,
3933 ipa_parm_adjustment_vec adjustments
)
3935 struct cgraph_node
*current_node
= cgraph_node::get (current_function_decl
);
3937 vec
<tree
, va_gc
> **debug_args
= NULL
;
3939 gimple_stmt_iterator gsi
, prev_gsi
;
3943 len
= adjustments
.length ();
3945 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
3946 current_node
->remove_stmt_references (stmt
);
3948 gsi
= gsi_for_stmt (stmt
);
3950 gsi_prev (&prev_gsi
);
3951 for (i
= 0; i
< len
; i
++)
3953 struct ipa_parm_adjustment
*adj
;
3955 adj
= &adjustments
[i
];
3957 if (adj
->op
== IPA_PARM_OP_COPY
)
3959 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
3961 vargs
.quick_push (arg
);
3963 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3965 tree expr
, base
, off
;
3967 unsigned int deref_align
= 0;
3968 bool deref_base
= false;
3970 /* We create a new parameter out of the value of the old one, we can
3971 do the following kind of transformations:
3973 - A scalar passed by reference is converted to a scalar passed by
3974 value. (adj->by_ref is false and the type of the original
3975 actual argument is a pointer to a scalar).
3977 - A part of an aggregate is passed instead of the whole aggregate.
3978 The part can be passed either by value or by reference, this is
3979 determined by value of adj->by_ref. Moreover, the code below
3980 handles both situations when the original aggregate is passed by
3981 value (its type is not a pointer) and when it is passed by
3982 reference (it is a pointer to an aggregate).
3984 When the new argument is passed by reference (adj->by_ref is true)
3985 it must be a part of an aggregate and therefore we form it by
3986 simply taking the address of a reference inside the original
3989 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
3990 base
= gimple_call_arg (stmt
, adj
->base_index
);
3991 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
3992 : EXPR_LOCATION (base
);
3994 if (TREE_CODE (base
) != ADDR_EXPR
3995 && POINTER_TYPE_P (TREE_TYPE (base
)))
3996 off
= build_int_cst (adj
->alias_ptr_type
,
3997 adj
->offset
/ BITS_PER_UNIT
);
4000 HOST_WIDE_INT base_offset
;
4004 if (TREE_CODE (base
) == ADDR_EXPR
)
4006 base
= TREE_OPERAND (base
, 0);
4012 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
4013 /* Aggregate arguments can have non-invariant addresses. */
4016 base
= build_fold_addr_expr (prev_base
);
4017 off
= build_int_cst (adj
->alias_ptr_type
,
4018 adj
->offset
/ BITS_PER_UNIT
);
4020 else if (TREE_CODE (base
) == MEM_REF
)
4025 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
4027 off
= build_int_cst (adj
->alias_ptr_type
,
4029 + adj
->offset
/ BITS_PER_UNIT
);
4030 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
4032 base
= TREE_OPERAND (base
, 0);
4036 off
= build_int_cst (adj
->alias_ptr_type
,
4038 + adj
->offset
/ BITS_PER_UNIT
);
4039 base
= build_fold_addr_expr (base
);
4045 tree type
= adj
->type
;
4047 unsigned HOST_WIDE_INT misalign
;
4051 align
= deref_align
;
4056 get_pointer_alignment_1 (base
, &align
, &misalign
);
4057 if (TYPE_ALIGN (type
) > align
)
4058 align
= TYPE_ALIGN (type
);
4060 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
4062 misalign
= misalign
& (align
- 1);
4064 align
= (misalign
& -misalign
);
4065 if (align
< TYPE_ALIGN (type
))
4066 type
= build_aligned_type (type
, align
);
4067 base
= force_gimple_operand_gsi (&gsi
, base
,
4068 true, NULL
, true, GSI_SAME_STMT
);
4069 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
4070 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4071 /* If expr is not a valid gimple call argument emit
4072 a load into a temporary. */
4073 if (is_gimple_reg_type (TREE_TYPE (expr
)))
4075 gimple tem
= gimple_build_assign (NULL_TREE
, expr
);
4076 if (gimple_in_ssa_p (cfun
))
4078 gimple_set_vuse (tem
, gimple_vuse (stmt
));
4079 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
4082 expr
= create_tmp_reg (TREE_TYPE (expr
));
4083 gimple_assign_set_lhs (tem
, expr
);
4084 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
4089 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
4090 REF_REVERSE_STORAGE_ORDER (expr
) = adj
->reverse
;
4091 expr
= build_fold_addr_expr (expr
);
4092 expr
= force_gimple_operand_gsi (&gsi
, expr
,
4093 true, NULL
, true, GSI_SAME_STMT
);
4095 vargs
.quick_push (expr
);
4097 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
4100 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
4103 arg
= gimple_call_arg (stmt
, adj
->base_index
);
4104 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
4106 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
4108 arg
= fold_convert_loc (gimple_location (stmt
),
4109 TREE_TYPE (origin
), arg
);
4111 if (debug_args
== NULL
)
4112 debug_args
= decl_debug_args_insert (callee_decl
);
4113 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
4114 if (ddecl
== origin
)
4116 ddecl
= (**debug_args
)[ix
+ 1];
4121 ddecl
= make_node (DEBUG_EXPR_DECL
);
4122 DECL_ARTIFICIAL (ddecl
) = 1;
4123 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
4124 DECL_MODE (ddecl
) = DECL_MODE (origin
);
4126 vec_safe_push (*debug_args
, origin
);
4127 vec_safe_push (*debug_args
, ddecl
);
4129 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
4130 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
4134 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4136 fprintf (dump_file
, "replacing stmt:");
4137 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
4140 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
4142 if (gimple_call_lhs (stmt
))
4143 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
4145 gimple_set_block (new_stmt
, gimple_block (stmt
));
4146 if (gimple_has_location (stmt
))
4147 gimple_set_location (new_stmt
, gimple_location (stmt
));
4148 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
4149 gimple_call_copy_flags (new_stmt
, stmt
);
4150 if (gimple_in_ssa_p (cfun
))
4152 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4153 if (gimple_vdef (stmt
))
4155 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4156 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
4160 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4162 fprintf (dump_file
, "with stmt:");
4163 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
4164 fprintf (dump_file
, "\n");
4166 gsi_replace (&gsi
, new_stmt
, true);
4168 cs
->set_call_stmt (new_stmt
);
4171 current_node
->record_stmt_references (gsi_stmt (gsi
));
4174 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
4177 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
4178 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
4179 specifies whether the function should care about type incompatibility the
4180 current and new expressions. If it is false, the function will leave
4181 incompatibility issues to the caller. Return true iff the expression
4185 ipa_modify_expr (tree
*expr
, bool convert
,
4186 ipa_parm_adjustment_vec adjustments
)
4188 struct ipa_parm_adjustment
*cand
4189 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
4196 src
= build_simple_mem_ref (cand
->new_decl
);
4197 REF_REVERSE_STORAGE_ORDER (src
) = cand
->reverse
;
4200 src
= cand
->new_decl
;
4202 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4204 fprintf (dump_file
, "About to replace expr ");
4205 print_generic_expr (dump_file
, *expr
, 0);
4206 fprintf (dump_file
, " with ");
4207 print_generic_expr (dump_file
, src
, 0);
4208 fprintf (dump_file
, "\n");
4211 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
4213 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
4221 /* If T is an SSA_NAME, return NULL if it is not a default def or
4222 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
4223 the base variable is always returned, regardless if it is a default
4224 def. Return T if it is not an SSA_NAME. */
4227 get_ssa_base_param (tree t
, bool ignore_default_def
)
4229 if (TREE_CODE (t
) == SSA_NAME
)
4231 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
4232 return SSA_NAME_VAR (t
);
4239 /* Given an expression, return an adjustment entry specifying the
4240 transformation to be done on EXPR. If no suitable adjustment entry
4241 was found, returns NULL.
4243 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
4244 default def, otherwise bail on them.
4246 If CONVERT is non-NULL, this function will set *CONVERT if the
4247 expression provided is a component reference. ADJUSTMENTS is the
4248 adjustments vector. */
4250 ipa_parm_adjustment
*
4251 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
4252 ipa_parm_adjustment_vec adjustments
,
4253 bool ignore_default_def
)
4255 if (TREE_CODE (**expr
) == BIT_FIELD_REF
4256 || TREE_CODE (**expr
) == IMAGPART_EXPR
4257 || TREE_CODE (**expr
) == REALPART_EXPR
)
4259 *expr
= &TREE_OPERAND (**expr
, 0);
4264 HOST_WIDE_INT offset
, size
, max_size
;
4267 = get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
, &reverse
);
4268 if (!base
|| size
== -1 || max_size
== -1)
4271 if (TREE_CODE (base
) == MEM_REF
)
4273 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
4274 base
= TREE_OPERAND (base
, 0);
4277 base
= get_ssa_base_param (base
, ignore_default_def
);
4278 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4281 struct ipa_parm_adjustment
*cand
= NULL
;
4282 unsigned int len
= adjustments
.length ();
4283 for (unsigned i
= 0; i
< len
; i
++)
4285 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4287 if (adj
->base
== base
4288 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4295 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4300 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4303 index_in_adjustments_multiple_times_p (int base_index
,
4304 ipa_parm_adjustment_vec adjustments
)
4306 int i
, len
= adjustments
.length ();
4309 for (i
= 0; i
< len
; i
++)
4311 struct ipa_parm_adjustment
*adj
;
4312 adj
= &adjustments
[i
];
4314 if (adj
->base_index
== base_index
)
4326 /* Return adjustments that should have the same effect on function parameters
4327 and call arguments as if they were first changed according to adjustments in
4328 INNER and then by adjustments in OUTER. */
4330 ipa_parm_adjustment_vec
4331 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4332 ipa_parm_adjustment_vec outer
)
4334 int i
, outlen
= outer
.length ();
4335 int inlen
= inner
.length ();
4337 ipa_parm_adjustment_vec adjustments
, tmp
;
4340 for (i
= 0; i
< inlen
; i
++)
4342 struct ipa_parm_adjustment
*n
;
4345 if (n
->op
== IPA_PARM_OP_REMOVE
)
4349 /* FIXME: Handling of new arguments are not implemented yet. */
4350 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4351 tmp
.quick_push (*n
);
4355 adjustments
.create (outlen
+ removals
);
4356 for (i
= 0; i
< outlen
; i
++)
4358 struct ipa_parm_adjustment r
;
4359 struct ipa_parm_adjustment
*out
= &outer
[i
];
4360 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4362 memset (&r
, 0, sizeof (r
));
4363 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4364 if (out
->op
== IPA_PARM_OP_REMOVE
)
4366 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4368 r
.op
= IPA_PARM_OP_REMOVE
;
4369 adjustments
.quick_push (r
);
4375 /* FIXME: Handling of new arguments are not implemented yet. */
4376 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4379 r
.base_index
= in
->base_index
;
4382 /* FIXME: Create nonlocal value too. */
4384 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4385 r
.op
= IPA_PARM_OP_COPY
;
4386 else if (in
->op
== IPA_PARM_OP_COPY
)
4387 r
.offset
= out
->offset
;
4388 else if (out
->op
== IPA_PARM_OP_COPY
)
4389 r
.offset
= in
->offset
;
4391 r
.offset
= in
->offset
+ out
->offset
;
4392 adjustments
.quick_push (r
);
4395 for (i
= 0; i
< inlen
; i
++)
4397 struct ipa_parm_adjustment
*n
= &inner
[i
];
4399 if (n
->op
== IPA_PARM_OP_REMOVE
)
4400 adjustments
.quick_push (*n
);
4407 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4408 friendly way, assuming they are meant to be applied to FNDECL. */
4411 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4414 int i
, len
= adjustments
.length ();
4416 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4418 fprintf (file
, "IPA param adjustments: ");
4419 for (i
= 0; i
< len
; i
++)
4421 struct ipa_parm_adjustment
*adj
;
4422 adj
= &adjustments
[i
];
4425 fprintf (file
, " ");
4429 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4430 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4433 fprintf (file
, ", base: ");
4434 print_generic_expr (file
, adj
->base
, 0);
4438 fprintf (file
, ", new_decl: ");
4439 print_generic_expr (file
, adj
->new_decl
, 0);
4441 if (adj
->new_ssa_base
)
4443 fprintf (file
, ", new_ssa_base: ");
4444 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4447 if (adj
->op
== IPA_PARM_OP_COPY
)
4448 fprintf (file
, ", copy_param");
4449 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4450 fprintf (file
, ", remove_param");
4452 fprintf (file
, ", offset %li", (long) adj
->offset
);
4454 fprintf (file
, ", by_ref");
4455 print_node_brief (file
, ", type: ", adj
->type
, 0);
4456 fprintf (file
, "\n");
4461 /* Dump the AV linked list. */
4464 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4467 fprintf (f
, " Aggregate replacements:");
4468 for (; av
; av
= av
->next
)
4470 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4471 av
->index
, av
->offset
);
4472 print_generic_expr (f
, av
->value
, 0);
4478 /* Stream out jump function JUMP_FUNC to OB. */
4481 ipa_write_jump_function (struct output_block
*ob
,
4482 struct ipa_jump_func
*jump_func
)
4484 struct ipa_agg_jf_item
*item
;
4485 struct bitpack_d bp
;
4488 streamer_write_uhwi (ob
, jump_func
->type
);
4489 switch (jump_func
->type
)
4491 case IPA_JF_UNKNOWN
:
4495 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4496 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4498 case IPA_JF_PASS_THROUGH
:
4499 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4500 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4502 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4503 bp
= bitpack_create (ob
->main_stream
);
4504 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4505 streamer_write_bitpack (&bp
);
4509 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4510 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4513 case IPA_JF_ANCESTOR
:
4514 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4515 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4516 bp
= bitpack_create (ob
->main_stream
);
4517 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4518 streamer_write_bitpack (&bp
);
4522 count
= vec_safe_length (jump_func
->agg
.items
);
4523 streamer_write_uhwi (ob
, count
);
4526 bp
= bitpack_create (ob
->main_stream
);
4527 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4528 streamer_write_bitpack (&bp
);
4531 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4533 streamer_write_uhwi (ob
, item
->offset
);
4534 stream_write_tree (ob
, item
->value
, true);
4537 bp
= bitpack_create (ob
->main_stream
);
4538 bp_pack_value (&bp
, jump_func
->alignment
.known
, 1);
4539 streamer_write_bitpack (&bp
);
4540 if (jump_func
->alignment
.known
)
4542 streamer_write_uhwi (ob
, jump_func
->alignment
.align
);
4543 streamer_write_uhwi (ob
, jump_func
->alignment
.misalign
);
4547 /* Read in jump function JUMP_FUNC from IB. */
4550 ipa_read_jump_function (struct lto_input_block
*ib
,
4551 struct ipa_jump_func
*jump_func
,
4552 struct cgraph_edge
*cs
,
4553 struct data_in
*data_in
)
4555 enum jump_func_type jftype
;
4556 enum tree_code operation
;
4559 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4562 case IPA_JF_UNKNOWN
:
4563 ipa_set_jf_unknown (jump_func
);
4566 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4568 case IPA_JF_PASS_THROUGH
:
4569 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4570 if (operation
== NOP_EXPR
)
4572 int formal_id
= streamer_read_uhwi (ib
);
4573 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4574 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4575 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
);
4579 tree operand
= stream_read_tree (ib
, data_in
);
4580 int formal_id
= streamer_read_uhwi (ib
);
4581 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4585 case IPA_JF_ANCESTOR
:
4587 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4588 int formal_id
= streamer_read_uhwi (ib
);
4589 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4590 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4591 ipa_set_ancestor_jf (jump_func
, offset
, formal_id
, agg_preserved
);
4596 count
= streamer_read_uhwi (ib
);
4597 vec_alloc (jump_func
->agg
.items
, count
);
4600 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4601 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4603 for (i
= 0; i
< count
; i
++)
4605 struct ipa_agg_jf_item item
;
4606 item
.offset
= streamer_read_uhwi (ib
);
4607 item
.value
= stream_read_tree (ib
, data_in
);
4608 jump_func
->agg
.items
->quick_push (item
);
4611 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4612 bool alignment_known
= bp_unpack_value (&bp
, 1);
4613 if (alignment_known
)
4615 jump_func
->alignment
.known
= true;
4616 jump_func
->alignment
.align
= streamer_read_uhwi (ib
);
4617 jump_func
->alignment
.misalign
= streamer_read_uhwi (ib
);
4620 jump_func
->alignment
.known
= false;
4623 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4624 relevant to indirect inlining to OB. */
4627 ipa_write_indirect_edge_info (struct output_block
*ob
,
4628 struct cgraph_edge
*cs
)
4630 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4631 struct bitpack_d bp
;
4633 streamer_write_hwi (ob
, ii
->param_index
);
4634 bp
= bitpack_create (ob
->main_stream
);
4635 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4636 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4637 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4638 bp_pack_value (&bp
, ii
->by_ref
, 1);
4639 bp_pack_value (&bp
, ii
->vptr_changed
, 1);
4640 streamer_write_bitpack (&bp
);
4641 if (ii
->agg_contents
|| ii
->polymorphic
)
4642 streamer_write_hwi (ob
, ii
->offset
);
4644 gcc_assert (ii
->offset
== 0);
4646 if (ii
->polymorphic
)
4648 streamer_write_hwi (ob
, ii
->otr_token
);
4649 stream_write_tree (ob
, ii
->otr_type
, true);
4650 ii
->context
.stream_out (ob
);
4654 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4655 relevant to indirect inlining from IB. */
4658 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4659 struct data_in
*data_in
,
4660 struct cgraph_edge
*cs
)
4662 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4663 struct bitpack_d bp
;
4665 ii
->param_index
= (int) streamer_read_hwi (ib
);
4666 bp
= streamer_read_bitpack (ib
);
4667 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4668 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4669 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4670 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4671 ii
->vptr_changed
= bp_unpack_value (&bp
, 1);
4672 if (ii
->agg_contents
|| ii
->polymorphic
)
4673 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4676 if (ii
->polymorphic
)
4678 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4679 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4680 ii
->context
.stream_in (ib
, data_in
);
4684 /* Stream out NODE info to OB. */
4687 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4690 lto_symtab_encoder_t encoder
;
4691 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4693 struct cgraph_edge
*e
;
4694 struct bitpack_d bp
;
4696 encoder
= ob
->decl_state
->symtab_node_encoder
;
4697 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4698 streamer_write_uhwi (ob
, node_ref
);
4700 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4701 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4702 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4703 bp
= bitpack_create (ob
->main_stream
);
4704 gcc_assert (info
->analysis_done
4705 || ipa_get_param_count (info
) == 0);
4706 gcc_assert (!info
->node_enqueued
);
4707 gcc_assert (!info
->ipcp_orig_node
);
4708 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4709 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4710 streamer_write_bitpack (&bp
);
4711 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4712 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4713 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4715 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4717 streamer_write_uhwi (ob
,
4718 ipa_get_cs_argument_count (args
) * 2
4719 + (args
->polymorphic_call_contexts
!= NULL
));
4720 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4722 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4723 if (args
->polymorphic_call_contexts
!= NULL
)
4724 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4727 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4729 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4731 streamer_write_uhwi (ob
,
4732 ipa_get_cs_argument_count (args
) * 2
4733 + (args
->polymorphic_call_contexts
!= NULL
));
4734 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4736 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4737 if (args
->polymorphic_call_contexts
!= NULL
)
4738 ipa_get_ith_polymorhic_call_context (args
, j
)->stream_out (ob
);
4740 ipa_write_indirect_edge_info (ob
, e
);
4744 /* Stream in NODE info from IB. */
4747 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4748 struct data_in
*data_in
)
4750 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4752 struct cgraph_edge
*e
;
4753 struct bitpack_d bp
;
4755 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
4757 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4758 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
4760 bp
= streamer_read_bitpack (ib
);
4761 if (ipa_get_param_count (info
) != 0)
4762 info
->analysis_done
= true;
4763 info
->node_enqueued
= false;
4764 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4765 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
4766 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4767 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
4768 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4770 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4771 int count
= streamer_read_uhwi (ib
);
4772 bool contexts_computed
= count
& 1;
4777 vec_safe_grow_cleared (args
->jump_functions
, count
);
4778 if (contexts_computed
)
4779 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4781 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4783 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4785 if (contexts_computed
)
4786 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
4789 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4791 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4792 int count
= streamer_read_uhwi (ib
);
4793 bool contexts_computed
= count
& 1;
4798 vec_safe_grow_cleared (args
->jump_functions
, count
);
4799 if (contexts_computed
)
4800 vec_safe_grow_cleared (args
->polymorphic_call_contexts
, count
);
4801 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4803 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4805 if (contexts_computed
)
4806 ipa_get_ith_polymorhic_call_context (args
, k
)->stream_in (ib
, data_in
);
4809 ipa_read_indirect_edge_info (ib
, data_in
, e
);
4813 /* Write jump functions for nodes in SET. */
4816 ipa_prop_write_jump_functions (void)
4818 struct cgraph_node
*node
;
4819 struct output_block
*ob
;
4820 unsigned int count
= 0;
4821 lto_symtab_encoder_iterator lsei
;
4822 lto_symtab_encoder_t encoder
;
4824 if (!ipa_node_params_sum
)
4827 ob
= create_output_block (LTO_section_jump_functions
);
4828 encoder
= ob
->decl_state
->symtab_node_encoder
;
4830 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4831 lsei_next_function_in_partition (&lsei
))
4833 node
= lsei_cgraph_node (lsei
);
4834 if (node
->has_gimple_body_p ()
4835 && IPA_NODE_REF (node
) != NULL
)
4839 streamer_write_uhwi (ob
, count
);
4841 /* Process all of the functions. */
4842 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4843 lsei_next_function_in_partition (&lsei
))
4845 node
= lsei_cgraph_node (lsei
);
4846 if (node
->has_gimple_body_p ()
4847 && IPA_NODE_REF (node
) != NULL
)
4848 ipa_write_node_info (ob
, node
);
4850 streamer_write_char_stream (ob
->main_stream
, 0);
4851 produce_asm (ob
, NULL
);
4852 destroy_output_block (ob
);
4855 /* Read section in file FILE_DATA of length LEN with data DATA. */
4858 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
4861 const struct lto_function_header
*header
=
4862 (const struct lto_function_header
*) data
;
4863 const int cfg_offset
= sizeof (struct lto_function_header
);
4864 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4865 const int string_offset
= main_offset
+ header
->main_size
;
4866 struct data_in
*data_in
;
4870 lto_input_block
ib_main ((const char *) data
+ main_offset
,
4871 header
->main_size
, file_data
->mode_table
);
4874 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4875 header
->string_size
, vNULL
);
4876 count
= streamer_read_uhwi (&ib_main
);
4878 for (i
= 0; i
< count
; i
++)
4881 struct cgraph_node
*node
;
4882 lto_symtab_encoder_t encoder
;
4884 index
= streamer_read_uhwi (&ib_main
);
4885 encoder
= file_data
->symtab_node_encoder
;
4886 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
4888 gcc_assert (node
->definition
);
4889 ipa_read_node_info (&ib_main
, node
, data_in
);
4891 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4893 lto_data_in_delete (data_in
);
4896 /* Read ipcp jump functions. */
4899 ipa_prop_read_jump_functions (void)
4901 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4902 struct lto_file_decl_data
*file_data
;
4905 ipa_check_create_node_params ();
4906 ipa_check_create_edge_args ();
4907 ipa_register_cgraph_hooks ();
4909 while ((file_data
= file_data_vec
[j
++]))
4912 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
4915 ipa_prop_read_section (file_data
, data
, len
);
4919 /* After merging units, we can get mismatch in argument counts.
4920 Also decl merging might've rendered parameter lists obsolete.
4921 Also compute called_with_variable_arg info. */
4924 ipa_update_after_lto_read (void)
4926 ipa_check_create_node_params ();
4927 ipa_check_create_edge_args ();
4931 write_ipcp_transformation_info (output_block
*ob
, cgraph_node
*node
)
4934 unsigned int count
= 0;
4935 lto_symtab_encoder_t encoder
;
4936 struct ipa_agg_replacement_value
*aggvals
, *av
;
4938 aggvals
= ipa_get_agg_replacements_for_node (node
);
4939 encoder
= ob
->decl_state
->symtab_node_encoder
;
4940 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4941 streamer_write_uhwi (ob
, node_ref
);
4943 for (av
= aggvals
; av
; av
= av
->next
)
4945 streamer_write_uhwi (ob
, count
);
4947 for (av
= aggvals
; av
; av
= av
->next
)
4949 struct bitpack_d bp
;
4951 streamer_write_uhwi (ob
, av
->offset
);
4952 streamer_write_uhwi (ob
, av
->index
);
4953 stream_write_tree (ob
, av
->value
, true);
4955 bp
= bitpack_create (ob
->main_stream
);
4956 bp_pack_value (&bp
, av
->by_ref
, 1);
4957 streamer_write_bitpack (&bp
);
4960 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
4961 if (ts
&& vec_safe_length (ts
->alignments
) > 0)
4963 count
= ts
->alignments
->length ();
4965 streamer_write_uhwi (ob
, count
);
4966 for (unsigned i
= 0; i
< count
; ++i
)
4968 ipa_alignment
*parm_al
= &(*ts
->alignments
)[i
];
4970 struct bitpack_d bp
;
4971 bp
= bitpack_create (ob
->main_stream
);
4972 bp_pack_value (&bp
, parm_al
->known
, 1);
4973 streamer_write_bitpack (&bp
);
4976 streamer_write_uhwi (ob
, parm_al
->align
);
4977 streamer_write_hwi_in_range (ob
->main_stream
, 0, parm_al
->align
,
4983 streamer_write_uhwi (ob
, 0);
4986 /* Stream in the aggregate value replacement chain for NODE from IB. */
4989 read_ipcp_transformation_info (lto_input_block
*ib
, cgraph_node
*node
,
4992 struct ipa_agg_replacement_value
*aggvals
= NULL
;
4993 unsigned int count
, i
;
4995 count
= streamer_read_uhwi (ib
);
4996 for (i
= 0; i
<count
; i
++)
4998 struct ipa_agg_replacement_value
*av
;
4999 struct bitpack_d bp
;
5001 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
5002 av
->offset
= streamer_read_uhwi (ib
);
5003 av
->index
= streamer_read_uhwi (ib
);
5004 av
->value
= stream_read_tree (ib
, data_in
);
5005 bp
= streamer_read_bitpack (ib
);
5006 av
->by_ref
= bp_unpack_value (&bp
, 1);
5010 ipa_set_node_agg_value_chain (node
, aggvals
);
5012 count
= streamer_read_uhwi (ib
);
5015 ipcp_grow_transformations_if_necessary ();
5017 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5018 vec_safe_grow_cleared (ts
->alignments
, count
);
5020 for (i
= 0; i
< count
; i
++)
5022 ipa_alignment
*parm_al
;
5023 parm_al
= &(*ts
->alignments
)[i
];
5024 struct bitpack_d bp
;
5025 bp
= streamer_read_bitpack (ib
);
5026 parm_al
->known
= bp_unpack_value (&bp
, 1);
5029 parm_al
->align
= streamer_read_uhwi (ib
);
5031 = streamer_read_hwi_in_range (ib
, "ipa-prop misalign",
5038 /* Write all aggregate replacement for nodes in set. */
5041 ipcp_write_transformation_summaries (void)
5043 struct cgraph_node
*node
;
5044 struct output_block
*ob
;
5045 unsigned int count
= 0;
5046 lto_symtab_encoder_iterator lsei
;
5047 lto_symtab_encoder_t encoder
;
5049 ob
= create_output_block (LTO_section_ipcp_transform
);
5050 encoder
= ob
->decl_state
->symtab_node_encoder
;
5052 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5053 lsei_next_function_in_partition (&lsei
))
5055 node
= lsei_cgraph_node (lsei
);
5056 if (node
->has_gimple_body_p ())
5060 streamer_write_uhwi (ob
, count
);
5062 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
5063 lsei_next_function_in_partition (&lsei
))
5065 node
= lsei_cgraph_node (lsei
);
5066 if (node
->has_gimple_body_p ())
5067 write_ipcp_transformation_info (ob
, node
);
5069 streamer_write_char_stream (ob
->main_stream
, 0);
5070 produce_asm (ob
, NULL
);
5071 destroy_output_block (ob
);
5074 /* Read replacements section in file FILE_DATA of length LEN with data
5078 read_replacements_section (struct lto_file_decl_data
*file_data
,
5082 const struct lto_function_header
*header
=
5083 (const struct lto_function_header
*) data
;
5084 const int cfg_offset
= sizeof (struct lto_function_header
);
5085 const int main_offset
= cfg_offset
+ header
->cfg_size
;
5086 const int string_offset
= main_offset
+ header
->main_size
;
5087 struct data_in
*data_in
;
5091 lto_input_block
ib_main ((const char *) data
+ main_offset
,
5092 header
->main_size
, file_data
->mode_table
);
5094 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
5095 header
->string_size
, vNULL
);
5096 count
= streamer_read_uhwi (&ib_main
);
5098 for (i
= 0; i
< count
; i
++)
5101 struct cgraph_node
*node
;
5102 lto_symtab_encoder_t encoder
;
5104 index
= streamer_read_uhwi (&ib_main
);
5105 encoder
= file_data
->symtab_node_encoder
;
5106 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
5108 gcc_assert (node
->definition
);
5109 read_ipcp_transformation_info (&ib_main
, node
, data_in
);
5111 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
5113 lto_data_in_delete (data_in
);
5116 /* Read IPA-CP aggregate replacements. */
5119 ipcp_read_transformation_summaries (void)
5121 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
5122 struct lto_file_decl_data
*file_data
;
5125 while ((file_data
= file_data_vec
[j
++]))
5128 const char *data
= lto_get_section_data (file_data
,
5129 LTO_section_ipcp_transform
,
5132 read_replacements_section (file_data
, data
, len
);
5136 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5140 adjust_agg_replacement_values (struct cgraph_node
*node
,
5141 struct ipa_agg_replacement_value
*aggval
)
5143 struct ipa_agg_replacement_value
*v
;
5144 int i
, c
= 0, d
= 0, *adj
;
5146 if (!node
->clone
.combined_args_to_skip
)
5149 for (v
= aggval
; v
; v
= v
->next
)
5151 gcc_assert (v
->index
>= 0);
5157 adj
= XALLOCAVEC (int, c
);
5158 for (i
= 0; i
< c
; i
++)
5159 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5167 for (v
= aggval
; v
; v
= v
->next
)
5168 v
->index
= adj
[v
->index
];
5171 /* Dominator walker driving the ipcp modification phase. */
5173 class ipcp_modif_dom_walker
: public dom_walker
5176 ipcp_modif_dom_walker (struct func_body_info
*fbi
,
5177 vec
<ipa_param_descriptor
> descs
,
5178 struct ipa_agg_replacement_value
*av
,
5180 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5181 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5183 virtual void before_dom_children (basic_block
);
5186 struct func_body_info
*m_fbi
;
5187 vec
<ipa_param_descriptor
> m_descriptors
;
5188 struct ipa_agg_replacement_value
*m_aggval
;
5189 bool *m_something_changed
, *m_cfg_changed
;
5193 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5195 gimple_stmt_iterator gsi
;
5196 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5198 struct ipa_agg_replacement_value
*v
;
5199 gimple stmt
= gsi_stmt (gsi
);
5201 HOST_WIDE_INT offset
, size
;
5205 if (!gimple_assign_load_p (stmt
))
5207 rhs
= gimple_assign_rhs1 (stmt
);
5208 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5213 while (handled_component_p (t
))
5215 /* V_C_E can do things like convert an array of integers to one
5216 bigger integer and similar things we do not handle below. */
5217 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
5222 t
= TREE_OPERAND (t
, 0);
5227 if (!ipa_load_from_parm_agg_1 (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5228 &offset
, &size
, &by_ref
))
5230 for (v
= m_aggval
; v
; v
= v
->next
)
5231 if (v
->index
== index
5232 && v
->offset
== offset
)
5235 || v
->by_ref
!= by_ref
5236 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
5239 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5240 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5242 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5243 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5244 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5245 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5246 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5251 fprintf (dump_file
, " const ");
5252 print_generic_expr (dump_file
, v
->value
, 0);
5253 fprintf (dump_file
, " can't be converted to type of ");
5254 print_generic_expr (dump_file
, rhs
, 0);
5255 fprintf (dump_file
, "\n");
5263 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5265 fprintf (dump_file
, "Modifying stmt:\n ");
5266 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5268 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5271 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5273 fprintf (dump_file
, "into:\n ");
5274 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5275 fprintf (dump_file
, "\n");
5278 *m_something_changed
= true;
5279 if (maybe_clean_eh_stmt (stmt
)
5280 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5281 *m_cfg_changed
= true;
5286 /* Update alignment of formal parameters as described in
5287 ipcp_transformation_summary. */
5290 ipcp_update_alignments (struct cgraph_node
*node
)
5292 tree fndecl
= node
->decl
;
5293 tree parm
= DECL_ARGUMENTS (fndecl
);
5294 tree next_parm
= parm
;
5295 ipcp_transformation_summary
*ts
= ipcp_get_transformation_summary (node
);
5296 if (!ts
|| vec_safe_length (ts
->alignments
) == 0)
5298 const vec
<ipa_alignment
, va_gc
> &alignments
= *ts
->alignments
;
5299 unsigned count
= alignments
.length ();
5301 for (unsigned i
= 0; i
< count
; ++i
, parm
= next_parm
)
5303 if (node
->clone
.combined_args_to_skip
5304 && bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5306 gcc_checking_assert (parm
);
5307 next_parm
= DECL_CHAIN (parm
);
5309 if (!alignments
[i
].known
|| !is_gimple_reg (parm
))
5311 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
);
5316 fprintf (dump_file
, " Adjusting alignment of param %u to %u, "
5317 "misalignment to %u\n", i
, alignments
[i
].align
,
5318 alignments
[i
].misalign
);
5320 struct ptr_info_def
*pi
= get_ptr_info (ddef
);
5321 gcc_checking_assert (pi
);
5323 unsigned old_misalign
;
5324 bool old_known
= get_ptr_info_alignment (pi
, &old_align
, &old_misalign
);
5327 && old_align
>= alignments
[i
].align
)
5330 fprintf (dump_file
, " But the alignment was already %u.\n",
5334 set_ptr_info_alignment (pi
, alignments
[i
].align
, alignments
[i
].misalign
);
5338 /* IPCP transformation phase doing propagation of aggregate values. */
5341 ipcp_transform_function (struct cgraph_node
*node
)
5343 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
5344 struct func_body_info fbi
;
5345 struct ipa_agg_replacement_value
*aggval
;
5347 bool cfg_changed
= false, something_changed
= false;
5349 gcc_checking_assert (cfun
);
5350 gcc_checking_assert (current_function_decl
);
5353 fprintf (dump_file
, "Modification phase of node %s/%i\n",
5354 node
->name (), node
->order
);
5356 ipcp_update_alignments (node
);
5357 aggval
= ipa_get_agg_replacements_for_node (node
);
5360 param_count
= count_formal_params (node
->decl
);
5361 if (param_count
== 0)
5363 adjust_agg_replacement_values (node
, aggval
);
5365 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5369 fbi
.bb_infos
= vNULL
;
5370 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5371 fbi
.param_count
= param_count
;
5374 descriptors
.safe_grow_cleared (param_count
);
5375 ipa_populate_param_decls (node
, descriptors
);
5376 calculate_dominance_info (CDI_DOMINATORS
);
5377 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5378 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5381 struct ipa_bb_info
*bi
;
5382 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5383 free_ipa_bb_info (bi
);
5384 fbi
.bb_infos
.release ();
5385 free_dominance_info (CDI_DOMINATORS
);
5386 (*ipcp_transformations
)[node
->uid
].agg_values
= NULL
;
5387 (*ipcp_transformations
)[node
->uid
].alignments
= NULL
;
5388 descriptors
.release ();
5390 if (!something_changed
)
5392 else if (cfg_changed
)
5393 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5395 return TODO_update_ssa_only_virtuals
;