1 /* Interprocedural analyses.
2 Copyright (C) 2005-2013 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 "langhooks.h"
29 #include "tree-flow.h"
30 #include "tree-pass.h"
31 #include "tree-inline.h"
32 #include "ipa-inline.h"
35 #include "diagnostic.h"
36 #include "gimple-pretty-print.h"
37 #include "lto-streamer.h"
38 #include "data-streamer.h"
39 #include "tree-streamer.h"
42 /* Intermediate information about a parameter that is only useful during the
43 run of ipa_analyze_node and is not kept afterwards. */
45 struct param_analysis_info
47 bool parm_modified, ref_modified, pt_modified;
48 bitmap parm_visited_statements, pt_visited_statements;
51 /* Vector where the parameter infos are actually stored. */
52 vec<ipa_node_params_t> ipa_node_params_vector;
53 /* Vector of known aggregate values in cloned nodes. */
54 vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
55 /* Vector where the parameter infos are actually stored. */
56 vec<ipa_edge_args_t, va_gc> *ipa_edge_args_vector;
58 /* Holders of ipa cgraph hooks: */
59 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
60 static struct cgraph_node_hook_list *node_removal_hook_holder;
61 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
62 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
63 static struct cgraph_node_hook_list *function_insertion_hook_holder;
65 /* Return index of the formal whose tree is PTREE in function which corresponds
69 ipa_get_param_decl_index_1 (vec<ipa_param_descriptor_t> descriptors, tree ptree)
73 count = descriptors.length ();
74 for (i = 0; i < count; i++)
75 if (descriptors[i].decl == ptree)
81 /* Return index of the formal whose tree is PTREE in function which corresponds
85 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
87 return ipa_get_param_decl_index_1 (info->descriptors, ptree);
90 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
94 ipa_populate_param_decls (struct cgraph_node *node,
95 vec<ipa_param_descriptor_t> &descriptors)
102 fndecl = node->symbol.decl;
103 fnargs = DECL_ARGUMENTS (fndecl);
105 for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
107 descriptors[param_num].decl = parm;
112 /* Return how many formal parameters FNDECL has. */
115 count_formal_params (tree fndecl)
120 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
126 /* Initialize the ipa_node_params structure associated with NODE by counting
127 the function parameters, creating the descriptors and populating their
131 ipa_initialize_node_params (struct cgraph_node *node)
133 struct ipa_node_params *info = IPA_NODE_REF (node);
135 if (!info->descriptors.exists ())
139 param_count = count_formal_params (node->symbol.decl);
142 info->descriptors.safe_grow_cleared (param_count);
143 ipa_populate_param_decls (node, info->descriptors);
148 /* Print the jump functions associated with call graph edge CS to file F. */
151 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
155 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
156 for (i = 0; i < count; i++)
158 struct ipa_jump_func *jump_func;
159 enum jump_func_type type;
161 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
162 type = jump_func->type;
164 fprintf (f, " param %d: ", i);
165 if (type == IPA_JF_UNKNOWN)
166 fprintf (f, "UNKNOWN\n");
167 else if (type == IPA_JF_KNOWN_TYPE)
169 fprintf (f, "KNOWN TYPE: base ");
170 print_generic_expr (f, jump_func->value.known_type.base_type, 0);
171 fprintf (f, ", offset "HOST_WIDE_INT_PRINT_DEC", component ",
172 jump_func->value.known_type.offset);
173 print_generic_expr (f, jump_func->value.known_type.component_type, 0);
176 else if (type == IPA_JF_CONST)
178 tree val = jump_func->value.constant;
179 fprintf (f, "CONST: ");
180 print_generic_expr (f, val, 0);
181 if (TREE_CODE (val) == ADDR_EXPR
182 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
185 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
190 else if (type == IPA_JF_PASS_THROUGH)
192 fprintf (f, "PASS THROUGH: ");
193 fprintf (f, "%d, op %s",
194 jump_func->value.pass_through.formal_id,
196 jump_func->value.pass_through.operation]);
197 if (jump_func->value.pass_through.operation != NOP_EXPR)
200 print_generic_expr (f,
201 jump_func->value.pass_through.operand, 0);
203 if (jump_func->value.pass_through.agg_preserved)
204 fprintf (f, ", agg_preserved");
207 else if (type == IPA_JF_ANCESTOR)
209 fprintf (f, "ANCESTOR: ");
210 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
211 jump_func->value.ancestor.formal_id,
212 jump_func->value.ancestor.offset);
213 print_generic_expr (f, jump_func->value.ancestor.type, 0);
214 if (jump_func->value.ancestor.agg_preserved)
215 fprintf (f, ", agg_preserved");
219 if (jump_func->agg.items)
221 struct ipa_agg_jf_item *item;
224 fprintf (f, " Aggregate passed by %s:\n",
225 jump_func->agg.by_ref ? "reference" : "value");
226 FOR_EACH_VEC_SAFE_ELT (jump_func->agg.items, j, item)
228 fprintf (f, " offset: " HOST_WIDE_INT_PRINT_DEC ", ",
230 if (TYPE_P (item->value))
231 fprintf (f, "clobber of " HOST_WIDE_INT_PRINT_DEC " bits",
232 tree_low_cst (TYPE_SIZE (item->value), 1));
235 fprintf (f, "cst: ");
236 print_generic_expr (f, item->value, 0);
245 /* Print the jump functions of all arguments on all call graph edges going from
249 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
251 struct cgraph_edge *cs;
254 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
255 for (cs = node->callees; cs; cs = cs->next_callee)
257 if (!ipa_edge_args_info_available_for_edge_p (cs))
260 fprintf (f, " callsite %s/%i -> %s/%i : \n",
261 xstrdup (cgraph_node_name (node)), node->uid,
262 xstrdup (cgraph_node_name (cs->callee)), cs->callee->uid);
263 ipa_print_node_jump_functions_for_edge (f, cs);
266 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
268 if (!ipa_edge_args_info_available_for_edge_p (cs))
273 fprintf (f, " indirect callsite %d for stmt ", i);
274 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
277 fprintf (f, " indirect callsite %d :\n", i);
278 ipa_print_node_jump_functions_for_edge (f, cs);
283 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
286 ipa_print_all_jump_functions (FILE *f)
288 struct cgraph_node *node;
290 fprintf (f, "\nJump functions:\n");
291 FOR_EACH_FUNCTION (node)
293 ipa_print_node_jump_functions (f, node);
297 /* Set JFUNC to be a known type jump function. */
300 ipa_set_jf_known_type (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
301 tree base_type, tree component_type)
303 jfunc->type = IPA_JF_KNOWN_TYPE;
304 jfunc->value.known_type.offset = offset,
305 jfunc->value.known_type.base_type = base_type;
306 jfunc->value.known_type.component_type = component_type;
309 /* Set JFUNC to be a constant jmp function. */
312 ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant)
314 constant = unshare_expr (constant);
315 if (constant && EXPR_P (constant))
316 SET_EXPR_LOCATION (constant, UNKNOWN_LOCATION);
317 jfunc->type = IPA_JF_CONST;
318 jfunc->value.constant = unshare_expr_without_location (constant);
321 /* Set JFUNC to be a simple pass-through jump function. */
323 ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
326 jfunc->type = IPA_JF_PASS_THROUGH;
327 jfunc->value.pass_through.operand = NULL_TREE;
328 jfunc->value.pass_through.formal_id = formal_id;
329 jfunc->value.pass_through.operation = NOP_EXPR;
330 jfunc->value.pass_through.agg_preserved = agg_preserved;
333 /* Set JFUNC to be an arithmetic pass through jump function. */
336 ipa_set_jf_arith_pass_through (struct ipa_jump_func *jfunc, int formal_id,
337 tree operand, enum tree_code operation)
339 jfunc->type = IPA_JF_PASS_THROUGH;
340 jfunc->value.pass_through.operand = unshare_expr_without_location (operand);
341 jfunc->value.pass_through.formal_id = formal_id;
342 jfunc->value.pass_through.operation = operation;
343 jfunc->value.pass_through.agg_preserved = false;
346 /* Set JFUNC to be an ancestor jump function. */
349 ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
350 tree type, int formal_id, bool agg_preserved)
352 jfunc->type = IPA_JF_ANCESTOR;
353 jfunc->value.ancestor.formal_id = formal_id;
354 jfunc->value.ancestor.offset = offset;
355 jfunc->value.ancestor.type = type;
356 jfunc->value.ancestor.agg_preserved = agg_preserved;
359 /* Structure to be passed in between detect_type_change and
360 check_stmt_for_type_change. */
362 struct type_change_info
364 /* Offset into the object where there is the virtual method pointer we are
366 HOST_WIDE_INT offset;
367 /* The declaration or SSA_NAME pointer of the base that we are checking for
370 /* If we actually can tell the type that the object has changed to, it is
371 stored in this field. Otherwise it remains NULL_TREE. */
372 tree known_current_type;
373 /* Set to true if dynamic type change has been detected. */
374 bool type_maybe_changed;
375 /* Set to true if multiple types have been encountered. known_current_type
376 must be disregarded in that case. */
377 bool multiple_types_encountered;
380 /* Return true if STMT can modify a virtual method table pointer.
382 This function makes special assumptions about both constructors and
383 destructors which are all the functions that are allowed to alter the VMT
384 pointers. It assumes that destructors begin with assignment into all VMT
385 pointers and that constructors essentially look in the following way:
387 1) The very first thing they do is that they call constructors of ancestor
388 sub-objects that have them.
390 2) Then VMT pointers of this and all its ancestors is set to new values
391 corresponding to the type corresponding to the constructor.
393 3) Only afterwards, other stuff such as constructor of member sub-objects
394 and the code written by the user is run. Only this may include calling
395 virtual functions, directly or indirectly.
397 There is no way to call a constructor of an ancestor sub-object in any
400 This means that we do not have to care whether constructors get the correct
401 type information because they will always change it (in fact, if we define
402 the type to be given by the VMT pointer, it is undefined).
404 The most important fact to derive from the above is that if, for some
405 statement in the section 3, we try to detect whether the dynamic type has
406 changed, we can safely ignore all calls as we examine the function body
407 backwards until we reach statements in section 2 because these calls cannot
408 be ancestor constructors or destructors (if the input is not bogus) and so
409 do not change the dynamic type (this holds true only for automatically
410 allocated objects but at the moment we devirtualize only these). We then
411 must detect that statements in section 2 change the dynamic type and can try
412 to derive the new type. That is enough and we can stop, we will never see
413 the calls into constructors of sub-objects in this code. Therefore we can
414 safely ignore all call statements that we traverse.
418 stmt_may_be_vtbl_ptr_store (gimple stmt)
420 if (is_gimple_call (stmt))
422 else if (is_gimple_assign (stmt))
424 tree lhs = gimple_assign_lhs (stmt);
426 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs)))
428 if (flag_strict_aliasing
429 && !POINTER_TYPE_P (TREE_TYPE (lhs)))
432 if (TREE_CODE (lhs) == COMPONENT_REF
433 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)))
435 /* In the future we might want to use get_base_ref_and_offset to find
436 if there is a field corresponding to the offset and if so, proceed
437 almost like if it was a component ref. */
443 /* If STMT can be proved to be an assignment to the virtual method table
444 pointer of ANALYZED_OBJ and the type associated with the new table
445 identified, return the type. Otherwise return NULL_TREE. */
448 extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci)
450 HOST_WIDE_INT offset, size, max_size;
453 if (!gimple_assign_single_p (stmt))
456 lhs = gimple_assign_lhs (stmt);
457 rhs = gimple_assign_rhs1 (stmt);
458 if (TREE_CODE (lhs) != COMPONENT_REF
459 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1))
460 || TREE_CODE (rhs) != ADDR_EXPR)
462 rhs = get_base_address (TREE_OPERAND (rhs, 0));
464 || TREE_CODE (rhs) != VAR_DECL
465 || !DECL_VIRTUAL_P (rhs))
468 base = get_ref_base_and_extent (lhs, &offset, &size, &max_size);
469 if (offset != tci->offset
470 || size != POINTER_SIZE
471 || max_size != POINTER_SIZE)
473 if (TREE_CODE (base) == MEM_REF)
475 if (TREE_CODE (tci->object) != MEM_REF
476 || TREE_OPERAND (tci->object, 0) != TREE_OPERAND (base, 0)
477 || !tree_int_cst_equal (TREE_OPERAND (tci->object, 1),
478 TREE_OPERAND (base, 1)))
481 else if (tci->object != base)
484 return DECL_CONTEXT (rhs);
487 /* Callback of walk_aliased_vdefs and a helper function for
488 detect_type_change to check whether a particular statement may modify
489 the virtual table pointer, and if possible also determine the new type of
490 the (sub-)object. It stores its result into DATA, which points to a
491 type_change_info structure. */
494 check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
496 gimple stmt = SSA_NAME_DEF_STMT (vdef);
497 struct type_change_info *tci = (struct type_change_info *) data;
499 if (stmt_may_be_vtbl_ptr_store (stmt))
502 type = extr_type_from_vtbl_ptr_store (stmt, tci);
503 if (tci->type_maybe_changed
504 && type != tci->known_current_type)
505 tci->multiple_types_encountered = true;
506 tci->known_current_type = type;
507 tci->type_maybe_changed = true;
516 /* Like detect_type_change but with extra argument COMP_TYPE which will become
517 the component type part of new JFUNC of dynamic type change is detected and
518 the new base type is identified. */
521 detect_type_change_1 (tree arg, tree base, tree comp_type, gimple call,
522 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
524 struct type_change_info tci;
527 gcc_checking_assert (DECL_P (arg)
528 || TREE_CODE (arg) == MEM_REF
529 || handled_component_p (arg));
530 /* Const calls cannot call virtual methods through VMT and so type changes do
532 if (!flag_devirtualize || !gimple_vuse (call))
535 ao_ref_init (&ao, arg);
538 ao.size = POINTER_SIZE;
539 ao.max_size = ao.size;
542 tci.object = get_base_address (arg);
543 tci.known_current_type = NULL_TREE;
544 tci.type_maybe_changed = false;
545 tci.multiple_types_encountered = false;
547 walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
549 if (!tci.type_maybe_changed)
552 if (!tci.known_current_type
553 || tci.multiple_types_encountered
555 jfunc->type = IPA_JF_UNKNOWN;
557 ipa_set_jf_known_type (jfunc, 0, tci.known_current_type, comp_type);
562 /* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
563 looking for assignments to its virtual table pointer. If it is, return true
564 and fill in the jump function JFUNC with relevant type information or set it
565 to unknown. ARG is the object itself (not a pointer to it, unless
566 dereferenced). BASE is the base of the memory access as returned by
567 get_ref_base_and_extent, as is the offset. */
570 detect_type_change (tree arg, tree base, gimple call,
571 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
573 return detect_type_change_1 (arg, base, TREE_TYPE (arg), call, jfunc, offset);
576 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
577 SSA name (its dereference will become the base and the offset is assumed to
581 detect_type_change_ssa (tree arg, gimple call, struct ipa_jump_func *jfunc)
585 gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
586 if (!flag_devirtualize
587 || !POINTER_TYPE_P (TREE_TYPE (arg))
588 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != RECORD_TYPE)
591 comp_type = TREE_TYPE (TREE_TYPE (arg));
592 arg = build2 (MEM_REF, ptr_type_node, arg,
593 build_int_cst (ptr_type_node, 0));
595 return detect_type_change_1 (arg, arg, comp_type, call, jfunc, 0);
598 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
599 boolean variable pointed to by DATA. */
602 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
605 bool *b = (bool *) data;
610 /* Return true if a load from a formal parameter PARM_LOAD is known to retreive
611 a value known not to be modified in this function before reaching the
612 statement STMT. PARM_AINFO is a pointer to a structure containing temporary
613 information about the parameter. */
616 parm_preserved_before_stmt_p (struct param_analysis_info *parm_ainfo,
617 gimple stmt, tree parm_load)
619 bool modified = false;
620 bitmap *visited_stmts;
623 if (parm_ainfo && parm_ainfo->parm_modified)
626 gcc_checking_assert (gimple_vuse (stmt) != NULL_TREE);
627 ao_ref_init (&refd, parm_load);
628 /* We can cache visited statements only when parm_ainfo is available and when
629 we are looking at a naked load of the whole parameter. */
630 if (!parm_ainfo || TREE_CODE (parm_load) != PARM_DECL)
631 visited_stmts = NULL;
633 visited_stmts = &parm_ainfo->parm_visited_statements;
634 walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, &modified,
636 if (parm_ainfo && modified)
637 parm_ainfo->parm_modified = true;
641 /* If STMT is an assignment that loads a value from an parameter declaration,
642 return the index of the parameter in ipa_node_params which has not been
643 modified. Otherwise return -1. */
646 load_from_unmodified_param (vec<ipa_param_descriptor_t> descriptors,
647 struct param_analysis_info *parms_ainfo,
653 if (!gimple_assign_single_p (stmt))
656 op1 = gimple_assign_rhs1 (stmt);
657 if (TREE_CODE (op1) != PARM_DECL)
660 index = ipa_get_param_decl_index_1 (descriptors, op1);
662 || !parm_preserved_before_stmt_p (parms_ainfo ? &parms_ainfo[index]
669 /* Return true if memory reference REF loads data that are known to be
670 unmodified in this function before reaching statement STMT. PARM_AINFO, if
671 non-NULL, is a pointer to a structure containing temporary information about
675 parm_ref_data_preserved_p (struct param_analysis_info *parm_ainfo,
676 gimple stmt, tree ref)
678 bool modified = false;
681 gcc_checking_assert (gimple_vuse (stmt));
682 if (parm_ainfo && parm_ainfo->ref_modified)
685 ao_ref_init (&refd, ref);
686 walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, &modified,
688 if (parm_ainfo && modified)
689 parm_ainfo->ref_modified = true;
693 /* Return true if the data pointed to by PARM is known to be unmodified in this
694 function before reaching call statement CALL into which it is passed.
695 PARM_AINFO is a pointer to a structure containing temporary information
699 parm_ref_data_pass_through_p (struct param_analysis_info *parm_ainfo,
700 gimple call, tree parm)
702 bool modified = false;
705 /* It's unnecessary to calculate anything about memory contnets for a const
706 function because it is not goin to use it. But do not cache the result
707 either. Also, no such calculations for non-pointers. */
708 if (!gimple_vuse (call)
709 || !POINTER_TYPE_P (TREE_TYPE (parm)))
712 if (parm_ainfo->pt_modified)
715 ao_ref_init_from_ptr_and_size (&refd, parm, NULL_TREE);
716 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified, &modified,
717 parm_ainfo ? &parm_ainfo->pt_visited_statements : NULL);
719 parm_ainfo->pt_modified = true;
723 /* Return true if we can prove that OP is a memory reference loading unmodified
724 data from an aggregate passed as a parameter and if the aggregate is passed
725 by reference, that the alias type of the load corresponds to the type of the
726 formal parameter (so that we can rely on this type for TBAA in callers).
727 INFO and PARMS_AINFO describe parameters of the current function (but the
728 latter can be NULL), STMT is the load statement. If function returns true,
729 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
730 within the aggregate and whether it is a load from a value passed by
731 reference respectively. */
734 ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor_t> descriptors,
735 struct param_analysis_info *parms_ainfo, gimple stmt,
736 tree op, int *index_p, HOST_WIDE_INT *offset_p,
740 HOST_WIDE_INT size, max_size;
741 tree base = get_ref_base_and_extent (op, offset_p, &size, &max_size);
743 if (max_size == -1 || max_size != size || *offset_p < 0)
748 int index = ipa_get_param_decl_index_1 (descriptors, base);
750 && parm_preserved_before_stmt_p (parms_ainfo ? &parms_ainfo[index]
760 if (TREE_CODE (base) != MEM_REF
761 || TREE_CODE (TREE_OPERAND (base, 0)) != SSA_NAME
762 || !integer_zerop (TREE_OPERAND (base, 1)))
765 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base, 0)))
767 tree parm = SSA_NAME_VAR (TREE_OPERAND (base, 0));
768 index = ipa_get_param_decl_index_1 (descriptors, parm);
772 /* This branch catches situations where a pointer parameter is not a
773 gimple register, for example:
775 void hip7(S*) (struct S * p)
777 void (*<T2e4>) (struct S *) D.1867;
787 gimple def = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0));
788 index = load_from_unmodified_param (descriptors, parms_ainfo, def);
792 && parm_ref_data_preserved_p (parms_ainfo ? &parms_ainfo[index] : NULL,
802 /* Just like the previous function, just without the param_analysis_info
803 pointer, for users outside of this file. */
806 ipa_load_from_parm_agg (struct ipa_node_params *info, gimple stmt,
807 tree op, int *index_p, HOST_WIDE_INT *offset_p,
810 return ipa_load_from_parm_agg_1 (info->descriptors, NULL, stmt, op, index_p,
814 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
815 of an assignment statement STMT, try to determine whether we are actually
816 handling any of the following cases and construct an appropriate jump
817 function into JFUNC if so:
819 1) The passed value is loaded from a formal parameter which is not a gimple
820 register (most probably because it is addressable, the value has to be
821 scalar) and we can guarantee the value has not changed. This case can
822 therefore be described by a simple pass-through jump function. For example:
831 2) The passed value can be described by a simple arithmetic pass-through
838 D.2064_4 = a.1(D) + 4;
841 This case can also occur in combination of the previous one, e.g.:
849 D.2064_4 = a.0_3 + 4;
852 3) The passed value is an address of an object within another one (which
853 also passed by reference). Such situations are described by an ancestor
854 jump function and describe situations such as:
856 B::foo() (struct B * const this)
860 D.1845_2 = &this_1(D)->D.1748;
863 INFO is the structure describing individual parameters access different
864 stages of IPA optimizations. PARMS_AINFO contains the information that is
865 only needed for intraprocedural analysis. */
868 compute_complex_assign_jump_func (struct ipa_node_params *info,
869 struct param_analysis_info *parms_ainfo,
870 struct ipa_jump_func *jfunc,
871 gimple call, gimple stmt, tree name)
873 HOST_WIDE_INT offset, size, max_size;
874 tree op1, tc_ssa, base, ssa;
877 op1 = gimple_assign_rhs1 (stmt);
879 if (TREE_CODE (op1) == SSA_NAME)
881 if (SSA_NAME_IS_DEFAULT_DEF (op1))
882 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
884 index = load_from_unmodified_param (info->descriptors, parms_ainfo,
885 SSA_NAME_DEF_STMT (op1));
890 index = load_from_unmodified_param (info->descriptors, parms_ainfo, stmt);
891 tc_ssa = gimple_assign_lhs (stmt);
896 tree op2 = gimple_assign_rhs2 (stmt);
900 if (!is_gimple_ip_invariant (op2)
901 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
902 && !useless_type_conversion_p (TREE_TYPE (name),
906 ipa_set_jf_arith_pass_through (jfunc, index, op2,
907 gimple_assign_rhs_code (stmt));
909 else if (gimple_assign_single_p (stmt)
910 && !detect_type_change_ssa (tc_ssa, call, jfunc))
912 bool agg_p = parm_ref_data_pass_through_p (&parms_ainfo[index],
914 ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
919 if (TREE_CODE (op1) != ADDR_EXPR)
921 op1 = TREE_OPERAND (op1, 0);
922 if (TREE_CODE (TREE_TYPE (op1)) != RECORD_TYPE)
924 base = get_ref_base_and_extent (op1, &offset, &size, &max_size);
925 if (TREE_CODE (base) != MEM_REF
926 /* If this is a varying address, punt. */
930 offset += mem_ref_offset (base).low * BITS_PER_UNIT;
931 ssa = TREE_OPERAND (base, 0);
932 if (TREE_CODE (ssa) != SSA_NAME
933 || !SSA_NAME_IS_DEFAULT_DEF (ssa)
937 /* Dynamic types are changed only in constructors and destructors and */
938 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa));
940 && !detect_type_change (op1, base, call, jfunc, offset))
941 ipa_set_ancestor_jf (jfunc, offset, TREE_TYPE (op1), index,
942 parm_ref_data_pass_through_p (&parms_ainfo[index],
946 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
949 iftmp.1_3 = &obj_2(D)->D.1762;
951 The base of the MEM_REF must be a default definition SSA NAME of a
952 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
953 whole MEM_REF expression is returned and the offset calculated from any
954 handled components and the MEM_REF itself is stored into *OFFSET. The whole
955 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
958 get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset)
960 HOST_WIDE_INT size, max_size;
961 tree expr, parm, obj;
963 if (!gimple_assign_single_p (assign))
965 expr = gimple_assign_rhs1 (assign);
967 if (TREE_CODE (expr) != ADDR_EXPR)
969 expr = TREE_OPERAND (expr, 0);
971 expr = get_ref_base_and_extent (expr, offset, &size, &max_size);
973 if (TREE_CODE (expr) != MEM_REF
974 /* If this is a varying address, punt. */
979 parm = TREE_OPERAND (expr, 0);
980 if (TREE_CODE (parm) != SSA_NAME
981 || !SSA_NAME_IS_DEFAULT_DEF (parm)
982 || TREE_CODE (SSA_NAME_VAR (parm)) != PARM_DECL)
985 *offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
991 /* Given that an actual argument is an SSA_NAME that is a result of a phi
992 statement PHI, try to find out whether NAME is in fact a
993 multiple-inheritance typecast from a descendant into an ancestor of a formal
994 parameter and thus can be described by an ancestor jump function and if so,
995 write the appropriate function into JFUNC.
997 Essentially we want to match the following pattern:
1005 iftmp.1_3 = &obj_2(D)->D.1762;
1008 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1009 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1013 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
1014 struct param_analysis_info *parms_ainfo,
1015 struct ipa_jump_func *jfunc,
1016 gimple call, gimple phi)
1018 HOST_WIDE_INT offset;
1019 gimple assign, cond;
1020 basic_block phi_bb, assign_bb, cond_bb;
1021 tree tmp, parm, expr, obj;
1024 if (gimple_phi_num_args (phi) != 2)
1027 if (integer_zerop (PHI_ARG_DEF (phi, 1)))
1028 tmp = PHI_ARG_DEF (phi, 0);
1029 else if (integer_zerop (PHI_ARG_DEF (phi, 0)))
1030 tmp = PHI_ARG_DEF (phi, 1);
1033 if (TREE_CODE (tmp) != SSA_NAME
1034 || SSA_NAME_IS_DEFAULT_DEF (tmp)
1035 || !POINTER_TYPE_P (TREE_TYPE (tmp))
1036 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
1039 assign = SSA_NAME_DEF_STMT (tmp);
1040 assign_bb = gimple_bb (assign);
1041 if (!single_pred_p (assign_bb))
1043 expr = get_ancestor_addr_info (assign, &obj, &offset);
1046 parm = TREE_OPERAND (expr, 0);
1047 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
1048 gcc_assert (index >= 0);
1050 cond_bb = single_pred (assign_bb);
1051 cond = last_stmt (cond_bb);
1053 || gimple_code (cond) != GIMPLE_COND
1054 || gimple_cond_code (cond) != NE_EXPR
1055 || gimple_cond_lhs (cond) != parm
1056 || !integer_zerop (gimple_cond_rhs (cond)))
1059 phi_bb = gimple_bb (phi);
1060 for (i = 0; i < 2; i++)
1062 basic_block pred = EDGE_PRED (phi_bb, i)->src;
1063 if (pred != assign_bb && pred != cond_bb)
1067 if (!detect_type_change (obj, expr, call, jfunc, offset))
1068 ipa_set_ancestor_jf (jfunc, offset, TREE_TYPE (obj), index,
1069 parm_ref_data_pass_through_p (&parms_ainfo[index],
1073 /* Given OP which is passed as an actual argument to a called function,
1074 determine if it is possible to construct a KNOWN_TYPE jump function for it
1075 and if so, create one and store it to JFUNC. */
1078 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
1081 HOST_WIDE_INT offset, size, max_size;
1084 if (!flag_devirtualize
1085 || TREE_CODE (op) != ADDR_EXPR
1086 || TREE_CODE (TREE_TYPE (TREE_TYPE (op))) != RECORD_TYPE)
1089 op = TREE_OPERAND (op, 0);
1090 base = get_ref_base_and_extent (op, &offset, &size, &max_size);
1094 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
1095 || is_global_var (base))
1098 if (!TYPE_BINFO (TREE_TYPE (base))
1099 || detect_type_change (op, base, call, jfunc, offset))
1102 ipa_set_jf_known_type (jfunc, offset, TREE_TYPE (base), TREE_TYPE (op));
1105 /* Inspect the given TYPE and return true iff it has the same structure (the
1106 same number of fields of the same types) as a C++ member pointer. If
1107 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1108 corresponding fields there. */
1111 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
1115 if (TREE_CODE (type) != RECORD_TYPE)
1118 fld = TYPE_FIELDS (type);
1119 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
1120 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE
1121 || !host_integerp (DECL_FIELD_OFFSET (fld), 1))
1127 fld = DECL_CHAIN (fld);
1128 if (!fld || INTEGRAL_TYPE_P (fld)
1129 || !host_integerp (DECL_FIELD_OFFSET (fld), 1))
1134 if (DECL_CHAIN (fld))
1140 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1141 return the rhs of its defining statement. Otherwise return RHS as it
1145 get_ssa_def_if_simple_copy (tree rhs)
1147 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
1149 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
1151 if (gimple_assign_single_p (def_stmt))
1152 rhs = gimple_assign_rhs1 (def_stmt);
1159 /* Simple linked list, describing known contents of an aggregate beforere
1162 struct ipa_known_agg_contents_list
1164 /* Offset and size of the described part of the aggregate. */
1165 HOST_WIDE_INT offset, size;
1166 /* Known constant value or NULL if the contents is known to be unknown. */
1168 /* Pointer to the next structure in the list. */
1169 struct ipa_known_agg_contents_list *next;
1172 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1173 in ARG is filled in with constant values. ARG can either be an aggregate
1174 expression or a pointer to an aggregate. JFUNC is the jump function into
1175 which the constants are subsequently stored. */
1178 determine_known_aggregate_parts (gimple call, tree arg,
1179 struct ipa_jump_func *jfunc)
1181 struct ipa_known_agg_contents_list *list = NULL;
1182 int item_count = 0, const_count = 0;
1183 HOST_WIDE_INT arg_offset, arg_size;
1184 gimple_stmt_iterator gsi;
1186 bool check_ref, by_ref;
1189 /* The function operates in three stages. First, we prepare check_ref, r,
1190 arg_base and arg_offset based on what is actually passed as an actual
1193 if (POINTER_TYPE_P (TREE_TYPE (arg)))
1196 if (TREE_CODE (arg) == SSA_NAME)
1199 if (!host_integerp (TYPE_SIZE (TREE_TYPE (TREE_TYPE (arg))), 1))
1204 type_size = TYPE_SIZE (TREE_TYPE (TREE_TYPE (arg)));
1205 arg_size = tree_low_cst (type_size, 1);
1206 ao_ref_init_from_ptr_and_size (&r, arg_base, NULL_TREE);
1208 else if (TREE_CODE (arg) == ADDR_EXPR)
1210 HOST_WIDE_INT arg_max_size;
1212 arg = TREE_OPERAND (arg, 0);
1213 arg_base = get_ref_base_and_extent (arg, &arg_offset, &arg_size,
1215 if (arg_max_size == -1
1216 || arg_max_size != arg_size
1219 if (DECL_P (arg_base))
1223 size = build_int_cst (integer_type_node, arg_size);
1224 ao_ref_init_from_ptr_and_size (&r, arg_base, size);
1234 HOST_WIDE_INT arg_max_size;
1236 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg)));
1240 arg_base = get_ref_base_and_extent (arg, &arg_offset, &arg_size,
1242 if (arg_max_size == -1
1243 || arg_max_size != arg_size
1247 ao_ref_init (&r, arg);
1250 /* Second stage walks back the BB, looks at individual statements and as long
1251 as it is confident of how the statements affect contents of the
1252 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1254 gsi = gsi_for_stmt (call);
1256 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
1258 struct ipa_known_agg_contents_list *n, **p;
1259 gimple stmt = gsi_stmt (gsi);
1260 HOST_WIDE_INT lhs_offset, lhs_size, lhs_max_size;
1261 tree lhs, rhs, lhs_base;
1262 bool partial_overlap;
1264 if (!stmt_may_clobber_ref_p_1 (stmt, &r))
1266 if (!gimple_assign_single_p (stmt))
1269 lhs = gimple_assign_lhs (stmt);
1270 rhs = gimple_assign_rhs1 (stmt);
1271 if (!is_gimple_reg_type (rhs)
1272 || TREE_CODE (lhs) == BIT_FIELD_REF
1273 || contains_bitfld_component_ref_p (lhs))
1276 lhs_base = get_ref_base_and_extent (lhs, &lhs_offset, &lhs_size,
1278 if (lhs_max_size == -1
1279 || lhs_max_size != lhs_size
1280 || (lhs_offset < arg_offset
1281 && lhs_offset + lhs_size > arg_offset)
1282 || (lhs_offset < arg_offset + arg_size
1283 && lhs_offset + lhs_size > arg_offset + arg_size))
1288 if (TREE_CODE (lhs_base) != MEM_REF
1289 || TREE_OPERAND (lhs_base, 0) != arg_base
1290 || !integer_zerop (TREE_OPERAND (lhs_base, 1)))
1293 else if (lhs_base != arg_base)
1295 if (DECL_P (lhs_base))
1301 if (lhs_offset + lhs_size < arg_offset
1302 || lhs_offset >= (arg_offset + arg_size))
1305 partial_overlap = false;
1307 while (*p && (*p)->offset < lhs_offset)
1309 if ((*p)->offset + (*p)->size > lhs_offset)
1311 partial_overlap = true;
1316 if (partial_overlap)
1318 if (*p && (*p)->offset < lhs_offset + lhs_size)
1320 if ((*p)->offset == lhs_offset && (*p)->size == lhs_size)
1321 /* We already know this value is subsequently overwritten with
1325 /* Otherwise this is a partial overlap which we cannot
1330 rhs = get_ssa_def_if_simple_copy (rhs);
1331 n = XALLOCA (struct ipa_known_agg_contents_list);
1333 n->offset = lhs_offset;
1334 if (is_gimple_ip_invariant (rhs))
1340 n->constant = NULL_TREE;
1345 if (const_count == PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS)
1346 || item_count == 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS))
1350 /* Third stage just goes over the list and creates an appropriate vector of
1351 ipa_agg_jf_item structures out of it, of sourse only if there are
1352 any known constants to begin with. */
1356 jfunc->agg.by_ref = by_ref;
1357 vec_alloc (jfunc->agg.items, const_count);
1362 struct ipa_agg_jf_item item;
1363 item.offset = list->offset - arg_offset;
1364 gcc_assert ((item.offset % BITS_PER_UNIT) == 0);
1365 item.value = unshare_expr_without_location (list->constant);
1366 jfunc->agg.items->quick_push (item);
1373 /* Compute jump function for all arguments of callsite CS and insert the
1374 information in the jump_functions array in the ipa_edge_args corresponding
1375 to this callsite. */
1378 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_ainfo,
1379 struct cgraph_edge *cs)
1381 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
1382 struct ipa_edge_args *args = IPA_EDGE_REF (cs);
1383 gimple call = cs->call_stmt;
1384 int n, arg_num = gimple_call_num_args (call);
1386 if (arg_num == 0 || args->jump_functions)
1388 vec_safe_grow_cleared (args->jump_functions, arg_num);
1390 for (n = 0; n < arg_num; n++)
1392 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, n);
1393 tree arg = gimple_call_arg (call, n);
1395 if (is_gimple_ip_invariant (arg))
1396 ipa_set_jf_constant (jfunc, arg);
1397 else if (!is_gimple_reg_type (TREE_TYPE (arg))
1398 && TREE_CODE (arg) == PARM_DECL)
1400 int index = ipa_get_param_decl_index (info, arg);
1402 gcc_assert (index >=0);
1403 /* Aggregate passed by value, check for pass-through, otherwise we
1404 will attempt to fill in aggregate contents later in this
1406 if (parm_preserved_before_stmt_p (&parms_ainfo[index], call, arg))
1408 ipa_set_jf_simple_pass_through (jfunc, index, false);
1412 else if (TREE_CODE (arg) == SSA_NAME)
1414 if (SSA_NAME_IS_DEFAULT_DEF (arg))
1416 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
1418 && !detect_type_change_ssa (arg, call, jfunc))
1421 agg_p = parm_ref_data_pass_through_p (&parms_ainfo[index],
1423 ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
1428 gimple stmt = SSA_NAME_DEF_STMT (arg);
1429 if (is_gimple_assign (stmt))
1430 compute_complex_assign_jump_func (info, parms_ainfo, jfunc,
1432 else if (gimple_code (stmt) == GIMPLE_PHI)
1433 compute_complex_ancestor_jump_func (info, parms_ainfo, jfunc,
1438 compute_known_type_jump_func (arg, jfunc, call);
1440 if ((jfunc->type != IPA_JF_PASS_THROUGH
1441 || !ipa_get_jf_pass_through_agg_preserved (jfunc))
1442 && (jfunc->type != IPA_JF_ANCESTOR
1443 || !ipa_get_jf_ancestor_agg_preserved (jfunc))
1444 && (AGGREGATE_TYPE_P (TREE_TYPE (arg))
1445 || (POINTER_TYPE_P (TREE_TYPE (arg)))))
1446 determine_known_aggregate_parts (call, arg, jfunc);
1450 /* Compute jump functions for all edges - both direct and indirect - outgoing
1451 from NODE. Also count the actual arguments in the process. */
1454 ipa_compute_jump_functions (struct cgraph_node *node,
1455 struct param_analysis_info *parms_ainfo)
1457 struct cgraph_edge *cs;
1459 for (cs = node->callees; cs; cs = cs->next_callee)
1461 struct cgraph_node *callee = cgraph_function_or_thunk_node (cs->callee,
1463 /* We do not need to bother analyzing calls to unknown
1464 functions unless they may become known during lto/whopr. */
1465 if (!callee->analyzed && !flag_lto)
1467 ipa_compute_jump_functions_for_edge (parms_ainfo, cs);
1470 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
1471 ipa_compute_jump_functions_for_edge (parms_ainfo, cs);
1474 /* If STMT looks like a statement loading a value from a member pointer formal
1475 parameter, return that parameter and store the offset of the field to
1476 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1477 might be clobbered). If USE_DELTA, then we look for a use of the delta
1478 field rather than the pfn. */
1481 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta,
1482 HOST_WIDE_INT *offset_p)
1484 tree rhs, rec, ref_field, ref_offset, fld, ptr_field, delta_field;
1486 if (!gimple_assign_single_p (stmt))
1489 rhs = gimple_assign_rhs1 (stmt);
1490 if (TREE_CODE (rhs) == COMPONENT_REF)
1492 ref_field = TREE_OPERAND (rhs, 1);
1493 rhs = TREE_OPERAND (rhs, 0);
1496 ref_field = NULL_TREE;
1497 if (TREE_CODE (rhs) != MEM_REF)
1499 rec = TREE_OPERAND (rhs, 0);
1500 if (TREE_CODE (rec) != ADDR_EXPR)
1502 rec = TREE_OPERAND (rec, 0);
1503 if (TREE_CODE (rec) != PARM_DECL
1504 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
1506 ref_offset = TREE_OPERAND (rhs, 1);
1513 *offset_p = int_bit_position (fld);
1517 if (integer_nonzerop (ref_offset))
1519 return ref_field == fld ? rec : NULL_TREE;
1522 return tree_int_cst_equal (byte_position (fld), ref_offset) ? rec
1526 /* Returns true iff T is an SSA_NAME defined by a statement. */
1529 ipa_is_ssa_with_stmt_def (tree t)
1531 if (TREE_CODE (t) == SSA_NAME
1532 && !SSA_NAME_IS_DEFAULT_DEF (t))
1538 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1539 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1540 indirect call graph edge. */
1542 static struct cgraph_edge *
1543 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
1545 struct cgraph_edge *cs;
1547 cs = cgraph_edge (node, stmt);
1548 cs->indirect_info->param_index = param_index;
1549 cs->indirect_info->offset = 0;
1550 cs->indirect_info->polymorphic = 0;
1551 cs->indirect_info->agg_contents = 0;
1555 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1556 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1557 intermediate information about each formal parameter. Currently it checks
1558 whether the call calls a pointer that is a formal parameter and if so, the
1559 parameter is marked with the called flag and an indirect call graph edge
1560 describing the call is created. This is very simple for ordinary pointers
1561 represented in SSA but not-so-nice when it comes to member pointers. The
1562 ugly part of this function does nothing more than trying to match the
1563 pattern of such a call. An example of such a pattern is the gimple dump
1564 below, the call is on the last line:
1567 f$__delta_5 = f.__delta;
1568 f$__pfn_24 = f.__pfn;
1572 f$__delta_5 = MEM[(struct *)&f];
1573 f$__pfn_24 = MEM[(struct *)&f + 4B];
1575 and a few lines below:
1578 D.2496_3 = (int) f$__pfn_24;
1579 D.2497_4 = D.2496_3 & 1;
1586 D.2500_7 = (unsigned int) f$__delta_5;
1587 D.2501_8 = &S + D.2500_7;
1588 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1589 D.2503_10 = *D.2502_9;
1590 D.2504_12 = f$__pfn_24 + -1;
1591 D.2505_13 = (unsigned int) D.2504_12;
1592 D.2506_14 = D.2503_10 + D.2505_13;
1593 D.2507_15 = *D.2506_14;
1594 iftmp.11_16 = (String:: *) D.2507_15;
1597 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1598 D.2500_19 = (unsigned int) f$__delta_5;
1599 D.2508_20 = &S + D.2500_19;
1600 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1602 Such patterns are results of simple calls to a member pointer:
1604 int doprinting (int (MyString::* f)(int) const)
1606 MyString S ("somestring");
1611 Moreover, the function also looks for called pointers loaded from aggregates
1612 passed by value or reference. */
1615 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1616 struct ipa_node_params *info,
1617 struct param_analysis_info *parms_ainfo,
1618 gimple call, tree target)
1623 tree rec, rec2, cond;
1626 basic_block bb, virt_bb, join;
1627 HOST_WIDE_INT offset;
1630 if (SSA_NAME_IS_DEFAULT_DEF (target))
1632 tree var = SSA_NAME_VAR (target);
1633 index = ipa_get_param_decl_index (info, var);
1635 ipa_note_param_call (node, index, call);
1639 def = SSA_NAME_DEF_STMT (target);
1640 if (gimple_assign_single_p (def)
1641 && ipa_load_from_parm_agg_1 (info->descriptors, parms_ainfo, def,
1642 gimple_assign_rhs1 (def), &index, &offset,
1645 struct cgraph_edge *cs = ipa_note_param_call (node, index, call);
1646 cs->indirect_info->offset = offset;
1647 cs->indirect_info->agg_contents = 1;
1648 cs->indirect_info->by_ref = by_ref;
1652 /* Now we need to try to match the complex pattern of calling a member
1654 if (gimple_code (def) != GIMPLE_PHI
1655 || gimple_phi_num_args (def) != 2
1656 || !POINTER_TYPE_P (TREE_TYPE (target))
1657 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1660 /* First, we need to check whether one of these is a load from a member
1661 pointer that is a parameter to this function. */
1662 n1 = PHI_ARG_DEF (def, 0);
1663 n2 = PHI_ARG_DEF (def, 1);
1664 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1666 d1 = SSA_NAME_DEF_STMT (n1);
1667 d2 = SSA_NAME_DEF_STMT (n2);
1669 join = gimple_bb (def);
1670 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false, &offset)))
1672 if (ipa_get_stmt_member_ptr_load_param (d2, false, NULL))
1675 bb = EDGE_PRED (join, 0)->src;
1676 virt_bb = gimple_bb (d2);
1678 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false, &offset)))
1680 bb = EDGE_PRED (join, 1)->src;
1681 virt_bb = gimple_bb (d1);
1686 /* Second, we need to check that the basic blocks are laid out in the way
1687 corresponding to the pattern. */
1689 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1690 || single_pred (virt_bb) != bb
1691 || single_succ (virt_bb) != join)
1694 /* Third, let's see that the branching is done depending on the least
1695 significant bit of the pfn. */
1697 branch = last_stmt (bb);
1698 if (!branch || gimple_code (branch) != GIMPLE_COND)
1701 if ((gimple_cond_code (branch) != NE_EXPR
1702 && gimple_cond_code (branch) != EQ_EXPR)
1703 || !integer_zerop (gimple_cond_rhs (branch)))
1706 cond = gimple_cond_lhs (branch);
1707 if (!ipa_is_ssa_with_stmt_def (cond))
1710 def = SSA_NAME_DEF_STMT (cond);
1711 if (!is_gimple_assign (def)
1712 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1713 || !integer_onep (gimple_assign_rhs2 (def)))
1716 cond = gimple_assign_rhs1 (def);
1717 if (!ipa_is_ssa_with_stmt_def (cond))
1720 def = SSA_NAME_DEF_STMT (cond);
1722 if (is_gimple_assign (def)
1723 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1725 cond = gimple_assign_rhs1 (def);
1726 if (!ipa_is_ssa_with_stmt_def (cond))
1728 def = SSA_NAME_DEF_STMT (cond);
1731 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1732 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1733 == ptrmemfunc_vbit_in_delta),
1738 index = ipa_get_param_decl_index (info, rec);
1740 && parm_preserved_before_stmt_p (&parms_ainfo[index], call, rec))
1742 struct cgraph_edge *cs = ipa_note_param_call (node, index, call);
1743 cs->indirect_info->offset = offset;
1744 cs->indirect_info->agg_contents = 1;
1750 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1751 object referenced in the expression is a formal parameter of the caller
1752 (described by INFO), create a call note for the statement. */
1755 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1756 struct ipa_node_params *info, gimple call,
1759 struct cgraph_edge *cs;
1760 struct cgraph_indirect_call_info *ii;
1761 struct ipa_jump_func jfunc;
1762 tree obj = OBJ_TYPE_REF_OBJECT (target);
1764 HOST_WIDE_INT anc_offset;
1766 if (!flag_devirtualize)
1769 if (TREE_CODE (obj) != SSA_NAME)
1772 if (SSA_NAME_IS_DEFAULT_DEF (obj))
1774 if (TREE_CODE (SSA_NAME_VAR (obj)) != PARM_DECL)
1778 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (obj));
1779 gcc_assert (index >= 0);
1780 if (detect_type_change_ssa (obj, call, &jfunc))
1785 gimple stmt = SSA_NAME_DEF_STMT (obj);
1788 expr = get_ancestor_addr_info (stmt, &obj, &anc_offset);
1791 index = ipa_get_param_decl_index (info,
1792 SSA_NAME_VAR (TREE_OPERAND (expr, 0)));
1793 gcc_assert (index >= 0);
1794 if (detect_type_change (obj, expr, call, &jfunc, anc_offset))
1798 cs = ipa_note_param_call (node, index, call);
1799 ii = cs->indirect_info;
1800 ii->offset = anc_offset;
1801 ii->otr_token = tree_low_cst (OBJ_TYPE_REF_TOKEN (target), 1);
1802 ii->otr_type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target)));
1803 ii->polymorphic = 1;
1806 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1807 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
1808 containing intermediate information about each formal parameter. */
1811 ipa_analyze_call_uses (struct cgraph_node *node,
1812 struct ipa_node_params *info,
1813 struct param_analysis_info *parms_ainfo, gimple call)
1815 tree target = gimple_call_fn (call);
1819 if (TREE_CODE (target) == SSA_NAME)
1820 ipa_analyze_indirect_call_uses (node, info, parms_ainfo, call, target);
1821 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1822 ipa_analyze_virtual_call_uses (node, info, call, target);
1826 /* Analyze the call statement STMT with respect to formal parameters (described
1827 in INFO) of caller given by NODE. Currently it only checks whether formal
1828 parameters are called. PARMS_AINFO is a pointer to a vector containing
1829 intermediate information about each formal parameter. */
1832 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1833 struct param_analysis_info *parms_ainfo, gimple stmt)
1835 if (is_gimple_call (stmt))
1836 ipa_analyze_call_uses (node, info, parms_ainfo, stmt);
1839 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1840 If OP is a parameter declaration, mark it as used in the info structure
1844 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1845 tree op, void *data)
1847 struct ipa_node_params *info = (struct ipa_node_params *) data;
1849 op = get_base_address (op);
1851 && TREE_CODE (op) == PARM_DECL)
1853 int index = ipa_get_param_decl_index (info, op);
1854 gcc_assert (index >= 0);
1855 ipa_set_param_used (info, index, true);
1861 /* Scan the function body of NODE and inspect the uses of formal parameters.
1862 Store the findings in various structures of the associated ipa_node_params
1863 structure, such as parameter flags, notes etc. PARMS_AINFO is a pointer to a
1864 vector containing intermediate information about each formal parameter. */
1867 ipa_analyze_params_uses (struct cgraph_node *node,
1868 struct param_analysis_info *parms_ainfo)
1870 tree decl = node->symbol.decl;
1872 struct function *func;
1873 gimple_stmt_iterator gsi;
1874 struct ipa_node_params *info = IPA_NODE_REF (node);
1877 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1880 for (i = 0; i < ipa_get_param_count (info); i++)
1882 tree parm = ipa_get_param (info, i);
1884 /* For SSA regs see if parameter is used. For non-SSA we compute
1885 the flag during modification analysis. */
1886 if (is_gimple_reg (parm)
1887 && (ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->symbol.decl),
1889 && !has_zero_uses (ddef))
1890 ipa_set_param_used (info, i, true);
1893 func = DECL_STRUCT_FUNCTION (decl);
1894 FOR_EACH_BB_FN (bb, func)
1896 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1898 gimple stmt = gsi_stmt (gsi);
1900 if (is_gimple_debug (stmt))
1903 ipa_analyze_stmt_uses (node, info, parms_ainfo, stmt);
1904 walk_stmt_load_store_addr_ops (stmt, info,
1905 visit_ref_for_mod_analysis,
1906 visit_ref_for_mod_analysis,
1907 visit_ref_for_mod_analysis);
1909 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1910 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1911 visit_ref_for_mod_analysis,
1912 visit_ref_for_mod_analysis,
1913 visit_ref_for_mod_analysis);
1916 info->uses_analysis_done = 1;
1919 /* Free stuff in PARMS_AINFO, assume there are PARAM_COUNT parameters. */
1922 free_parms_ainfo (struct param_analysis_info *parms_ainfo, int param_count)
1926 for (i = 0; i < param_count; i++)
1928 if (parms_ainfo[i].parm_visited_statements)
1929 BITMAP_FREE (parms_ainfo[i].parm_visited_statements);
1930 if (parms_ainfo[i].pt_visited_statements)
1931 BITMAP_FREE (parms_ainfo[i].pt_visited_statements);
1935 /* Initialize the array describing properties of of formal parameters
1936 of NODE, analyze their uses and compute jump functions associated
1937 with actual arguments of calls from within NODE. */
1940 ipa_analyze_node (struct cgraph_node *node)
1942 struct ipa_node_params *info;
1943 struct param_analysis_info *parms_ainfo;
1946 ipa_check_create_node_params ();
1947 ipa_check_create_edge_args ();
1948 info = IPA_NODE_REF (node);
1949 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
1950 ipa_initialize_node_params (node);
1952 param_count = ipa_get_param_count (info);
1953 parms_ainfo = XALLOCAVEC (struct param_analysis_info, param_count);
1954 memset (parms_ainfo, 0, sizeof (struct param_analysis_info) * param_count);
1956 ipa_analyze_params_uses (node, parms_ainfo);
1957 ipa_compute_jump_functions (node, parms_ainfo);
1959 free_parms_ainfo (parms_ainfo, param_count);
1964 /* Update the jump function DST when the call graph edge corresponding to SRC is
1965 is being inlined, knowing that DST is of type ancestor and src of known
1969 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1970 struct ipa_jump_func *dst)
1972 HOST_WIDE_INT combined_offset;
1975 combined_offset = ipa_get_jf_known_type_offset (src)
1976 + ipa_get_jf_ancestor_offset (dst);
1977 combined_type = ipa_get_jf_ancestor_type (dst);
1979 ipa_set_jf_known_type (dst, combined_offset,
1980 ipa_get_jf_known_type_base_type (src),
1984 /* Update the jump functions associated with call graph edge E when the call
1985 graph edge CS is being inlined, assuming that E->caller is already (possibly
1986 indirectly) inlined into CS->callee and that E has not been inlined. */
1989 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1990 struct cgraph_edge *e)
1992 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1993 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1994 int count = ipa_get_cs_argument_count (args);
1997 for (i = 0; i < count; i++)
1999 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
2001 if (dst->type == IPA_JF_ANCESTOR)
2003 struct ipa_jump_func *src;
2004 int dst_fid = dst->value.ancestor.formal_id;
2006 /* Variable number of arguments can cause havoc if we try to access
2007 one that does not exist in the inlined edge. So make sure we
2009 if (dst_fid >= ipa_get_cs_argument_count (top))
2011 dst->type = IPA_JF_UNKNOWN;
2015 src = ipa_get_ith_jump_func (top, dst_fid);
2018 && (dst->value.ancestor.agg_preserved || !src->agg.by_ref))
2020 struct ipa_agg_jf_item *item;
2023 /* Currently we do not produce clobber aggregate jump functions,
2024 replace with merging when we do. */
2025 gcc_assert (!dst->agg.items);
2027 dst->agg.items = vec_safe_copy (src->agg.items);
2028 dst->agg.by_ref = src->agg.by_ref;
2029 FOR_EACH_VEC_SAFE_ELT (dst->agg.items, j, item)
2030 item->offset -= dst->value.ancestor.offset;
2033 if (src->type == IPA_JF_KNOWN_TYPE)
2034 combine_known_type_and_ancestor_jfs (src, dst);
2035 else if (src->type == IPA_JF_PASS_THROUGH
2036 && src->value.pass_through.operation == NOP_EXPR)
2038 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
2039 dst->value.ancestor.agg_preserved &=
2040 src->value.pass_through.agg_preserved;
2042 else if (src->type == IPA_JF_ANCESTOR)
2044 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
2045 dst->value.ancestor.offset += src->value.ancestor.offset;
2046 dst->value.ancestor.agg_preserved &=
2047 src->value.ancestor.agg_preserved;
2050 dst->type = IPA_JF_UNKNOWN;
2052 else if (dst->type == IPA_JF_PASS_THROUGH)
2054 struct ipa_jump_func *src;
2055 /* We must check range due to calls with variable number of arguments
2056 and we cannot combine jump functions with operations. */
2057 if (dst->value.pass_through.operation == NOP_EXPR
2058 && (dst->value.pass_through.formal_id
2059 < ipa_get_cs_argument_count (top)))
2062 int dst_fid = dst->value.pass_through.formal_id;
2063 src = ipa_get_ith_jump_func (top, dst_fid);
2064 agg_p = dst->value.pass_through.agg_preserved;
2066 dst->type = src->type;
2067 dst->value = src->value;
2070 && (agg_p || !src->agg.by_ref))
2072 /* Currently we do not produce clobber aggregate jump
2073 functions, replace with merging when we do. */
2074 gcc_assert (!dst->agg.items);
2076 dst->agg.by_ref = src->agg.by_ref;
2077 dst->agg.items = vec_safe_copy (src->agg.items);
2082 if (dst->type == IPA_JF_PASS_THROUGH)
2083 dst->value.pass_through.agg_preserved = false;
2084 else if (dst->type == IPA_JF_ANCESTOR)
2085 dst->value.ancestor.agg_preserved = false;
2089 dst->type = IPA_JF_UNKNOWN;
2094 /* If TARGET is an addr_expr of a function declaration, make it the destination
2095 of an indirect edge IE and return the edge. Otherwise, return NULL. */
2097 struct cgraph_edge *
2098 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
2100 struct cgraph_node *callee;
2101 struct inline_edge_summary *es = inline_edge_summary (ie);
2103 if (TREE_CODE (target) == ADDR_EXPR)
2104 target = TREE_OPERAND (target, 0);
2105 if (TREE_CODE (target) != FUNCTION_DECL)
2107 target = canonicalize_constructor_val (target, NULL);
2108 if (!target || TREE_CODE (target) != FUNCTION_DECL)
2111 fprintf (dump_file, "ipa-prop: Discovered direct call to non-function"
2113 cgraph_node_name (ie->caller), ie->caller->uid);
2117 callee = cgraph_get_node (target);
2119 /* Because may-edges are not explicitely represented and vtable may be external,
2120 we may create the first reference to the object in the unit. */
2121 if (!callee || callee->global.inlined_to)
2123 struct cgraph_node *first_clone = callee;
2125 /* We are better to ensure we can refer to it.
2126 In the case of static functions we are out of luck, since we already
2127 removed its body. In the case of public functions we may or may
2128 not introduce the reference. */
2129 if (!canonicalize_constructor_val (target, NULL)
2130 || !TREE_PUBLIC (target))
2133 fprintf (dump_file, "ipa-prop: Discovered call to a known target "
2134 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2135 xstrdup (cgraph_node_name (ie->caller)), ie->caller->uid,
2136 xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid);
2140 /* Create symbol table node. Even if inline clone exists, we can not take
2141 it as a target of non-inlined call. */
2142 callee = cgraph_create_node (target);
2144 /* OK, we previously inlined the function, then removed the offline copy and
2145 now we want it back for external call. This can happen when devirtualizing
2146 while inlining function called once that happens after extern inlined and
2147 virtuals are already removed. In this case introduce the external node
2148 and make it available for call. */
2151 first_clone->clone_of = callee;
2152 callee->clones = first_clone;
2153 symtab_prevail_in_asm_name_hash ((symtab_node)callee);
2154 symtab_insert_node_to_hashtable ((symtab_node)callee);
2156 fprintf (dump_file, "ipa-prop: Introduced new external node "
2157 "(%s/%i) and turned into root of the clone tree.\n",
2158 xstrdup (cgraph_node_name (callee)), callee->uid);
2161 fprintf (dump_file, "ipa-prop: Introduced new external node "
2163 xstrdup (cgraph_node_name (callee)), callee->uid);
2165 ipa_check_create_node_params ();
2167 /* We can not make edges to inline clones. It is bug that someone removed
2168 the cgraph node too early. */
2169 gcc_assert (!callee->global.inlined_to);
2171 cgraph_make_edge_direct (ie, callee);
2172 es = inline_edge_summary (ie);
2173 es->call_stmt_size -= (eni_size_weights.indirect_call_cost
2174 - eni_size_weights.call_cost);
2175 es->call_stmt_time -= (eni_time_weights.indirect_call_cost
2176 - eni_time_weights.call_cost);
2179 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
2180 "(%s/%i -> %s/%i), for stmt ",
2181 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
2182 xstrdup (cgraph_node_name (ie->caller)), ie->caller->uid,
2183 xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid);
2185 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
2187 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
2189 callee = cgraph_function_or_thunk_node (callee, NULL);
2194 /* Retrieve value from aggregate jump function AGG for the given OFFSET or
2195 return NULL if there is not any. BY_REF specifies whether the value has to
2196 be passed by reference or by value. */
2199 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *agg,
2200 HOST_WIDE_INT offset, bool by_ref)
2202 struct ipa_agg_jf_item *item;
2205 if (by_ref != agg->by_ref)
2208 FOR_EACH_VEC_SAFE_ELT (agg->items, i, item)
2209 if (item->offset == offset)
2211 /* Currently we do not have clobber values, return NULL for them once
2213 gcc_checking_assert (is_gimple_ip_invariant (item->value));
2219 /* Try to find a destination for indirect edge IE that corresponds to a simple
2220 call or a call of a member function pointer and where the destination is a
2221 pointer formal parameter described by jump function JFUNC. If it can be
2222 determined, return the newly direct edge, otherwise return NULL.
2223 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
2225 static struct cgraph_edge *
2226 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
2227 struct ipa_jump_func *jfunc,
2228 struct ipa_node_params *new_root_info)
2232 if (ie->indirect_info->agg_contents)
2233 target = ipa_find_agg_cst_for_param (&jfunc->agg,
2234 ie->indirect_info->offset,
2235 ie->indirect_info->by_ref);
2237 target = ipa_value_from_jfunc (new_root_info, jfunc);
2240 return ipa_make_edge_direct_to_target (ie, target);
2243 /* Try to find a destination for indirect edge IE that corresponds to a virtual
2244 call based on a formal parameter which is described by jump function JFUNC
2245 and if it can be determined, make it direct and return the direct edge.
2246 Otherwise, return NULL. NEW_ROOT_INFO is the node info that JFUNC lattices
2249 static struct cgraph_edge *
2250 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
2251 struct ipa_jump_func *jfunc,
2252 struct ipa_node_params *new_root_info)
2256 binfo = ipa_value_from_jfunc (new_root_info, jfunc);
2261 if (TREE_CODE (binfo) != TREE_BINFO)
2263 binfo = gimple_extract_devirt_binfo_from_cst (binfo);
2268 binfo = get_binfo_at_offset (binfo, ie->indirect_info->offset,
2269 ie->indirect_info->otr_type);
2271 target = gimple_get_virt_method_for_binfo (ie->indirect_info->otr_token,
2277 return ipa_make_edge_direct_to_target (ie, target);
2282 /* Update the param called notes associated with NODE when CS is being inlined,
2283 assuming NODE is (potentially indirectly) inlined into CS->callee.
2284 Moreover, if the callee is discovered to be constant, create a new cgraph
2285 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
2286 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
2289 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
2290 struct cgraph_node *node,
2291 vec<cgraph_edge_p> *new_edges)
2293 struct ipa_edge_args *top;
2294 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
2295 struct ipa_node_params *new_root_info;
2298 ipa_check_create_edge_args ();
2299 top = IPA_EDGE_REF (cs);
2300 new_root_info = IPA_NODE_REF (cs->caller->global.inlined_to
2301 ? cs->caller->global.inlined_to
2304 for (ie = node->indirect_calls; ie; ie = next_ie)
2306 struct cgraph_indirect_call_info *ici = ie->indirect_info;
2307 struct ipa_jump_func *jfunc;
2310 next_ie = ie->next_callee;
2312 if (ici->param_index == -1)
2315 /* We must check range due to calls with variable number of arguments: */
2316 if (ici->param_index >= ipa_get_cs_argument_count (top))
2318 ici->param_index = -1;
2322 param_index = ici->param_index;
2323 jfunc = ipa_get_ith_jump_func (top, param_index);
2325 if (!flag_indirect_inlining)
2326 new_direct_edge = NULL;
2327 else if (ici->polymorphic)
2328 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc,
2331 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc,
2333 if (new_direct_edge)
2335 new_direct_edge->indirect_inlining_edge = 1;
2336 if (new_direct_edge->call_stmt)
2337 new_direct_edge->call_stmt_cannot_inline_p
2338 = !gimple_check_call_matching_types (new_direct_edge->call_stmt,
2339 new_direct_edge->callee->symbol.decl);
2342 new_edges->safe_push (new_direct_edge);
2343 top = IPA_EDGE_REF (cs);
2347 else if (jfunc->type == IPA_JF_PASS_THROUGH
2348 && ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
2350 if (ici->agg_contents
2351 && !ipa_get_jf_pass_through_agg_preserved (jfunc))
2352 ici->param_index = -1;
2354 ici->param_index = ipa_get_jf_pass_through_formal_id (jfunc);
2356 else if (jfunc->type == IPA_JF_ANCESTOR)
2358 if (ici->agg_contents
2359 && !ipa_get_jf_ancestor_agg_preserved (jfunc))
2360 ici->param_index = -1;
2363 ici->param_index = ipa_get_jf_ancestor_formal_id (jfunc);
2364 ici->offset += ipa_get_jf_ancestor_offset (jfunc);
2368 /* Either we can find a destination for this edge now or never. */
2369 ici->param_index = -1;
2375 /* Recursively traverse subtree of NODE (including node) made of inlined
2376 cgraph_edges when CS has been inlined and invoke
2377 update_indirect_edges_after_inlining on all nodes and
2378 update_jump_functions_after_inlining on all non-inlined edges that lead out
2379 of this subtree. Newly discovered indirect edges will be added to
2380 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
2384 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
2385 struct cgraph_node *node,
2386 vec<cgraph_edge_p> *new_edges)
2388 struct cgraph_edge *e;
2391 res = update_indirect_edges_after_inlining (cs, node, new_edges);
2393 for (e = node->callees; e; e = e->next_callee)
2394 if (!e->inline_failed)
2395 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
2397 update_jump_functions_after_inlining (cs, e);
2398 for (e = node->indirect_calls; e; e = e->next_callee)
2399 update_jump_functions_after_inlining (cs, e);
2404 /* Update jump functions and call note functions on inlining the call site CS.
2405 CS is expected to lead to a node already cloned by
2406 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
2407 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
2411 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
2412 vec<cgraph_edge_p> *new_edges)
2415 /* Do nothing if the preparation phase has not been carried out yet
2416 (i.e. during early inlining). */
2417 if (!ipa_node_params_vector.exists ())
2419 gcc_assert (ipa_edge_args_vector);
2421 changed = propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
2423 /* We do not keep jump functions of inlined edges up to date. Better to free
2424 them so we do not access them accidentally. */
2425 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
2429 /* Frees all dynamically allocated structures that the argument info points
2433 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
2435 vec_free (args->jump_functions);
2436 memset (args, 0, sizeof (*args));
2439 /* Free all ipa_edge structures. */
2442 ipa_free_all_edge_args (void)
2445 struct ipa_edge_args *args;
2447 if (!ipa_edge_args_vector)
2450 FOR_EACH_VEC_ELT (*ipa_edge_args_vector, i, args)
2451 ipa_free_edge_args_substructures (args);
2453 vec_free (ipa_edge_args_vector);
2456 /* Frees all dynamically allocated structures that the param info points
2460 ipa_free_node_params_substructures (struct ipa_node_params *info)
2462 info->descriptors.release ();
2463 free (info->lattices);
2464 /* Lattice values and their sources are deallocated with their alocation
2466 info->known_vals.release ();
2467 memset (info, 0, sizeof (*info));
2470 /* Free all ipa_node_params structures. */
2473 ipa_free_all_node_params (void)
2476 struct ipa_node_params *info;
2478 FOR_EACH_VEC_ELT (ipa_node_params_vector, i, info)
2479 ipa_free_node_params_substructures (info);
2481 ipa_node_params_vector.release ();
2484 /* Set the aggregate replacements of NODE to be AGGVALS. */
2487 ipa_set_node_agg_value_chain (struct cgraph_node *node,
2488 struct ipa_agg_replacement_value *aggvals)
2490 if (vec_safe_length (ipa_node_agg_replacements) <= (unsigned) cgraph_max_uid)
2491 vec_safe_grow_cleared (ipa_node_agg_replacements, cgraph_max_uid + 1);
2493 (*ipa_node_agg_replacements)[node->uid] = aggvals;
2496 /* Hook that is called by cgraph.c when an edge is removed. */
2499 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
2501 /* During IPA-CP updating we can be called on not-yet analyze clones. */
2502 if (vec_safe_length (ipa_edge_args_vector) <= (unsigned)cs->uid)
2504 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
2507 /* Hook that is called by cgraph.c when a node is removed. */
2510 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
2512 /* During IPA-CP updating we can be called on not-yet analyze clones. */
2513 if (ipa_node_params_vector.length () > (unsigned)node->uid)
2514 ipa_free_node_params_substructures (IPA_NODE_REF (node));
2515 if (vec_safe_length (ipa_node_agg_replacements) > (unsigned)node->uid)
2516 (*ipa_node_agg_replacements)[(unsigned)node->uid] = NULL;
2519 /* Hook that is called by cgraph.c when an edge is duplicated. */
2522 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
2523 __attribute__((unused)) void *data)
2525 struct ipa_edge_args *old_args, *new_args;
2528 ipa_check_create_edge_args ();
2530 old_args = IPA_EDGE_REF (src);
2531 new_args = IPA_EDGE_REF (dst);
2533 new_args->jump_functions = vec_safe_copy (old_args->jump_functions);
2535 for (i = 0; i < vec_safe_length (old_args->jump_functions); i++)
2536 (*new_args->jump_functions)[i].agg.items
2537 = vec_safe_copy ((*old_args->jump_functions)[i].agg.items);
2540 /* Hook that is called by cgraph.c when a node is duplicated. */
2543 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
2544 ATTRIBUTE_UNUSED void *data)
2546 struct ipa_node_params *old_info, *new_info;
2547 struct ipa_agg_replacement_value *old_av, *new_av;
2549 ipa_check_create_node_params ();
2550 old_info = IPA_NODE_REF (src);
2551 new_info = IPA_NODE_REF (dst);
2553 new_info->descriptors = old_info->descriptors.copy ();
2554 new_info->lattices = NULL;
2555 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
2557 new_info->uses_analysis_done = old_info->uses_analysis_done;
2558 new_info->node_enqueued = old_info->node_enqueued;
2560 old_av = ipa_get_agg_replacements_for_node (src);
2567 struct ipa_agg_replacement_value *v;
2569 v = ggc_alloc_ipa_agg_replacement_value ();
2570 memcpy (v, old_av, sizeof (*v));
2573 old_av = old_av->next;
2575 ipa_set_node_agg_value_chain (dst, new_av);
2579 /* Analyze newly added function into callgraph. */
2582 ipa_add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
2584 ipa_analyze_node (node);
2587 /* Register our cgraph hooks if they are not already there. */
2590 ipa_register_cgraph_hooks (void)
2592 if (!edge_removal_hook_holder)
2593 edge_removal_hook_holder =
2594 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
2595 if (!node_removal_hook_holder)
2596 node_removal_hook_holder =
2597 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
2598 if (!edge_duplication_hook_holder)
2599 edge_duplication_hook_holder =
2600 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
2601 if (!node_duplication_hook_holder)
2602 node_duplication_hook_holder =
2603 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
2604 function_insertion_hook_holder =
2605 cgraph_add_function_insertion_hook (&ipa_add_new_function, NULL);
2608 /* Unregister our cgraph hooks if they are not already there. */
2611 ipa_unregister_cgraph_hooks (void)
2613 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
2614 edge_removal_hook_holder = NULL;
2615 cgraph_remove_node_removal_hook (node_removal_hook_holder);
2616 node_removal_hook_holder = NULL;
2617 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
2618 edge_duplication_hook_holder = NULL;
2619 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
2620 node_duplication_hook_holder = NULL;
2621 cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
2622 function_insertion_hook_holder = NULL;
2625 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2626 longer needed after ipa-cp. */
2629 ipa_free_all_structures_after_ipa_cp (void)
2633 ipa_free_all_edge_args ();
2634 ipa_free_all_node_params ();
2635 free_alloc_pool (ipcp_sources_pool);
2636 free_alloc_pool (ipcp_values_pool);
2637 free_alloc_pool (ipcp_agg_lattice_pool);
2638 ipa_unregister_cgraph_hooks ();
2642 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2643 longer needed after indirect inlining. */
2646 ipa_free_all_structures_after_iinln (void)
2648 ipa_free_all_edge_args ();
2649 ipa_free_all_node_params ();
2650 ipa_unregister_cgraph_hooks ();
2651 if (ipcp_sources_pool)
2652 free_alloc_pool (ipcp_sources_pool);
2653 if (ipcp_values_pool)
2654 free_alloc_pool (ipcp_values_pool);
2655 if (ipcp_agg_lattice_pool)
2656 free_alloc_pool (ipcp_agg_lattice_pool);
2659 /* Print ipa_tree_map data structures of all functions in the
2663 ipa_print_node_params (FILE *f, struct cgraph_node *node)
2667 struct ipa_node_params *info;
2669 if (!node->analyzed)
2671 info = IPA_NODE_REF (node);
2672 fprintf (f, " function %s parameter descriptors:\n",
2673 cgraph_node_name (node));
2674 count = ipa_get_param_count (info);
2675 for (i = 0; i < count; i++)
2677 temp = ipa_get_param (info, i);
2678 if (TREE_CODE (temp) == PARM_DECL)
2679 fprintf (f, " param %d : %s", i,
2681 ? (*lang_hooks.decl_printable_name) (temp, 2)
2683 if (ipa_is_param_used (info, i))
2684 fprintf (f, " used");
2689 /* Print ipa_tree_map data structures of all functions in the
2693 ipa_print_all_params (FILE * f)
2695 struct cgraph_node *node;
2697 fprintf (f, "\nFunction parameters:\n");
2698 FOR_EACH_FUNCTION (node)
2699 ipa_print_node_params (f, node);
2702 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2705 ipa_get_vector_of_formal_parms (tree fndecl)
2711 count = count_formal_params (fndecl);
2712 args.create (count);
2713 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
2714 args.quick_push (parm);
2719 /* Return a heap allocated vector containing types of formal parameters of
2720 function type FNTYPE. */
2722 static inline vec<tree>
2723 get_vector_of_formal_parm_types (tree fntype)
2729 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2732 types.create (count);
2733 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2734 types.quick_push (TREE_VALUE (t));
2739 /* Modify the function declaration FNDECL and its type according to the plan in
2740 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2741 to reflect the actual parameters being modified which are determined by the
2742 base_index field. */
2745 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
2746 const char *synth_parm_prefix)
2748 vec<tree> oparms, otypes;
2749 tree orig_type, new_type = NULL;
2750 tree old_arg_types, t, new_arg_types = NULL;
2751 tree parm, *link = &DECL_ARGUMENTS (fndecl);
2752 int i, len = adjustments.length ();
2753 tree new_reversed = NULL;
2754 bool care_for_types, last_parm_void;
2756 if (!synth_parm_prefix)
2757 synth_parm_prefix = "SYNTH";
2759 oparms = ipa_get_vector_of_formal_parms (fndecl);
2760 orig_type = TREE_TYPE (fndecl);
2761 old_arg_types = TYPE_ARG_TYPES (orig_type);
2763 /* The following test is an ugly hack, some functions simply don't have any
2764 arguments in their type. This is probably a bug but well... */
2765 care_for_types = (old_arg_types != NULL_TREE);
2768 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
2770 otypes = get_vector_of_formal_parm_types (orig_type);
2772 gcc_assert (oparms.length () + 1 == otypes.length ());
2774 gcc_assert (oparms.length () == otypes.length ());
2778 last_parm_void = false;
2782 for (i = 0; i < len; i++)
2784 struct ipa_parm_adjustment *adj;
2787 adj = &adjustments[i];
2788 parm = oparms[adj->base_index];
2791 if (adj->copy_param)
2794 new_arg_types = tree_cons (NULL_TREE, otypes[adj->base_index],
2797 link = &DECL_CHAIN (parm);
2799 else if (!adj->remove_param)
2805 ptype = build_pointer_type (adj->type);
2810 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2812 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2814 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2816 DECL_ARTIFICIAL (new_parm) = 1;
2817 DECL_ARG_TYPE (new_parm) = ptype;
2818 DECL_CONTEXT (new_parm) = fndecl;
2819 TREE_USED (new_parm) = 1;
2820 DECL_IGNORED_P (new_parm) = 1;
2821 layout_decl (new_parm, 0);
2824 adj->reduction = new_parm;
2828 link = &DECL_CHAIN (new_parm);
2836 new_reversed = nreverse (new_arg_types);
2840 TREE_CHAIN (new_arg_types) = void_list_node;
2842 new_reversed = void_list_node;
2846 /* Use copy_node to preserve as much as possible from original type
2847 (debug info, attribute lists etc.)
2848 Exception is METHOD_TYPEs must have THIS argument.
2849 When we are asked to remove it, we need to build new FUNCTION_TYPE
2851 if (TREE_CODE (orig_type) != METHOD_TYPE
2852 || (adjustments[0].copy_param
2853 && adjustments[0].base_index == 0))
2855 new_type = build_distinct_type_copy (orig_type);
2856 TYPE_ARG_TYPES (new_type) = new_reversed;
2861 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2863 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2864 DECL_VINDEX (fndecl) = NULL_TREE;
2867 /* When signature changes, we need to clear builtin info. */
2868 if (DECL_BUILT_IN (fndecl))
2870 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2871 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2874 /* This is a new type, not a copy of an old type. Need to reassociate
2875 variants. We can handle everything except the main variant lazily. */
2876 t = TYPE_MAIN_VARIANT (orig_type);
2879 TYPE_MAIN_VARIANT (new_type) = t;
2880 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2881 TYPE_NEXT_VARIANT (t) = new_type;
2885 TYPE_MAIN_VARIANT (new_type) = new_type;
2886 TYPE_NEXT_VARIANT (new_type) = NULL;
2889 TREE_TYPE (fndecl) = new_type;
2890 DECL_VIRTUAL_P (fndecl) = 0;
2895 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2896 If this is a directly recursive call, CS must be NULL. Otherwise it must
2897 contain the corresponding call graph edge. */
2900 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2901 ipa_parm_adjustment_vec adjustments)
2904 vec<tree, va_gc> **debug_args = NULL;
2906 gimple_stmt_iterator gsi;
2910 len = adjustments.length ();
2912 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->symbol.decl;
2914 gsi = gsi_for_stmt (stmt);
2915 for (i = 0; i < len; i++)
2917 struct ipa_parm_adjustment *adj;
2919 adj = &adjustments[i];
2921 if (adj->copy_param)
2923 tree arg = gimple_call_arg (stmt, adj->base_index);
2925 vargs.quick_push (arg);
2927 else if (!adj->remove_param)
2929 tree expr, base, off;
2931 unsigned int deref_align;
2932 bool deref_base = false;
2934 /* We create a new parameter out of the value of the old one, we can
2935 do the following kind of transformations:
2937 - A scalar passed by reference is converted to a scalar passed by
2938 value. (adj->by_ref is false and the type of the original
2939 actual argument is a pointer to a scalar).
2941 - A part of an aggregate is passed instead of the whole aggregate.
2942 The part can be passed either by value or by reference, this is
2943 determined by value of adj->by_ref. Moreover, the code below
2944 handles both situations when the original aggregate is passed by
2945 value (its type is not a pointer) and when it is passed by
2946 reference (it is a pointer to an aggregate).
2948 When the new argument is passed by reference (adj->by_ref is true)
2949 it must be a part of an aggregate and therefore we form it by
2950 simply taking the address of a reference inside the original
2953 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
2954 base = gimple_call_arg (stmt, adj->base_index);
2955 loc = DECL_P (base) ? DECL_SOURCE_LOCATION (base)
2956 : EXPR_LOCATION (base);
2958 if (TREE_CODE (base) != ADDR_EXPR
2959 && POINTER_TYPE_P (TREE_TYPE (base)))
2960 off = build_int_cst (adj->alias_ptr_type,
2961 adj->offset / BITS_PER_UNIT);
2964 HOST_WIDE_INT base_offset;
2968 if (TREE_CODE (base) == ADDR_EXPR)
2970 base = TREE_OPERAND (base, 0);
2976 base = get_addr_base_and_unit_offset (base, &base_offset);
2977 /* Aggregate arguments can have non-invariant addresses. */
2980 base = build_fold_addr_expr (prev_base);
2981 off = build_int_cst (adj->alias_ptr_type,
2982 adj->offset / BITS_PER_UNIT);
2984 else if (TREE_CODE (base) == MEM_REF)
2989 deref_align = TYPE_ALIGN (TREE_TYPE (base));
2991 off = build_int_cst (adj->alias_ptr_type,
2993 + adj->offset / BITS_PER_UNIT);
2994 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
2996 base = TREE_OPERAND (base, 0);
3000 off = build_int_cst (adj->alias_ptr_type,
3002 + adj->offset / BITS_PER_UNIT);
3003 base = build_fold_addr_expr (base);
3009 tree type = adj->type;
3011 unsigned HOST_WIDE_INT misalign;
3015 align = deref_align;
3020 get_pointer_alignment_1 (base, &align, &misalign);
3021 if (TYPE_ALIGN (type) > align)
3022 align = TYPE_ALIGN (type);
3024 misalign += (tree_to_double_int (off)
3025 .sext (TYPE_PRECISION (TREE_TYPE (off))).low
3027 misalign = misalign & (align - 1);
3029 align = (misalign & -misalign);
3030 if (align < TYPE_ALIGN (type))
3031 type = build_aligned_type (type, align);
3032 expr = fold_build2_loc (loc, MEM_REF, type, base, off);
3036 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
3037 expr = build_fold_addr_expr (expr);
3040 expr = force_gimple_operand_gsi (&gsi, expr,
3042 || is_gimple_reg_type (adj->type),
3043 NULL, true, GSI_SAME_STMT);
3044 vargs.quick_push (expr);
3046 if (!adj->copy_param && MAY_HAVE_DEBUG_STMTS)
3049 tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
3052 arg = gimple_call_arg (stmt, adj->base_index);
3053 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
3055 if (!fold_convertible_p (TREE_TYPE (origin), arg))
3057 arg = fold_convert_loc (gimple_location (stmt),
3058 TREE_TYPE (origin), arg);
3060 if (debug_args == NULL)
3061 debug_args = decl_debug_args_insert (callee_decl);
3062 for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl); ix += 2)
3063 if (ddecl == origin)
3065 ddecl = (**debug_args)[ix + 1];
3070 ddecl = make_node (DEBUG_EXPR_DECL);
3071 DECL_ARTIFICIAL (ddecl) = 1;
3072 TREE_TYPE (ddecl) = TREE_TYPE (origin);
3073 DECL_MODE (ddecl) = DECL_MODE (origin);
3075 vec_safe_push (*debug_args, origin);
3076 vec_safe_push (*debug_args, ddecl);
3078 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg), stmt);
3079 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
3083 if (dump_file && (dump_flags & TDF_DETAILS))
3085 fprintf (dump_file, "replacing stmt:");
3086 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
3089 new_stmt = gimple_build_call_vec (callee_decl, vargs);
3091 if (gimple_call_lhs (stmt))
3092 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
3094 gimple_set_block (new_stmt, gimple_block (stmt));
3095 if (gimple_has_location (stmt))
3096 gimple_set_location (new_stmt, gimple_location (stmt));
3097 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
3098 gimple_call_copy_flags (new_stmt, stmt);
3100 if (dump_file && (dump_flags & TDF_DETAILS))
3102 fprintf (dump_file, "with stmt:");
3103 print_gimple_stmt (dump_file, new_stmt, 0, 0);
3104 fprintf (dump_file, "\n");
3106 gsi_replace (&gsi, new_stmt, true);
3108 cgraph_set_call_stmt (cs, new_stmt);
3109 update_ssa (TODO_update_ssa);
3110 free_dominance_info (CDI_DOMINATORS);
3113 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
3116 index_in_adjustments_multiple_times_p (int base_index,
3117 ipa_parm_adjustment_vec adjustments)
3119 int i, len = adjustments.length ();
3122 for (i = 0; i < len; i++)
3124 struct ipa_parm_adjustment *adj;
3125 adj = &adjustments[i];
3127 if (adj->base_index == base_index)
3139 /* Return adjustments that should have the same effect on function parameters
3140 and call arguments as if they were first changed according to adjustments in
3141 INNER and then by adjustments in OUTER. */
3143 ipa_parm_adjustment_vec
3144 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
3145 ipa_parm_adjustment_vec outer)
3147 int i, outlen = outer.length ();
3148 int inlen = inner.length ();
3150 ipa_parm_adjustment_vec adjustments, tmp;
3153 for (i = 0; i < inlen; i++)
3155 struct ipa_parm_adjustment *n;
3158 if (n->remove_param)
3161 tmp.quick_push (*n);
3164 adjustments.create (outlen + removals);
3165 for (i = 0; i < outlen; i++)
3167 struct ipa_parm_adjustment r;
3168 struct ipa_parm_adjustment *out = &outer[i];
3169 struct ipa_parm_adjustment *in = &tmp[out->base_index];
3171 memset (&r, 0, sizeof (r));
3172 gcc_assert (!in->remove_param);
3173 if (out->remove_param)
3175 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
3177 r.remove_param = true;
3178 adjustments.quick_push (r);
3183 r.base_index = in->base_index;
3186 /* FIXME: Create nonlocal value too. */
3188 if (in->copy_param && out->copy_param)
3189 r.copy_param = true;
3190 else if (in->copy_param)
3191 r.offset = out->offset;
3192 else if (out->copy_param)
3193 r.offset = in->offset;
3195 r.offset = in->offset + out->offset;
3196 adjustments.quick_push (r);
3199 for (i = 0; i < inlen; i++)
3201 struct ipa_parm_adjustment *n = &inner[i];
3203 if (n->remove_param)
3204 adjustments.quick_push (*n);
3211 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
3212 friendly way, assuming they are meant to be applied to FNDECL. */
3215 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
3218 int i, len = adjustments.length ();
3220 vec<tree> parms = ipa_get_vector_of_formal_parms (fndecl);
3222 fprintf (file, "IPA param adjustments: ");
3223 for (i = 0; i < len; i++)
3225 struct ipa_parm_adjustment *adj;
3226 adj = &adjustments[i];
3229 fprintf (file, " ");
3233 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
3234 print_generic_expr (file, parms[adj->base_index], 0);
3237 fprintf (file, ", base: ");
3238 print_generic_expr (file, adj->base, 0);
3242 fprintf (file, ", reduction: ");
3243 print_generic_expr (file, adj->reduction, 0);
3245 if (adj->new_ssa_base)
3247 fprintf (file, ", new_ssa_base: ");
3248 print_generic_expr (file, adj->new_ssa_base, 0);
3251 if (adj->copy_param)
3252 fprintf (file, ", copy_param");
3253 else if (adj->remove_param)
3254 fprintf (file, ", remove_param");
3256 fprintf (file, ", offset %li", (long) adj->offset);
3258 fprintf (file, ", by_ref");
3259 print_node_brief (file, ", type: ", adj->type, 0);
3260 fprintf (file, "\n");
3265 /* Dump the AV linked list. */
3268 ipa_dump_agg_replacement_values (FILE *f, struct ipa_agg_replacement_value *av)
3271 fprintf (f, " Aggregate replacements:");
3272 for (; av; av = av->next)
3274 fprintf (f, "%s %i[" HOST_WIDE_INT_PRINT_DEC "]=", comma ? "," : "",
3275 av->index, av->offset);
3276 print_generic_expr (f, av->value, 0);
3282 /* Stream out jump function JUMP_FUNC to OB. */
3285 ipa_write_jump_function (struct output_block *ob,
3286 struct ipa_jump_func *jump_func)
3288 struct ipa_agg_jf_item *item;
3289 struct bitpack_d bp;
3292 streamer_write_uhwi (ob, jump_func->type);
3293 switch (jump_func->type)
3295 case IPA_JF_UNKNOWN:
3297 case IPA_JF_KNOWN_TYPE:
3298 streamer_write_uhwi (ob, jump_func->value.known_type.offset);
3299 stream_write_tree (ob, jump_func->value.known_type.base_type, true);
3300 stream_write_tree (ob, jump_func->value.known_type.component_type, true);
3304 EXPR_LOCATION (jump_func->value.constant) == UNKNOWN_LOCATION);
3305 stream_write_tree (ob, jump_func->value.constant, true);
3307 case IPA_JF_PASS_THROUGH:
3308 stream_write_tree (ob, jump_func->value.pass_through.operand, true);
3309 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
3310 streamer_write_uhwi (ob, jump_func->value.pass_through.operation);
3311 bp = bitpack_create (ob->main_stream);
3312 bp_pack_value (&bp, jump_func->value.pass_through.agg_preserved, 1);
3313 streamer_write_bitpack (&bp);
3315 case IPA_JF_ANCESTOR:
3316 streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
3317 stream_write_tree (ob, jump_func->value.ancestor.type, true);
3318 streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
3319 bp = bitpack_create (ob->main_stream);
3320 bp_pack_value (&bp, jump_func->value.ancestor.agg_preserved, 1);
3321 streamer_write_bitpack (&bp);
3325 count = vec_safe_length (jump_func->agg.items);
3326 streamer_write_uhwi (ob, count);
3329 bp = bitpack_create (ob->main_stream);
3330 bp_pack_value (&bp, jump_func->agg.by_ref, 1);
3331 streamer_write_bitpack (&bp);
3334 FOR_EACH_VEC_SAFE_ELT (jump_func->agg.items, i, item)
3336 streamer_write_uhwi (ob, item->offset);
3337 stream_write_tree (ob, item->value, true);
3341 /* Read in jump function JUMP_FUNC from IB. */
3344 ipa_read_jump_function (struct lto_input_block *ib,
3345 struct ipa_jump_func *jump_func,
3346 struct data_in *data_in)
3348 struct bitpack_d bp;
3351 jump_func->type = (enum jump_func_type) streamer_read_uhwi (ib);
3352 switch (jump_func->type)
3354 case IPA_JF_UNKNOWN:
3356 case IPA_JF_KNOWN_TYPE:
3357 jump_func->value.known_type.offset = streamer_read_uhwi (ib);
3358 jump_func->value.known_type.base_type = stream_read_tree (ib, data_in);
3359 jump_func->value.known_type.component_type = stream_read_tree (ib,
3363 jump_func->value.constant = stream_read_tree (ib, data_in);
3365 case IPA_JF_PASS_THROUGH:
3366 jump_func->value.pass_through.operand = stream_read_tree (ib, data_in);
3367 jump_func->value.pass_through.formal_id = streamer_read_uhwi (ib);
3368 jump_func->value.pass_through.operation
3369 = (enum tree_code) streamer_read_uhwi (ib);
3370 bp = streamer_read_bitpack (ib);
3371 jump_func->value.pass_through.agg_preserved = bp_unpack_value (&bp, 1);
3373 case IPA_JF_ANCESTOR:
3374 jump_func->value.ancestor.offset = streamer_read_uhwi (ib);
3375 jump_func->value.ancestor.type = stream_read_tree (ib, data_in);
3376 jump_func->value.ancestor.formal_id = streamer_read_uhwi (ib);
3377 bp = streamer_read_bitpack (ib);
3378 jump_func->value.ancestor.agg_preserved = bp_unpack_value (&bp, 1);
3382 count = streamer_read_uhwi (ib);
3383 vec_alloc (jump_func->agg.items, count);
3386 bp = streamer_read_bitpack (ib);
3387 jump_func->agg.by_ref = bp_unpack_value (&bp, 1);
3389 for (i = 0; i < count; i++)
3391 struct ipa_agg_jf_item item;
3392 item.offset = streamer_read_uhwi (ib);
3393 item.value = stream_read_tree (ib, data_in);
3394 jump_func->agg.items->quick_push (item);
3398 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
3399 relevant to indirect inlining to OB. */
3402 ipa_write_indirect_edge_info (struct output_block *ob,
3403 struct cgraph_edge *cs)
3405 struct cgraph_indirect_call_info *ii = cs->indirect_info;
3406 struct bitpack_d bp;
3408 streamer_write_hwi (ob, ii->param_index);
3409 streamer_write_hwi (ob, ii->offset);
3410 bp = bitpack_create (ob->main_stream);
3411 bp_pack_value (&bp, ii->polymorphic, 1);
3412 bp_pack_value (&bp, ii->agg_contents, 1);
3413 bp_pack_value (&bp, ii->by_ref, 1);
3414 streamer_write_bitpack (&bp);
3416 if (ii->polymorphic)
3418 streamer_write_hwi (ob, ii->otr_token);
3419 stream_write_tree (ob, ii->otr_type, true);
3423 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
3424 relevant to indirect inlining from IB. */
3427 ipa_read_indirect_edge_info (struct lto_input_block *ib,
3428 struct data_in *data_in ATTRIBUTE_UNUSED,
3429 struct cgraph_edge *cs)
3431 struct cgraph_indirect_call_info *ii = cs->indirect_info;
3432 struct bitpack_d bp;
3434 ii->param_index = (int) streamer_read_hwi (ib);
3435 ii->offset = (HOST_WIDE_INT) streamer_read_hwi (ib);
3436 bp = streamer_read_bitpack (ib);
3437 ii->polymorphic = bp_unpack_value (&bp, 1);
3438 ii->agg_contents = bp_unpack_value (&bp, 1);
3439 ii->by_ref = bp_unpack_value (&bp, 1);
3440 if (ii->polymorphic)
3442 ii->otr_token = (HOST_WIDE_INT) streamer_read_hwi (ib);
3443 ii->otr_type = stream_read_tree (ib, data_in);
3447 /* Stream out NODE info to OB. */
3450 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
3453 lto_symtab_encoder_t encoder;
3454 struct ipa_node_params *info = IPA_NODE_REF (node);
3456 struct cgraph_edge *e;
3457 struct bitpack_d bp;
3459 encoder = ob->decl_state->symtab_node_encoder;
3460 node_ref = lto_symtab_encoder_encode (encoder, (symtab_node) node);
3461 streamer_write_uhwi (ob, node_ref);
3463 bp = bitpack_create (ob->main_stream);
3464 gcc_assert (info->uses_analysis_done
3465 || ipa_get_param_count (info) == 0);
3466 gcc_assert (!info->node_enqueued);
3467 gcc_assert (!info->ipcp_orig_node);
3468 for (j = 0; j < ipa_get_param_count (info); j++)
3469 bp_pack_value (&bp, ipa_is_param_used (info, j), 1);
3470 streamer_write_bitpack (&bp);
3471 for (e = node->callees; e; e = e->next_callee)
3473 struct ipa_edge_args *args = IPA_EDGE_REF (e);
3475 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
3476 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
3477 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
3479 for (e = node->indirect_calls; e; e = e->next_callee)
3481 struct ipa_edge_args *args = IPA_EDGE_REF (e);
3483 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
3484 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
3485 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
3486 ipa_write_indirect_edge_info (ob, e);
3490 /* Stream in NODE info from IB. */
3493 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
3494 struct data_in *data_in)
3496 struct ipa_node_params *info = IPA_NODE_REF (node);
3498 struct cgraph_edge *e;
3499 struct bitpack_d bp;
3501 ipa_initialize_node_params (node);
3503 bp = streamer_read_bitpack (ib);
3504 if (ipa_get_param_count (info) != 0)
3505 info->uses_analysis_done = true;
3506 info->node_enqueued = false;
3507 for (k = 0; k < ipa_get_param_count (info); k++)
3508 ipa_set_param_used (info, k, bp_unpack_value (&bp, 1));
3509 for (e = node->callees; e; e = e->next_callee)
3511 struct ipa_edge_args *args = IPA_EDGE_REF (e);
3512 int count = streamer_read_uhwi (ib);
3516 vec_safe_grow_cleared (args->jump_functions, count);
3518 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
3519 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
3521 for (e = node->indirect_calls; e; e = e->next_callee)
3523 struct ipa_edge_args *args = IPA_EDGE_REF (e);
3524 int count = streamer_read_uhwi (ib);
3528 vec_safe_grow_cleared (args->jump_functions, count);
3529 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
3530 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k),
3533 ipa_read_indirect_edge_info (ib, data_in, e);
3537 /* Write jump functions for nodes in SET. */
3540 ipa_prop_write_jump_functions (void)
3542 struct cgraph_node *node;
3543 struct output_block *ob;
3544 unsigned int count = 0;
3545 lto_symtab_encoder_iterator lsei;
3546 lto_symtab_encoder_t encoder;
3549 if (!ipa_node_params_vector.exists ())
3552 ob = create_output_block (LTO_section_jump_functions);
3553 encoder = ob->decl_state->symtab_node_encoder;
3554 ob->cgraph_node = NULL;
3555 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
3556 lsei_next_function_in_partition (&lsei))
3558 node = lsei_cgraph_node (lsei);
3559 if (cgraph_function_with_gimple_body_p (node)
3560 && IPA_NODE_REF (node) != NULL)
3564 streamer_write_uhwi (ob, count);
3566 /* Process all of the functions. */
3567 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
3568 lsei_next_function_in_partition (&lsei))
3570 node = lsei_cgraph_node (lsei);
3571 if (cgraph_function_with_gimple_body_p (node)
3572 && IPA_NODE_REF (node) != NULL)
3573 ipa_write_node_info (ob, node);
3575 streamer_write_char_stream (ob->main_stream, 0);
3576 produce_asm (ob, NULL);
3577 destroy_output_block (ob);
3580 /* Read section in file FILE_DATA of length LEN with data DATA. */
3583 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
3586 const struct lto_function_header *header =
3587 (const struct lto_function_header *) data;
3588 const int cfg_offset = sizeof (struct lto_function_header);
3589 const int main_offset = cfg_offset + header->cfg_size;
3590 const int string_offset = main_offset + header->main_size;
3591 struct data_in *data_in;
3592 struct lto_input_block ib_main;
3596 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
3600 lto_data_in_create (file_data, (const char *) data + string_offset,
3601 header->string_size, vNULL);
3602 count = streamer_read_uhwi (&ib_main);
3604 for (i = 0; i < count; i++)
3607 struct cgraph_node *node;
3608 lto_symtab_encoder_t encoder;
3610 index = streamer_read_uhwi (&ib_main);
3611 encoder = file_data->symtab_node_encoder;
3612 node = cgraph (lto_symtab_encoder_deref (encoder, index));
3613 gcc_assert (node->analyzed);
3614 ipa_read_node_info (&ib_main, node, data_in);
3616 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
3618 lto_data_in_delete (data_in);
3621 /* Read ipcp jump functions. */
3624 ipa_prop_read_jump_functions (void)
3626 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
3627 struct lto_file_decl_data *file_data;
3630 ipa_check_create_node_params ();
3631 ipa_check_create_edge_args ();
3632 ipa_register_cgraph_hooks ();
3634 while ((file_data = file_data_vec[j++]))
3637 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
3640 ipa_prop_read_section (file_data, data, len);
3644 /* After merging units, we can get mismatch in argument counts.
3645 Also decl merging might've rendered parameter lists obsolete.
3646 Also compute called_with_variable_arg info. */
3649 ipa_update_after_lto_read (void)
3651 struct cgraph_node *node;
3653 ipa_check_create_node_params ();
3654 ipa_check_create_edge_args ();
3656 FOR_EACH_DEFINED_FUNCTION (node)
3658 ipa_initialize_node_params (node);
3662 write_agg_replacement_chain (struct output_block *ob, struct cgraph_node *node)
3665 unsigned int count = 0;
3666 lto_symtab_encoder_t encoder;
3667 struct ipa_agg_replacement_value *aggvals, *av;
3669 aggvals = ipa_get_agg_replacements_for_node (node);
3670 encoder = ob->decl_state->symtab_node_encoder;
3671 node_ref = lto_symtab_encoder_encode (encoder, (symtab_node) node);
3672 streamer_write_uhwi (ob, node_ref);
3674 for (av = aggvals; av; av = av->next)
3676 streamer_write_uhwi (ob, count);
3678 for (av = aggvals; av; av = av->next)
3680 struct bitpack_d bp;
3682 streamer_write_uhwi (ob, av->offset);
3683 streamer_write_uhwi (ob, av->index);
3684 stream_write_tree (ob, av->value, true);
3686 bp = bitpack_create (ob->main_stream);
3687 bp_pack_value (&bp, av->by_ref, 1);
3688 streamer_write_bitpack (&bp);
3692 /* Stream in the aggregate value replacement chain for NODE from IB. */
3695 read_agg_replacement_chain (struct lto_input_block *ib,
3696 struct cgraph_node *node,
3697 struct data_in *data_in)
3699 struct ipa_agg_replacement_value *aggvals = NULL;
3700 unsigned int count, i;
3702 count = streamer_read_uhwi (ib);
3703 for (i = 0; i <count; i++)
3705 struct ipa_agg_replacement_value *av;
3706 struct bitpack_d bp;
3708 av = ggc_alloc_ipa_agg_replacement_value ();
3709 av->offset = streamer_read_uhwi (ib);
3710 av->index = streamer_read_uhwi (ib);
3711 av->value = stream_read_tree (ib, data_in);
3712 bp = streamer_read_bitpack (ib);
3713 av->by_ref = bp_unpack_value (&bp, 1);
3717 ipa_set_node_agg_value_chain (node, aggvals);
3720 /* Write all aggregate replacement for nodes in set. */
3723 ipa_prop_write_all_agg_replacement (void)
3725 struct cgraph_node *node;
3726 struct output_block *ob;
3727 unsigned int count = 0;
3728 lto_symtab_encoder_iterator lsei;
3729 lto_symtab_encoder_t encoder;
3731 if (!ipa_node_agg_replacements)
3734 ob = create_output_block (LTO_section_ipcp_transform);
3735 encoder = ob->decl_state->symtab_node_encoder;
3736 ob->cgraph_node = NULL;
3737 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
3738 lsei_next_function_in_partition (&lsei))
3740 node = lsei_cgraph_node (lsei);
3741 if (cgraph_function_with_gimple_body_p (node)
3742 && ipa_get_agg_replacements_for_node (node) != NULL)
3746 streamer_write_uhwi (ob, count);
3748 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
3749 lsei_next_function_in_partition (&lsei))
3751 node = lsei_cgraph_node (lsei);
3752 if (cgraph_function_with_gimple_body_p (node)
3753 && ipa_get_agg_replacements_for_node (node) != NULL)
3754 write_agg_replacement_chain (ob, node);
3756 streamer_write_char_stream (ob->main_stream, 0);
3757 produce_asm (ob, NULL);
3758 destroy_output_block (ob);
3761 /* Read replacements section in file FILE_DATA of length LEN with data
3765 read_replacements_section (struct lto_file_decl_data *file_data,
3769 const struct lto_function_header *header =
3770 (const struct lto_function_header *) data;
3771 const int cfg_offset = sizeof (struct lto_function_header);
3772 const int main_offset = cfg_offset + header->cfg_size;
3773 const int string_offset = main_offset + header->main_size;
3774 struct data_in *data_in;
3775 struct lto_input_block ib_main;
3779 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
3782 data_in = lto_data_in_create (file_data, (const char *) data + string_offset,
3783 header->string_size, vNULL);
3784 count = streamer_read_uhwi (&ib_main);
3786 for (i = 0; i < count; i++)
3789 struct cgraph_node *node;
3790 lto_symtab_encoder_t encoder;
3792 index = streamer_read_uhwi (&ib_main);
3793 encoder = file_data->symtab_node_encoder;
3794 node = cgraph (lto_symtab_encoder_deref (encoder, index));
3795 gcc_assert (node->analyzed);
3796 read_agg_replacement_chain (&ib_main, node, data_in);
3798 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
3800 lto_data_in_delete (data_in);
3803 /* Read IPA-CP aggregate replacements. */
3806 ipa_prop_read_all_agg_replacement (void)
3808 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
3809 struct lto_file_decl_data *file_data;
3812 while ((file_data = file_data_vec[j++]))
3815 const char *data = lto_get_section_data (file_data,
3816 LTO_section_ipcp_transform,
3819 read_replacements_section (file_data, data, len);
3823 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
3827 adjust_agg_replacement_values (struct cgraph_node *node,
3828 struct ipa_agg_replacement_value *aggval)
3830 struct ipa_agg_replacement_value *v;
3831 int i, c = 0, d = 0, *adj;
3833 if (!node->clone.combined_args_to_skip)
3836 for (v = aggval; v; v = v->next)
3838 gcc_assert (v->index >= 0);
3844 adj = XALLOCAVEC (int, c);
3845 for (i = 0; i < c; i++)
3846 if (bitmap_bit_p (node->clone.combined_args_to_skip, i))
3854 for (v = aggval; v; v = v->next)
3855 v->index = adj[v->index];
3859 /* Function body transformation phase. */
3862 ipcp_transform_function (struct cgraph_node *node)
3864 vec<ipa_param_descriptor_t> descriptors = vNULL;
3865 struct param_analysis_info *parms_ainfo;
3866 struct ipa_agg_replacement_value *aggval;
3867 gimple_stmt_iterator gsi;
3870 bool cfg_changed = false, something_changed = false;
3872 gcc_checking_assert (cfun);
3873 gcc_checking_assert (current_function_decl);
3876 fprintf (dump_file, "Modification phase of node %s/%i\n",
3877 cgraph_node_name (node), node->uid);
3879 aggval = ipa_get_agg_replacements_for_node (node);
3882 param_count = count_formal_params (node->symbol.decl);
3883 if (param_count == 0)
3885 adjust_agg_replacement_values (node, aggval);
3887 ipa_dump_agg_replacement_values (dump_file, aggval);
3888 parms_ainfo = XALLOCAVEC (struct param_analysis_info, param_count);
3889 memset (parms_ainfo, 0, sizeof (struct param_analysis_info) * param_count);
3890 descriptors.safe_grow_cleared (param_count);
3891 ipa_populate_param_decls (node, descriptors);
3894 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3896 struct ipa_agg_replacement_value *v;
3897 gimple stmt = gsi_stmt (gsi);
3899 HOST_WIDE_INT offset;
3903 if (!gimple_assign_load_p (stmt))
3905 rhs = gimple_assign_rhs1 (stmt);
3906 if (!is_gimple_reg_type (TREE_TYPE (rhs)))
3911 while (handled_component_p (t))
3913 /* V_C_E can do things like convert an array of integers to one
3914 bigger integer and similar things we do not handle below. */
3915 if (TREE_CODE (rhs) == VIEW_CONVERT_EXPR)
3920 t = TREE_OPERAND (t, 0);
3925 if (!ipa_load_from_parm_agg_1 (descriptors, parms_ainfo, stmt,
3926 rhs, &index, &offset, &by_ref))
3928 for (v = aggval; v; v = v->next)
3929 if (v->index == index
3930 && v->offset == offset)
3932 if (!v || v->by_ref != by_ref)
3935 gcc_checking_assert (is_gimple_ip_invariant (v->value));
3936 if (!useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (v->value)))
3938 if (fold_convertible_p (TREE_TYPE (rhs), v->value))
3939 val = fold_build1 (NOP_EXPR, TREE_TYPE (rhs), v->value);
3940 else if (TYPE_SIZE (TREE_TYPE (rhs))
3941 == TYPE_SIZE (TREE_TYPE (v->value)))
3942 val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (rhs), v->value);
3947 fprintf (dump_file, " const ");
3948 print_generic_expr (dump_file, v->value, 0);
3949 fprintf (dump_file, " can't be converted to type of ");
3950 print_generic_expr (dump_file, rhs, 0);
3951 fprintf (dump_file, "\n");
3959 if (dump_file && (dump_flags & TDF_DETAILS))
3961 fprintf (dump_file, "Modifying stmt:\n ");
3962 print_gimple_stmt (dump_file, stmt, 0, 0);
3964 gimple_assign_set_rhs_from_tree (&gsi, val);
3967 if (dump_file && (dump_flags & TDF_DETAILS))
3969 fprintf (dump_file, "into:\n ");
3970 print_gimple_stmt (dump_file, stmt, 0, 0);
3971 fprintf (dump_file, "\n");
3974 something_changed = true;
3975 if (maybe_clean_eh_stmt (stmt)
3976 && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
3980 (*ipa_node_agg_replacements)[node->uid] = NULL;
3981 free_parms_ainfo (parms_ainfo, param_count);
3982 descriptors.release ();
3984 if (!something_changed)
3986 else if (cfg_changed)
3987 return TODO_update_ssa_only_virtuals | TODO_cleanup_cfg;
3989 return TODO_update_ssa_only_virtuals;