1 /* Interprocedural analyses.
2 Copyright (C) 2005-2014 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"
24 #include "basic-block.h"
25 #include "tree-ssa-alias.h"
26 #include "internal-fn.h"
27 #include "gimple-fold.h"
29 #include "gimple-expr.h"
33 #include "stor-layout.h"
34 #include "print-tree.h"
36 #include "gimple-iterator.h"
37 #include "gimplify-me.h"
38 #include "gimple-walk.h"
39 #include "langhooks.h"
43 #include "gimple-ssa.h"
45 #include "tree-phinodes.h"
46 #include "ssa-iterators.h"
47 #include "tree-into-ssa.h"
49 #include "tree-pass.h"
50 #include "tree-inline.h"
51 #include "ipa-inline.h"
53 #include "diagnostic.h"
54 #include "gimple-pretty-print.h"
55 #include "lto-streamer.h"
56 #include "data-streamer.h"
57 #include "tree-streamer.h"
59 #include "ipa-utils.h"
60 #include "stringpool.h"
61 #include "tree-ssanames.h"
66 /* Intermediate information that we get from alias analysis about a particular
67 parameter in a particular basic_block. When a parameter or the memory it
68 references is marked modified, we use that information in all dominatd
69 blocks without cosulting alias analysis oracle. */
71 struct param_aa_status
73 /* Set when this structure contains meaningful information. If not, the
74 structure describing a dominating BB should be used instead. */
77 /* Whether we have seen something which might have modified the data in
78 question. PARM is for the parameter itself, REF is for data it points to
79 but using the alias type of individual accesses and PT is the same thing
80 but for computing aggregate pass-through functions using a very inclusive
82 bool parm_modified
, ref_modified
, pt_modified
;
85 /* Information related to a given BB that used only when looking at function
90 /* Call graph edges going out of this BB. */
91 vec
<cgraph_edge_p
> cg_edges
;
92 /* Alias analysis statuses of each formal parameter at this bb. */
93 vec
<param_aa_status
> param_aa_statuses
;
96 /* Structure with global information that is only used when looking at function
101 /* The node that is being analyzed. */
105 struct ipa_node_params
*info
;
107 /* Information about individual BBs. */
108 vec
<ipa_bb_info
> bb_infos
;
110 /* Number of parameters. */
113 /* Number of statements already walked by when analyzing this function. */
114 unsigned int aa_walked
;
117 /* Vector where the parameter infos are actually stored. */
118 vec
<ipa_node_params
> ipa_node_params_vector
;
119 /* Vector of known aggregate values in cloned nodes. */
120 vec
<ipa_agg_replacement_value_p
, va_gc
> *ipa_node_agg_replacements
;
121 /* Vector where the parameter infos are actually stored. */
122 vec
<ipa_edge_args
, va_gc
> *ipa_edge_args_vector
;
124 /* Holders of ipa cgraph hooks: */
125 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
126 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
127 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
128 static struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
129 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
131 /* Description of a reference to an IPA constant. */
132 struct ipa_cst_ref_desc
134 /* Edge that corresponds to the statement which took the reference. */
135 struct cgraph_edge
*cs
;
136 /* Linked list of duplicates created when call graph edges are cloned. */
137 struct ipa_cst_ref_desc
*next_duplicate
;
138 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
139 if out of control. */
143 /* Allocation pool for reference descriptions. */
145 static alloc_pool ipa_refdesc_pool
;
147 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
148 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
151 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
153 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
154 struct cl_optimization
*os
;
158 os
= TREE_OPTIMIZATION (fs_opts
);
159 return !os
->x_optimize
|| !os
->x_flag_ipa_cp
;
162 /* Return index of the formal whose tree is PTREE in function which corresponds
166 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
> descriptors
, tree ptree
)
170 count
= descriptors
.length ();
171 for (i
= 0; i
< count
; i
++)
172 if (descriptors
[i
].decl
== ptree
)
178 /* Return index of the formal whose tree is PTREE in function which corresponds
182 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
184 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
187 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
191 ipa_populate_param_decls (struct cgraph_node
*node
,
192 vec
<ipa_param_descriptor
> &descriptors
)
200 gcc_assert (gimple_has_body_p (fndecl
));
201 fnargs
= DECL_ARGUMENTS (fndecl
);
203 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
205 descriptors
[param_num
].decl
= parm
;
206 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
));
211 /* Return how many formal parameters FNDECL has. */
214 count_formal_params (tree fndecl
)
218 gcc_assert (gimple_has_body_p (fndecl
));
220 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
226 /* Return the declaration of Ith formal parameter of the function corresponding
227 to INFO. Note there is no setter function as this array is built just once
228 using ipa_initialize_node_params. */
231 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
233 fprintf (file
, "param #%i", i
);
234 if (info
->descriptors
[i
].decl
)
237 print_generic_expr (file
, info
->descriptors
[i
].decl
, 0);
241 /* Initialize the ipa_node_params structure associated with NODE
242 to hold PARAM_COUNT parameters. */
245 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
247 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
249 if (!info
->descriptors
.exists () && param_count
)
250 info
->descriptors
.safe_grow_cleared (param_count
);
253 /* Initialize the ipa_node_params structure associated with NODE by counting
254 the function parameters, creating the descriptors and populating their
258 ipa_initialize_node_params (struct cgraph_node
*node
)
260 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
262 if (!info
->descriptors
.exists ())
264 ipa_alloc_node_params (node
, count_formal_params (node
->decl
));
265 ipa_populate_param_decls (node
, info
->descriptors
);
269 /* Print the jump functions associated with call graph edge CS to file F. */
272 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
276 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
277 for (i
= 0; i
< count
; i
++)
279 struct ipa_jump_func
*jump_func
;
280 enum jump_func_type type
;
282 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
283 type
= jump_func
->type
;
285 fprintf (f
, " param %d: ", i
);
286 if (type
== IPA_JF_UNKNOWN
)
287 fprintf (f
, "UNKNOWN\n");
288 else if (type
== IPA_JF_KNOWN_TYPE
)
290 fprintf (f
, "KNOWN TYPE: base ");
291 print_generic_expr (f
, jump_func
->value
.known_type
.base_type
, 0);
292 fprintf (f
, ", offset "HOST_WIDE_INT_PRINT_DEC
", component ",
293 jump_func
->value
.known_type
.offset
);
294 print_generic_expr (f
, jump_func
->value
.known_type
.component_type
, 0);
297 else if (type
== IPA_JF_CONST
)
299 tree val
= jump_func
->value
.constant
.value
;
300 fprintf (f
, "CONST: ");
301 print_generic_expr (f
, val
, 0);
302 if (TREE_CODE (val
) == ADDR_EXPR
303 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
306 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
311 else if (type
== IPA_JF_PASS_THROUGH
)
313 fprintf (f
, "PASS THROUGH: ");
314 fprintf (f
, "%d, op %s",
315 jump_func
->value
.pass_through
.formal_id
,
316 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
317 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
320 print_generic_expr (f
,
321 jump_func
->value
.pass_through
.operand
, 0);
323 if (jump_func
->value
.pass_through
.agg_preserved
)
324 fprintf (f
, ", agg_preserved");
325 if (jump_func
->value
.pass_through
.type_preserved
)
326 fprintf (f
, ", type_preserved");
329 else if (type
== IPA_JF_ANCESTOR
)
331 fprintf (f
, "ANCESTOR: ");
332 fprintf (f
, "%d, offset "HOST_WIDE_INT_PRINT_DEC
", ",
333 jump_func
->value
.ancestor
.formal_id
,
334 jump_func
->value
.ancestor
.offset
);
335 print_generic_expr (f
, jump_func
->value
.ancestor
.type
, 0);
336 if (jump_func
->value
.ancestor
.agg_preserved
)
337 fprintf (f
, ", agg_preserved");
338 if (jump_func
->value
.ancestor
.type_preserved
)
339 fprintf (f
, ", type_preserved");
343 if (jump_func
->agg
.items
)
345 struct ipa_agg_jf_item
*item
;
348 fprintf (f
, " Aggregate passed by %s:\n",
349 jump_func
->agg
.by_ref
? "reference" : "value");
350 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
352 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
354 if (TYPE_P (item
->value
))
355 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
356 tree_to_uhwi (TYPE_SIZE (item
->value
)));
359 fprintf (f
, "cst: ");
360 print_generic_expr (f
, item
->value
, 0);
369 /* Print the jump functions of all arguments on all call graph edges going from
373 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
375 struct cgraph_edge
*cs
;
377 fprintf (f
, " Jump functions of caller %s/%i:\n", node
->name (),
379 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
381 if (!ipa_edge_args_info_available_for_edge_p (cs
))
384 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
385 xstrdup (node
->name ()), node
->order
,
386 xstrdup (cs
->callee
->name ()),
388 ipa_print_node_jump_functions_for_edge (f
, cs
);
391 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
393 struct cgraph_indirect_call_info
*ii
;
394 if (!ipa_edge_args_info_available_for_edge_p (cs
))
397 ii
= cs
->indirect_info
;
398 if (ii
->agg_contents
)
399 fprintf (f
, " indirect %s callsite, calling param %i, "
400 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
401 ii
->member_ptr
? "member ptr" : "aggregate",
402 ii
->param_index
, ii
->offset
,
403 ii
->by_ref
? "by reference" : "by_value");
405 fprintf (f
, " indirect %s callsite, calling param %i, "
406 "offset " HOST_WIDE_INT_PRINT_DEC
,
407 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
412 fprintf (f
, ", for stmt ");
413 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
417 ipa_print_node_jump_functions_for_edge (f
, cs
);
421 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
424 ipa_print_all_jump_functions (FILE *f
)
426 struct cgraph_node
*node
;
428 fprintf (f
, "\nJump functions:\n");
429 FOR_EACH_FUNCTION (node
)
431 ipa_print_node_jump_functions (f
, node
);
435 /* Set JFUNC to be a known type jump function. */
438 ipa_set_jf_known_type (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
439 tree base_type
, tree component_type
)
441 gcc_assert (TREE_CODE (component_type
) == RECORD_TYPE
442 && TYPE_BINFO (component_type
));
443 if (!flag_devirtualize
)
445 gcc_assert (BINFO_VTABLE (TYPE_BINFO (component_type
)));
446 jfunc
->type
= IPA_JF_KNOWN_TYPE
;
447 jfunc
->value
.known_type
.offset
= offset
,
448 jfunc
->value
.known_type
.base_type
= base_type
;
449 jfunc
->value
.known_type
.component_type
= component_type
;
450 gcc_assert (component_type
);
453 /* Set JFUNC to be a copy of another jmp (to be used by jump function
454 combination code). The two functions will share their rdesc. */
457 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
458 struct ipa_jump_func
*src
)
461 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
462 dst
->type
= IPA_JF_CONST
;
463 dst
->value
.constant
= src
->value
.constant
;
466 /* Set JFUNC to be a constant jmp function. */
469 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
470 struct cgraph_edge
*cs
)
472 constant
= unshare_expr (constant
);
473 if (constant
&& EXPR_P (constant
))
474 SET_EXPR_LOCATION (constant
, UNKNOWN_LOCATION
);
475 jfunc
->type
= IPA_JF_CONST
;
476 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
478 if (TREE_CODE (constant
) == ADDR_EXPR
479 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
481 struct ipa_cst_ref_desc
*rdesc
;
482 if (!ipa_refdesc_pool
)
483 ipa_refdesc_pool
= create_alloc_pool ("IPA-PROP ref descriptions",
484 sizeof (struct ipa_cst_ref_desc
), 32);
486 rdesc
= (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
488 rdesc
->next_duplicate
= NULL
;
490 jfunc
->value
.constant
.rdesc
= rdesc
;
493 jfunc
->value
.constant
.rdesc
= NULL
;
496 /* Set JFUNC to be a simple pass-through jump function. */
498 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
499 bool agg_preserved
, bool type_preserved
)
501 jfunc
->type
= IPA_JF_PASS_THROUGH
;
502 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
503 jfunc
->value
.pass_through
.formal_id
= formal_id
;
504 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
505 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
506 jfunc
->value
.pass_through
.type_preserved
= type_preserved
;
509 /* Set JFUNC to be an arithmetic pass through jump function. */
512 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
513 tree operand
, enum tree_code operation
)
515 jfunc
->type
= IPA_JF_PASS_THROUGH
;
516 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
517 jfunc
->value
.pass_through
.formal_id
= formal_id
;
518 jfunc
->value
.pass_through
.operation
= operation
;
519 jfunc
->value
.pass_through
.agg_preserved
= false;
520 jfunc
->value
.pass_through
.type_preserved
= false;
523 /* Set JFUNC to be an ancestor jump function. */
526 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
527 tree type
, int formal_id
, bool agg_preserved
,
530 if (!flag_devirtualize
)
531 type_preserved
= false;
532 gcc_assert (!type_preserved
533 || (TREE_CODE (type
) == RECORD_TYPE
535 && BINFO_VTABLE (TYPE_BINFO (type
))));
536 jfunc
->type
= IPA_JF_ANCESTOR
;
537 jfunc
->value
.ancestor
.formal_id
= formal_id
;
538 jfunc
->value
.ancestor
.offset
= offset
;
539 jfunc
->value
.ancestor
.type
= type_preserved
? type
: NULL
;
540 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
541 jfunc
->value
.ancestor
.type_preserved
= type_preserved
;
544 /* Extract the acual BINFO being described by JFUNC which must be a known type
548 ipa_binfo_from_known_type_jfunc (struct ipa_jump_func
*jfunc
)
550 tree base_binfo
= TYPE_BINFO (jfunc
->value
.known_type
.base_type
);
553 return get_binfo_at_offset (base_binfo
,
554 jfunc
->value
.known_type
.offset
,
555 jfunc
->value
.known_type
.component_type
);
558 /* Get IPA BB information about the given BB. FBI is the context of analyzis
559 of this function body. */
561 static struct ipa_bb_info
*
562 ipa_get_bb_info (struct func_body_info
*fbi
, basic_block bb
)
564 gcc_checking_assert (fbi
);
565 return &fbi
->bb_infos
[bb
->index
];
568 /* Structure to be passed in between detect_type_change and
569 check_stmt_for_type_change. */
571 struct type_change_info
573 /* Offset into the object where there is the virtual method pointer we are
575 HOST_WIDE_INT offset
;
576 /* The declaration or SSA_NAME pointer of the base that we are checking for
579 /* If we actually can tell the type that the object has changed to, it is
580 stored in this field. Otherwise it remains NULL_TREE. */
581 tree known_current_type
;
582 /* Set to true if dynamic type change has been detected. */
583 bool type_maybe_changed
;
584 /* Set to true if multiple types have been encountered. known_current_type
585 must be disregarded in that case. */
586 bool multiple_types_encountered
;
589 /* Return true if STMT can modify a virtual method table pointer.
591 This function makes special assumptions about both constructors and
592 destructors which are all the functions that are allowed to alter the VMT
593 pointers. It assumes that destructors begin with assignment into all VMT
594 pointers and that constructors essentially look in the following way:
596 1) The very first thing they do is that they call constructors of ancestor
597 sub-objects that have them.
599 2) Then VMT pointers of this and all its ancestors is set to new values
600 corresponding to the type corresponding to the constructor.
602 3) Only afterwards, other stuff such as constructor of member sub-objects
603 and the code written by the user is run. Only this may include calling
604 virtual functions, directly or indirectly.
606 There is no way to call a constructor of an ancestor sub-object in any
609 This means that we do not have to care whether constructors get the correct
610 type information because they will always change it (in fact, if we define
611 the type to be given by the VMT pointer, it is undefined).
613 The most important fact to derive from the above is that if, for some
614 statement in the section 3, we try to detect whether the dynamic type has
615 changed, we can safely ignore all calls as we examine the function body
616 backwards until we reach statements in section 2 because these calls cannot
617 be ancestor constructors or destructors (if the input is not bogus) and so
618 do not change the dynamic type (this holds true only for automatically
619 allocated objects but at the moment we devirtualize only these). We then
620 must detect that statements in section 2 change the dynamic type and can try
621 to derive the new type. That is enough and we can stop, we will never see
622 the calls into constructors of sub-objects in this code. Therefore we can
623 safely ignore all call statements that we traverse.
627 stmt_may_be_vtbl_ptr_store (gimple stmt
)
629 if (is_gimple_call (stmt
))
631 /* TODO: Skip clobbers, doing so triggers problem in PR60306. */
632 else if (is_gimple_assign (stmt
))
634 tree lhs
= gimple_assign_lhs (stmt
);
636 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
638 if (flag_strict_aliasing
639 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
642 if (TREE_CODE (lhs
) == COMPONENT_REF
643 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
645 /* In the future we might want to use get_base_ref_and_offset to find
646 if there is a field corresponding to the offset and if so, proceed
647 almost like if it was a component ref. */
653 /* If STMT can be proved to be an assignment to the virtual method table
654 pointer of ANALYZED_OBJ and the type associated with the new table
655 identified, return the type. Otherwise return NULL_TREE. */
658 extr_type_from_vtbl_ptr_store (gimple stmt
, struct type_change_info
*tci
)
660 HOST_WIDE_INT offset
, size
, max_size
;
661 tree lhs
, rhs
, base
, binfo
;
663 if (!gimple_assign_single_p (stmt
))
666 lhs
= gimple_assign_lhs (stmt
);
667 rhs
= gimple_assign_rhs1 (stmt
);
668 if (TREE_CODE (lhs
) != COMPONENT_REF
669 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
672 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
673 if (offset
!= tci
->offset
674 || size
!= POINTER_SIZE
675 || max_size
!= POINTER_SIZE
)
677 if (TREE_CODE (base
) == MEM_REF
)
679 if (TREE_CODE (tci
->object
) != MEM_REF
680 || TREE_OPERAND (tci
->object
, 0) != TREE_OPERAND (base
, 0)
681 || !tree_int_cst_equal (TREE_OPERAND (tci
->object
, 1),
682 TREE_OPERAND (base
, 1)))
685 else if (tci
->object
!= base
)
688 binfo
= vtable_pointer_value_to_binfo (rhs
);
690 /* FIXME: vtable_pointer_value_to_binfo may return BINFO of a
691 base of outer type. In this case we would need to either
692 work on binfos or translate it back to outer type and offset.
693 KNOWN_TYPE jump functions are not ready for that, yet. */
694 if (!binfo
|| TYPE_BINFO (BINFO_TYPE (binfo
)) != binfo
)
697 return BINFO_TYPE (binfo
);
700 /* Callback of walk_aliased_vdefs and a helper function for
701 detect_type_change to check whether a particular statement may modify
702 the virtual table pointer, and if possible also determine the new type of
703 the (sub-)object. It stores its result into DATA, which points to a
704 type_change_info structure. */
707 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
709 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
710 struct type_change_info
*tci
= (struct type_change_info
*) data
;
712 if (stmt_may_be_vtbl_ptr_store (stmt
))
715 type
= extr_type_from_vtbl_ptr_store (stmt
, tci
);
716 if (tci
->type_maybe_changed
717 && type
!= tci
->known_current_type
)
718 tci
->multiple_types_encountered
= true;
719 tci
->known_current_type
= type
;
720 tci
->type_maybe_changed
= true;
729 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
730 callsite CALL) by looking for assignments to its virtual table pointer. If
731 it is, return true and fill in the jump function JFUNC with relevant type
732 information or set it to unknown. ARG is the object itself (not a pointer
733 to it, unless dereferenced). BASE is the base of the memory access as
734 returned by get_ref_base_and_extent, as is the offset. */
737 detect_type_change (tree arg
, tree base
, tree comp_type
, gimple call
,
738 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
740 struct type_change_info tci
;
743 gcc_checking_assert (DECL_P (arg
)
744 || TREE_CODE (arg
) == MEM_REF
745 || handled_component_p (arg
));
746 /* Const calls cannot call virtual methods through VMT and so type changes do
748 if (!flag_devirtualize
|| !gimple_vuse (call
)
749 /* Be sure expected_type is polymorphic. */
751 || TREE_CODE (comp_type
) != RECORD_TYPE
752 || !TYPE_BINFO (comp_type
)
753 || !BINFO_VTABLE (TYPE_BINFO (comp_type
)))
756 /* C++ methods are not allowed to change THIS pointer unless they
757 are constructors or destructors. */
758 if (TREE_CODE (base
) == MEM_REF
759 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
760 && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0))
761 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (base
, 0))) == PARM_DECL
762 && TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
763 && !DECL_CXX_CONSTRUCTOR_P (current_function_decl
)
764 && !DECL_CXX_DESTRUCTOR_P (current_function_decl
)
765 && (SSA_NAME_VAR (TREE_OPERAND (base
, 0))
766 == DECL_ARGUMENTS (current_function_decl
)))
769 ao_ref_init (&ao
, arg
);
772 ao
.size
= POINTER_SIZE
;
773 ao
.max_size
= ao
.size
;
776 tci
.object
= get_base_address (arg
);
777 tci
.known_current_type
= NULL_TREE
;
778 tci
.type_maybe_changed
= false;
779 tci
.multiple_types_encountered
= false;
781 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
783 if (!tci
.type_maybe_changed
)
786 if (!tci
.known_current_type
787 || tci
.multiple_types_encountered
789 jfunc
->type
= IPA_JF_UNKNOWN
;
791 ipa_set_jf_known_type (jfunc
, 0, tci
.known_current_type
, comp_type
);
796 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
797 SSA name (its dereference will become the base and the offset is assumed to
801 detect_type_change_ssa (tree arg
, tree comp_type
,
802 gimple call
, struct ipa_jump_func
*jfunc
)
804 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
805 if (!flag_devirtualize
806 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
809 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
810 build_int_cst (ptr_type_node
, 0));
812 return detect_type_change (arg
, arg
, comp_type
, call
, jfunc
, 0);
815 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
816 boolean variable pointed to by DATA. */
819 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
822 bool *b
= (bool *) data
;
827 /* Return true if we have already walked so many statements in AA that we
828 should really just start giving up. */
831 aa_overwalked (struct func_body_info
*fbi
)
833 gcc_checking_assert (fbi
);
834 return fbi
->aa_walked
> (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS
);
837 /* Find the nearest valid aa status for parameter specified by INDEX that
840 static struct param_aa_status
*
841 find_dominating_aa_status (struct func_body_info
*fbi
, basic_block bb
,
846 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
849 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
850 if (!bi
->param_aa_statuses
.is_empty ()
851 && bi
->param_aa_statuses
[index
].valid
)
852 return &bi
->param_aa_statuses
[index
];
856 /* Get AA status structure for the given BB and parameter with INDEX. Allocate
857 structures and/or intialize the result with a dominating description as
860 static struct param_aa_status
*
861 parm_bb_aa_status_for_bb (struct func_body_info
*fbi
, basic_block bb
,
864 gcc_checking_assert (fbi
);
865 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
866 if (bi
->param_aa_statuses
.is_empty ())
867 bi
->param_aa_statuses
.safe_grow_cleared (fbi
->param_count
);
868 struct param_aa_status
*paa
= &bi
->param_aa_statuses
[index
];
871 gcc_checking_assert (!paa
->parm_modified
872 && !paa
->ref_modified
873 && !paa
->pt_modified
);
874 struct param_aa_status
*dom_paa
;
875 dom_paa
= find_dominating_aa_status (fbi
, bb
, index
);
885 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
886 a value known not to be modified in this function before reaching the
887 statement STMT. FBI holds information about the function we have so far
888 gathered but do not survive the summary building stage. */
891 parm_preserved_before_stmt_p (struct func_body_info
*fbi
, int index
,
892 gimple stmt
, tree parm_load
)
894 struct param_aa_status
*paa
;
895 bool modified
= false;
898 /* FIXME: FBI can be NULL if we are being called from outside
899 ipa_node_analysis or ipcp_transform_function, which currently happens
900 during inlining analysis. It would be great to extend fbi's lifetime and
901 always have it. Currently, we are just not afraid of too much walking in
905 if (aa_overwalked (fbi
))
907 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
908 if (paa
->parm_modified
)
914 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
915 ao_ref_init (&refd
, parm_load
);
916 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
919 fbi
->aa_walked
+= walked
;
921 paa
->parm_modified
= true;
925 /* If STMT is an assignment that loads a value from an parameter declaration,
926 return the index of the parameter in ipa_node_params which has not been
927 modified. Otherwise return -1. */
930 load_from_unmodified_param (struct func_body_info
*fbi
,
931 vec
<ipa_param_descriptor
> descriptors
,
937 if (!gimple_assign_single_p (stmt
))
940 op1
= gimple_assign_rhs1 (stmt
);
941 if (TREE_CODE (op1
) != PARM_DECL
)
944 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
946 || !parm_preserved_before_stmt_p (fbi
, index
, stmt
, op1
))
952 /* Return true if memory reference REF (which must be a load through parameter
953 with INDEX) loads data that are known to be unmodified in this function
954 before reaching statement STMT. */
957 parm_ref_data_preserved_p (struct func_body_info
*fbi
,
958 int index
, gimple stmt
, tree ref
)
960 struct param_aa_status
*paa
;
961 bool modified
= false;
964 /* FIXME: FBI can be NULL if we are being called from outside
965 ipa_node_analysis or ipcp_transform_function, which currently happens
966 during inlining analysis. It would be great to extend fbi's lifetime and
967 always have it. Currently, we are just not afraid of too much walking in
971 if (aa_overwalked (fbi
))
973 paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (stmt
), index
);
974 if (paa
->ref_modified
)
980 gcc_checking_assert (gimple_vuse (stmt
));
981 ao_ref_init (&refd
, ref
);
982 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
,
985 fbi
->aa_walked
+= walked
;
987 paa
->ref_modified
= true;
991 /* Return true if the data pointed to by PARM (which is a parameter with INDEX)
992 is known to be unmodified in this function before reaching call statement
993 CALL into which it is passed. FBI describes the function body. */
996 parm_ref_data_pass_through_p (struct func_body_info
*fbi
, int index
,
997 gimple call
, tree parm
)
999 bool modified
= false;
1002 /* It's unnecessary to calculate anything about memory contnets for a const
1003 function because it is not goin to use it. But do not cache the result
1004 either. Also, no such calculations for non-pointers. */
1005 if (!gimple_vuse (call
)
1006 || !POINTER_TYPE_P (TREE_TYPE (parm
))
1007 || aa_overwalked (fbi
))
1010 struct param_aa_status
*paa
= parm_bb_aa_status_for_bb (fbi
, gimple_bb (call
),
1012 if (paa
->pt_modified
)
1015 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
1016 int walked
= walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
1018 fbi
->aa_walked
+= walked
;
1020 paa
->pt_modified
= true;
1024 /* Return true if we can prove that OP is a memory reference loading unmodified
1025 data from an aggregate passed as a parameter and if the aggregate is passed
1026 by reference, that the alias type of the load corresponds to the type of the
1027 formal parameter (so that we can rely on this type for TBAA in callers).
1028 INFO and PARMS_AINFO describe parameters of the current function (but the
1029 latter can be NULL), STMT is the load statement. If function returns true,
1030 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
1031 within the aggregate and whether it is a load from a value passed by
1032 reference respectively. */
1035 ipa_load_from_parm_agg_1 (struct func_body_info
*fbi
,
1036 vec
<ipa_param_descriptor
> descriptors
,
1037 gimple stmt
, tree op
, int *index_p
,
1038 HOST_WIDE_INT
*offset_p
, HOST_WIDE_INT
*size_p
,
1042 HOST_WIDE_INT size
, max_size
;
1043 tree base
= get_ref_base_and_extent (op
, offset_p
, &size
, &max_size
);
1045 if (max_size
== -1 || max_size
!= size
|| *offset_p
< 0)
1050 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
1052 && parm_preserved_before_stmt_p (fbi
, index
, stmt
, op
))
1063 if (TREE_CODE (base
) != MEM_REF
1064 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
1065 || !integer_zerop (TREE_OPERAND (base
, 1)))
1068 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
1070 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
1071 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
1075 /* This branch catches situations where a pointer parameter is not a
1076 gimple register, for example:
1078 void hip7(S*) (struct S * p)
1080 void (*<T2e4>) (struct S *) D.1867;
1085 D.1867_2 = p.1_1->f;
1090 gimple def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
1091 index
= load_from_unmodified_param (fbi
, descriptors
, def
);
1095 && parm_ref_data_preserved_p (fbi
, index
, stmt
, op
))
1106 /* Just like the previous function, just without the param_analysis_info
1107 pointer, for users outside of this file. */
1110 ipa_load_from_parm_agg (struct ipa_node_params
*info
, gimple stmt
,
1111 tree op
, int *index_p
, HOST_WIDE_INT
*offset_p
,
1114 return ipa_load_from_parm_agg_1 (NULL
, info
->descriptors
, stmt
, op
, index_p
,
1115 offset_p
, NULL
, by_ref_p
);
1118 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
1119 of an assignment statement STMT, try to determine whether we are actually
1120 handling any of the following cases and construct an appropriate jump
1121 function into JFUNC if so:
1123 1) The passed value is loaded from a formal parameter which is not a gimple
1124 register (most probably because it is addressable, the value has to be
1125 scalar) and we can guarantee the value has not changed. This case can
1126 therefore be described by a simple pass-through jump function. For example:
1135 2) The passed value can be described by a simple arithmetic pass-through
1142 D.2064_4 = a.1(D) + 4;
1145 This case can also occur in combination of the previous one, e.g.:
1153 D.2064_4 = a.0_3 + 4;
1156 3) The passed value is an address of an object within another one (which
1157 also passed by reference). Such situations are described by an ancestor
1158 jump function and describe situations such as:
1160 B::foo() (struct B * const this)
1164 D.1845_2 = &this_1(D)->D.1748;
1167 INFO is the structure describing individual parameters access different
1168 stages of IPA optimizations. PARMS_AINFO contains the information that is
1169 only needed for intraprocedural analysis. */
1172 compute_complex_assign_jump_func (struct func_body_info
*fbi
,
1173 struct ipa_node_params
*info
,
1174 struct ipa_jump_func
*jfunc
,
1175 gimple call
, gimple stmt
, tree name
,
1178 HOST_WIDE_INT offset
, size
, max_size
;
1179 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 bool type_p
= false;
1219 if (param_type
&& POINTER_TYPE_P (param_type
))
1220 type_p
= !detect_type_change_ssa (tc_ssa
, TREE_TYPE (param_type
),
1222 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1223 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
, type_p
);
1228 if (TREE_CODE (op1
) != ADDR_EXPR
)
1230 op1
= TREE_OPERAND (op1
, 0);
1231 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1233 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
);
1234 if (TREE_CODE (base
) != MEM_REF
1235 /* If this is a varying address, punt. */
1237 || max_size
!= size
)
1239 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1240 ssa
= TREE_OPERAND (base
, 0);
1241 if (TREE_CODE (ssa
) != SSA_NAME
1242 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1246 /* Dynamic types are changed in constructors and destructors. */
1247 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1248 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1250 bool type_p
= !detect_type_change (op1
, base
, TREE_TYPE (param_type
),
1251 call
, jfunc
, offset
);
1252 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1253 ipa_set_ancestor_jf (jfunc
, offset
,
1254 type_p
? TREE_TYPE (param_type
) : NULL
, index
,
1255 parm_ref_data_pass_through_p (fbi
, index
,
1256 call
, ssa
), type_p
);
1260 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1263 iftmp.1_3 = &obj_2(D)->D.1762;
1265 The base of the MEM_REF must be a default definition SSA NAME of a
1266 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1267 whole MEM_REF expression is returned and the offset calculated from any
1268 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1269 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1272 get_ancestor_addr_info (gimple assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1274 HOST_WIDE_INT size
, max_size
;
1275 tree expr
, parm
, obj
;
1277 if (!gimple_assign_single_p (assign
))
1279 expr
= gimple_assign_rhs1 (assign
);
1281 if (TREE_CODE (expr
) != ADDR_EXPR
)
1283 expr
= TREE_OPERAND (expr
, 0);
1285 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
);
1287 if (TREE_CODE (expr
) != MEM_REF
1288 /* If this is a varying address, punt. */
1293 parm
= TREE_OPERAND (expr
, 0);
1294 if (TREE_CODE (parm
) != SSA_NAME
1295 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1296 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1299 *offset
+= mem_ref_offset (expr
).to_short_addr () * BITS_PER_UNIT
;
1305 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1306 statement PHI, try to find out whether NAME is in fact a
1307 multiple-inheritance typecast from a descendant into an ancestor of a formal
1308 parameter and thus can be described by an ancestor jump function and if so,
1309 write the appropriate function into JFUNC.
1311 Essentially we want to match the following pattern:
1319 iftmp.1_3 = &obj_2(D)->D.1762;
1322 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1323 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1327 compute_complex_ancestor_jump_func (struct func_body_info
*fbi
,
1328 struct ipa_node_params
*info
,
1329 struct ipa_jump_func
*jfunc
,
1330 gimple call
, gimple phi
, tree param_type
)
1332 HOST_WIDE_INT offset
;
1333 gimple assign
, cond
;
1334 basic_block phi_bb
, assign_bb
, cond_bb
;
1335 tree tmp
, parm
, expr
, obj
;
1338 if (gimple_phi_num_args (phi
) != 2)
1341 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1342 tmp
= PHI_ARG_DEF (phi
, 0);
1343 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1344 tmp
= PHI_ARG_DEF (phi
, 1);
1347 if (TREE_CODE (tmp
) != SSA_NAME
1348 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1349 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1350 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1353 assign
= SSA_NAME_DEF_STMT (tmp
);
1354 assign_bb
= gimple_bb (assign
);
1355 if (!single_pred_p (assign_bb
))
1357 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1360 parm
= TREE_OPERAND (expr
, 0);
1361 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1365 cond_bb
= single_pred (assign_bb
);
1366 cond
= last_stmt (cond_bb
);
1368 || gimple_code (cond
) != GIMPLE_COND
1369 || gimple_cond_code (cond
) != NE_EXPR
1370 || gimple_cond_lhs (cond
) != parm
1371 || !integer_zerop (gimple_cond_rhs (cond
)))
1374 phi_bb
= gimple_bb (phi
);
1375 for (i
= 0; i
< 2; i
++)
1377 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1378 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1382 bool type_p
= false;
1383 if (param_type
&& POINTER_TYPE_P (param_type
))
1384 type_p
= !detect_type_change (obj
, expr
, TREE_TYPE (param_type
),
1385 call
, jfunc
, offset
);
1386 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1387 ipa_set_ancestor_jf (jfunc
, offset
, type_p
? TREE_TYPE (param_type
) : NULL
,
1389 parm_ref_data_pass_through_p (fbi
, index
, call
, parm
),
1393 /* Given OP which is passed as an actual argument to a called function,
1394 determine if it is possible to construct a KNOWN_TYPE jump function for it
1395 and if so, create one and store it to JFUNC.
1396 EXPECTED_TYPE represents a type the argument should be in */
1399 compute_known_type_jump_func (tree op
, struct ipa_jump_func
*jfunc
,
1400 gimple call
, tree expected_type
)
1402 HOST_WIDE_INT offset
, size
, max_size
;
1405 if (!flag_devirtualize
1406 || TREE_CODE (op
) != ADDR_EXPR
1407 || TREE_CODE (TREE_TYPE (TREE_TYPE (op
))) != RECORD_TYPE
1408 /* Be sure expected_type is polymorphic. */
1410 || TREE_CODE (expected_type
) != RECORD_TYPE
1411 || !TYPE_BINFO (expected_type
)
1412 || !BINFO_VTABLE (TYPE_BINFO (expected_type
)))
1415 op
= TREE_OPERAND (op
, 0);
1416 base
= get_ref_base_and_extent (op
, &offset
, &size
, &max_size
);
1420 || TREE_CODE (TREE_TYPE (base
)) != RECORD_TYPE
1421 || is_global_var (base
))
1424 if (detect_type_change (op
, base
, expected_type
, call
, jfunc
, offset
))
1427 ipa_set_jf_known_type (jfunc
, offset
, TREE_TYPE (base
),
1431 /* Inspect the given TYPE and return true iff it has the same structure (the
1432 same number of fields of the same types) as a C++ member pointer. If
1433 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1434 corresponding fields there. */
1437 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1441 if (TREE_CODE (type
) != RECORD_TYPE
)
1444 fld
= TYPE_FIELDS (type
);
1445 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1446 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1447 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1453 fld
= DECL_CHAIN (fld
);
1454 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1455 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1460 if (DECL_CHAIN (fld
))
1466 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1467 return the rhs of its defining statement. Otherwise return RHS as it
1471 get_ssa_def_if_simple_copy (tree rhs
)
1473 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1475 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1477 if (gimple_assign_single_p (def_stmt
))
1478 rhs
= gimple_assign_rhs1 (def_stmt
);
1485 /* Simple linked list, describing known contents of an aggregate beforere
1488 struct ipa_known_agg_contents_list
1490 /* Offset and size of the described part of the aggregate. */
1491 HOST_WIDE_INT offset
, size
;
1492 /* Known constant value or NULL if the contents is known to be unknown. */
1494 /* Pointer to the next structure in the list. */
1495 struct ipa_known_agg_contents_list
*next
;
1498 /* Find the proper place in linked list of ipa_known_agg_contents_list
1499 structures where to put a new one with the given LHS_OFFSET and LHS_SIZE,
1500 unless there is a partial overlap, in which case return NULL, or such
1501 element is already there, in which case set *ALREADY_THERE to true. */
1503 static struct ipa_known_agg_contents_list
**
1504 get_place_in_agg_contents_list (struct ipa_known_agg_contents_list
**list
,
1505 HOST_WIDE_INT lhs_offset
,
1506 HOST_WIDE_INT lhs_size
,
1507 bool *already_there
)
1509 struct ipa_known_agg_contents_list
**p
= list
;
1510 while (*p
&& (*p
)->offset
< lhs_offset
)
1512 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1517 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1519 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1520 /* We already know this value is subsequently overwritten with
1522 *already_there
= true;
1524 /* Otherwise this is a partial overlap which we cannot
1531 /* Build aggregate jump function from LIST, assuming there are exactly
1532 CONST_COUNT constant entries there and that th offset of the passed argument
1533 is ARG_OFFSET and store it into JFUNC. */
1536 build_agg_jump_func_from_list (struct ipa_known_agg_contents_list
*list
,
1537 int const_count
, HOST_WIDE_INT arg_offset
,
1538 struct ipa_jump_func
*jfunc
)
1540 vec_alloc (jfunc
->agg
.items
, const_count
);
1545 struct ipa_agg_jf_item item
;
1546 item
.offset
= list
->offset
- arg_offset
;
1547 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1548 item
.value
= unshare_expr_without_location (list
->constant
);
1549 jfunc
->agg
.items
->quick_push (item
);
1555 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1556 in ARG is filled in with constant values. ARG can either be an aggregate
1557 expression or a pointer to an aggregate. ARG_TYPE is the type of the
1558 aggregate. JFUNC is the jump function into which the constants are
1559 subsequently stored. */
1562 determine_locally_known_aggregate_parts (gimple call
, tree arg
, tree arg_type
,
1563 struct ipa_jump_func
*jfunc
)
1565 struct ipa_known_agg_contents_list
*list
= NULL
;
1566 int item_count
= 0, const_count
= 0;
1567 HOST_WIDE_INT arg_offset
, arg_size
;
1568 gimple_stmt_iterator gsi
;
1570 bool check_ref
, by_ref
;
1573 /* The function operates in three stages. First, we prepare check_ref, r,
1574 arg_base and arg_offset based on what is actually passed as an actual
1577 if (POINTER_TYPE_P (arg_type
))
1580 if (TREE_CODE (arg
) == SSA_NAME
)
1583 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
))))
1588 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1589 arg_size
= tree_to_uhwi (type_size
);
1590 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1592 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1594 HOST_WIDE_INT arg_max_size
;
1596 arg
= TREE_OPERAND (arg
, 0);
1597 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1599 if (arg_max_size
== -1
1600 || arg_max_size
!= arg_size
1603 if (DECL_P (arg_base
))
1606 ao_ref_init (&r
, arg_base
);
1616 HOST_WIDE_INT arg_max_size
;
1618 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1622 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1624 if (arg_max_size
== -1
1625 || arg_max_size
!= arg_size
1629 ao_ref_init (&r
, arg
);
1632 /* Second stage walks back the BB, looks at individual statements and as long
1633 as it is confident of how the statements affect contents of the
1634 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1636 gsi
= gsi_for_stmt (call
);
1638 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1640 struct ipa_known_agg_contents_list
*n
, **p
;
1641 gimple stmt
= gsi_stmt (gsi
);
1642 HOST_WIDE_INT lhs_offset
, lhs_size
, lhs_max_size
;
1643 tree lhs
, rhs
, lhs_base
;
1645 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1647 if (!gimple_assign_single_p (stmt
))
1650 lhs
= gimple_assign_lhs (stmt
);
1651 rhs
= gimple_assign_rhs1 (stmt
);
1652 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1653 || TREE_CODE (lhs
) == BIT_FIELD_REF
1654 || contains_bitfld_component_ref_p (lhs
))
1657 lhs_base
= get_ref_base_and_extent (lhs
, &lhs_offset
, &lhs_size
,
1659 if (lhs_max_size
== -1
1660 || lhs_max_size
!= lhs_size
)
1665 if (TREE_CODE (lhs_base
) != MEM_REF
1666 || TREE_OPERAND (lhs_base
, 0) != arg_base
1667 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1670 else if (lhs_base
!= arg_base
)
1672 if (DECL_P (lhs_base
))
1678 bool already_there
= false;
1679 p
= get_place_in_agg_contents_list (&list
, lhs_offset
, lhs_size
,
1686 rhs
= get_ssa_def_if_simple_copy (rhs
);
1687 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1689 n
->offset
= lhs_offset
;
1690 if (is_gimple_ip_invariant (rhs
))
1696 n
->constant
= NULL_TREE
;
1701 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1702 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1706 /* Third stage just goes over the list and creates an appropriate vector of
1707 ipa_agg_jf_item structures out of it, of sourse only if there are
1708 any known constants to begin with. */
1712 jfunc
->agg
.by_ref
= by_ref
;
1713 build_agg_jump_func_from_list (list
, const_count
, arg_offset
, jfunc
);
1718 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1721 tree type
= (e
->callee
1722 ? TREE_TYPE (e
->callee
->decl
)
1723 : gimple_call_fntype (e
->call_stmt
));
1724 tree t
= TYPE_ARG_TYPES (type
);
1726 for (n
= 0; n
< i
; n
++)
1733 return TREE_VALUE (t
);
1736 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1737 for (n
= 0; n
< i
; n
++)
1744 return TREE_TYPE (t
);
1748 /* Compute jump function for all arguments of callsite CS and insert the
1749 information in the jump_functions array in the ipa_edge_args corresponding
1750 to this callsite. */
1753 ipa_compute_jump_functions_for_edge (struct func_body_info
*fbi
,
1754 struct cgraph_edge
*cs
)
1756 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1757 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1758 gimple call
= cs
->call_stmt
;
1759 int n
, arg_num
= gimple_call_num_args (call
);
1761 if (arg_num
== 0 || args
->jump_functions
)
1763 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1765 if (gimple_call_internal_p (call
))
1767 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1770 for (n
= 0; n
< arg_num
; n
++)
1772 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1773 tree arg
= gimple_call_arg (call
, n
);
1774 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1776 if (is_gimple_ip_invariant (arg
))
1777 ipa_set_jf_constant (jfunc
, arg
, cs
);
1778 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1779 && TREE_CODE (arg
) == PARM_DECL
)
1781 int index
= ipa_get_param_decl_index (info
, arg
);
1783 gcc_assert (index
>=0);
1784 /* Aggregate passed by value, check for pass-through, otherwise we
1785 will attempt to fill in aggregate contents later in this
1787 if (parm_preserved_before_stmt_p (fbi
, index
, call
, arg
))
1789 ipa_set_jf_simple_pass_through (jfunc
, index
, false, false);
1793 else if (TREE_CODE (arg
) == SSA_NAME
)
1795 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1797 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1801 agg_p
= parm_ref_data_pass_through_p (fbi
, index
, call
, arg
);
1802 if (param_type
&& POINTER_TYPE_P (param_type
))
1803 type_p
= !detect_type_change_ssa (arg
, TREE_TYPE (param_type
),
1807 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1808 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
,
1814 gimple stmt
= SSA_NAME_DEF_STMT (arg
);
1815 if (is_gimple_assign (stmt
))
1816 compute_complex_assign_jump_func (fbi
, info
, jfunc
,
1817 call
, stmt
, arg
, param_type
);
1818 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1819 compute_complex_ancestor_jump_func (fbi
, info
, jfunc
,
1820 call
, stmt
, param_type
);
1824 compute_known_type_jump_func (arg
, jfunc
, call
,
1826 && POINTER_TYPE_P (param_type
)
1827 ? TREE_TYPE (param_type
)
1830 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1831 passed (because type conversions are ignored in gimple). Usually we can
1832 safely get type from function declaration, but in case of K&R prototypes or
1833 variadic functions we can try our luck with type of the pointer passed.
1834 TODO: Since we look for actual initialization of the memory object, we may better
1835 work out the type based on the memory stores we find. */
1837 param_type
= TREE_TYPE (arg
);
1839 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1840 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1841 && (jfunc
->type
!= IPA_JF_ANCESTOR
1842 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1843 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1844 || POINTER_TYPE_P (param_type
)))
1845 determine_locally_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1849 /* Compute jump functions for all edges - both direct and indirect - outgoing
1853 ipa_compute_jump_functions_for_bb (struct func_body_info
*fbi
, basic_block bb
)
1855 struct ipa_bb_info
*bi
= ipa_get_bb_info (fbi
, bb
);
1857 struct cgraph_edge
*cs
;
1859 FOR_EACH_VEC_ELT_REVERSE (bi
->cg_edges
, i
, cs
)
1861 struct cgraph_node
*callee
= cs
->callee
;
1865 cgraph_function_or_thunk_node (callee
, NULL
);
1866 /* We do not need to bother analyzing calls to unknown functions
1867 unless they may become known during lto/whopr. */
1868 if (!callee
->definition
&& !flag_lto
)
1871 ipa_compute_jump_functions_for_edge (fbi
, cs
);
1875 /* If STMT looks like a statement loading a value from a member pointer formal
1876 parameter, return that parameter and store the offset of the field to
1877 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1878 might be clobbered). If USE_DELTA, then we look for a use of the delta
1879 field rather than the pfn. */
1882 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
,
1883 HOST_WIDE_INT
*offset_p
)
1885 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
1887 if (!gimple_assign_single_p (stmt
))
1890 rhs
= gimple_assign_rhs1 (stmt
);
1891 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1893 ref_field
= TREE_OPERAND (rhs
, 1);
1894 rhs
= TREE_OPERAND (rhs
, 0);
1897 ref_field
= NULL_TREE
;
1898 if (TREE_CODE (rhs
) != MEM_REF
)
1900 rec
= TREE_OPERAND (rhs
, 0);
1901 if (TREE_CODE (rec
) != ADDR_EXPR
)
1903 rec
= TREE_OPERAND (rec
, 0);
1904 if (TREE_CODE (rec
) != PARM_DECL
1905 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1907 ref_offset
= TREE_OPERAND (rhs
, 1);
1914 *offset_p
= int_bit_position (fld
);
1918 if (integer_nonzerop (ref_offset
))
1920 return ref_field
== fld
? rec
: NULL_TREE
;
1923 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
1927 /* Returns true iff T is an SSA_NAME defined by a statement. */
1930 ipa_is_ssa_with_stmt_def (tree t
)
1932 if (TREE_CODE (t
) == SSA_NAME
1933 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1939 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1940 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1941 indirect call graph edge. */
1943 static struct cgraph_edge
*
1944 ipa_note_param_call (struct cgraph_node
*node
, int param_index
, gimple stmt
)
1946 struct cgraph_edge
*cs
;
1948 cs
= cgraph_edge (node
, stmt
);
1949 cs
->indirect_info
->param_index
= param_index
;
1950 cs
->indirect_info
->agg_contents
= 0;
1951 cs
->indirect_info
->member_ptr
= 0;
1955 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1956 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1957 intermediate information about each formal parameter. Currently it checks
1958 whether the call calls a pointer that is a formal parameter and if so, the
1959 parameter is marked with the called flag and an indirect call graph edge
1960 describing the call is created. This is very simple for ordinary pointers
1961 represented in SSA but not-so-nice when it comes to member pointers. The
1962 ugly part of this function does nothing more than trying to match the
1963 pattern of such a call. An example of such a pattern is the gimple dump
1964 below, the call is on the last line:
1967 f$__delta_5 = f.__delta;
1968 f$__pfn_24 = f.__pfn;
1972 f$__delta_5 = MEM[(struct *)&f];
1973 f$__pfn_24 = MEM[(struct *)&f + 4B];
1975 and a few lines below:
1978 D.2496_3 = (int) f$__pfn_24;
1979 D.2497_4 = D.2496_3 & 1;
1986 D.2500_7 = (unsigned int) f$__delta_5;
1987 D.2501_8 = &S + D.2500_7;
1988 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1989 D.2503_10 = *D.2502_9;
1990 D.2504_12 = f$__pfn_24 + -1;
1991 D.2505_13 = (unsigned int) D.2504_12;
1992 D.2506_14 = D.2503_10 + D.2505_13;
1993 D.2507_15 = *D.2506_14;
1994 iftmp.11_16 = (String:: *) D.2507_15;
1997 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1998 D.2500_19 = (unsigned int) f$__delta_5;
1999 D.2508_20 = &S + D.2500_19;
2000 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
2002 Such patterns are results of simple calls to a member pointer:
2004 int doprinting (int (MyString::* f)(int) const)
2006 MyString S ("somestring");
2011 Moreover, the function also looks for called pointers loaded from aggregates
2012 passed by value or reference. */
2015 ipa_analyze_indirect_call_uses (struct func_body_info
*fbi
, gimple call
,
2018 struct ipa_node_params
*info
= fbi
->info
;
2019 HOST_WIDE_INT offset
;
2022 if (SSA_NAME_IS_DEFAULT_DEF (target
))
2024 tree var
= SSA_NAME_VAR (target
);
2025 int index
= ipa_get_param_decl_index (info
, var
);
2027 ipa_note_param_call (fbi
->node
, index
, call
);
2032 gimple def
= SSA_NAME_DEF_STMT (target
);
2033 if (gimple_assign_single_p (def
)
2034 && ipa_load_from_parm_agg_1 (fbi
, info
->descriptors
, def
,
2035 gimple_assign_rhs1 (def
), &index
, &offset
,
2038 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2039 if (cs
->indirect_info
->offset
!= offset
)
2040 cs
->indirect_info
->outer_type
= NULL
;
2041 cs
->indirect_info
->offset
= offset
;
2042 cs
->indirect_info
->agg_contents
= 1;
2043 cs
->indirect_info
->by_ref
= by_ref
;
2047 /* Now we need to try to match the complex pattern of calling a member
2049 if (gimple_code (def
) != GIMPLE_PHI
2050 || gimple_phi_num_args (def
) != 2
2051 || !POINTER_TYPE_P (TREE_TYPE (target
))
2052 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
2055 /* First, we need to check whether one of these is a load from a member
2056 pointer that is a parameter to this function. */
2057 tree n1
= PHI_ARG_DEF (def
, 0);
2058 tree n2
= PHI_ARG_DEF (def
, 1);
2059 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
2061 gimple d1
= SSA_NAME_DEF_STMT (n1
);
2062 gimple d2
= SSA_NAME_DEF_STMT (n2
);
2065 basic_block bb
, virt_bb
;
2066 basic_block join
= gimple_bb (def
);
2067 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
2069 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
2072 bb
= EDGE_PRED (join
, 0)->src
;
2073 virt_bb
= gimple_bb (d2
);
2075 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
2077 bb
= EDGE_PRED (join
, 1)->src
;
2078 virt_bb
= gimple_bb (d1
);
2083 /* Second, we need to check that the basic blocks are laid out in the way
2084 corresponding to the pattern. */
2086 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
2087 || single_pred (virt_bb
) != bb
2088 || single_succ (virt_bb
) != join
)
2091 /* Third, let's see that the branching is done depending on the least
2092 significant bit of the pfn. */
2094 gimple branch
= last_stmt (bb
);
2095 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
2098 if ((gimple_cond_code (branch
) != NE_EXPR
2099 && gimple_cond_code (branch
) != EQ_EXPR
)
2100 || !integer_zerop (gimple_cond_rhs (branch
)))
2103 tree cond
= gimple_cond_lhs (branch
);
2104 if (!ipa_is_ssa_with_stmt_def (cond
))
2107 def
= SSA_NAME_DEF_STMT (cond
);
2108 if (!is_gimple_assign (def
)
2109 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
2110 || !integer_onep (gimple_assign_rhs2 (def
)))
2113 cond
= gimple_assign_rhs1 (def
);
2114 if (!ipa_is_ssa_with_stmt_def (cond
))
2117 def
= SSA_NAME_DEF_STMT (cond
);
2119 if (is_gimple_assign (def
)
2120 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
2122 cond
= gimple_assign_rhs1 (def
);
2123 if (!ipa_is_ssa_with_stmt_def (cond
))
2125 def
= SSA_NAME_DEF_STMT (cond
);
2129 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
2130 (TARGET_PTRMEMFUNC_VBIT_LOCATION
2131 == ptrmemfunc_vbit_in_delta
),
2136 index
= ipa_get_param_decl_index (info
, rec
);
2138 && parm_preserved_before_stmt_p (fbi
, index
, call
, rec
))
2140 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2141 if (cs
->indirect_info
->offset
!= offset
)
2142 cs
->indirect_info
->outer_type
= NULL
;
2143 cs
->indirect_info
->offset
= offset
;
2144 cs
->indirect_info
->agg_contents
= 1;
2145 cs
->indirect_info
->member_ptr
= 1;
2151 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
2152 object referenced in the expression is a formal parameter of the caller
2153 FBI->node (described by FBI->info), create a call note for the
2157 ipa_analyze_virtual_call_uses (struct func_body_info
*fbi
,
2158 gimple call
, tree target
)
2160 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2162 HOST_WIDE_INT anc_offset
;
2164 if (!flag_devirtualize
)
2167 if (TREE_CODE (obj
) != SSA_NAME
)
2170 struct ipa_node_params
*info
= fbi
->info
;
2171 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2173 struct ipa_jump_func jfunc
;
2174 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2178 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2179 gcc_assert (index
>= 0);
2180 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2186 struct ipa_jump_func jfunc
;
2187 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
2190 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2193 index
= ipa_get_param_decl_index (info
,
2194 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2195 gcc_assert (index
>= 0);
2196 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2197 call
, &jfunc
, anc_offset
))
2201 struct cgraph_edge
*cs
= ipa_note_param_call (fbi
->node
, index
, call
);
2202 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2203 ii
->offset
= anc_offset
;
2204 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2205 ii
->otr_type
= obj_type_ref_class (target
);
2206 ii
->polymorphic
= 1;
2209 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2210 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2211 containing intermediate information about each formal parameter. */
2214 ipa_analyze_call_uses (struct func_body_info
*fbi
, gimple call
)
2216 tree target
= gimple_call_fn (call
);
2219 || (TREE_CODE (target
) != SSA_NAME
2220 && !virtual_method_call_p (target
)))
2223 /* If we previously turned the call into a direct call, there is
2224 no need to analyze. */
2225 struct cgraph_edge
*cs
= cgraph_edge (fbi
->node
, call
);
2226 if (cs
&& !cs
->indirect_unknown_callee
)
2228 if (TREE_CODE (target
) == SSA_NAME
)
2229 ipa_analyze_indirect_call_uses (fbi
, call
, target
);
2230 else if (virtual_method_call_p (target
))
2231 ipa_analyze_virtual_call_uses (fbi
, call
, target
);
2235 /* Analyze the call statement STMT with respect to formal parameters (described
2236 in INFO) of caller given by FBI->NODE. Currently it only checks whether
2237 formal parameters are called. */
2240 ipa_analyze_stmt_uses (struct func_body_info
*fbi
, gimple stmt
)
2242 if (is_gimple_call (stmt
))
2243 ipa_analyze_call_uses (fbi
, stmt
);
2246 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2247 If OP is a parameter declaration, mark it as used in the info structure
2251 visit_ref_for_mod_analysis (gimple
, tree op
, tree
, void *data
)
2253 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2255 op
= get_base_address (op
);
2257 && TREE_CODE (op
) == PARM_DECL
)
2259 int index
= ipa_get_param_decl_index (info
, op
);
2260 gcc_assert (index
>= 0);
2261 ipa_set_param_used (info
, index
, true);
2267 /* Scan the statements in BB and inspect the uses of formal parameters. Store
2268 the findings in various structures of the associated ipa_node_params
2269 structure, such as parameter flags, notes etc. FBI holds various data about
2270 the function being analyzed. */
2273 ipa_analyze_params_uses_in_bb (struct func_body_info
*fbi
, basic_block bb
)
2275 gimple_stmt_iterator gsi
;
2276 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2278 gimple stmt
= gsi_stmt (gsi
);
2280 if (is_gimple_debug (stmt
))
2283 ipa_analyze_stmt_uses (fbi
, stmt
);
2284 walk_stmt_load_store_addr_ops (stmt
, fbi
->info
,
2285 visit_ref_for_mod_analysis
,
2286 visit_ref_for_mod_analysis
,
2287 visit_ref_for_mod_analysis
);
2289 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2290 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), fbi
->info
,
2291 visit_ref_for_mod_analysis
,
2292 visit_ref_for_mod_analysis
,
2293 visit_ref_for_mod_analysis
);
2296 /* Calculate controlled uses of parameters of NODE. */
2299 ipa_analyze_controlled_uses (struct cgraph_node
*node
)
2301 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2303 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2305 tree parm
= ipa_get_param (info
, i
);
2306 int controlled_uses
= 0;
2308 /* For SSA regs see if parameter is used. For non-SSA we compute
2309 the flag during modification analysis. */
2310 if (is_gimple_reg (parm
))
2312 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2314 if (ddef
&& !has_zero_uses (ddef
))
2316 imm_use_iterator imm_iter
;
2317 use_operand_p use_p
;
2319 ipa_set_param_used (info
, i
, true);
2320 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2321 if (!is_gimple_call (USE_STMT (use_p
)))
2323 if (!is_gimple_debug (USE_STMT (use_p
)))
2325 controlled_uses
= IPA_UNDESCRIBED_USE
;
2333 controlled_uses
= 0;
2336 controlled_uses
= IPA_UNDESCRIBED_USE
;
2337 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2341 /* Free stuff in BI. */
2344 free_ipa_bb_info (struct ipa_bb_info
*bi
)
2346 bi
->cg_edges
.release ();
2347 bi
->param_aa_statuses
.release ();
2350 /* Dominator walker driving the analysis. */
2352 class analysis_dom_walker
: public dom_walker
2355 analysis_dom_walker (struct func_body_info
*fbi
)
2356 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
) {}
2358 virtual void before_dom_children (basic_block
);
2361 struct func_body_info
*m_fbi
;
2365 analysis_dom_walker::before_dom_children (basic_block bb
)
2367 ipa_analyze_params_uses_in_bb (m_fbi
, bb
);
2368 ipa_compute_jump_functions_for_bb (m_fbi
, bb
);
2371 /* Initialize the array describing properties of of formal parameters
2372 of NODE, analyze their uses and compute jump functions associated
2373 with actual arguments of calls from within NODE. */
2376 ipa_analyze_node (struct cgraph_node
*node
)
2378 struct func_body_info fbi
;
2379 struct ipa_node_params
*info
;
2381 ipa_check_create_node_params ();
2382 ipa_check_create_edge_args ();
2383 info
= IPA_NODE_REF (node
);
2385 if (info
->analysis_done
)
2387 info
->analysis_done
= 1;
2389 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2391 for (int i
= 0; i
< ipa_get_param_count (info
); i
++)
2393 ipa_set_param_used (info
, i
, true);
2394 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2399 struct function
*func
= DECL_STRUCT_FUNCTION (node
->decl
);
2401 calculate_dominance_info (CDI_DOMINATORS
);
2402 ipa_initialize_node_params (node
);
2403 ipa_analyze_controlled_uses (node
);
2406 fbi
.info
= IPA_NODE_REF (node
);
2407 fbi
.bb_infos
= vNULL
;
2408 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
2409 fbi
.param_count
= ipa_get_param_count (info
);
2412 for (struct cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2414 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2415 bi
->cg_edges
.safe_push (cs
);
2418 for (struct cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2420 ipa_bb_info
*bi
= ipa_get_bb_info (&fbi
, gimple_bb (cs
->call_stmt
));
2421 bi
->cg_edges
.safe_push (cs
);
2424 analysis_dom_walker (&fbi
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
2427 struct ipa_bb_info
*bi
;
2428 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
2429 free_ipa_bb_info (bi
);
2430 fbi
.bb_infos
.release ();
2431 free_dominance_info (CDI_DOMINATORS
);
2435 /* Given a statement CALL which must be a GIMPLE_CALL calling an OBJ_TYPE_REF
2436 attempt a type-based devirtualization. If successful, return the
2437 target function declaration, otherwise return NULL. */
2440 ipa_intraprocedural_devirtualization (gimple call
)
2442 tree binfo
, token
, fndecl
;
2443 struct ipa_jump_func jfunc
;
2444 tree otr
= gimple_call_fn (call
);
2446 jfunc
.type
= IPA_JF_UNKNOWN
;
2447 compute_known_type_jump_func (OBJ_TYPE_REF_OBJECT (otr
), &jfunc
,
2448 call
, obj_type_ref_class (otr
));
2449 if (jfunc
.type
!= IPA_JF_KNOWN_TYPE
)
2451 binfo
= ipa_binfo_from_known_type_jfunc (&jfunc
);
2454 token
= OBJ_TYPE_REF_TOKEN (otr
);
2455 fndecl
= gimple_get_virt_method_for_binfo (tree_to_uhwi (token
),
2457 #ifdef ENABLE_CHECKING
2459 gcc_assert (possible_polymorphic_call_target_p
2460 (otr
, cgraph_get_node (fndecl
)));
2465 /* Update the jump function DST when the call graph edge corresponding to SRC is
2466 is being inlined, knowing that DST is of type ancestor and src of known
2470 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
2471 struct ipa_jump_func
*dst
)
2473 HOST_WIDE_INT combined_offset
;
2476 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2478 dst
->type
= IPA_JF_UNKNOWN
;
2482 combined_offset
= ipa_get_jf_known_type_offset (src
)
2483 + ipa_get_jf_ancestor_offset (dst
);
2484 combined_type
= ipa_get_jf_ancestor_type (dst
);
2486 ipa_set_jf_known_type (dst
, combined_offset
,
2487 ipa_get_jf_known_type_base_type (src
),
2491 /* Update the jump functions associated with call graph edge E when the call
2492 graph edge CS is being inlined, assuming that E->caller is already (possibly
2493 indirectly) inlined into CS->callee and that E has not been inlined. */
2496 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2497 struct cgraph_edge
*e
)
2499 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2500 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2501 int count
= ipa_get_cs_argument_count (args
);
2504 for (i
= 0; i
< count
; i
++)
2506 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2508 if (dst
->type
== IPA_JF_ANCESTOR
)
2510 struct ipa_jump_func
*src
;
2511 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2513 /* Variable number of arguments can cause havoc if we try to access
2514 one that does not exist in the inlined edge. So make sure we
2516 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2518 dst
->type
= IPA_JF_UNKNOWN
;
2522 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2525 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2527 struct ipa_agg_jf_item
*item
;
2530 /* Currently we do not produce clobber aggregate jump functions,
2531 replace with merging when we do. */
2532 gcc_assert (!dst
->agg
.items
);
2534 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2535 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2536 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2537 item
->offset
-= dst
->value
.ancestor
.offset
;
2540 if (src
->type
== IPA_JF_KNOWN_TYPE
)
2541 combine_known_type_and_ancestor_jfs (src
, dst
);
2542 else if (src
->type
== IPA_JF_PASS_THROUGH
2543 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2545 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2546 dst
->value
.ancestor
.agg_preserved
&=
2547 src
->value
.pass_through
.agg_preserved
;
2548 dst
->value
.ancestor
.type_preserved
&=
2549 src
->value
.pass_through
.type_preserved
;
2551 else if (src
->type
== IPA_JF_ANCESTOR
)
2553 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2554 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2555 dst
->value
.ancestor
.agg_preserved
&=
2556 src
->value
.ancestor
.agg_preserved
;
2557 dst
->value
.ancestor
.type_preserved
&=
2558 src
->value
.ancestor
.type_preserved
;
2561 dst
->type
= IPA_JF_UNKNOWN
;
2563 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2565 struct ipa_jump_func
*src
;
2566 /* We must check range due to calls with variable number of arguments
2567 and we cannot combine jump functions with operations. */
2568 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2569 && (dst
->value
.pass_through
.formal_id
2570 < ipa_get_cs_argument_count (top
)))
2572 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2573 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2574 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2578 case IPA_JF_UNKNOWN
:
2579 dst
->type
= IPA_JF_UNKNOWN
;
2581 case IPA_JF_KNOWN_TYPE
:
2582 if (ipa_get_jf_pass_through_type_preserved (dst
))
2583 ipa_set_jf_known_type (dst
,
2584 ipa_get_jf_known_type_offset (src
),
2585 ipa_get_jf_known_type_base_type (src
),
2586 ipa_get_jf_known_type_component_type (src
));
2588 dst
->type
= IPA_JF_UNKNOWN
;
2591 ipa_set_jf_cst_copy (dst
, src
);
2594 case IPA_JF_PASS_THROUGH
:
2596 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2597 enum tree_code operation
;
2598 operation
= ipa_get_jf_pass_through_operation (src
);
2600 if (operation
== NOP_EXPR
)
2604 && ipa_get_jf_pass_through_agg_preserved (src
);
2605 type_p
= ipa_get_jf_pass_through_type_preserved (src
)
2606 && ipa_get_jf_pass_through_type_preserved (dst
);
2607 ipa_set_jf_simple_pass_through (dst
, formal_id
,
2612 tree operand
= ipa_get_jf_pass_through_operand (src
);
2613 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2618 case IPA_JF_ANCESTOR
:
2622 && ipa_get_jf_ancestor_agg_preserved (src
);
2623 type_p
= ipa_get_jf_ancestor_type_preserved (src
)
2624 && ipa_get_jf_pass_through_type_preserved (dst
);
2625 ipa_set_ancestor_jf (dst
,
2626 ipa_get_jf_ancestor_offset (src
),
2627 ipa_get_jf_ancestor_type (src
),
2628 ipa_get_jf_ancestor_formal_id (src
),
2637 && (dst_agg_p
|| !src
->agg
.by_ref
))
2639 /* Currently we do not produce clobber aggregate jump
2640 functions, replace with merging when we do. */
2641 gcc_assert (!dst
->agg
.items
);
2643 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2644 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2648 dst
->type
= IPA_JF_UNKNOWN
;
2653 /* If TARGET is an addr_expr of a function declaration, make it the destination
2654 of an indirect edge IE and return the edge. Otherwise, return NULL. */
2656 struct cgraph_edge
*
2657 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
)
2659 struct cgraph_node
*callee
;
2660 struct inline_edge_summary
*es
= inline_edge_summary (ie
);
2661 bool unreachable
= false;
2663 if (TREE_CODE (target
) == ADDR_EXPR
)
2664 target
= TREE_OPERAND (target
, 0);
2665 if (TREE_CODE (target
) != FUNCTION_DECL
)
2667 target
= canonicalize_constructor_val (target
, NULL
);
2668 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2670 if (ie
->indirect_info
->member_ptr
)
2671 /* Member pointer call that goes through a VMT lookup. */
2674 if (dump_enabled_p ())
2676 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2677 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2678 "discovered direct call to non-function in %s/%i, "
2679 "making it __builtin_unreachable\n",
2680 ie
->caller
->name (), ie
->caller
->order
);
2683 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2684 callee
= cgraph_get_create_node (target
);
2688 callee
= cgraph_get_node (target
);
2691 callee
= cgraph_get_node (target
);
2693 /* Because may-edges are not explicitely represented and vtable may be external,
2694 we may create the first reference to the object in the unit. */
2695 if (!callee
|| callee
->global
.inlined_to
)
2698 /* We are better to ensure we can refer to it.
2699 In the case of static functions we are out of luck, since we already
2700 removed its body. In the case of public functions we may or may
2701 not introduce the reference. */
2702 if (!canonicalize_constructor_val (target
, NULL
)
2703 || !TREE_PUBLIC (target
))
2706 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2707 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2708 xstrdup (ie
->caller
->name ()),
2710 xstrdup (ie
->callee
->name ()),
2714 callee
= cgraph_get_create_node (target
);
2717 if (!dbg_cnt (devirt
))
2720 ipa_check_create_node_params ();
2722 /* We can not make edges to inline clones. It is bug that someone removed
2723 the cgraph node too early. */
2724 gcc_assert (!callee
->global
.inlined_to
);
2726 if (dump_file
&& !unreachable
)
2728 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
2729 "(%s/%i -> %s/%i), for stmt ",
2730 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2731 xstrdup (ie
->caller
->name ()),
2733 xstrdup (callee
->name ()),
2736 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2738 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2740 if (dump_enabled_p ())
2742 location_t loc
= gimple_location_safe (ie
->call_stmt
);
2744 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
2745 "converting indirect call in %s to direct call to %s\n",
2746 ie
->caller
->name (), callee
->name ());
2748 ie
= cgraph_make_edge_direct (ie
, callee
);
2749 es
= inline_edge_summary (ie
);
2750 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2751 - eni_size_weights
.call_cost
);
2752 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2753 - eni_time_weights
.call_cost
);
2758 /* Retrieve value from aggregate jump function AGG for the given OFFSET or
2759 return NULL if there is not any. BY_REF specifies whether the value has to
2760 be passed by reference or by value. */
2763 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
,
2764 HOST_WIDE_INT offset
, bool by_ref
)
2766 struct ipa_agg_jf_item
*item
;
2769 if (by_ref
!= agg
->by_ref
)
2772 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2773 if (item
->offset
== offset
)
2775 /* Currently we do not have clobber values, return NULL for them once
2777 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2783 /* Remove a reference to SYMBOL from the list of references of a node given by
2784 reference description RDESC. Return true if the reference has been
2785 successfully found and removed. */
2788 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
2790 struct ipa_ref
*to_del
;
2791 struct cgraph_edge
*origin
;
2796 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
2797 origin
->lto_stmt_uid
);
2801 to_del
->remove_reference ();
2803 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
2804 xstrdup (origin
->caller
->name ()),
2805 origin
->caller
->order
, xstrdup (symbol
->name ()));
2809 /* If JFUNC has a reference description with refcount different from
2810 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
2811 NULL. JFUNC must be a constant jump function. */
2813 static struct ipa_cst_ref_desc
*
2814 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
2816 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
2817 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
2823 /* If the value of constant jump function JFUNC is an address of a function
2824 declaration, return the associated call graph node. Otherwise return
2827 static cgraph_node
*
2828 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
2830 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
2831 tree cst
= ipa_get_jf_constant (jfunc
);
2832 if (TREE_CODE (cst
) != ADDR_EXPR
2833 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
2836 return cgraph_get_node (TREE_OPERAND (cst
, 0));
2840 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
2841 refcount and if it hits zero, remove reference to SYMBOL from the caller of
2842 the edge specified in the rdesc. Return false if either the symbol or the
2843 reference could not be found, otherwise return true. */
2846 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
2848 struct ipa_cst_ref_desc
*rdesc
;
2849 if (jfunc
->type
== IPA_JF_CONST
2850 && (rdesc
= jfunc_rdesc_usable (jfunc
))
2851 && --rdesc
->refcount
== 0)
2853 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
2857 return remove_described_reference (symbol
, rdesc
);
2862 /* Try to find a destination for indirect edge IE that corresponds to a simple
2863 call or a call of a member function pointer and where the destination is a
2864 pointer formal parameter described by jump function JFUNC. If it can be
2865 determined, return the newly direct edge, otherwise return NULL.
2866 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
2868 static struct cgraph_edge
*
2869 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
2870 struct ipa_jump_func
*jfunc
,
2871 struct ipa_node_params
*new_root_info
)
2873 struct cgraph_edge
*cs
;
2875 bool agg_contents
= ie
->indirect_info
->agg_contents
;
2877 if (ie
->indirect_info
->agg_contents
)
2878 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2879 ie
->indirect_info
->offset
,
2880 ie
->indirect_info
->by_ref
);
2882 target
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2885 cs
= ipa_make_edge_direct_to_target (ie
, target
);
2887 if (cs
&& !agg_contents
)
2890 gcc_checking_assert (cs
->callee
2892 || jfunc
->type
!= IPA_JF_CONST
2893 || !cgraph_node_for_jfunc (jfunc
)
2894 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
2895 ok
= try_decrement_rdesc_refcount (jfunc
);
2896 gcc_checking_assert (ok
);
2902 /* Return the target to be used in cases of impossible devirtualization. IE
2903 and target (the latter can be NULL) are dumped when dumping is enabled. */
2906 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
2912 "Type inconsistent devirtualization: %s/%i->%s\n",
2913 ie
->caller
->name (), ie
->caller
->order
,
2914 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
2917 "No devirtualization target in %s/%i\n",
2918 ie
->caller
->name (), ie
->caller
->order
);
2920 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2921 cgraph_get_create_node (new_target
);
2925 /* Try to find a destination for indirect edge IE that corresponds to a virtual
2926 call based on a formal parameter which is described by jump function JFUNC
2927 and if it can be determined, make it direct and return the direct edge.
2928 Otherwise, return NULL. NEW_ROOT_INFO is the node info that JFUNC lattices
2931 static struct cgraph_edge
*
2932 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
2933 struct ipa_jump_func
*jfunc
,
2934 struct ipa_node_params
*new_root_info
)
2938 if (!flag_devirtualize
)
2941 /* First try to do lookup via known virtual table pointer value. */
2942 if (!ie
->indirect_info
->by_ref
)
2945 unsigned HOST_WIDE_INT offset
;
2946 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2947 ie
->indirect_info
->offset
,
2949 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2951 target
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
2955 if ((TREE_CODE (TREE_TYPE (target
)) == FUNCTION_TYPE
2956 && DECL_FUNCTION_CODE (target
) == BUILT_IN_UNREACHABLE
)
2957 || !possible_polymorphic_call_target_p
2958 (ie
, cgraph_get_node (target
)))
2959 target
= ipa_impossible_devirt_target (ie
, target
);
2960 return ipa_make_edge_direct_to_target (ie
, target
);
2965 binfo
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2970 if (TREE_CODE (binfo
) != TREE_BINFO
)
2972 ipa_polymorphic_call_context context
;
2973 vec
<cgraph_node
*>targets
;
2976 if (!get_polymorphic_call_info_from_invariant
2977 (&context
, binfo
, ie
->indirect_info
->otr_type
,
2978 ie
->indirect_info
->offset
))
2980 targets
= possible_polymorphic_call_targets
2981 (ie
->indirect_info
->otr_type
,
2982 ie
->indirect_info
->otr_token
,
2984 if (!final
|| targets
.length () > 1)
2986 if (targets
.length () == 1)
2987 target
= targets
[0]->decl
;
2989 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
2993 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->offset
,
2994 ie
->indirect_info
->otr_type
);
2996 target
= gimple_get_virt_method_for_binfo (ie
->indirect_info
->otr_token
,
3004 if (!possible_polymorphic_call_target_p (ie
, cgraph_get_node (target
)))
3005 target
= ipa_impossible_devirt_target (ie
, target
);
3006 return ipa_make_edge_direct_to_target (ie
, target
);
3012 /* Update the param called notes associated with NODE when CS is being inlined,
3013 assuming NODE is (potentially indirectly) inlined into CS->callee.
3014 Moreover, if the callee is discovered to be constant, create a new cgraph
3015 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3016 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3019 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3020 struct cgraph_node
*node
,
3021 vec
<cgraph_edge_p
> *new_edges
)
3023 struct ipa_edge_args
*top
;
3024 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3025 struct ipa_node_params
*new_root_info
;
3028 ipa_check_create_edge_args ();
3029 top
= IPA_EDGE_REF (cs
);
3030 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3031 ? cs
->caller
->global
.inlined_to
3034 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3036 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3037 struct ipa_jump_func
*jfunc
;
3040 next_ie
= ie
->next_callee
;
3042 if (ici
->param_index
== -1)
3045 /* We must check range due to calls with variable number of arguments: */
3046 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3048 ici
->param_index
= -1;
3052 param_index
= ici
->param_index
;
3053 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3055 if (!flag_indirect_inlining
)
3056 new_direct_edge
= NULL
;
3057 else if (ici
->polymorphic
)
3058 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
,
3061 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3063 /* If speculation was removed, then we need to do nothing. */
3064 if (new_direct_edge
&& new_direct_edge
!= ie
)
3066 new_direct_edge
->indirect_inlining_edge
= 1;
3067 top
= IPA_EDGE_REF (cs
);
3070 else if (new_direct_edge
)
3072 new_direct_edge
->indirect_inlining_edge
= 1;
3073 if (new_direct_edge
->call_stmt
)
3074 new_direct_edge
->call_stmt_cannot_inline_p
3075 = !gimple_check_call_matching_types (
3076 new_direct_edge
->call_stmt
,
3077 new_direct_edge
->callee
->decl
, false);
3080 new_edges
->safe_push (new_direct_edge
);
3083 top
= IPA_EDGE_REF (cs
);
3085 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
3086 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3088 if ((ici
->agg_contents
3089 && !ipa_get_jf_pass_through_agg_preserved (jfunc
))
3090 || (ici
->polymorphic
3091 && !ipa_get_jf_pass_through_type_preserved (jfunc
)))
3092 ici
->param_index
= -1;
3094 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3096 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3098 if ((ici
->agg_contents
3099 && !ipa_get_jf_ancestor_agg_preserved (jfunc
))
3100 || (ici
->polymorphic
3101 && !ipa_get_jf_ancestor_type_preserved (jfunc
)))
3102 ici
->param_index
= -1;
3105 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3106 if (ipa_get_jf_ancestor_offset (jfunc
))
3107 ici
->outer_type
= NULL
;
3108 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3112 /* Either we can find a destination for this edge now or never. */
3113 ici
->param_index
= -1;
3119 /* Recursively traverse subtree of NODE (including node) made of inlined
3120 cgraph_edges when CS has been inlined and invoke
3121 update_indirect_edges_after_inlining on all nodes and
3122 update_jump_functions_after_inlining on all non-inlined edges that lead out
3123 of this subtree. Newly discovered indirect edges will be added to
3124 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3128 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3129 struct cgraph_node
*node
,
3130 vec
<cgraph_edge_p
> *new_edges
)
3132 struct cgraph_edge
*e
;
3135 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3137 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3138 if (!e
->inline_failed
)
3139 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3141 update_jump_functions_after_inlining (cs
, e
);
3142 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3143 update_jump_functions_after_inlining (cs
, e
);
3148 /* Combine two controlled uses counts as done during inlining. */
3151 combine_controlled_uses_counters (int c
, int d
)
3153 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3154 return IPA_UNDESCRIBED_USE
;
3159 /* Propagate number of controlled users from CS->caleee to the new root of the
3160 tree of inlined nodes. */
3163 propagate_controlled_uses (struct cgraph_edge
*cs
)
3165 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3166 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3167 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3168 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3169 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3172 count
= MIN (ipa_get_cs_argument_count (args
),
3173 ipa_get_param_count (old_root_info
));
3174 for (i
= 0; i
< count
; i
++)
3176 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3177 struct ipa_cst_ref_desc
*rdesc
;
3179 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3182 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3183 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3184 d
= ipa_get_controlled_uses (old_root_info
, i
);
3186 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3187 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3188 c
= combine_controlled_uses_counters (c
, d
);
3189 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3190 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3192 struct cgraph_node
*n
;
3193 struct ipa_ref
*ref
;
3194 tree t
= new_root_info
->known_vals
[src_idx
];
3196 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3197 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3198 && (n
= cgraph_get_node (TREE_OPERAND (t
, 0)))
3199 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3202 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3203 "reference from %s/%i to %s/%i.\n",
3204 xstrdup (new_root
->name ()),
3206 xstrdup (n
->name ()), n
->order
);
3207 ref
->remove_reference ();
3211 else if (jf
->type
== IPA_JF_CONST
3212 && (rdesc
= jfunc_rdesc_usable (jf
)))
3214 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3215 int c
= rdesc
->refcount
;
3216 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3217 if (rdesc
->refcount
== 0)
3219 tree cst
= ipa_get_jf_constant (jf
);
3220 struct cgraph_node
*n
;
3221 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3222 && TREE_CODE (TREE_OPERAND (cst
, 0))
3224 n
= cgraph_get_node (TREE_OPERAND (cst
, 0));
3227 struct cgraph_node
*clone
;
3229 ok
= remove_described_reference (n
, rdesc
);
3230 gcc_checking_assert (ok
);
3233 while (clone
->global
.inlined_to
3234 && clone
!= rdesc
->cs
->caller
3235 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3237 struct ipa_ref
*ref
;
3238 ref
= clone
->find_reference (n
, NULL
, 0);
3242 fprintf (dump_file
, "ipa-prop: Removing "
3243 "cloning-created reference "
3244 "from %s/%i to %s/%i.\n",
3245 xstrdup (clone
->name ()),
3247 xstrdup (n
->name ()),
3249 ref
->remove_reference ();
3251 clone
= clone
->callers
->caller
;
3258 for (i
= ipa_get_param_count (old_root_info
);
3259 i
< ipa_get_cs_argument_count (args
);
3262 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3264 if (jf
->type
== IPA_JF_CONST
)
3266 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3268 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3270 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3271 ipa_set_controlled_uses (new_root_info
,
3272 jf
->value
.pass_through
.formal_id
,
3273 IPA_UNDESCRIBED_USE
);
3277 /* Update jump functions and call note functions on inlining the call site CS.
3278 CS is expected to lead to a node already cloned by
3279 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3280 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3284 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3285 vec
<cgraph_edge_p
> *new_edges
)
3288 /* Do nothing if the preparation phase has not been carried out yet
3289 (i.e. during early inlining). */
3290 if (!ipa_node_params_vector
.exists ())
3292 gcc_assert (ipa_edge_args_vector
);
3294 propagate_controlled_uses (cs
);
3295 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3300 /* Frees all dynamically allocated structures that the argument info points
3304 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3306 vec_free (args
->jump_functions
);
3307 memset (args
, 0, sizeof (*args
));
3310 /* Free all ipa_edge structures. */
3313 ipa_free_all_edge_args (void)
3316 struct ipa_edge_args
*args
;
3318 if (!ipa_edge_args_vector
)
3321 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3322 ipa_free_edge_args_substructures (args
);
3324 vec_free (ipa_edge_args_vector
);
3327 /* Frees all dynamically allocated structures that the param info points
3331 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
3333 info
->descriptors
.release ();
3334 free (info
->lattices
);
3335 /* Lattice values and their sources are deallocated with their alocation
3337 info
->known_vals
.release ();
3338 memset (info
, 0, sizeof (*info
));
3341 /* Free all ipa_node_params structures. */
3344 ipa_free_all_node_params (void)
3347 struct ipa_node_params
*info
;
3349 FOR_EACH_VEC_ELT (ipa_node_params_vector
, i
, info
)
3350 ipa_free_node_params_substructures (info
);
3352 ipa_node_params_vector
.release ();
3355 /* Set the aggregate replacements of NODE to be AGGVALS. */
3358 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3359 struct ipa_agg_replacement_value
*aggvals
)
3361 if (vec_safe_length (ipa_node_agg_replacements
) <= (unsigned) cgraph_max_uid
)
3362 vec_safe_grow_cleared (ipa_node_agg_replacements
, cgraph_max_uid
+ 1);
3364 (*ipa_node_agg_replacements
)[node
->uid
] = aggvals
;
3367 /* Hook that is called by cgraph.c when an edge is removed. */
3370 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3372 struct ipa_edge_args
*args
;
3374 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3375 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3378 args
= IPA_EDGE_REF (cs
);
3379 if (args
->jump_functions
)
3381 struct ipa_jump_func
*jf
;
3383 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3385 struct ipa_cst_ref_desc
*rdesc
;
3386 try_decrement_rdesc_refcount (jf
);
3387 if (jf
->type
== IPA_JF_CONST
3388 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3394 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3397 /* Hook that is called by cgraph.c when a node is removed. */
3400 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3402 /* During IPA-CP updating we can be called on not-yet analyze clones. */
3403 if (ipa_node_params_vector
.length () > (unsigned)node
->uid
)
3404 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
3405 if (vec_safe_length (ipa_node_agg_replacements
) > (unsigned)node
->uid
)
3406 (*ipa_node_agg_replacements
)[(unsigned)node
->uid
] = NULL
;
3409 /* Hook that is called by cgraph.c when an edge is duplicated. */
3412 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3413 __attribute__((unused
)) void *data
)
3415 struct ipa_edge_args
*old_args
, *new_args
;
3418 ipa_check_create_edge_args ();
3420 old_args
= IPA_EDGE_REF (src
);
3421 new_args
= IPA_EDGE_REF (dst
);
3423 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3425 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3427 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3428 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3430 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3432 if (src_jf
->type
== IPA_JF_CONST
)
3434 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3437 dst_jf
->value
.constant
.rdesc
= NULL
;
3438 else if (src
->caller
== dst
->caller
)
3440 struct ipa_ref
*ref
;
3441 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3442 gcc_checking_assert (n
);
3443 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3445 gcc_checking_assert (ref
);
3446 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3448 gcc_checking_assert (ipa_refdesc_pool
);
3449 struct ipa_cst_ref_desc
*dst_rdesc
3450 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3451 dst_rdesc
->cs
= dst
;
3452 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3453 dst_rdesc
->next_duplicate
= NULL
;
3454 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3456 else if (src_rdesc
->cs
== src
)
3458 struct ipa_cst_ref_desc
*dst_rdesc
;
3459 gcc_checking_assert (ipa_refdesc_pool
);
3461 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3462 dst_rdesc
->cs
= dst
;
3463 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3464 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3465 src_rdesc
->next_duplicate
= dst_rdesc
;
3466 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3470 struct ipa_cst_ref_desc
*dst_rdesc
;
3471 /* This can happen during inlining, when a JFUNC can refer to a
3472 reference taken in a function up in the tree of inline clones.
3473 We need to find the duplicate that refers to our tree of
3476 gcc_assert (dst
->caller
->global
.inlined_to
);
3477 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3479 dst_rdesc
= dst_rdesc
->next_duplicate
)
3481 struct cgraph_node
*top
;
3482 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3483 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3484 : dst_rdesc
->cs
->caller
;
3485 if (dst
->caller
->global
.inlined_to
== top
)
3488 gcc_assert (dst_rdesc
);
3489 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3495 /* Hook that is called by cgraph.c when a node is duplicated. */
3498 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
3499 ATTRIBUTE_UNUSED
void *data
)
3501 struct ipa_node_params
*old_info
, *new_info
;
3502 struct ipa_agg_replacement_value
*old_av
, *new_av
;
3504 ipa_check_create_node_params ();
3505 old_info
= IPA_NODE_REF (src
);
3506 new_info
= IPA_NODE_REF (dst
);
3508 new_info
->descriptors
= old_info
->descriptors
.copy ();
3509 new_info
->lattices
= NULL
;
3510 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3512 new_info
->analysis_done
= old_info
->analysis_done
;
3513 new_info
->node_enqueued
= old_info
->node_enqueued
;
3515 old_av
= ipa_get_agg_replacements_for_node (src
);
3522 struct ipa_agg_replacement_value
*v
;
3524 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3525 memcpy (v
, old_av
, sizeof (*v
));
3528 old_av
= old_av
->next
;
3530 ipa_set_node_agg_value_chain (dst
, new_av
);
3534 /* Analyze newly added function into callgraph. */
3537 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3539 if (cgraph_function_with_gimple_body_p (node
))
3540 ipa_analyze_node (node
);
3543 /* Register our cgraph hooks if they are not already there. */
3546 ipa_register_cgraph_hooks (void)
3548 if (!edge_removal_hook_holder
)
3549 edge_removal_hook_holder
=
3550 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3551 if (!node_removal_hook_holder
)
3552 node_removal_hook_holder
=
3553 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
3554 if (!edge_duplication_hook_holder
)
3555 edge_duplication_hook_holder
=
3556 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3557 if (!node_duplication_hook_holder
)
3558 node_duplication_hook_holder
=
3559 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
3560 function_insertion_hook_holder
=
3561 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
3564 /* Unregister our cgraph hooks if they are not already there. */
3567 ipa_unregister_cgraph_hooks (void)
3569 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
3570 edge_removal_hook_holder
= NULL
;
3571 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
3572 node_removal_hook_holder
= NULL
;
3573 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
3574 edge_duplication_hook_holder
= NULL
;
3575 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
3576 node_duplication_hook_holder
= NULL
;
3577 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
3578 function_insertion_hook_holder
= NULL
;
3581 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3582 longer needed after ipa-cp. */
3585 ipa_free_all_structures_after_ipa_cp (void)
3589 ipa_free_all_edge_args ();
3590 ipa_free_all_node_params ();
3591 free_alloc_pool (ipcp_sources_pool
);
3592 free_alloc_pool (ipcp_values_pool
);
3593 free_alloc_pool (ipcp_agg_lattice_pool
);
3594 ipa_unregister_cgraph_hooks ();
3595 if (ipa_refdesc_pool
)
3596 free_alloc_pool (ipa_refdesc_pool
);
3600 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3601 longer needed after indirect inlining. */
3604 ipa_free_all_structures_after_iinln (void)
3606 ipa_free_all_edge_args ();
3607 ipa_free_all_node_params ();
3608 ipa_unregister_cgraph_hooks ();
3609 if (ipcp_sources_pool
)
3610 free_alloc_pool (ipcp_sources_pool
);
3611 if (ipcp_values_pool
)
3612 free_alloc_pool (ipcp_values_pool
);
3613 if (ipcp_agg_lattice_pool
)
3614 free_alloc_pool (ipcp_agg_lattice_pool
);
3615 if (ipa_refdesc_pool
)
3616 free_alloc_pool (ipa_refdesc_pool
);
3619 /* Print ipa_tree_map data structures of all functions in the
3623 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3626 struct ipa_node_params
*info
;
3628 if (!node
->definition
)
3630 info
= IPA_NODE_REF (node
);
3631 fprintf (f
, " function %s/%i parameter descriptors:\n",
3632 node
->name (), node
->order
);
3633 count
= ipa_get_param_count (info
);
3634 for (i
= 0; i
< count
; i
++)
3639 ipa_dump_param (f
, info
, i
);
3640 if (ipa_is_param_used (info
, i
))
3641 fprintf (f
, " used");
3642 c
= ipa_get_controlled_uses (info
, i
);
3643 if (c
== IPA_UNDESCRIBED_USE
)
3644 fprintf (f
, " undescribed_use");
3646 fprintf (f
, " controlled_uses=%i", c
);
3651 /* Print ipa_tree_map data structures of all functions in the
3655 ipa_print_all_params (FILE * f
)
3657 struct cgraph_node
*node
;
3659 fprintf (f
, "\nFunction parameters:\n");
3660 FOR_EACH_FUNCTION (node
)
3661 ipa_print_node_params (f
, node
);
3664 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3667 ipa_get_vector_of_formal_parms (tree fndecl
)
3673 gcc_assert (!flag_wpa
);
3674 count
= count_formal_params (fndecl
);
3675 args
.create (count
);
3676 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3677 args
.quick_push (parm
);
3682 /* Return a heap allocated vector containing types of formal parameters of
3683 function type FNTYPE. */
3686 ipa_get_vector_of_formal_parm_types (tree fntype
)
3692 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3695 types
.create (count
);
3696 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3697 types
.quick_push (TREE_VALUE (t
));
3702 /* Modify the function declaration FNDECL and its type according to the plan in
3703 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3704 to reflect the actual parameters being modified which are determined by the
3705 base_index field. */
3708 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
3710 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
3711 tree orig_type
= TREE_TYPE (fndecl
);
3712 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
3714 /* The following test is an ugly hack, some functions simply don't have any
3715 arguments in their type. This is probably a bug but well... */
3716 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
3717 bool last_parm_void
;
3721 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
3723 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
3725 gcc_assert (oparms
.length () + 1 == otypes
.length ());
3727 gcc_assert (oparms
.length () == otypes
.length ());
3731 last_parm_void
= false;
3735 int len
= adjustments
.length ();
3736 tree
*link
= &DECL_ARGUMENTS (fndecl
);
3737 tree new_arg_types
= NULL
;
3738 for (int i
= 0; i
< len
; i
++)
3740 struct ipa_parm_adjustment
*adj
;
3743 adj
= &adjustments
[i
];
3745 if (adj
->op
== IPA_PARM_OP_NEW
)
3748 parm
= oparms
[adj
->base_index
];
3751 if (adj
->op
== IPA_PARM_OP_COPY
)
3754 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
3757 link
= &DECL_CHAIN (parm
);
3759 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3765 ptype
= build_pointer_type (adj
->type
);
3769 if (is_gimple_reg_type (ptype
))
3771 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
3772 if (TYPE_ALIGN (ptype
) < malign
)
3773 ptype
= build_aligned_type (ptype
, malign
);
3778 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
3780 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
3782 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
3783 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
3784 DECL_ARTIFICIAL (new_parm
) = 1;
3785 DECL_ARG_TYPE (new_parm
) = ptype
;
3786 DECL_CONTEXT (new_parm
) = fndecl
;
3787 TREE_USED (new_parm
) = 1;
3788 DECL_IGNORED_P (new_parm
) = 1;
3789 layout_decl (new_parm
, 0);
3791 if (adj
->op
== IPA_PARM_OP_NEW
)
3795 adj
->new_decl
= new_parm
;
3798 link
= &DECL_CHAIN (new_parm
);
3804 tree new_reversed
= NULL
;
3807 new_reversed
= nreverse (new_arg_types
);
3811 TREE_CHAIN (new_arg_types
) = void_list_node
;
3813 new_reversed
= void_list_node
;
3817 /* Use copy_node to preserve as much as possible from original type
3818 (debug info, attribute lists etc.)
3819 Exception is METHOD_TYPEs must have THIS argument.
3820 When we are asked to remove it, we need to build new FUNCTION_TYPE
3822 tree new_type
= NULL
;
3823 if (TREE_CODE (orig_type
) != METHOD_TYPE
3824 || (adjustments
[0].op
== IPA_PARM_OP_COPY
3825 && adjustments
[0].base_index
== 0))
3827 new_type
= build_distinct_type_copy (orig_type
);
3828 TYPE_ARG_TYPES (new_type
) = new_reversed
;
3833 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
3835 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
3836 DECL_VINDEX (fndecl
) = NULL_TREE
;
3839 /* When signature changes, we need to clear builtin info. */
3840 if (DECL_BUILT_IN (fndecl
))
3842 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
3843 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
3846 /* This is a new type, not a copy of an old type. Need to reassociate
3847 variants. We can handle everything except the main variant lazily. */
3848 tree t
= TYPE_MAIN_VARIANT (orig_type
);
3851 TYPE_MAIN_VARIANT (new_type
) = t
;
3852 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
3853 TYPE_NEXT_VARIANT (t
) = new_type
;
3857 TYPE_MAIN_VARIANT (new_type
) = new_type
;
3858 TYPE_NEXT_VARIANT (new_type
) = NULL
;
3861 TREE_TYPE (fndecl
) = new_type
;
3862 DECL_VIRTUAL_P (fndecl
) = 0;
3863 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
3868 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
3869 If this is a directly recursive call, CS must be NULL. Otherwise it must
3870 contain the corresponding call graph edge. */
3873 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
3874 ipa_parm_adjustment_vec adjustments
)
3876 struct cgraph_node
*current_node
= cgraph_get_node (current_function_decl
);
3878 vec
<tree
, va_gc
> **debug_args
= NULL
;
3880 gimple_stmt_iterator gsi
, prev_gsi
;
3884 len
= adjustments
.length ();
3886 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
3887 current_node
->remove_stmt_references (stmt
);
3889 gsi
= gsi_for_stmt (stmt
);
3891 gsi_prev (&prev_gsi
);
3892 for (i
= 0; i
< len
; i
++)
3894 struct ipa_parm_adjustment
*adj
;
3896 adj
= &adjustments
[i
];
3898 if (adj
->op
== IPA_PARM_OP_COPY
)
3900 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
3902 vargs
.quick_push (arg
);
3904 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3906 tree expr
, base
, off
;
3908 unsigned int deref_align
= 0;
3909 bool deref_base
= false;
3911 /* We create a new parameter out of the value of the old one, we can
3912 do the following kind of transformations:
3914 - A scalar passed by reference is converted to a scalar passed by
3915 value. (adj->by_ref is false and the type of the original
3916 actual argument is a pointer to a scalar).
3918 - A part of an aggregate is passed instead of the whole aggregate.
3919 The part can be passed either by value or by reference, this is
3920 determined by value of adj->by_ref. Moreover, the code below
3921 handles both situations when the original aggregate is passed by
3922 value (its type is not a pointer) and when it is passed by
3923 reference (it is a pointer to an aggregate).
3925 When the new argument is passed by reference (adj->by_ref is true)
3926 it must be a part of an aggregate and therefore we form it by
3927 simply taking the address of a reference inside the original
3930 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
3931 base
= gimple_call_arg (stmt
, adj
->base_index
);
3932 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
3933 : EXPR_LOCATION (base
);
3935 if (TREE_CODE (base
) != ADDR_EXPR
3936 && POINTER_TYPE_P (TREE_TYPE (base
)))
3937 off
= build_int_cst (adj
->alias_ptr_type
,
3938 adj
->offset
/ BITS_PER_UNIT
);
3941 HOST_WIDE_INT base_offset
;
3945 if (TREE_CODE (base
) == ADDR_EXPR
)
3947 base
= TREE_OPERAND (base
, 0);
3953 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
3954 /* Aggregate arguments can have non-invariant addresses. */
3957 base
= build_fold_addr_expr (prev_base
);
3958 off
= build_int_cst (adj
->alias_ptr_type
,
3959 adj
->offset
/ BITS_PER_UNIT
);
3961 else if (TREE_CODE (base
) == MEM_REF
)
3966 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
3968 off
= build_int_cst (adj
->alias_ptr_type
,
3970 + adj
->offset
/ BITS_PER_UNIT
);
3971 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
3973 base
= TREE_OPERAND (base
, 0);
3977 off
= build_int_cst (adj
->alias_ptr_type
,
3979 + adj
->offset
/ BITS_PER_UNIT
);
3980 base
= build_fold_addr_expr (base
);
3986 tree type
= adj
->type
;
3988 unsigned HOST_WIDE_INT misalign
;
3992 align
= deref_align
;
3997 get_pointer_alignment_1 (base
, &align
, &misalign
);
3998 if (TYPE_ALIGN (type
) > align
)
3999 align
= TYPE_ALIGN (type
);
4001 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
4003 misalign
= misalign
& (align
- 1);
4005 align
= (misalign
& -misalign
);
4006 if (align
< TYPE_ALIGN (type
))
4007 type
= build_aligned_type (type
, align
);
4008 base
= force_gimple_operand_gsi (&gsi
, base
,
4009 true, NULL
, true, GSI_SAME_STMT
);
4010 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
4011 /* If expr is not a valid gimple call argument emit
4012 a load into a temporary. */
4013 if (is_gimple_reg_type (TREE_TYPE (expr
)))
4015 gimple tem
= gimple_build_assign (NULL_TREE
, expr
);
4016 if (gimple_in_ssa_p (cfun
))
4018 gimple_set_vuse (tem
, gimple_vuse (stmt
));
4019 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
4022 expr
= create_tmp_reg (TREE_TYPE (expr
), NULL
);
4023 gimple_assign_set_lhs (tem
, expr
);
4024 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
4029 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
4030 expr
= build_fold_addr_expr (expr
);
4031 expr
= force_gimple_operand_gsi (&gsi
, expr
,
4032 true, NULL
, true, GSI_SAME_STMT
);
4034 vargs
.quick_push (expr
);
4036 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
4039 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
4042 arg
= gimple_call_arg (stmt
, adj
->base_index
);
4043 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
4045 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
4047 arg
= fold_convert_loc (gimple_location (stmt
),
4048 TREE_TYPE (origin
), arg
);
4050 if (debug_args
== NULL
)
4051 debug_args
= decl_debug_args_insert (callee_decl
);
4052 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
4053 if (ddecl
== origin
)
4055 ddecl
= (**debug_args
)[ix
+ 1];
4060 ddecl
= make_node (DEBUG_EXPR_DECL
);
4061 DECL_ARTIFICIAL (ddecl
) = 1;
4062 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
4063 DECL_MODE (ddecl
) = DECL_MODE (origin
);
4065 vec_safe_push (*debug_args
, origin
);
4066 vec_safe_push (*debug_args
, ddecl
);
4068 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
4069 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
4073 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4075 fprintf (dump_file
, "replacing stmt:");
4076 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
4079 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
4081 if (gimple_call_lhs (stmt
))
4082 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
4084 gimple_set_block (new_stmt
, gimple_block (stmt
));
4085 if (gimple_has_location (stmt
))
4086 gimple_set_location (new_stmt
, gimple_location (stmt
));
4087 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
4088 gimple_call_copy_flags (new_stmt
, stmt
);
4089 if (gimple_in_ssa_p (cfun
))
4091 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4092 if (gimple_vdef (stmt
))
4094 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4095 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
4099 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4101 fprintf (dump_file
, "with stmt:");
4102 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
4103 fprintf (dump_file
, "\n");
4105 gsi_replace (&gsi
, new_stmt
, true);
4107 cgraph_set_call_stmt (cs
, new_stmt
);
4110 ipa_record_stmt_references (current_node
, gsi_stmt (gsi
));
4113 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
4116 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
4117 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
4118 specifies whether the function should care about type incompatibility the
4119 current and new expressions. If it is false, the function will leave
4120 incompatibility issues to the caller. Return true iff the expression
4124 ipa_modify_expr (tree
*expr
, bool convert
,
4125 ipa_parm_adjustment_vec adjustments
)
4127 struct ipa_parm_adjustment
*cand
4128 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
4134 src
= build_simple_mem_ref (cand
->new_decl
);
4136 src
= cand
->new_decl
;
4138 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4140 fprintf (dump_file
, "About to replace expr ");
4141 print_generic_expr (dump_file
, *expr
, 0);
4142 fprintf (dump_file
, " with ");
4143 print_generic_expr (dump_file
, src
, 0);
4144 fprintf (dump_file
, "\n");
4147 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
4149 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
4157 /* If T is an SSA_NAME, return NULL if it is not a default def or
4158 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
4159 the base variable is always returned, regardless if it is a default
4160 def. Return T if it is not an SSA_NAME. */
4163 get_ssa_base_param (tree t
, bool ignore_default_def
)
4165 if (TREE_CODE (t
) == SSA_NAME
)
4167 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
4168 return SSA_NAME_VAR (t
);
4175 /* Given an expression, return an adjustment entry specifying the
4176 transformation to be done on EXPR. If no suitable adjustment entry
4177 was found, returns NULL.
4179 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
4180 default def, otherwise bail on them.
4182 If CONVERT is non-NULL, this function will set *CONVERT if the
4183 expression provided is a component reference. ADJUSTMENTS is the
4184 adjustments vector. */
4186 ipa_parm_adjustment
*
4187 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
4188 ipa_parm_adjustment_vec adjustments
,
4189 bool ignore_default_def
)
4191 if (TREE_CODE (**expr
) == BIT_FIELD_REF
4192 || TREE_CODE (**expr
) == IMAGPART_EXPR
4193 || TREE_CODE (**expr
) == REALPART_EXPR
)
4195 *expr
= &TREE_OPERAND (**expr
, 0);
4200 HOST_WIDE_INT offset
, size
, max_size
;
4201 tree base
= get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
);
4202 if (!base
|| size
== -1 || max_size
== -1)
4205 if (TREE_CODE (base
) == MEM_REF
)
4207 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
4208 base
= TREE_OPERAND (base
, 0);
4211 base
= get_ssa_base_param (base
, ignore_default_def
);
4212 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4215 struct ipa_parm_adjustment
*cand
= NULL
;
4216 unsigned int len
= adjustments
.length ();
4217 for (unsigned i
= 0; i
< len
; i
++)
4219 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4221 if (adj
->base
== base
4222 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4229 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4234 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4237 index_in_adjustments_multiple_times_p (int base_index
,
4238 ipa_parm_adjustment_vec adjustments
)
4240 int i
, len
= adjustments
.length ();
4243 for (i
= 0; i
< len
; i
++)
4245 struct ipa_parm_adjustment
*adj
;
4246 adj
= &adjustments
[i
];
4248 if (adj
->base_index
== base_index
)
4260 /* Return adjustments that should have the same effect on function parameters
4261 and call arguments as if they were first changed according to adjustments in
4262 INNER and then by adjustments in OUTER. */
4264 ipa_parm_adjustment_vec
4265 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4266 ipa_parm_adjustment_vec outer
)
4268 int i
, outlen
= outer
.length ();
4269 int inlen
= inner
.length ();
4271 ipa_parm_adjustment_vec adjustments
, tmp
;
4274 for (i
= 0; i
< inlen
; i
++)
4276 struct ipa_parm_adjustment
*n
;
4279 if (n
->op
== IPA_PARM_OP_REMOVE
)
4283 /* FIXME: Handling of new arguments are not implemented yet. */
4284 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4285 tmp
.quick_push (*n
);
4289 adjustments
.create (outlen
+ removals
);
4290 for (i
= 0; i
< outlen
; i
++)
4292 struct ipa_parm_adjustment r
;
4293 struct ipa_parm_adjustment
*out
= &outer
[i
];
4294 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4296 memset (&r
, 0, sizeof (r
));
4297 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4298 if (out
->op
== IPA_PARM_OP_REMOVE
)
4300 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4302 r
.op
= IPA_PARM_OP_REMOVE
;
4303 adjustments
.quick_push (r
);
4309 /* FIXME: Handling of new arguments are not implemented yet. */
4310 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4313 r
.base_index
= in
->base_index
;
4316 /* FIXME: Create nonlocal value too. */
4318 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4319 r
.op
= IPA_PARM_OP_COPY
;
4320 else if (in
->op
== IPA_PARM_OP_COPY
)
4321 r
.offset
= out
->offset
;
4322 else if (out
->op
== IPA_PARM_OP_COPY
)
4323 r
.offset
= in
->offset
;
4325 r
.offset
= in
->offset
+ out
->offset
;
4326 adjustments
.quick_push (r
);
4329 for (i
= 0; i
< inlen
; i
++)
4331 struct ipa_parm_adjustment
*n
= &inner
[i
];
4333 if (n
->op
== IPA_PARM_OP_REMOVE
)
4334 adjustments
.quick_push (*n
);
4341 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4342 friendly way, assuming they are meant to be applied to FNDECL. */
4345 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4348 int i
, len
= adjustments
.length ();
4350 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4352 fprintf (file
, "IPA param adjustments: ");
4353 for (i
= 0; i
< len
; i
++)
4355 struct ipa_parm_adjustment
*adj
;
4356 adj
= &adjustments
[i
];
4359 fprintf (file
, " ");
4363 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4364 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4367 fprintf (file
, ", base: ");
4368 print_generic_expr (file
, adj
->base
, 0);
4372 fprintf (file
, ", new_decl: ");
4373 print_generic_expr (file
, adj
->new_decl
, 0);
4375 if (adj
->new_ssa_base
)
4377 fprintf (file
, ", new_ssa_base: ");
4378 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4381 if (adj
->op
== IPA_PARM_OP_COPY
)
4382 fprintf (file
, ", copy_param");
4383 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4384 fprintf (file
, ", remove_param");
4386 fprintf (file
, ", offset %li", (long) adj
->offset
);
4388 fprintf (file
, ", by_ref");
4389 print_node_brief (file
, ", type: ", adj
->type
, 0);
4390 fprintf (file
, "\n");
4395 /* Dump the AV linked list. */
4398 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4401 fprintf (f
, " Aggregate replacements:");
4402 for (; av
; av
= av
->next
)
4404 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4405 av
->index
, av
->offset
);
4406 print_generic_expr (f
, av
->value
, 0);
4412 /* Stream out jump function JUMP_FUNC to OB. */
4415 ipa_write_jump_function (struct output_block
*ob
,
4416 struct ipa_jump_func
*jump_func
)
4418 struct ipa_agg_jf_item
*item
;
4419 struct bitpack_d bp
;
4422 streamer_write_uhwi (ob
, jump_func
->type
);
4423 switch (jump_func
->type
)
4425 case IPA_JF_UNKNOWN
:
4427 case IPA_JF_KNOWN_TYPE
:
4428 streamer_write_uhwi (ob
, jump_func
->value
.known_type
.offset
);
4429 stream_write_tree (ob
, jump_func
->value
.known_type
.base_type
, true);
4430 stream_write_tree (ob
, jump_func
->value
.known_type
.component_type
, true);
4434 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4435 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4437 case IPA_JF_PASS_THROUGH
:
4438 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4439 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4441 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4442 bp
= bitpack_create (ob
->main_stream
);
4443 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4444 bp_pack_value (&bp
, jump_func
->value
.pass_through
.type_preserved
, 1);
4445 streamer_write_bitpack (&bp
);
4449 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4450 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4453 case IPA_JF_ANCESTOR
:
4454 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4455 stream_write_tree (ob
, jump_func
->value
.ancestor
.type
, true);
4456 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4457 bp
= bitpack_create (ob
->main_stream
);
4458 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4459 bp_pack_value (&bp
, jump_func
->value
.ancestor
.type_preserved
, 1);
4460 streamer_write_bitpack (&bp
);
4464 count
= vec_safe_length (jump_func
->agg
.items
);
4465 streamer_write_uhwi (ob
, count
);
4468 bp
= bitpack_create (ob
->main_stream
);
4469 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4470 streamer_write_bitpack (&bp
);
4473 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4475 streamer_write_uhwi (ob
, item
->offset
);
4476 stream_write_tree (ob
, item
->value
, true);
4480 /* Read in jump function JUMP_FUNC from IB. */
4483 ipa_read_jump_function (struct lto_input_block
*ib
,
4484 struct ipa_jump_func
*jump_func
,
4485 struct cgraph_edge
*cs
,
4486 struct data_in
*data_in
)
4488 enum jump_func_type jftype
;
4489 enum tree_code operation
;
4492 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4495 case IPA_JF_UNKNOWN
:
4496 jump_func
->type
= IPA_JF_UNKNOWN
;
4498 case IPA_JF_KNOWN_TYPE
:
4500 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4501 tree base_type
= stream_read_tree (ib
, data_in
);
4502 tree component_type
= stream_read_tree (ib
, data_in
);
4504 ipa_set_jf_known_type (jump_func
, offset
, base_type
, component_type
);
4508 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4510 case IPA_JF_PASS_THROUGH
:
4511 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4512 if (operation
== NOP_EXPR
)
4514 int formal_id
= streamer_read_uhwi (ib
);
4515 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4516 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4517 bool type_preserved
= bp_unpack_value (&bp
, 1);
4518 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
,
4523 tree operand
= stream_read_tree (ib
, data_in
);
4524 int formal_id
= streamer_read_uhwi (ib
);
4525 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4529 case IPA_JF_ANCESTOR
:
4531 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4532 tree type
= stream_read_tree (ib
, data_in
);
4533 int formal_id
= streamer_read_uhwi (ib
);
4534 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4535 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4536 bool type_preserved
= bp_unpack_value (&bp
, 1);
4538 ipa_set_ancestor_jf (jump_func
, offset
, type
, formal_id
, agg_preserved
,
4544 count
= streamer_read_uhwi (ib
);
4545 vec_alloc (jump_func
->agg
.items
, count
);
4548 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4549 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4551 for (i
= 0; i
< count
; i
++)
4553 struct ipa_agg_jf_item item
;
4554 item
.offset
= streamer_read_uhwi (ib
);
4555 item
.value
= stream_read_tree (ib
, data_in
);
4556 jump_func
->agg
.items
->quick_push (item
);
4560 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4561 relevant to indirect inlining to OB. */
4564 ipa_write_indirect_edge_info (struct output_block
*ob
,
4565 struct cgraph_edge
*cs
)
4567 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4568 struct bitpack_d bp
;
4570 streamer_write_hwi (ob
, ii
->param_index
);
4571 streamer_write_hwi (ob
, ii
->offset
);
4572 bp
= bitpack_create (ob
->main_stream
);
4573 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4574 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4575 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4576 bp_pack_value (&bp
, ii
->by_ref
, 1);
4577 bp_pack_value (&bp
, ii
->maybe_in_construction
, 1);
4578 bp_pack_value (&bp
, ii
->maybe_derived_type
, 1);
4579 streamer_write_bitpack (&bp
);
4581 if (ii
->polymorphic
)
4583 streamer_write_hwi (ob
, ii
->otr_token
);
4584 stream_write_tree (ob
, ii
->otr_type
, true);
4585 stream_write_tree (ob
, ii
->outer_type
, true);
4589 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4590 relevant to indirect inlining from IB. */
4593 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4594 struct data_in
*data_in ATTRIBUTE_UNUSED
,
4595 struct cgraph_edge
*cs
)
4597 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4598 struct bitpack_d bp
;
4600 ii
->param_index
= (int) streamer_read_hwi (ib
);
4601 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4602 bp
= streamer_read_bitpack (ib
);
4603 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4604 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4605 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4606 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4607 ii
->maybe_in_construction
= bp_unpack_value (&bp
, 1);
4608 ii
->maybe_derived_type
= bp_unpack_value (&bp
, 1);
4609 if (ii
->polymorphic
)
4611 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4612 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4613 ii
->outer_type
= stream_read_tree (ib
, data_in
);
4617 /* Stream out NODE info to OB. */
4620 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4623 lto_symtab_encoder_t encoder
;
4624 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4626 struct cgraph_edge
*e
;
4627 struct bitpack_d bp
;
4629 encoder
= ob
->decl_state
->symtab_node_encoder
;
4630 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4631 streamer_write_uhwi (ob
, node_ref
);
4633 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4634 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4635 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4636 bp
= bitpack_create (ob
->main_stream
);
4637 gcc_assert (info
->analysis_done
4638 || ipa_get_param_count (info
) == 0);
4639 gcc_assert (!info
->node_enqueued
);
4640 gcc_assert (!info
->ipcp_orig_node
);
4641 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4642 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4643 streamer_write_bitpack (&bp
);
4644 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4645 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4646 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4648 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4650 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4651 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4652 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4654 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4656 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4658 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4659 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4660 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4661 ipa_write_indirect_edge_info (ob
, e
);
4665 /* Stream in NODE info from IB. */
4668 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4669 struct data_in
*data_in
)
4671 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4673 struct cgraph_edge
*e
;
4674 struct bitpack_d bp
;
4676 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
4678 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4679 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
4681 bp
= streamer_read_bitpack (ib
);
4682 if (ipa_get_param_count (info
) != 0)
4683 info
->analysis_done
= true;
4684 info
->node_enqueued
= false;
4685 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4686 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
4687 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4688 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
4689 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4691 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4692 int count
= streamer_read_uhwi (ib
);
4696 vec_safe_grow_cleared (args
->jump_functions
, count
);
4698 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4699 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4702 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4704 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4705 int count
= streamer_read_uhwi (ib
);
4709 vec_safe_grow_cleared (args
->jump_functions
, count
);
4710 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4711 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4714 ipa_read_indirect_edge_info (ib
, data_in
, e
);
4718 /* Write jump functions for nodes in SET. */
4721 ipa_prop_write_jump_functions (void)
4723 struct cgraph_node
*node
;
4724 struct output_block
*ob
;
4725 unsigned int count
= 0;
4726 lto_symtab_encoder_iterator lsei
;
4727 lto_symtab_encoder_t encoder
;
4730 if (!ipa_node_params_vector
.exists ())
4733 ob
= create_output_block (LTO_section_jump_functions
);
4734 encoder
= ob
->decl_state
->symtab_node_encoder
;
4735 ob
->cgraph_node
= NULL
;
4736 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4737 lsei_next_function_in_partition (&lsei
))
4739 node
= lsei_cgraph_node (lsei
);
4740 if (cgraph_function_with_gimple_body_p (node
)
4741 && IPA_NODE_REF (node
) != NULL
)
4745 streamer_write_uhwi (ob
, count
);
4747 /* Process all of the functions. */
4748 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4749 lsei_next_function_in_partition (&lsei
))
4751 node
= lsei_cgraph_node (lsei
);
4752 if (cgraph_function_with_gimple_body_p (node
)
4753 && IPA_NODE_REF (node
) != NULL
)
4754 ipa_write_node_info (ob
, node
);
4756 streamer_write_char_stream (ob
->main_stream
, 0);
4757 produce_asm (ob
, NULL
);
4758 destroy_output_block (ob
);
4761 /* Read section in file FILE_DATA of length LEN with data DATA. */
4764 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
4767 const struct lto_function_header
*header
=
4768 (const struct lto_function_header
*) data
;
4769 const int cfg_offset
= sizeof (struct lto_function_header
);
4770 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4771 const int string_offset
= main_offset
+ header
->main_size
;
4772 struct data_in
*data_in
;
4773 struct lto_input_block ib_main
;
4777 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4781 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4782 header
->string_size
, vNULL
);
4783 count
= streamer_read_uhwi (&ib_main
);
4785 for (i
= 0; i
< count
; i
++)
4788 struct cgraph_node
*node
;
4789 lto_symtab_encoder_t encoder
;
4791 index
= streamer_read_uhwi (&ib_main
);
4792 encoder
= file_data
->symtab_node_encoder
;
4793 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4794 gcc_assert (node
->definition
);
4795 ipa_read_node_info (&ib_main
, node
, data_in
);
4797 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4799 lto_data_in_delete (data_in
);
4802 /* Read ipcp jump functions. */
4805 ipa_prop_read_jump_functions (void)
4807 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4808 struct lto_file_decl_data
*file_data
;
4811 ipa_check_create_node_params ();
4812 ipa_check_create_edge_args ();
4813 ipa_register_cgraph_hooks ();
4815 while ((file_data
= file_data_vec
[j
++]))
4818 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
4821 ipa_prop_read_section (file_data
, data
, len
);
4825 /* After merging units, we can get mismatch in argument counts.
4826 Also decl merging might've rendered parameter lists obsolete.
4827 Also compute called_with_variable_arg info. */
4830 ipa_update_after_lto_read (void)
4832 ipa_check_create_node_params ();
4833 ipa_check_create_edge_args ();
4837 write_agg_replacement_chain (struct output_block
*ob
, struct cgraph_node
*node
)
4840 unsigned int count
= 0;
4841 lto_symtab_encoder_t encoder
;
4842 struct ipa_agg_replacement_value
*aggvals
, *av
;
4844 aggvals
= ipa_get_agg_replacements_for_node (node
);
4845 encoder
= ob
->decl_state
->symtab_node_encoder
;
4846 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4847 streamer_write_uhwi (ob
, node_ref
);
4849 for (av
= aggvals
; av
; av
= av
->next
)
4851 streamer_write_uhwi (ob
, count
);
4853 for (av
= aggvals
; av
; av
= av
->next
)
4855 struct bitpack_d bp
;
4857 streamer_write_uhwi (ob
, av
->offset
);
4858 streamer_write_uhwi (ob
, av
->index
);
4859 stream_write_tree (ob
, av
->value
, true);
4861 bp
= bitpack_create (ob
->main_stream
);
4862 bp_pack_value (&bp
, av
->by_ref
, 1);
4863 streamer_write_bitpack (&bp
);
4867 /* Stream in the aggregate value replacement chain for NODE from IB. */
4870 read_agg_replacement_chain (struct lto_input_block
*ib
,
4871 struct cgraph_node
*node
,
4872 struct data_in
*data_in
)
4874 struct ipa_agg_replacement_value
*aggvals
= NULL
;
4875 unsigned int count
, i
;
4877 count
= streamer_read_uhwi (ib
);
4878 for (i
= 0; i
<count
; i
++)
4880 struct ipa_agg_replacement_value
*av
;
4881 struct bitpack_d bp
;
4883 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
4884 av
->offset
= streamer_read_uhwi (ib
);
4885 av
->index
= streamer_read_uhwi (ib
);
4886 av
->value
= stream_read_tree (ib
, data_in
);
4887 bp
= streamer_read_bitpack (ib
);
4888 av
->by_ref
= bp_unpack_value (&bp
, 1);
4892 ipa_set_node_agg_value_chain (node
, aggvals
);
4895 /* Write all aggregate replacement for nodes in set. */
4898 ipa_prop_write_all_agg_replacement (void)
4900 struct cgraph_node
*node
;
4901 struct output_block
*ob
;
4902 unsigned int count
= 0;
4903 lto_symtab_encoder_iterator lsei
;
4904 lto_symtab_encoder_t encoder
;
4906 if (!ipa_node_agg_replacements
)
4909 ob
= create_output_block (LTO_section_ipcp_transform
);
4910 encoder
= ob
->decl_state
->symtab_node_encoder
;
4911 ob
->cgraph_node
= NULL
;
4912 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4913 lsei_next_function_in_partition (&lsei
))
4915 node
= lsei_cgraph_node (lsei
);
4916 if (cgraph_function_with_gimple_body_p (node
)
4917 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4921 streamer_write_uhwi (ob
, count
);
4923 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4924 lsei_next_function_in_partition (&lsei
))
4926 node
= lsei_cgraph_node (lsei
);
4927 if (cgraph_function_with_gimple_body_p (node
)
4928 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4929 write_agg_replacement_chain (ob
, node
);
4931 streamer_write_char_stream (ob
->main_stream
, 0);
4932 produce_asm (ob
, NULL
);
4933 destroy_output_block (ob
);
4936 /* Read replacements section in file FILE_DATA of length LEN with data
4940 read_replacements_section (struct lto_file_decl_data
*file_data
,
4944 const struct lto_function_header
*header
=
4945 (const struct lto_function_header
*) data
;
4946 const int cfg_offset
= sizeof (struct lto_function_header
);
4947 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4948 const int string_offset
= main_offset
+ header
->main_size
;
4949 struct data_in
*data_in
;
4950 struct lto_input_block ib_main
;
4954 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4957 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4958 header
->string_size
, vNULL
);
4959 count
= streamer_read_uhwi (&ib_main
);
4961 for (i
= 0; i
< count
; i
++)
4964 struct cgraph_node
*node
;
4965 lto_symtab_encoder_t encoder
;
4967 index
= streamer_read_uhwi (&ib_main
);
4968 encoder
= file_data
->symtab_node_encoder
;
4969 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4970 gcc_assert (node
->definition
);
4971 read_agg_replacement_chain (&ib_main
, node
, data_in
);
4973 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4975 lto_data_in_delete (data_in
);
4978 /* Read IPA-CP aggregate replacements. */
4981 ipa_prop_read_all_agg_replacement (void)
4983 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4984 struct lto_file_decl_data
*file_data
;
4987 while ((file_data
= file_data_vec
[j
++]))
4990 const char *data
= lto_get_section_data (file_data
,
4991 LTO_section_ipcp_transform
,
4994 read_replacements_section (file_data
, data
, len
);
4998 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5002 adjust_agg_replacement_values (struct cgraph_node
*node
,
5003 struct ipa_agg_replacement_value
*aggval
)
5005 struct ipa_agg_replacement_value
*v
;
5006 int i
, c
= 0, d
= 0, *adj
;
5008 if (!node
->clone
.combined_args_to_skip
)
5011 for (v
= aggval
; v
; v
= v
->next
)
5013 gcc_assert (v
->index
>= 0);
5019 adj
= XALLOCAVEC (int, c
);
5020 for (i
= 0; i
< c
; i
++)
5021 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5029 for (v
= aggval
; v
; v
= v
->next
)
5030 v
->index
= adj
[v
->index
];
5033 /* Dominator walker driving the ipcp modification phase. */
5035 class ipcp_modif_dom_walker
: public dom_walker
5038 ipcp_modif_dom_walker (struct func_body_info
*fbi
,
5039 vec
<ipa_param_descriptor
> descs
,
5040 struct ipa_agg_replacement_value
*av
,
5042 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5043 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5045 virtual void before_dom_children (basic_block
);
5048 struct func_body_info
*m_fbi
;
5049 vec
<ipa_param_descriptor
> m_descriptors
;
5050 struct ipa_agg_replacement_value
*m_aggval
;
5051 bool *m_something_changed
, *m_cfg_changed
;
5055 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5057 gimple_stmt_iterator gsi
;
5058 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5060 struct ipa_agg_replacement_value
*v
;
5061 gimple stmt
= gsi_stmt (gsi
);
5063 HOST_WIDE_INT offset
, size
;
5067 if (!gimple_assign_load_p (stmt
))
5069 rhs
= gimple_assign_rhs1 (stmt
);
5070 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5075 while (handled_component_p (t
))
5077 /* V_C_E can do things like convert an array of integers to one
5078 bigger integer and similar things we do not handle below. */
5079 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
5084 t
= TREE_OPERAND (t
, 0);
5089 if (!ipa_load_from_parm_agg_1 (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5090 &offset
, &size
, &by_ref
))
5092 for (v
= m_aggval
; v
; v
= v
->next
)
5093 if (v
->index
== index
5094 && v
->offset
== offset
)
5097 || v
->by_ref
!= by_ref
5098 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
5101 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5102 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5104 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5105 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5106 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5107 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5108 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5113 fprintf (dump_file
, " const ");
5114 print_generic_expr (dump_file
, v
->value
, 0);
5115 fprintf (dump_file
, " can't be converted to type of ");
5116 print_generic_expr (dump_file
, rhs
, 0);
5117 fprintf (dump_file
, "\n");
5125 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5127 fprintf (dump_file
, "Modifying stmt:\n ");
5128 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5130 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5133 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5135 fprintf (dump_file
, "into:\n ");
5136 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5137 fprintf (dump_file
, "\n");
5140 *m_something_changed
= true;
5141 if (maybe_clean_eh_stmt (stmt
)
5142 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5143 *m_cfg_changed
= true;
5148 /* IPCP transformation phase doing propagation of aggregate values. */
5151 ipcp_transform_function (struct cgraph_node
*node
)
5153 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
5154 struct func_body_info fbi
;
5155 struct ipa_agg_replacement_value
*aggval
;
5157 bool cfg_changed
= false, something_changed
= false;
5159 gcc_checking_assert (cfun
);
5160 gcc_checking_assert (current_function_decl
);
5163 fprintf (dump_file
, "Modification phase of node %s/%i\n",
5164 node
->name (), node
->order
);
5166 aggval
= ipa_get_agg_replacements_for_node (node
);
5169 param_count
= count_formal_params (node
->decl
);
5170 if (param_count
== 0)
5172 adjust_agg_replacement_values (node
, aggval
);
5174 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5178 fbi
.bb_infos
= vNULL
;
5179 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5180 fbi
.param_count
= param_count
;
5183 descriptors
.safe_grow_cleared (param_count
);
5184 ipa_populate_param_decls (node
, descriptors
);
5185 calculate_dominance_info (CDI_DOMINATORS
);
5186 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5187 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5190 struct ipa_bb_info
*bi
;
5191 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5192 free_ipa_bb_info (bi
);
5193 fbi
.bb_infos
.release ();
5194 free_dominance_info (CDI_DOMINATORS
);
5195 (*ipa_node_agg_replacements
)[node
->uid
] = NULL
;
5196 descriptors
.release ();
5198 if (!something_changed
)
5200 else if (cfg_changed
)
5201 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5203 return TODO_update_ssa_only_virtuals
;