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 const char *fmt
= "discovered direct call to non-function in %s/%i, "
2677 "making it __builtin_unreachable\n";
2681 location_t loc
= gimple_location (ie
->call_stmt
);
2682 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
, fmt
,
2683 ie
->caller
->name (), ie
->caller
->order
);
2686 fprintf (dump_file
, fmt
, ie
->caller
->name (), ie
->caller
->order
);
2689 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2690 callee
= cgraph_get_create_node (target
);
2694 callee
= cgraph_get_node (target
);
2697 callee
= cgraph_get_node (target
);
2699 /* Because may-edges are not explicitely represented and vtable may be external,
2700 we may create the first reference to the object in the unit. */
2701 if (!callee
|| callee
->global
.inlined_to
)
2704 /* We are better to ensure we can refer to it.
2705 In the case of static functions we are out of luck, since we already
2706 removed its body. In the case of public functions we may or may
2707 not introduce the reference. */
2708 if (!canonicalize_constructor_val (target
, NULL
)
2709 || !TREE_PUBLIC (target
))
2712 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2713 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2714 xstrdup (ie
->caller
->name ()),
2716 xstrdup (ie
->callee
->name ()),
2720 callee
= cgraph_get_create_node (target
);
2723 if (!dbg_cnt (devirt
))
2726 ipa_check_create_node_params ();
2728 /* We can not make edges to inline clones. It is bug that someone removed
2729 the cgraph node too early. */
2730 gcc_assert (!callee
->global
.inlined_to
);
2732 if (dump_file
&& !unreachable
)
2734 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
2735 "(%s/%i -> %s/%i), for stmt ",
2736 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2737 xstrdup (ie
->caller
->name ()),
2739 xstrdup (callee
->name ()),
2742 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2744 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2746 if (dump_enabled_p ())
2748 const char *fmt
= "converting indirect call in %s to direct call to %s\n";
2752 location_t loc
= gimple_location (ie
->call_stmt
);
2754 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
, fmt
,
2755 ie
->caller
->name (), callee
->name ());
2759 fprintf (dump_file
, fmt
, ie
->caller
->name (), callee
->name ());
2761 ie
= cgraph_make_edge_direct (ie
, callee
);
2762 es
= inline_edge_summary (ie
);
2763 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2764 - eni_size_weights
.call_cost
);
2765 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2766 - eni_time_weights
.call_cost
);
2771 /* Retrieve value from aggregate jump function AGG for the given OFFSET or
2772 return NULL if there is not any. BY_REF specifies whether the value has to
2773 be passed by reference or by value. */
2776 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
,
2777 HOST_WIDE_INT offset
, bool by_ref
)
2779 struct ipa_agg_jf_item
*item
;
2782 if (by_ref
!= agg
->by_ref
)
2785 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2786 if (item
->offset
== offset
)
2788 /* Currently we do not have clobber values, return NULL for them once
2790 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2796 /* Remove a reference to SYMBOL from the list of references of a node given by
2797 reference description RDESC. Return true if the reference has been
2798 successfully found and removed. */
2801 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
2803 struct ipa_ref
*to_del
;
2804 struct cgraph_edge
*origin
;
2809 to_del
= origin
->caller
->find_reference (symbol
, origin
->call_stmt
,
2810 origin
->lto_stmt_uid
);
2814 to_del
->remove_reference ();
2816 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
2817 xstrdup (origin
->caller
->name ()),
2818 origin
->caller
->order
, xstrdup (symbol
->name ()));
2822 /* If JFUNC has a reference description with refcount different from
2823 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
2824 NULL. JFUNC must be a constant jump function. */
2826 static struct ipa_cst_ref_desc
*
2827 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
2829 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
2830 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
2836 /* If the value of constant jump function JFUNC is an address of a function
2837 declaration, return the associated call graph node. Otherwise return
2840 static cgraph_node
*
2841 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
2843 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
2844 tree cst
= ipa_get_jf_constant (jfunc
);
2845 if (TREE_CODE (cst
) != ADDR_EXPR
2846 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
2849 return cgraph_get_node (TREE_OPERAND (cst
, 0));
2853 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
2854 refcount and if it hits zero, remove reference to SYMBOL from the caller of
2855 the edge specified in the rdesc. Return false if either the symbol or the
2856 reference could not be found, otherwise return true. */
2859 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
2861 struct ipa_cst_ref_desc
*rdesc
;
2862 if (jfunc
->type
== IPA_JF_CONST
2863 && (rdesc
= jfunc_rdesc_usable (jfunc
))
2864 && --rdesc
->refcount
== 0)
2866 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
2870 return remove_described_reference (symbol
, rdesc
);
2875 /* Try to find a destination for indirect edge IE that corresponds to a simple
2876 call or a call of a member function pointer and where the destination is a
2877 pointer formal parameter described by jump function JFUNC. If it can be
2878 determined, return the newly direct edge, otherwise return NULL.
2879 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
2881 static struct cgraph_edge
*
2882 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
2883 struct ipa_jump_func
*jfunc
,
2884 struct ipa_node_params
*new_root_info
)
2886 struct cgraph_edge
*cs
;
2888 bool agg_contents
= ie
->indirect_info
->agg_contents
;
2890 if (ie
->indirect_info
->agg_contents
)
2891 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2892 ie
->indirect_info
->offset
,
2893 ie
->indirect_info
->by_ref
);
2895 target
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2898 cs
= ipa_make_edge_direct_to_target (ie
, target
);
2900 if (cs
&& !agg_contents
)
2903 gcc_checking_assert (cs
->callee
2905 || jfunc
->type
!= IPA_JF_CONST
2906 || !cgraph_node_for_jfunc (jfunc
)
2907 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
2908 ok
= try_decrement_rdesc_refcount (jfunc
);
2909 gcc_checking_assert (ok
);
2915 /* Return the target to be used in cases of impossible devirtualization. IE
2916 and target (the latter can be NULL) are dumped when dumping is enabled. */
2919 ipa_impossible_devirt_target (struct cgraph_edge
*ie
, tree target
)
2925 "Type inconsistent devirtualization: %s/%i->%s\n",
2926 ie
->caller
->name (), ie
->caller
->order
,
2927 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
2930 "No devirtualization target in %s/%i\n",
2931 ie
->caller
->name (), ie
->caller
->order
);
2933 tree new_target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2934 cgraph_get_create_node (new_target
);
2938 /* Try to find a destination for indirect edge IE that corresponds to a virtual
2939 call based on a formal parameter which is described by jump function JFUNC
2940 and if it can be determined, make it direct and return the direct edge.
2941 Otherwise, return NULL. NEW_ROOT_INFO is the node info that JFUNC lattices
2944 static struct cgraph_edge
*
2945 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
2946 struct ipa_jump_func
*jfunc
,
2947 struct ipa_node_params
*new_root_info
)
2951 if (!flag_devirtualize
)
2954 /* First try to do lookup via known virtual table pointer value. */
2955 if (!ie
->indirect_info
->by_ref
)
2958 unsigned HOST_WIDE_INT offset
;
2959 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2960 ie
->indirect_info
->offset
,
2962 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2964 target
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
2968 if ((TREE_CODE (TREE_TYPE (target
)) == FUNCTION_TYPE
2969 && DECL_FUNCTION_CODE (target
) == BUILT_IN_UNREACHABLE
)
2970 || !possible_polymorphic_call_target_p
2971 (ie
, cgraph_get_node (target
)))
2972 target
= ipa_impossible_devirt_target (ie
, target
);
2973 return ipa_make_edge_direct_to_target (ie
, target
);
2978 binfo
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2983 if (TREE_CODE (binfo
) != TREE_BINFO
)
2985 ipa_polymorphic_call_context context
;
2986 vec
<cgraph_node
*>targets
;
2989 if (!get_polymorphic_call_info_from_invariant
2990 (&context
, binfo
, ie
->indirect_info
->otr_type
,
2991 ie
->indirect_info
->offset
))
2993 targets
= possible_polymorphic_call_targets
2994 (ie
->indirect_info
->otr_type
,
2995 ie
->indirect_info
->otr_token
,
2997 if (!final
|| targets
.length () > 1)
2999 if (targets
.length () == 1)
3000 target
= targets
[0]->decl
;
3002 target
= ipa_impossible_devirt_target (ie
, NULL_TREE
);
3006 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->offset
,
3007 ie
->indirect_info
->otr_type
);
3009 target
= gimple_get_virt_method_for_binfo (ie
->indirect_info
->otr_token
,
3017 if (!possible_polymorphic_call_target_p (ie
, cgraph_get_node (target
)))
3018 target
= ipa_impossible_devirt_target (ie
, target
);
3019 return ipa_make_edge_direct_to_target (ie
, target
);
3025 /* Update the param called notes associated with NODE when CS is being inlined,
3026 assuming NODE is (potentially indirectly) inlined into CS->callee.
3027 Moreover, if the callee is discovered to be constant, create a new cgraph
3028 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
3029 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
3032 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
3033 struct cgraph_node
*node
,
3034 vec
<cgraph_edge_p
> *new_edges
)
3036 struct ipa_edge_args
*top
;
3037 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
3038 struct ipa_node_params
*new_root_info
;
3041 ipa_check_create_edge_args ();
3042 top
= IPA_EDGE_REF (cs
);
3043 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
3044 ? cs
->caller
->global
.inlined_to
3047 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
3049 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
3050 struct ipa_jump_func
*jfunc
;
3053 next_ie
= ie
->next_callee
;
3055 if (ici
->param_index
== -1)
3058 /* We must check range due to calls with variable number of arguments: */
3059 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
3061 ici
->param_index
= -1;
3065 param_index
= ici
->param_index
;
3066 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
3068 if (!flag_indirect_inlining
)
3069 new_direct_edge
= NULL
;
3070 else if (ici
->polymorphic
)
3071 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
,
3074 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
3076 /* If speculation was removed, then we need to do nothing. */
3077 if (new_direct_edge
&& new_direct_edge
!= ie
)
3079 new_direct_edge
->indirect_inlining_edge
= 1;
3080 top
= IPA_EDGE_REF (cs
);
3083 else if (new_direct_edge
)
3085 new_direct_edge
->indirect_inlining_edge
= 1;
3086 if (new_direct_edge
->call_stmt
)
3087 new_direct_edge
->call_stmt_cannot_inline_p
3088 = !gimple_check_call_matching_types (
3089 new_direct_edge
->call_stmt
,
3090 new_direct_edge
->callee
->decl
, false);
3093 new_edges
->safe_push (new_direct_edge
);
3096 top
= IPA_EDGE_REF (cs
);
3098 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
3099 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
3101 if ((ici
->agg_contents
3102 && !ipa_get_jf_pass_through_agg_preserved (jfunc
))
3103 || (ici
->polymorphic
3104 && !ipa_get_jf_pass_through_type_preserved (jfunc
)))
3105 ici
->param_index
= -1;
3107 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
3109 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3111 if ((ici
->agg_contents
3112 && !ipa_get_jf_ancestor_agg_preserved (jfunc
))
3113 || (ici
->polymorphic
3114 && !ipa_get_jf_ancestor_type_preserved (jfunc
)))
3115 ici
->param_index
= -1;
3118 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
3119 if (ipa_get_jf_ancestor_offset (jfunc
))
3120 ici
->outer_type
= NULL
;
3121 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
3125 /* Either we can find a destination for this edge now or never. */
3126 ici
->param_index
= -1;
3132 /* Recursively traverse subtree of NODE (including node) made of inlined
3133 cgraph_edges when CS has been inlined and invoke
3134 update_indirect_edges_after_inlining on all nodes and
3135 update_jump_functions_after_inlining on all non-inlined edges that lead out
3136 of this subtree. Newly discovered indirect edges will be added to
3137 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
3141 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
3142 struct cgraph_node
*node
,
3143 vec
<cgraph_edge_p
> *new_edges
)
3145 struct cgraph_edge
*e
;
3148 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
3150 for (e
= node
->callees
; e
; e
= e
->next_callee
)
3151 if (!e
->inline_failed
)
3152 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
3154 update_jump_functions_after_inlining (cs
, e
);
3155 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
3156 update_jump_functions_after_inlining (cs
, e
);
3161 /* Combine two controlled uses counts as done during inlining. */
3164 combine_controlled_uses_counters (int c
, int d
)
3166 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
3167 return IPA_UNDESCRIBED_USE
;
3172 /* Propagate number of controlled users from CS->caleee to the new root of the
3173 tree of inlined nodes. */
3176 propagate_controlled_uses (struct cgraph_edge
*cs
)
3178 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
3179 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
3180 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
3181 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
3182 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
3185 count
= MIN (ipa_get_cs_argument_count (args
),
3186 ipa_get_param_count (old_root_info
));
3187 for (i
= 0; i
< count
; i
++)
3189 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3190 struct ipa_cst_ref_desc
*rdesc
;
3192 if (jf
->type
== IPA_JF_PASS_THROUGH
)
3195 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
3196 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
3197 d
= ipa_get_controlled_uses (old_root_info
, i
);
3199 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
3200 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
3201 c
= combine_controlled_uses_counters (c
, d
);
3202 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
3203 if (c
== 0 && new_root_info
->ipcp_orig_node
)
3205 struct cgraph_node
*n
;
3206 struct ipa_ref
*ref
;
3207 tree t
= new_root_info
->known_vals
[src_idx
];
3209 if (t
&& TREE_CODE (t
) == ADDR_EXPR
3210 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
3211 && (n
= cgraph_get_node (TREE_OPERAND (t
, 0)))
3212 && (ref
= new_root
->find_reference (n
, NULL
, 0)))
3215 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
3216 "reference from %s/%i to %s/%i.\n",
3217 xstrdup (new_root
->name ()),
3219 xstrdup (n
->name ()), n
->order
);
3220 ref
->remove_reference ();
3224 else if (jf
->type
== IPA_JF_CONST
3225 && (rdesc
= jfunc_rdesc_usable (jf
)))
3227 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3228 int c
= rdesc
->refcount
;
3229 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3230 if (rdesc
->refcount
== 0)
3232 tree cst
= ipa_get_jf_constant (jf
);
3233 struct cgraph_node
*n
;
3234 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3235 && TREE_CODE (TREE_OPERAND (cst
, 0))
3237 n
= cgraph_get_node (TREE_OPERAND (cst
, 0));
3240 struct cgraph_node
*clone
;
3242 ok
= remove_described_reference (n
, rdesc
);
3243 gcc_checking_assert (ok
);
3246 while (clone
->global
.inlined_to
3247 && clone
!= rdesc
->cs
->caller
3248 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3250 struct ipa_ref
*ref
;
3251 ref
= clone
->find_reference (n
, NULL
, 0);
3255 fprintf (dump_file
, "ipa-prop: Removing "
3256 "cloning-created reference "
3257 "from %s/%i to %s/%i.\n",
3258 xstrdup (clone
->name ()),
3260 xstrdup (n
->name ()),
3262 ref
->remove_reference ();
3264 clone
= clone
->callers
->caller
;
3271 for (i
= ipa_get_param_count (old_root_info
);
3272 i
< ipa_get_cs_argument_count (args
);
3275 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3277 if (jf
->type
== IPA_JF_CONST
)
3279 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3281 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3283 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3284 ipa_set_controlled_uses (new_root_info
,
3285 jf
->value
.pass_through
.formal_id
,
3286 IPA_UNDESCRIBED_USE
);
3290 /* Update jump functions and call note functions on inlining the call site CS.
3291 CS is expected to lead to a node already cloned by
3292 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3293 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3297 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3298 vec
<cgraph_edge_p
> *new_edges
)
3301 /* Do nothing if the preparation phase has not been carried out yet
3302 (i.e. during early inlining). */
3303 if (!ipa_node_params_vector
.exists ())
3305 gcc_assert (ipa_edge_args_vector
);
3307 propagate_controlled_uses (cs
);
3308 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3313 /* Frees all dynamically allocated structures that the argument info points
3317 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3319 vec_free (args
->jump_functions
);
3320 memset (args
, 0, sizeof (*args
));
3323 /* Free all ipa_edge structures. */
3326 ipa_free_all_edge_args (void)
3329 struct ipa_edge_args
*args
;
3331 if (!ipa_edge_args_vector
)
3334 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3335 ipa_free_edge_args_substructures (args
);
3337 vec_free (ipa_edge_args_vector
);
3340 /* Frees all dynamically allocated structures that the param info points
3344 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
3346 info
->descriptors
.release ();
3347 free (info
->lattices
);
3348 /* Lattice values and their sources are deallocated with their alocation
3350 info
->known_vals
.release ();
3351 memset (info
, 0, sizeof (*info
));
3354 /* Free all ipa_node_params structures. */
3357 ipa_free_all_node_params (void)
3360 struct ipa_node_params
*info
;
3362 FOR_EACH_VEC_ELT (ipa_node_params_vector
, i
, info
)
3363 ipa_free_node_params_substructures (info
);
3365 ipa_node_params_vector
.release ();
3368 /* Set the aggregate replacements of NODE to be AGGVALS. */
3371 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3372 struct ipa_agg_replacement_value
*aggvals
)
3374 if (vec_safe_length (ipa_node_agg_replacements
) <= (unsigned) cgraph_max_uid
)
3375 vec_safe_grow_cleared (ipa_node_agg_replacements
, cgraph_max_uid
+ 1);
3377 (*ipa_node_agg_replacements
)[node
->uid
] = aggvals
;
3380 /* Hook that is called by cgraph.c when an edge is removed. */
3383 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3385 struct ipa_edge_args
*args
;
3387 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3388 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3391 args
= IPA_EDGE_REF (cs
);
3392 if (args
->jump_functions
)
3394 struct ipa_jump_func
*jf
;
3396 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3398 struct ipa_cst_ref_desc
*rdesc
;
3399 try_decrement_rdesc_refcount (jf
);
3400 if (jf
->type
== IPA_JF_CONST
3401 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3407 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3410 /* Hook that is called by cgraph.c when a node is removed. */
3413 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3415 /* During IPA-CP updating we can be called on not-yet analyze clones. */
3416 if (ipa_node_params_vector
.length () > (unsigned)node
->uid
)
3417 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
3418 if (vec_safe_length (ipa_node_agg_replacements
) > (unsigned)node
->uid
)
3419 (*ipa_node_agg_replacements
)[(unsigned)node
->uid
] = NULL
;
3422 /* Hook that is called by cgraph.c when an edge is duplicated. */
3425 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3426 __attribute__((unused
)) void *data
)
3428 struct ipa_edge_args
*old_args
, *new_args
;
3431 ipa_check_create_edge_args ();
3433 old_args
= IPA_EDGE_REF (src
);
3434 new_args
= IPA_EDGE_REF (dst
);
3436 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3438 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3440 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3441 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3443 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3445 if (src_jf
->type
== IPA_JF_CONST
)
3447 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3450 dst_jf
->value
.constant
.rdesc
= NULL
;
3451 else if (src
->caller
== dst
->caller
)
3453 struct ipa_ref
*ref
;
3454 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3455 gcc_checking_assert (n
);
3456 ref
= src
->caller
->find_reference (n
, src
->call_stmt
,
3458 gcc_checking_assert (ref
);
3459 dst
->caller
->clone_reference (ref
, ref
->stmt
);
3461 gcc_checking_assert (ipa_refdesc_pool
);
3462 struct ipa_cst_ref_desc
*dst_rdesc
3463 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3464 dst_rdesc
->cs
= dst
;
3465 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3466 dst_rdesc
->next_duplicate
= NULL
;
3467 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3469 else if (src_rdesc
->cs
== src
)
3471 struct ipa_cst_ref_desc
*dst_rdesc
;
3472 gcc_checking_assert (ipa_refdesc_pool
);
3474 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3475 dst_rdesc
->cs
= dst
;
3476 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3477 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3478 src_rdesc
->next_duplicate
= dst_rdesc
;
3479 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3483 struct ipa_cst_ref_desc
*dst_rdesc
;
3484 /* This can happen during inlining, when a JFUNC can refer to a
3485 reference taken in a function up in the tree of inline clones.
3486 We need to find the duplicate that refers to our tree of
3489 gcc_assert (dst
->caller
->global
.inlined_to
);
3490 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3492 dst_rdesc
= dst_rdesc
->next_duplicate
)
3494 struct cgraph_node
*top
;
3495 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3496 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3497 : dst_rdesc
->cs
->caller
;
3498 if (dst
->caller
->global
.inlined_to
== top
)
3501 gcc_assert (dst_rdesc
);
3502 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3508 /* Hook that is called by cgraph.c when a node is duplicated. */
3511 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
3512 ATTRIBUTE_UNUSED
void *data
)
3514 struct ipa_node_params
*old_info
, *new_info
;
3515 struct ipa_agg_replacement_value
*old_av
, *new_av
;
3517 ipa_check_create_node_params ();
3518 old_info
= IPA_NODE_REF (src
);
3519 new_info
= IPA_NODE_REF (dst
);
3521 new_info
->descriptors
= old_info
->descriptors
.copy ();
3522 new_info
->lattices
= NULL
;
3523 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3525 new_info
->analysis_done
= old_info
->analysis_done
;
3526 new_info
->node_enqueued
= old_info
->node_enqueued
;
3528 old_av
= ipa_get_agg_replacements_for_node (src
);
3535 struct ipa_agg_replacement_value
*v
;
3537 v
= ggc_alloc
<ipa_agg_replacement_value
> ();
3538 memcpy (v
, old_av
, sizeof (*v
));
3541 old_av
= old_av
->next
;
3543 ipa_set_node_agg_value_chain (dst
, new_av
);
3547 /* Analyze newly added function into callgraph. */
3550 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3552 if (cgraph_function_with_gimple_body_p (node
))
3553 ipa_analyze_node (node
);
3556 /* Register our cgraph hooks if they are not already there. */
3559 ipa_register_cgraph_hooks (void)
3561 if (!edge_removal_hook_holder
)
3562 edge_removal_hook_holder
=
3563 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3564 if (!node_removal_hook_holder
)
3565 node_removal_hook_holder
=
3566 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
3567 if (!edge_duplication_hook_holder
)
3568 edge_duplication_hook_holder
=
3569 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3570 if (!node_duplication_hook_holder
)
3571 node_duplication_hook_holder
=
3572 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
3573 function_insertion_hook_holder
=
3574 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
3577 /* Unregister our cgraph hooks if they are not already there. */
3580 ipa_unregister_cgraph_hooks (void)
3582 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
3583 edge_removal_hook_holder
= NULL
;
3584 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
3585 node_removal_hook_holder
= NULL
;
3586 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
3587 edge_duplication_hook_holder
= NULL
;
3588 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
3589 node_duplication_hook_holder
= NULL
;
3590 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
3591 function_insertion_hook_holder
= NULL
;
3594 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3595 longer needed after ipa-cp. */
3598 ipa_free_all_structures_after_ipa_cp (void)
3602 ipa_free_all_edge_args ();
3603 ipa_free_all_node_params ();
3604 free_alloc_pool (ipcp_sources_pool
);
3605 free_alloc_pool (ipcp_values_pool
);
3606 free_alloc_pool (ipcp_agg_lattice_pool
);
3607 ipa_unregister_cgraph_hooks ();
3608 if (ipa_refdesc_pool
)
3609 free_alloc_pool (ipa_refdesc_pool
);
3613 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3614 longer needed after indirect inlining. */
3617 ipa_free_all_structures_after_iinln (void)
3619 ipa_free_all_edge_args ();
3620 ipa_free_all_node_params ();
3621 ipa_unregister_cgraph_hooks ();
3622 if (ipcp_sources_pool
)
3623 free_alloc_pool (ipcp_sources_pool
);
3624 if (ipcp_values_pool
)
3625 free_alloc_pool (ipcp_values_pool
);
3626 if (ipcp_agg_lattice_pool
)
3627 free_alloc_pool (ipcp_agg_lattice_pool
);
3628 if (ipa_refdesc_pool
)
3629 free_alloc_pool (ipa_refdesc_pool
);
3632 /* Print ipa_tree_map data structures of all functions in the
3636 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3639 struct ipa_node_params
*info
;
3641 if (!node
->definition
)
3643 info
= IPA_NODE_REF (node
);
3644 fprintf (f
, " function %s/%i parameter descriptors:\n",
3645 node
->name (), node
->order
);
3646 count
= ipa_get_param_count (info
);
3647 for (i
= 0; i
< count
; i
++)
3652 ipa_dump_param (f
, info
, i
);
3653 if (ipa_is_param_used (info
, i
))
3654 fprintf (f
, " used");
3655 c
= ipa_get_controlled_uses (info
, i
);
3656 if (c
== IPA_UNDESCRIBED_USE
)
3657 fprintf (f
, " undescribed_use");
3659 fprintf (f
, " controlled_uses=%i", c
);
3664 /* Print ipa_tree_map data structures of all functions in the
3668 ipa_print_all_params (FILE * f
)
3670 struct cgraph_node
*node
;
3672 fprintf (f
, "\nFunction parameters:\n");
3673 FOR_EACH_FUNCTION (node
)
3674 ipa_print_node_params (f
, node
);
3677 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3680 ipa_get_vector_of_formal_parms (tree fndecl
)
3686 gcc_assert (!flag_wpa
);
3687 count
= count_formal_params (fndecl
);
3688 args
.create (count
);
3689 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3690 args
.quick_push (parm
);
3695 /* Return a heap allocated vector containing types of formal parameters of
3696 function type FNTYPE. */
3699 ipa_get_vector_of_formal_parm_types (tree fntype
)
3705 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3708 types
.create (count
);
3709 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3710 types
.quick_push (TREE_VALUE (t
));
3715 /* Modify the function declaration FNDECL and its type according to the plan in
3716 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3717 to reflect the actual parameters being modified which are determined by the
3718 base_index field. */
3721 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
3723 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
3724 tree orig_type
= TREE_TYPE (fndecl
);
3725 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
3727 /* The following test is an ugly hack, some functions simply don't have any
3728 arguments in their type. This is probably a bug but well... */
3729 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
3730 bool last_parm_void
;
3734 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
3736 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
3738 gcc_assert (oparms
.length () + 1 == otypes
.length ());
3740 gcc_assert (oparms
.length () == otypes
.length ());
3744 last_parm_void
= false;
3748 int len
= adjustments
.length ();
3749 tree
*link
= &DECL_ARGUMENTS (fndecl
);
3750 tree new_arg_types
= NULL
;
3751 for (int i
= 0; i
< len
; i
++)
3753 struct ipa_parm_adjustment
*adj
;
3756 adj
= &adjustments
[i
];
3758 if (adj
->op
== IPA_PARM_OP_NEW
)
3761 parm
= oparms
[adj
->base_index
];
3764 if (adj
->op
== IPA_PARM_OP_COPY
)
3767 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
3770 link
= &DECL_CHAIN (parm
);
3772 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3778 ptype
= build_pointer_type (adj
->type
);
3782 if (is_gimple_reg_type (ptype
))
3784 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
3785 if (TYPE_ALIGN (ptype
) < malign
)
3786 ptype
= build_aligned_type (ptype
, malign
);
3791 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
3793 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
3795 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
3796 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
3797 DECL_ARTIFICIAL (new_parm
) = 1;
3798 DECL_ARG_TYPE (new_parm
) = ptype
;
3799 DECL_CONTEXT (new_parm
) = fndecl
;
3800 TREE_USED (new_parm
) = 1;
3801 DECL_IGNORED_P (new_parm
) = 1;
3802 layout_decl (new_parm
, 0);
3804 if (adj
->op
== IPA_PARM_OP_NEW
)
3808 adj
->new_decl
= new_parm
;
3811 link
= &DECL_CHAIN (new_parm
);
3817 tree new_reversed
= NULL
;
3820 new_reversed
= nreverse (new_arg_types
);
3824 TREE_CHAIN (new_arg_types
) = void_list_node
;
3826 new_reversed
= void_list_node
;
3830 /* Use copy_node to preserve as much as possible from original type
3831 (debug info, attribute lists etc.)
3832 Exception is METHOD_TYPEs must have THIS argument.
3833 When we are asked to remove it, we need to build new FUNCTION_TYPE
3835 tree new_type
= NULL
;
3836 if (TREE_CODE (orig_type
) != METHOD_TYPE
3837 || (adjustments
[0].op
== IPA_PARM_OP_COPY
3838 && adjustments
[0].base_index
== 0))
3840 new_type
= build_distinct_type_copy (orig_type
);
3841 TYPE_ARG_TYPES (new_type
) = new_reversed
;
3846 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
3848 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
3849 DECL_VINDEX (fndecl
) = NULL_TREE
;
3852 /* When signature changes, we need to clear builtin info. */
3853 if (DECL_BUILT_IN (fndecl
))
3855 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
3856 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
3859 /* This is a new type, not a copy of an old type. Need to reassociate
3860 variants. We can handle everything except the main variant lazily. */
3861 tree t
= TYPE_MAIN_VARIANT (orig_type
);
3864 TYPE_MAIN_VARIANT (new_type
) = t
;
3865 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
3866 TYPE_NEXT_VARIANT (t
) = new_type
;
3870 TYPE_MAIN_VARIANT (new_type
) = new_type
;
3871 TYPE_NEXT_VARIANT (new_type
) = NULL
;
3874 TREE_TYPE (fndecl
) = new_type
;
3875 DECL_VIRTUAL_P (fndecl
) = 0;
3876 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
3881 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
3882 If this is a directly recursive call, CS must be NULL. Otherwise it must
3883 contain the corresponding call graph edge. */
3886 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
3887 ipa_parm_adjustment_vec adjustments
)
3889 struct cgraph_node
*current_node
= cgraph_get_node (current_function_decl
);
3891 vec
<tree
, va_gc
> **debug_args
= NULL
;
3893 gimple_stmt_iterator gsi
, prev_gsi
;
3897 len
= adjustments
.length ();
3899 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
3900 current_node
->remove_stmt_references (stmt
);
3902 gsi
= gsi_for_stmt (stmt
);
3904 gsi_prev (&prev_gsi
);
3905 for (i
= 0; i
< len
; i
++)
3907 struct ipa_parm_adjustment
*adj
;
3909 adj
= &adjustments
[i
];
3911 if (adj
->op
== IPA_PARM_OP_COPY
)
3913 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
3915 vargs
.quick_push (arg
);
3917 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3919 tree expr
, base
, off
;
3921 unsigned int deref_align
= 0;
3922 bool deref_base
= false;
3924 /* We create a new parameter out of the value of the old one, we can
3925 do the following kind of transformations:
3927 - A scalar passed by reference is converted to a scalar passed by
3928 value. (adj->by_ref is false and the type of the original
3929 actual argument is a pointer to a scalar).
3931 - A part of an aggregate is passed instead of the whole aggregate.
3932 The part can be passed either by value or by reference, this is
3933 determined by value of adj->by_ref. Moreover, the code below
3934 handles both situations when the original aggregate is passed by
3935 value (its type is not a pointer) and when it is passed by
3936 reference (it is a pointer to an aggregate).
3938 When the new argument is passed by reference (adj->by_ref is true)
3939 it must be a part of an aggregate and therefore we form it by
3940 simply taking the address of a reference inside the original
3943 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
3944 base
= gimple_call_arg (stmt
, adj
->base_index
);
3945 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
3946 : EXPR_LOCATION (base
);
3948 if (TREE_CODE (base
) != ADDR_EXPR
3949 && POINTER_TYPE_P (TREE_TYPE (base
)))
3950 off
= build_int_cst (adj
->alias_ptr_type
,
3951 adj
->offset
/ BITS_PER_UNIT
);
3954 HOST_WIDE_INT base_offset
;
3958 if (TREE_CODE (base
) == ADDR_EXPR
)
3960 base
= TREE_OPERAND (base
, 0);
3966 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
3967 /* Aggregate arguments can have non-invariant addresses. */
3970 base
= build_fold_addr_expr (prev_base
);
3971 off
= build_int_cst (adj
->alias_ptr_type
,
3972 adj
->offset
/ BITS_PER_UNIT
);
3974 else if (TREE_CODE (base
) == MEM_REF
)
3979 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
3981 off
= build_int_cst (adj
->alias_ptr_type
,
3983 + adj
->offset
/ BITS_PER_UNIT
);
3984 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
3986 base
= TREE_OPERAND (base
, 0);
3990 off
= build_int_cst (adj
->alias_ptr_type
,
3992 + adj
->offset
/ BITS_PER_UNIT
);
3993 base
= build_fold_addr_expr (base
);
3999 tree type
= adj
->type
;
4001 unsigned HOST_WIDE_INT misalign
;
4005 align
= deref_align
;
4010 get_pointer_alignment_1 (base
, &align
, &misalign
);
4011 if (TYPE_ALIGN (type
) > align
)
4012 align
= TYPE_ALIGN (type
);
4014 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
4016 misalign
= misalign
& (align
- 1);
4018 align
= (misalign
& -misalign
);
4019 if (align
< TYPE_ALIGN (type
))
4020 type
= build_aligned_type (type
, align
);
4021 base
= force_gimple_operand_gsi (&gsi
, base
,
4022 true, NULL
, true, GSI_SAME_STMT
);
4023 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
4024 /* If expr is not a valid gimple call argument emit
4025 a load into a temporary. */
4026 if (is_gimple_reg_type (TREE_TYPE (expr
)))
4028 gimple tem
= gimple_build_assign (NULL_TREE
, expr
);
4029 if (gimple_in_ssa_p (cfun
))
4031 gimple_set_vuse (tem
, gimple_vuse (stmt
));
4032 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
4035 expr
= create_tmp_reg (TREE_TYPE (expr
), NULL
);
4036 gimple_assign_set_lhs (tem
, expr
);
4037 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
4042 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
4043 expr
= build_fold_addr_expr (expr
);
4044 expr
= force_gimple_operand_gsi (&gsi
, expr
,
4045 true, NULL
, true, GSI_SAME_STMT
);
4047 vargs
.quick_push (expr
);
4049 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
4052 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
4055 arg
= gimple_call_arg (stmt
, adj
->base_index
);
4056 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
4058 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
4060 arg
= fold_convert_loc (gimple_location (stmt
),
4061 TREE_TYPE (origin
), arg
);
4063 if (debug_args
== NULL
)
4064 debug_args
= decl_debug_args_insert (callee_decl
);
4065 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
4066 if (ddecl
== origin
)
4068 ddecl
= (**debug_args
)[ix
+ 1];
4073 ddecl
= make_node (DEBUG_EXPR_DECL
);
4074 DECL_ARTIFICIAL (ddecl
) = 1;
4075 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
4076 DECL_MODE (ddecl
) = DECL_MODE (origin
);
4078 vec_safe_push (*debug_args
, origin
);
4079 vec_safe_push (*debug_args
, ddecl
);
4081 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
4082 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
4086 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4088 fprintf (dump_file
, "replacing stmt:");
4089 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
4092 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
4094 if (gimple_call_lhs (stmt
))
4095 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
4097 gimple_set_block (new_stmt
, gimple_block (stmt
));
4098 if (gimple_has_location (stmt
))
4099 gimple_set_location (new_stmt
, gimple_location (stmt
));
4100 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
4101 gimple_call_copy_flags (new_stmt
, stmt
);
4102 if (gimple_in_ssa_p (cfun
))
4104 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4105 if (gimple_vdef (stmt
))
4107 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4108 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
4112 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4114 fprintf (dump_file
, "with stmt:");
4115 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
4116 fprintf (dump_file
, "\n");
4118 gsi_replace (&gsi
, new_stmt
, true);
4120 cgraph_set_call_stmt (cs
, new_stmt
);
4123 ipa_record_stmt_references (current_node
, gsi_stmt (gsi
));
4126 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
4129 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
4130 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
4131 specifies whether the function should care about type incompatibility the
4132 current and new expressions. If it is false, the function will leave
4133 incompatibility issues to the caller. Return true iff the expression
4137 ipa_modify_expr (tree
*expr
, bool convert
,
4138 ipa_parm_adjustment_vec adjustments
)
4140 struct ipa_parm_adjustment
*cand
4141 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
4147 src
= build_simple_mem_ref (cand
->new_decl
);
4149 src
= cand
->new_decl
;
4151 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4153 fprintf (dump_file
, "About to replace expr ");
4154 print_generic_expr (dump_file
, *expr
, 0);
4155 fprintf (dump_file
, " with ");
4156 print_generic_expr (dump_file
, src
, 0);
4157 fprintf (dump_file
, "\n");
4160 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
4162 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
4170 /* If T is an SSA_NAME, return NULL if it is not a default def or
4171 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
4172 the base variable is always returned, regardless if it is a default
4173 def. Return T if it is not an SSA_NAME. */
4176 get_ssa_base_param (tree t
, bool ignore_default_def
)
4178 if (TREE_CODE (t
) == SSA_NAME
)
4180 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
4181 return SSA_NAME_VAR (t
);
4188 /* Given an expression, return an adjustment entry specifying the
4189 transformation to be done on EXPR. If no suitable adjustment entry
4190 was found, returns NULL.
4192 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
4193 default def, otherwise bail on them.
4195 If CONVERT is non-NULL, this function will set *CONVERT if the
4196 expression provided is a component reference. ADJUSTMENTS is the
4197 adjustments vector. */
4199 ipa_parm_adjustment
*
4200 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
4201 ipa_parm_adjustment_vec adjustments
,
4202 bool ignore_default_def
)
4204 if (TREE_CODE (**expr
) == BIT_FIELD_REF
4205 || TREE_CODE (**expr
) == IMAGPART_EXPR
4206 || TREE_CODE (**expr
) == REALPART_EXPR
)
4208 *expr
= &TREE_OPERAND (**expr
, 0);
4213 HOST_WIDE_INT offset
, size
, max_size
;
4214 tree base
= get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
);
4215 if (!base
|| size
== -1 || max_size
== -1)
4218 if (TREE_CODE (base
) == MEM_REF
)
4220 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
4221 base
= TREE_OPERAND (base
, 0);
4224 base
= get_ssa_base_param (base
, ignore_default_def
);
4225 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4228 struct ipa_parm_adjustment
*cand
= NULL
;
4229 unsigned int len
= adjustments
.length ();
4230 for (unsigned i
= 0; i
< len
; i
++)
4232 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4234 if (adj
->base
== base
4235 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4242 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4247 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4250 index_in_adjustments_multiple_times_p (int base_index
,
4251 ipa_parm_adjustment_vec adjustments
)
4253 int i
, len
= adjustments
.length ();
4256 for (i
= 0; i
< len
; i
++)
4258 struct ipa_parm_adjustment
*adj
;
4259 adj
= &adjustments
[i
];
4261 if (adj
->base_index
== base_index
)
4273 /* Return adjustments that should have the same effect on function parameters
4274 and call arguments as if they were first changed according to adjustments in
4275 INNER and then by adjustments in OUTER. */
4277 ipa_parm_adjustment_vec
4278 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4279 ipa_parm_adjustment_vec outer
)
4281 int i
, outlen
= outer
.length ();
4282 int inlen
= inner
.length ();
4284 ipa_parm_adjustment_vec adjustments
, tmp
;
4287 for (i
= 0; i
< inlen
; i
++)
4289 struct ipa_parm_adjustment
*n
;
4292 if (n
->op
== IPA_PARM_OP_REMOVE
)
4296 /* FIXME: Handling of new arguments are not implemented yet. */
4297 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4298 tmp
.quick_push (*n
);
4302 adjustments
.create (outlen
+ removals
);
4303 for (i
= 0; i
< outlen
; i
++)
4305 struct ipa_parm_adjustment r
;
4306 struct ipa_parm_adjustment
*out
= &outer
[i
];
4307 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4309 memset (&r
, 0, sizeof (r
));
4310 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4311 if (out
->op
== IPA_PARM_OP_REMOVE
)
4313 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4315 r
.op
= IPA_PARM_OP_REMOVE
;
4316 adjustments
.quick_push (r
);
4322 /* FIXME: Handling of new arguments are not implemented yet. */
4323 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4326 r
.base_index
= in
->base_index
;
4329 /* FIXME: Create nonlocal value too. */
4331 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4332 r
.op
= IPA_PARM_OP_COPY
;
4333 else if (in
->op
== IPA_PARM_OP_COPY
)
4334 r
.offset
= out
->offset
;
4335 else if (out
->op
== IPA_PARM_OP_COPY
)
4336 r
.offset
= in
->offset
;
4338 r
.offset
= in
->offset
+ out
->offset
;
4339 adjustments
.quick_push (r
);
4342 for (i
= 0; i
< inlen
; i
++)
4344 struct ipa_parm_adjustment
*n
= &inner
[i
];
4346 if (n
->op
== IPA_PARM_OP_REMOVE
)
4347 adjustments
.quick_push (*n
);
4354 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4355 friendly way, assuming they are meant to be applied to FNDECL. */
4358 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4361 int i
, len
= adjustments
.length ();
4363 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4365 fprintf (file
, "IPA param adjustments: ");
4366 for (i
= 0; i
< len
; i
++)
4368 struct ipa_parm_adjustment
*adj
;
4369 adj
= &adjustments
[i
];
4372 fprintf (file
, " ");
4376 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4377 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4380 fprintf (file
, ", base: ");
4381 print_generic_expr (file
, adj
->base
, 0);
4385 fprintf (file
, ", new_decl: ");
4386 print_generic_expr (file
, adj
->new_decl
, 0);
4388 if (adj
->new_ssa_base
)
4390 fprintf (file
, ", new_ssa_base: ");
4391 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4394 if (adj
->op
== IPA_PARM_OP_COPY
)
4395 fprintf (file
, ", copy_param");
4396 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4397 fprintf (file
, ", remove_param");
4399 fprintf (file
, ", offset %li", (long) adj
->offset
);
4401 fprintf (file
, ", by_ref");
4402 print_node_brief (file
, ", type: ", adj
->type
, 0);
4403 fprintf (file
, "\n");
4408 /* Dump the AV linked list. */
4411 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4414 fprintf (f
, " Aggregate replacements:");
4415 for (; av
; av
= av
->next
)
4417 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4418 av
->index
, av
->offset
);
4419 print_generic_expr (f
, av
->value
, 0);
4425 /* Stream out jump function JUMP_FUNC to OB. */
4428 ipa_write_jump_function (struct output_block
*ob
,
4429 struct ipa_jump_func
*jump_func
)
4431 struct ipa_agg_jf_item
*item
;
4432 struct bitpack_d bp
;
4435 streamer_write_uhwi (ob
, jump_func
->type
);
4436 switch (jump_func
->type
)
4438 case IPA_JF_UNKNOWN
:
4440 case IPA_JF_KNOWN_TYPE
:
4441 streamer_write_uhwi (ob
, jump_func
->value
.known_type
.offset
);
4442 stream_write_tree (ob
, jump_func
->value
.known_type
.base_type
, true);
4443 stream_write_tree (ob
, jump_func
->value
.known_type
.component_type
, true);
4447 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4448 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4450 case IPA_JF_PASS_THROUGH
:
4451 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4452 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4454 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4455 bp
= bitpack_create (ob
->main_stream
);
4456 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4457 bp_pack_value (&bp
, jump_func
->value
.pass_through
.type_preserved
, 1);
4458 streamer_write_bitpack (&bp
);
4462 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4463 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4466 case IPA_JF_ANCESTOR
:
4467 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4468 stream_write_tree (ob
, jump_func
->value
.ancestor
.type
, true);
4469 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4470 bp
= bitpack_create (ob
->main_stream
);
4471 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4472 bp_pack_value (&bp
, jump_func
->value
.ancestor
.type_preserved
, 1);
4473 streamer_write_bitpack (&bp
);
4477 count
= vec_safe_length (jump_func
->agg
.items
);
4478 streamer_write_uhwi (ob
, count
);
4481 bp
= bitpack_create (ob
->main_stream
);
4482 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4483 streamer_write_bitpack (&bp
);
4486 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4488 streamer_write_uhwi (ob
, item
->offset
);
4489 stream_write_tree (ob
, item
->value
, true);
4493 /* Read in jump function JUMP_FUNC from IB. */
4496 ipa_read_jump_function (struct lto_input_block
*ib
,
4497 struct ipa_jump_func
*jump_func
,
4498 struct cgraph_edge
*cs
,
4499 struct data_in
*data_in
)
4501 enum jump_func_type jftype
;
4502 enum tree_code operation
;
4505 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4508 case IPA_JF_UNKNOWN
:
4509 jump_func
->type
= IPA_JF_UNKNOWN
;
4511 case IPA_JF_KNOWN_TYPE
:
4513 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4514 tree base_type
= stream_read_tree (ib
, data_in
);
4515 tree component_type
= stream_read_tree (ib
, data_in
);
4517 ipa_set_jf_known_type (jump_func
, offset
, base_type
, component_type
);
4521 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4523 case IPA_JF_PASS_THROUGH
:
4524 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4525 if (operation
== NOP_EXPR
)
4527 int formal_id
= streamer_read_uhwi (ib
);
4528 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4529 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4530 bool type_preserved
= bp_unpack_value (&bp
, 1);
4531 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
,
4536 tree operand
= stream_read_tree (ib
, data_in
);
4537 int formal_id
= streamer_read_uhwi (ib
);
4538 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4542 case IPA_JF_ANCESTOR
:
4544 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4545 tree type
= stream_read_tree (ib
, data_in
);
4546 int formal_id
= streamer_read_uhwi (ib
);
4547 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4548 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4549 bool type_preserved
= bp_unpack_value (&bp
, 1);
4551 ipa_set_ancestor_jf (jump_func
, offset
, type
, formal_id
, agg_preserved
,
4557 count
= streamer_read_uhwi (ib
);
4558 vec_alloc (jump_func
->agg
.items
, count
);
4561 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4562 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4564 for (i
= 0; i
< count
; i
++)
4566 struct ipa_agg_jf_item item
;
4567 item
.offset
= streamer_read_uhwi (ib
);
4568 item
.value
= stream_read_tree (ib
, data_in
);
4569 jump_func
->agg
.items
->quick_push (item
);
4573 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4574 relevant to indirect inlining to OB. */
4577 ipa_write_indirect_edge_info (struct output_block
*ob
,
4578 struct cgraph_edge
*cs
)
4580 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4581 struct bitpack_d bp
;
4583 streamer_write_hwi (ob
, ii
->param_index
);
4584 streamer_write_hwi (ob
, ii
->offset
);
4585 bp
= bitpack_create (ob
->main_stream
);
4586 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4587 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4588 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4589 bp_pack_value (&bp
, ii
->by_ref
, 1);
4590 bp_pack_value (&bp
, ii
->maybe_in_construction
, 1);
4591 bp_pack_value (&bp
, ii
->maybe_derived_type
, 1);
4592 streamer_write_bitpack (&bp
);
4594 if (ii
->polymorphic
)
4596 streamer_write_hwi (ob
, ii
->otr_token
);
4597 stream_write_tree (ob
, ii
->otr_type
, true);
4598 stream_write_tree (ob
, ii
->outer_type
, true);
4602 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4603 relevant to indirect inlining from IB. */
4606 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4607 struct data_in
*data_in ATTRIBUTE_UNUSED
,
4608 struct cgraph_edge
*cs
)
4610 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4611 struct bitpack_d bp
;
4613 ii
->param_index
= (int) streamer_read_hwi (ib
);
4614 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4615 bp
= streamer_read_bitpack (ib
);
4616 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4617 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4618 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4619 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4620 ii
->maybe_in_construction
= bp_unpack_value (&bp
, 1);
4621 ii
->maybe_derived_type
= bp_unpack_value (&bp
, 1);
4622 if (ii
->polymorphic
)
4624 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4625 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4626 ii
->outer_type
= stream_read_tree (ib
, data_in
);
4630 /* Stream out NODE info to OB. */
4633 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4636 lto_symtab_encoder_t encoder
;
4637 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4639 struct cgraph_edge
*e
;
4640 struct bitpack_d bp
;
4642 encoder
= ob
->decl_state
->symtab_node_encoder
;
4643 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4644 streamer_write_uhwi (ob
, node_ref
);
4646 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4647 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4648 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4649 bp
= bitpack_create (ob
->main_stream
);
4650 gcc_assert (info
->analysis_done
4651 || ipa_get_param_count (info
) == 0);
4652 gcc_assert (!info
->node_enqueued
);
4653 gcc_assert (!info
->ipcp_orig_node
);
4654 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4655 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4656 streamer_write_bitpack (&bp
);
4657 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4658 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4659 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4661 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4663 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4664 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4665 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4667 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4669 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4671 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4672 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4673 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4674 ipa_write_indirect_edge_info (ob
, e
);
4678 /* Stream in NODE info from IB. */
4681 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4682 struct data_in
*data_in
)
4684 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4686 struct cgraph_edge
*e
;
4687 struct bitpack_d bp
;
4689 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
4691 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4692 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
4694 bp
= streamer_read_bitpack (ib
);
4695 if (ipa_get_param_count (info
) != 0)
4696 info
->analysis_done
= true;
4697 info
->node_enqueued
= false;
4698 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4699 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
4700 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4701 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
4702 for (e
= node
->callees
; 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
);
4711 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4712 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4715 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4717 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4718 int count
= streamer_read_uhwi (ib
);
4722 vec_safe_grow_cleared (args
->jump_functions
, count
);
4723 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4724 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4727 ipa_read_indirect_edge_info (ib
, data_in
, e
);
4731 /* Write jump functions for nodes in SET. */
4734 ipa_prop_write_jump_functions (void)
4736 struct cgraph_node
*node
;
4737 struct output_block
*ob
;
4738 unsigned int count
= 0;
4739 lto_symtab_encoder_iterator lsei
;
4740 lto_symtab_encoder_t encoder
;
4743 if (!ipa_node_params_vector
.exists ())
4746 ob
= create_output_block (LTO_section_jump_functions
);
4747 encoder
= ob
->decl_state
->symtab_node_encoder
;
4748 ob
->cgraph_node
= NULL
;
4749 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4750 lsei_next_function_in_partition (&lsei
))
4752 node
= lsei_cgraph_node (lsei
);
4753 if (cgraph_function_with_gimple_body_p (node
)
4754 && IPA_NODE_REF (node
) != NULL
)
4758 streamer_write_uhwi (ob
, count
);
4760 /* Process all of the functions. */
4761 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4762 lsei_next_function_in_partition (&lsei
))
4764 node
= lsei_cgraph_node (lsei
);
4765 if (cgraph_function_with_gimple_body_p (node
)
4766 && IPA_NODE_REF (node
) != NULL
)
4767 ipa_write_node_info (ob
, node
);
4769 streamer_write_char_stream (ob
->main_stream
, 0);
4770 produce_asm (ob
, NULL
);
4771 destroy_output_block (ob
);
4774 /* Read section in file FILE_DATA of length LEN with data DATA. */
4777 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
4780 const struct lto_function_header
*header
=
4781 (const struct lto_function_header
*) data
;
4782 const int cfg_offset
= sizeof (struct lto_function_header
);
4783 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4784 const int string_offset
= main_offset
+ header
->main_size
;
4785 struct data_in
*data_in
;
4786 struct lto_input_block ib_main
;
4790 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4794 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4795 header
->string_size
, vNULL
);
4796 count
= streamer_read_uhwi (&ib_main
);
4798 for (i
= 0; i
< count
; i
++)
4801 struct cgraph_node
*node
;
4802 lto_symtab_encoder_t encoder
;
4804 index
= streamer_read_uhwi (&ib_main
);
4805 encoder
= file_data
->symtab_node_encoder
;
4806 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4807 gcc_assert (node
->definition
);
4808 ipa_read_node_info (&ib_main
, node
, data_in
);
4810 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4812 lto_data_in_delete (data_in
);
4815 /* Read ipcp jump functions. */
4818 ipa_prop_read_jump_functions (void)
4820 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4821 struct lto_file_decl_data
*file_data
;
4824 ipa_check_create_node_params ();
4825 ipa_check_create_edge_args ();
4826 ipa_register_cgraph_hooks ();
4828 while ((file_data
= file_data_vec
[j
++]))
4831 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
4834 ipa_prop_read_section (file_data
, data
, len
);
4838 /* After merging units, we can get mismatch in argument counts.
4839 Also decl merging might've rendered parameter lists obsolete.
4840 Also compute called_with_variable_arg info. */
4843 ipa_update_after_lto_read (void)
4845 ipa_check_create_node_params ();
4846 ipa_check_create_edge_args ();
4850 write_agg_replacement_chain (struct output_block
*ob
, struct cgraph_node
*node
)
4853 unsigned int count
= 0;
4854 lto_symtab_encoder_t encoder
;
4855 struct ipa_agg_replacement_value
*aggvals
, *av
;
4857 aggvals
= ipa_get_agg_replacements_for_node (node
);
4858 encoder
= ob
->decl_state
->symtab_node_encoder
;
4859 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4860 streamer_write_uhwi (ob
, node_ref
);
4862 for (av
= aggvals
; av
; av
= av
->next
)
4864 streamer_write_uhwi (ob
, count
);
4866 for (av
= aggvals
; av
; av
= av
->next
)
4868 struct bitpack_d bp
;
4870 streamer_write_uhwi (ob
, av
->offset
);
4871 streamer_write_uhwi (ob
, av
->index
);
4872 stream_write_tree (ob
, av
->value
, true);
4874 bp
= bitpack_create (ob
->main_stream
);
4875 bp_pack_value (&bp
, av
->by_ref
, 1);
4876 streamer_write_bitpack (&bp
);
4880 /* Stream in the aggregate value replacement chain for NODE from IB. */
4883 read_agg_replacement_chain (struct lto_input_block
*ib
,
4884 struct cgraph_node
*node
,
4885 struct data_in
*data_in
)
4887 struct ipa_agg_replacement_value
*aggvals
= NULL
;
4888 unsigned int count
, i
;
4890 count
= streamer_read_uhwi (ib
);
4891 for (i
= 0; i
<count
; i
++)
4893 struct ipa_agg_replacement_value
*av
;
4894 struct bitpack_d bp
;
4896 av
= ggc_alloc
<ipa_agg_replacement_value
> ();
4897 av
->offset
= streamer_read_uhwi (ib
);
4898 av
->index
= streamer_read_uhwi (ib
);
4899 av
->value
= stream_read_tree (ib
, data_in
);
4900 bp
= streamer_read_bitpack (ib
);
4901 av
->by_ref
= bp_unpack_value (&bp
, 1);
4905 ipa_set_node_agg_value_chain (node
, aggvals
);
4908 /* Write all aggregate replacement for nodes in set. */
4911 ipa_prop_write_all_agg_replacement (void)
4913 struct cgraph_node
*node
;
4914 struct output_block
*ob
;
4915 unsigned int count
= 0;
4916 lto_symtab_encoder_iterator lsei
;
4917 lto_symtab_encoder_t encoder
;
4919 if (!ipa_node_agg_replacements
)
4922 ob
= create_output_block (LTO_section_ipcp_transform
);
4923 encoder
= ob
->decl_state
->symtab_node_encoder
;
4924 ob
->cgraph_node
= NULL
;
4925 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4926 lsei_next_function_in_partition (&lsei
))
4928 node
= lsei_cgraph_node (lsei
);
4929 if (cgraph_function_with_gimple_body_p (node
)
4930 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4934 streamer_write_uhwi (ob
, count
);
4936 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4937 lsei_next_function_in_partition (&lsei
))
4939 node
= lsei_cgraph_node (lsei
);
4940 if (cgraph_function_with_gimple_body_p (node
)
4941 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4942 write_agg_replacement_chain (ob
, node
);
4944 streamer_write_char_stream (ob
->main_stream
, 0);
4945 produce_asm (ob
, NULL
);
4946 destroy_output_block (ob
);
4949 /* Read replacements section in file FILE_DATA of length LEN with data
4953 read_replacements_section (struct lto_file_decl_data
*file_data
,
4957 const struct lto_function_header
*header
=
4958 (const struct lto_function_header
*) data
;
4959 const int cfg_offset
= sizeof (struct lto_function_header
);
4960 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4961 const int string_offset
= main_offset
+ header
->main_size
;
4962 struct data_in
*data_in
;
4963 struct lto_input_block ib_main
;
4967 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4970 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4971 header
->string_size
, vNULL
);
4972 count
= streamer_read_uhwi (&ib_main
);
4974 for (i
= 0; i
< count
; i
++)
4977 struct cgraph_node
*node
;
4978 lto_symtab_encoder_t encoder
;
4980 index
= streamer_read_uhwi (&ib_main
);
4981 encoder
= file_data
->symtab_node_encoder
;
4982 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4983 gcc_assert (node
->definition
);
4984 read_agg_replacement_chain (&ib_main
, node
, data_in
);
4986 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4988 lto_data_in_delete (data_in
);
4991 /* Read IPA-CP aggregate replacements. */
4994 ipa_prop_read_all_agg_replacement (void)
4996 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4997 struct lto_file_decl_data
*file_data
;
5000 while ((file_data
= file_data_vec
[j
++]))
5003 const char *data
= lto_get_section_data (file_data
,
5004 LTO_section_ipcp_transform
,
5007 read_replacements_section (file_data
, data
, len
);
5011 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
5015 adjust_agg_replacement_values (struct cgraph_node
*node
,
5016 struct ipa_agg_replacement_value
*aggval
)
5018 struct ipa_agg_replacement_value
*v
;
5019 int i
, c
= 0, d
= 0, *adj
;
5021 if (!node
->clone
.combined_args_to_skip
)
5024 for (v
= aggval
; v
; v
= v
->next
)
5026 gcc_assert (v
->index
>= 0);
5032 adj
= XALLOCAVEC (int, c
);
5033 for (i
= 0; i
< c
; i
++)
5034 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
5042 for (v
= aggval
; v
; v
= v
->next
)
5043 v
->index
= adj
[v
->index
];
5046 /* Dominator walker driving the ipcp modification phase. */
5048 class ipcp_modif_dom_walker
: public dom_walker
5051 ipcp_modif_dom_walker (struct func_body_info
*fbi
,
5052 vec
<ipa_param_descriptor
> descs
,
5053 struct ipa_agg_replacement_value
*av
,
5055 : dom_walker (CDI_DOMINATORS
), m_fbi (fbi
), m_descriptors (descs
),
5056 m_aggval (av
), m_something_changed (sc
), m_cfg_changed (cc
) {}
5058 virtual void before_dom_children (basic_block
);
5061 struct func_body_info
*m_fbi
;
5062 vec
<ipa_param_descriptor
> m_descriptors
;
5063 struct ipa_agg_replacement_value
*m_aggval
;
5064 bool *m_something_changed
, *m_cfg_changed
;
5068 ipcp_modif_dom_walker::before_dom_children (basic_block bb
)
5070 gimple_stmt_iterator gsi
;
5071 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5073 struct ipa_agg_replacement_value
*v
;
5074 gimple stmt
= gsi_stmt (gsi
);
5076 HOST_WIDE_INT offset
, size
;
5080 if (!gimple_assign_load_p (stmt
))
5082 rhs
= gimple_assign_rhs1 (stmt
);
5083 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
5088 while (handled_component_p (t
))
5090 /* V_C_E can do things like convert an array of integers to one
5091 bigger integer and similar things we do not handle below. */
5092 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
5097 t
= TREE_OPERAND (t
, 0);
5102 if (!ipa_load_from_parm_agg_1 (m_fbi
, m_descriptors
, stmt
, rhs
, &index
,
5103 &offset
, &size
, &by_ref
))
5105 for (v
= m_aggval
; v
; v
= v
->next
)
5106 if (v
->index
== index
5107 && v
->offset
== offset
)
5110 || v
->by_ref
!= by_ref
5111 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
5114 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
5115 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
5117 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
5118 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
5119 else if (TYPE_SIZE (TREE_TYPE (rhs
))
5120 == TYPE_SIZE (TREE_TYPE (v
->value
)))
5121 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
5126 fprintf (dump_file
, " const ");
5127 print_generic_expr (dump_file
, v
->value
, 0);
5128 fprintf (dump_file
, " can't be converted to type of ");
5129 print_generic_expr (dump_file
, rhs
, 0);
5130 fprintf (dump_file
, "\n");
5138 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5140 fprintf (dump_file
, "Modifying stmt:\n ");
5141 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5143 gimple_assign_set_rhs_from_tree (&gsi
, val
);
5146 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5148 fprintf (dump_file
, "into:\n ");
5149 print_gimple_stmt (dump_file
, stmt
, 0, 0);
5150 fprintf (dump_file
, "\n");
5153 *m_something_changed
= true;
5154 if (maybe_clean_eh_stmt (stmt
)
5155 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
5156 *m_cfg_changed
= true;
5161 /* IPCP transformation phase doing propagation of aggregate values. */
5164 ipcp_transform_function (struct cgraph_node
*node
)
5166 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
5167 struct func_body_info fbi
;
5168 struct ipa_agg_replacement_value
*aggval
;
5170 bool cfg_changed
= false, something_changed
= false;
5172 gcc_checking_assert (cfun
);
5173 gcc_checking_assert (current_function_decl
);
5176 fprintf (dump_file
, "Modification phase of node %s/%i\n",
5177 node
->name (), node
->order
);
5179 aggval
= ipa_get_agg_replacements_for_node (node
);
5182 param_count
= count_formal_params (node
->decl
);
5183 if (param_count
== 0)
5185 adjust_agg_replacement_values (node
, aggval
);
5187 ipa_dump_agg_replacement_values (dump_file
, aggval
);
5191 fbi
.bb_infos
= vNULL
;
5192 fbi
.bb_infos
.safe_grow_cleared (last_basic_block_for_fn (cfun
));
5193 fbi
.param_count
= param_count
;
5196 descriptors
.safe_grow_cleared (param_count
);
5197 ipa_populate_param_decls (node
, descriptors
);
5198 calculate_dominance_info (CDI_DOMINATORS
);
5199 ipcp_modif_dom_walker (&fbi
, descriptors
, aggval
, &something_changed
,
5200 &cfg_changed
).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5203 struct ipa_bb_info
*bi
;
5204 FOR_EACH_VEC_ELT (fbi
.bb_infos
, i
, bi
)
5205 free_ipa_bb_info (bi
);
5206 fbi
.bb_infos
.release ();
5207 free_dominance_info (CDI_DOMINATORS
);
5208 (*ipa_node_agg_replacements
)[node
->uid
] = NULL
;
5209 descriptors
.release ();
5211 if (!something_changed
)
5213 else if (cfg_changed
)
5214 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
5216 return TODO_update_ssa_only_virtuals
;