OSDN Git Service

* gcc.dg/lto/ipacp_0.c: New test.
[pf3gnuchains/gcc-fork.git] / gcc / ipa-prop.c
1 /* Interprocedural analyses.
2    Copyright (C) 2005, 2007, 2008, 2009, 2010
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tree.h"
25 #include "langhooks.h"
26 #include "ggc.h"
27 #include "target.h"
28 #include "cgraph.h"
29 #include "ipa-prop.h"
30 #include "tree-flow.h"
31 #include "tree-pass.h"
32 #include "tree-inline.h"
33 #include "gimple.h"
34 #include "flags.h"
35 #include "timevar.h"
36 #include "flags.h"
37 #include "diagnostic.h"
38 #include "lto-streamer.h"
39
40 /* Vector where the parameter infos are actually stored. */
41 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
42 /* Vector where the parameter infos are actually stored. */
43 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
44
45 /* Bitmap with all UIDs of call graph edges that have been already processed
46    by indirect inlining.  */
47 static bitmap iinlining_processed_edges;
48
49 /* Holders of ipa cgraph hooks: */
50 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
51 static struct cgraph_node_hook_list *node_removal_hook_holder;
52 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
53 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
54
55 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
56    it is in one or not.  It should almost never be used directly, as opposed to
57    ipa_push_func_to_list.  */
58
59 void
60 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
61                          struct cgraph_node *node,
62                          struct ipa_node_params *info)
63 {
64   struct ipa_func_list *temp;
65
66   info->node_enqueued = 1;
67   temp = XCNEW (struct ipa_func_list);
68   temp->node = node;
69   temp->next = *wl;
70   *wl = temp;
71 }
72
73 /* Initialize worklist to contain all functions.  */
74
75 struct ipa_func_list *
76 ipa_init_func_list (void)
77 {
78   struct cgraph_node *node;
79   struct ipa_func_list * wl;
80
81   wl = NULL;
82   for (node = cgraph_nodes; node; node = node->next)
83     if (node->analyzed)
84       {
85         struct ipa_node_params *info = IPA_NODE_REF (node);
86         /* Unreachable nodes should have been eliminated before ipcp and
87            inlining.  */
88         gcc_assert (node->needed || node->reachable);
89         ipa_push_func_to_list_1 (&wl, node, info);
90       }
91
92   return wl;
93 }
94
95 /* Remove a function from the worklist WL and return it.  */
96
97 struct cgraph_node *
98 ipa_pop_func_from_list (struct ipa_func_list **wl)
99 {
100   struct ipa_node_params *info;
101   struct ipa_func_list *first;
102   struct cgraph_node *node;
103
104   first = *wl;
105   *wl = (*wl)->next;
106   node = first->node;
107   free (first);
108
109   info = IPA_NODE_REF (node);
110   info->node_enqueued = 0;
111   return node;
112 }
113
114 /* Return index of the formal whose tree is PTREE in function which corresponds
115    to INFO.  */
116
117 static int
118 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
119 {
120   int i, count;
121
122   count = ipa_get_param_count (info);
123   for (i = 0; i < count; i++)
124     if (ipa_get_param(info, i) == ptree)
125       return i;
126
127   return -1;
128 }
129
130 /* Populate the param_decl field in parameter descriptors of INFO that
131    corresponds to NODE.  */
132
133 static void
134 ipa_populate_param_decls (struct cgraph_node *node,
135                           struct ipa_node_params *info)
136 {
137   tree fndecl;
138   tree fnargs;
139   tree parm;
140   int param_num;
141
142   fndecl = node->decl;
143   fnargs = DECL_ARGUMENTS (fndecl);
144   param_num = 0;
145   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
146     {
147       info->params[param_num].decl = parm;
148       param_num++;
149     }
150 }
151
152 /* Return how many formal parameters FNDECL has.  */
153
154 static inline int
155 count_formal_params_1 (tree fndecl)
156 {
157   tree parm;
158   int count = 0;
159
160   for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
161     count++;
162
163   return count;
164 }
165
166 /* Count number of formal parameters in NOTE. Store the result to the
167    appropriate field of INFO.  */
168
169 static void
170 ipa_count_formal_params (struct cgraph_node *node,
171                          struct ipa_node_params *info)
172 {
173   int param_num;
174
175   param_num = count_formal_params_1 (node->decl);
176   ipa_set_param_count (info, param_num);
177 }
178
179 /* Initialize the ipa_node_params structure associated with NODE by counting
180    the function parameters, creating the descriptors and populating their
181    param_decls.  */
182
183 void
184 ipa_initialize_node_params (struct cgraph_node *node)
185 {
186   struct ipa_node_params *info = IPA_NODE_REF (node);
187
188   if (!info->params)
189     {
190       ipa_count_formal_params (node, info);
191       info->params = XCNEWVEC (struct ipa_param_descriptor,
192                                     ipa_get_param_count (info));
193       ipa_populate_param_decls (node, info);
194     }
195 }
196
197 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
198    parameters.  If OP is a parameter declaration, mark it as modified in the
199    info structure passed in DATA.  */
200
201 static bool
202 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
203                                    tree op, void *data)
204 {
205   struct ipa_node_params *info = (struct ipa_node_params *) data;
206
207   op = get_base_address (op);
208   if (op
209       && TREE_CODE (op) == PARM_DECL)
210     {
211       int index = ipa_get_param_decl_index (info, op);
212       gcc_assert (index >= 0);
213       info->params[index].modified = true;
214       info->params[index].used = true;
215     }
216
217   return false;
218 }
219
220 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
221    If OP is a parameter declaration, mark it as used in the info structure
222    passed in DATA.  */
223
224 static bool
225 visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
226                              tree op, void *data)
227 {
228   struct ipa_node_params *info = (struct ipa_node_params *) data;
229
230   op = get_base_address (op);
231   if (op
232       && TREE_CODE (op) == PARM_DECL)
233     {
234       int index = ipa_get_param_decl_index (info, op);
235       gcc_assert (index >= 0);
236       info->params[index].used = true;
237     }
238
239   return false;
240 }
241
242 /* Compute which formal parameters of function associated with NODE are locally
243    modified or their address is taken.  Note that this does not apply on
244    parameters with SSA names but those can and should be analyzed
245    differently.  */
246
247 void
248 ipa_detect_param_modifications (struct cgraph_node *node)
249 {
250   tree decl = node->decl;
251   basic_block bb;
252   struct function *func;
253   gimple_stmt_iterator gsi;
254   struct ipa_node_params *info = IPA_NODE_REF (node);
255   int i;
256
257   if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
258     return;
259
260   for (i = 0; i < ipa_get_param_count (info); i++)
261     {
262       tree parm = ipa_get_param (info, i);
263       /* For SSA regs see if parameter is used.  For non-SSA we compute
264          the flag during modification analysis.  */
265       if (is_gimple_reg (parm)
266           && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
267         info->params[i].used = true;
268     }
269
270   func = DECL_STRUCT_FUNCTION (decl);
271   FOR_EACH_BB_FN (bb, func)
272     {
273       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
274         walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
275                                        visit_load_for_mod_analysis,
276                                        visit_store_addr_for_mod_analysis,
277                                        visit_store_addr_for_mod_analysis);
278       for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
279         walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
280                                        visit_load_for_mod_analysis,
281                                        visit_store_addr_for_mod_analysis,
282                                        visit_store_addr_for_mod_analysis);
283     }
284
285   info->modification_analysis_done = 1;
286 }
287
288 /* Count number of arguments callsite CS has and store it in
289    ipa_edge_args structure corresponding to this callsite.  */
290
291 void
292 ipa_count_arguments (struct cgraph_edge *cs)
293 {
294   gimple stmt;
295   int arg_num;
296
297   stmt = cs->call_stmt;
298   gcc_assert (is_gimple_call (stmt));
299   arg_num = gimple_call_num_args (stmt);
300   if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
301       <= (unsigned) cgraph_edge_max_uid)
302     VEC_safe_grow_cleared (ipa_edge_args_t, gc,
303                            ipa_edge_args_vector, cgraph_edge_max_uid + 1);
304   ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
305 }
306
307 /* Print the jump functions of all arguments on all call graph edges going from
308    NODE to file F.  */
309
310 void
311 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
312 {
313   int i, count;
314   struct cgraph_edge *cs;
315   struct ipa_jump_func *jump_func;
316   enum jump_func_type type;
317
318   fprintf (f, "  Jump functions of caller  %s:\n", cgraph_node_name (node));
319   for (cs = node->callees; cs; cs = cs->next_callee)
320     {
321       if (!ipa_edge_args_info_available_for_edge_p (cs))
322         continue;
323
324       fprintf (f, "    callsite  %s ", cgraph_node_name (node));
325       fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
326
327       count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
328       for (i = 0; i < count; i++)
329         {
330           jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
331           type = jump_func->type;
332
333           fprintf (f, "       param %d: ", i);
334           if (type == IPA_JF_UNKNOWN)
335             fprintf (f, "UNKNOWN\n");
336           else if (type == IPA_JF_KNOWN_TYPE)
337             {
338               tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
339               fprintf (f, "KNOWN TYPE, type in binfo is: ");
340               print_generic_expr (f, binfo_type, 0);
341               fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
342             }
343           else if (type == IPA_JF_CONST)
344             {
345               tree val = jump_func->value.constant;
346               fprintf (f, "CONST: ");
347               print_generic_expr (f, val, 0);
348               if (TREE_CODE (val) == ADDR_EXPR
349                   && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
350                 {
351                   fprintf (f, " -> ");
352                   print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
353                                                        0);
354                 }
355               fprintf (f, "\n");
356             }
357           else if (type == IPA_JF_CONST_MEMBER_PTR)
358             {
359               fprintf (f, "CONST MEMBER PTR: ");
360               print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
361               fprintf (f, ", ");
362               print_generic_expr (f, jump_func->value.member_cst.delta, 0);
363               fprintf (f, "\n");
364             }
365           else if (type == IPA_JF_PASS_THROUGH)
366             {
367               fprintf (f, "PASS THROUGH: ");
368               fprintf (f, "%d, op %s ",
369                        jump_func->value.pass_through.formal_id,
370                        tree_code_name[(int)
371                                       jump_func->value.pass_through.operation]);
372               if (jump_func->value.pass_through.operation != NOP_EXPR)
373                 print_generic_expr (dump_file,
374                                     jump_func->value.pass_through.operand, 0);
375               fprintf (dump_file, "\n");
376             }
377           else if (type == IPA_JF_ANCESTOR)
378             {
379               fprintf (f, "ANCESTOR: ");
380               fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
381                        jump_func->value.ancestor.formal_id,
382                        jump_func->value.ancestor.offset);
383               print_generic_expr (f, jump_func->value.ancestor.type, 0);
384               fprintf (dump_file, "\n");
385             }
386         }
387     }
388 }
389
390 /* Print ipa_jump_func data structures of all nodes in the call graph to F.  */
391
392 void
393 ipa_print_all_jump_functions (FILE *f)
394 {
395   struct cgraph_node *node;
396
397   fprintf (f, "\nJump functions:\n");
398   for (node = cgraph_nodes; node; node = node->next)
399     {
400       ipa_print_node_jump_functions (f, node);
401     }
402 }
403
404 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
405    of an assignment statement STMT, try to find out whether NAME can be
406    described by a (possibly polynomial) pass-through jump-function or an
407    ancestor jump function and if so, write the appropriate function into
408    JFUNC */
409
410 static void
411 compute_complex_assign_jump_func (struct ipa_node_params *info,
412                                   struct ipa_jump_func *jfunc,
413                                   gimple stmt, tree name)
414 {
415   HOST_WIDE_INT offset, size, max_size;
416   tree op1, op2, type;
417   int index;
418
419   op1 = gimple_assign_rhs1 (stmt);
420   op2 = gimple_assign_rhs2 (stmt);
421
422   if (TREE_CODE (op1) == SSA_NAME
423       && SSA_NAME_IS_DEFAULT_DEF (op1))
424     {
425       index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
426       if (index < 0)
427         return;
428
429       if (op2)
430         {
431           if (!is_gimple_ip_invariant (op2)
432               || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
433                   && !useless_type_conversion_p (TREE_TYPE (name),
434                                                  TREE_TYPE (op1))))
435             return;
436
437           jfunc->type = IPA_JF_PASS_THROUGH;
438           jfunc->value.pass_through.formal_id = index;
439           jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
440           jfunc->value.pass_through.operand = op2;
441         }
442       else if (gimple_assign_unary_nop_p (stmt))
443         {
444           jfunc->type = IPA_JF_PASS_THROUGH;
445           jfunc->value.pass_through.formal_id = index;
446           jfunc->value.pass_through.operation = NOP_EXPR;
447         }
448       return;
449     }
450
451   if (TREE_CODE (op1) != ADDR_EXPR)
452     return;
453
454   op1 = TREE_OPERAND (op1, 0);
455   type = TREE_TYPE (op1);
456   if (TREE_CODE (type) != RECORD_TYPE)
457     return;
458   op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
459   if (TREE_CODE (op1) != INDIRECT_REF
460       /* If this is a varying address, punt.  */
461       || max_size == -1
462       || max_size != size)
463     return;
464   op1 = TREE_OPERAND (op1, 0);
465   if (TREE_CODE (op1) != SSA_NAME
466       || !SSA_NAME_IS_DEFAULT_DEF (op1))
467     return;
468
469   index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
470   if (index >= 0)
471     {
472       jfunc->type = IPA_JF_ANCESTOR;
473       jfunc->value.ancestor.formal_id = index;
474       jfunc->value.ancestor.offset = offset;
475       jfunc->value.ancestor.type = type;
476     }
477 }
478
479
480 /* Given that an actual argument is an SSA_NAME that is a result of a phi
481    statement PHI, try to find out whether NAME is in fact a
482    multiple-inheritance typecast from a descendant into an ancestor of a formal
483    parameter and thus can be described by an ancestor jump function and if so,
484    write the appropriate function into JFUNC.
485
486    Essentially we want to match the following pattern:
487
488      if (obj_2(D) != 0B)
489        goto <bb 3>;
490      else
491        goto <bb 4>;
492
493    <bb 3>:
494      iftmp.1_3 = &obj_2(D)->D.1762;
495
496    <bb 4>:
497      # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
498      D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
499      return D.1879_6;  */
500
501 static void
502 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
503                                     struct ipa_jump_func *jfunc,
504                                     gimple phi)
505 {
506   HOST_WIDE_INT offset, size, max_size;
507   gimple assign, cond;
508   basic_block phi_bb, assign_bb, cond_bb;
509   tree tmp, parm, expr;
510   int index, i;
511
512   if (gimple_phi_num_args (phi) != 2
513       || !integer_zerop (PHI_ARG_DEF (phi, 1)))
514     return;
515
516   tmp = PHI_ARG_DEF (phi, 0);
517   if (TREE_CODE (tmp) != SSA_NAME
518       || SSA_NAME_IS_DEFAULT_DEF (tmp)
519       || !POINTER_TYPE_P (TREE_TYPE (tmp))
520       || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
521     return;
522
523   assign = SSA_NAME_DEF_STMT (tmp);
524   assign_bb = gimple_bb (assign);
525   if (!single_pred_p (assign_bb)
526       || !gimple_assign_single_p (assign))
527     return;
528   expr = gimple_assign_rhs1 (assign);
529
530   if (TREE_CODE (expr) != ADDR_EXPR)
531     return;
532   expr = TREE_OPERAND (expr, 0);
533   expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
534
535   if (TREE_CODE (expr) != INDIRECT_REF
536       /* If this is a varying address, punt.  */
537       || max_size == -1
538       || max_size != size)
539     return;
540   parm = TREE_OPERAND (expr, 0);
541   if (TREE_CODE (parm) != SSA_NAME
542       || !SSA_NAME_IS_DEFAULT_DEF (parm))
543     return;
544
545   index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
546   if (index < 0)
547     return;
548
549   cond_bb = single_pred (assign_bb);
550   cond = last_stmt (cond_bb);
551   if (gimple_code (cond) != GIMPLE_COND
552       || gimple_cond_code (cond) != NE_EXPR
553       || gimple_cond_lhs (cond) != parm
554       || !integer_zerop (gimple_cond_rhs (cond)))
555     return;
556
557
558   phi_bb = gimple_bb (phi);
559   for (i = 0; i < 2; i++)
560     {
561       basic_block pred = EDGE_PRED (phi_bb, i)->src;
562       if (pred != assign_bb && pred != cond_bb)
563         return;
564     }
565
566   jfunc->type = IPA_JF_ANCESTOR;
567   jfunc->value.ancestor.formal_id = index;
568   jfunc->value.ancestor.offset = offset;
569   jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
570 }
571
572 /* Given OP whch is passed as an actual argument to a called function,
573    determine if it is possible to construct a KNOWN_TYPE jump function for it
574    and if so, create one and store it to JFUNC.  */
575
576 static void
577 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
578 {
579   tree binfo;
580
581   if (TREE_CODE (op) != ADDR_EXPR)
582     return;
583
584   op = TREE_OPERAND (op, 0);
585   binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
586   if (binfo)
587     {
588       jfunc->type = IPA_JF_KNOWN_TYPE;
589       jfunc->value.base_binfo = binfo;
590     }
591 }
592
593
594 /* Determine the jump functions of scalar arguments.  Scalar means SSA names
595    and constants of a number of selected types.  INFO is the ipa_node_params
596    structure associated with the caller, FUNCTIONS is a pointer to an array of
597    jump function structures associated with CALL which is the call statement
598    being examined.*/
599
600 static void
601 compute_scalar_jump_functions (struct ipa_node_params *info,
602                                struct ipa_jump_func *functions,
603                                gimple call)
604 {
605   tree arg;
606   unsigned num = 0;
607
608   for (num = 0; num < gimple_call_num_args (call); num++)
609     {
610       arg = gimple_call_arg (call, num);
611
612       if (is_gimple_ip_invariant (arg))
613         {
614           functions[num].type = IPA_JF_CONST;
615           functions[num].value.constant = arg;
616         }
617       else if (TREE_CODE (arg) == SSA_NAME)
618         {
619           if (SSA_NAME_IS_DEFAULT_DEF (arg))
620             {
621               int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
622
623               if (index >= 0)
624                 {
625                   functions[num].type = IPA_JF_PASS_THROUGH;
626                   functions[num].value.pass_through.formal_id = index;
627                   functions[num].value.pass_through.operation = NOP_EXPR;
628                 }
629             }
630           else
631             {
632               gimple stmt = SSA_NAME_DEF_STMT (arg);
633               if (is_gimple_assign (stmt))
634                 compute_complex_assign_jump_func (info, &functions[num],
635                                                   stmt, arg);
636               else if (gimple_code (stmt) == GIMPLE_PHI)
637                 compute_complex_ancestor_jump_func (info, &functions[num],
638                                                     stmt);
639             }
640         }
641       else
642         compute_known_type_jump_func (arg, &functions[num]);
643     }
644 }
645
646 /* Inspect the given TYPE and return true iff it has the same structure (the
647    same number of fields of the same types) as a C++ member pointer.  If
648    METHOD_PTR and DELTA are non-NULL, store the trees representing the
649    corresponding fields there.  */
650
651 static bool
652 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
653 {
654   tree fld;
655
656   if (TREE_CODE (type) != RECORD_TYPE)
657     return false;
658
659   fld = TYPE_FIELDS (type);
660   if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
661       || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
662     return false;
663
664   if (method_ptr)
665     *method_ptr = fld;
666
667   fld = TREE_CHAIN (fld);
668   if (!fld || INTEGRAL_TYPE_P (fld))
669     return false;
670   if (delta)
671     *delta = fld;
672
673   if (TREE_CHAIN (fld))
674     return false;
675
676   return true;
677 }
678
679 /* Go through arguments of the CALL and for every one that looks like a member
680    pointer, check whether it can be safely declared pass-through and if so,
681    mark that to the corresponding item of jump FUNCTIONS.  Return true iff
682    there are non-pass-through member pointers within the arguments.  INFO
683    describes formal parameters of the caller.  */
684
685 static bool
686 compute_pass_through_member_ptrs (struct ipa_node_params *info,
687                                   struct ipa_jump_func *functions,
688                                   gimple call)
689 {
690   bool undecided_members = false;
691   unsigned num;
692   tree arg;
693
694   for (num = 0; num < gimple_call_num_args (call); num++)
695     {
696       arg = gimple_call_arg (call, num);
697
698       if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
699         {
700           if (TREE_CODE (arg) == PARM_DECL)
701             {
702               int index = ipa_get_param_decl_index (info, arg);
703
704               gcc_assert (index >=0);
705               if (!ipa_is_param_modified (info, index))
706                 {
707                   functions[num].type = IPA_JF_PASS_THROUGH;
708                   functions[num].value.pass_through.formal_id = index;
709                   functions[num].value.pass_through.operation = NOP_EXPR;
710                 }
711               else
712                 undecided_members = true;
713             }
714           else
715             undecided_members = true;
716         }
717     }
718
719   return undecided_members;
720 }
721
722 /* Simple function filling in a member pointer constant jump function (with PFN
723    and DELTA as the constant value) into JFUNC.  */
724
725 static void
726 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
727                                    tree pfn, tree delta)
728 {
729   jfunc->type = IPA_JF_CONST_MEMBER_PTR;
730   jfunc->value.member_cst.pfn = pfn;
731   jfunc->value.member_cst.delta = delta;
732 }
733
734 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
735    return the rhs of its defining statement.  */
736
737 static inline tree
738 get_ssa_def_if_simple_copy (tree rhs)
739 {
740   while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
741     {
742       gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
743
744       if (gimple_assign_single_p (def_stmt))
745         rhs = gimple_assign_rhs1 (def_stmt);
746       else
747         break;
748     }
749   return rhs;
750 }
751
752 /* Traverse statements from CALL backwards, scanning whether the argument ARG
753    which is a member pointer is filled in with constant values.  If it is, fill
754    the jump function JFUNC in appropriately.  METHOD_FIELD and DELTA_FIELD are
755    fields of the record type of the member pointer.  To give an example, we
756    look for a pattern looking like the following:
757
758      D.2515.__pfn ={v} printStuff;
759      D.2515.__delta ={v} 0;
760      i_1 = doprinting (D.2515);  */
761
762 static void
763 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
764                           tree delta_field, struct ipa_jump_func *jfunc)
765 {
766   gimple_stmt_iterator gsi;
767   tree method = NULL_TREE;
768   tree delta = NULL_TREE;
769
770   gsi = gsi_for_stmt (call);
771
772   gsi_prev (&gsi);
773   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
774     {
775       gimple stmt = gsi_stmt (gsi);
776       tree lhs, rhs, fld;
777
778       if (!gimple_assign_single_p (stmt))
779         return;
780
781       lhs = gimple_assign_lhs (stmt);
782       rhs = gimple_assign_rhs1 (stmt);
783
784       if (TREE_CODE (lhs) != COMPONENT_REF
785           || TREE_OPERAND (lhs, 0) != arg)
786         continue;
787
788       fld = TREE_OPERAND (lhs, 1);
789       if (!method && fld == method_field)
790         {
791           rhs = get_ssa_def_if_simple_copy (rhs);
792           if (TREE_CODE (rhs) == ADDR_EXPR
793               && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
794               && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
795             {
796               method = TREE_OPERAND (rhs, 0);
797               if (delta)
798                 {
799                   fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
800                   return;
801                 }
802             }
803           else
804             return;
805         }
806
807       if (!delta && fld == delta_field)
808         {
809           rhs = get_ssa_def_if_simple_copy (rhs);
810           if (TREE_CODE (rhs) == INTEGER_CST)
811             {
812               delta = rhs;
813               if (method)
814                 {
815                   fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
816                   return;
817                 }
818             }
819           else
820             return;
821         }
822     }
823
824   return;
825 }
826
827 /* Go through the arguments of the CALL and for every member pointer within
828    tries determine whether it is a constant.  If it is, create a corresponding
829    constant jump function in FUNCTIONS which is an array of jump functions
830    associated with the call.  */
831
832 static void
833 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
834                                   gimple call)
835 {
836   unsigned num;
837   tree arg, method_field, delta_field;
838
839   for (num = 0; num < gimple_call_num_args (call); num++)
840     {
841       arg = gimple_call_arg (call, num);
842
843       if (functions[num].type == IPA_JF_UNKNOWN
844           && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
845                                      &delta_field))
846         determine_cst_member_ptr (call, arg, method_field, delta_field,
847                                   &functions[num]);
848     }
849 }
850
851 /* Compute jump function for all arguments of callsite CS and insert the
852    information in the jump_functions array in the ipa_edge_args corresponding
853    to this callsite.  */
854
855 void
856 ipa_compute_jump_functions (struct cgraph_edge *cs)
857 {
858   struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
859   struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
860   gimple call;
861
862   if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
863     return;
864   arguments->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
865                                            ipa_get_cs_argument_count (arguments));
866
867   call = cs->call_stmt;
868   gcc_assert (is_gimple_call (call));
869
870   /* We will deal with constants and SSA scalars first:  */
871   compute_scalar_jump_functions (info, arguments->jump_functions, call);
872
873   /* Let's check whether there are any potential member pointers and if so,
874      whether we can determine their functions as pass_through.  */
875   if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
876     return;
877
878   /* Finally, let's check whether we actually pass a new constant member
879      pointer here...  */
880   compute_cst_member_ptr_arguments (arguments->jump_functions, call);
881 }
882
883 /* If RHS looks like a rhs of a statement loading pfn from a member
884    pointer formal parameter, return the parameter, otherwise return
885    NULL.  If USE_DELTA, then we look for a use of the delta field
886    rather than the pfn.  */
887
888 static tree
889 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
890 {
891   tree rec, fld;
892   tree ptr_field;
893   tree delta_field;
894
895   if (TREE_CODE (rhs) != COMPONENT_REF)
896     return NULL_TREE;
897
898   rec = TREE_OPERAND (rhs, 0);
899   if (TREE_CODE (rec) != PARM_DECL
900       || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
901     return NULL_TREE;
902
903   fld = TREE_OPERAND (rhs, 1);
904   if (use_delta ? (fld == delta_field) : (fld == ptr_field))
905     return rec;
906   else
907     return NULL_TREE;
908 }
909
910 /* If STMT looks like a statement loading a value from a member pointer formal
911    parameter, this function returns that parameter.  */
912
913 static tree
914 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
915 {
916   tree rhs;
917
918   if (!gimple_assign_single_p (stmt))
919     return NULL_TREE;
920
921   rhs = gimple_assign_rhs1 (stmt);
922   return ipa_get_member_ptr_load_param (rhs, use_delta);
923 }
924
925 /* Returns true iff T is an SSA_NAME defined by a statement.  */
926
927 static bool
928 ipa_is_ssa_with_stmt_def (tree t)
929 {
930   if (TREE_CODE (t) == SSA_NAME
931       && !SSA_NAME_IS_DEFAULT_DEF (t))
932     return true;
933   else
934     return false;
935 }
936
937 /* Find the indirect call graph edge corresponding to STMT and add to it all
938    information necessary to describe a call to a parameter number PARAM_INDEX.
939    NODE is the caller.  POLYMORPHIC should be set to true iff the call is a
940    virtual one.  */
941
942 static void
943 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
944                      bool polymorphic)
945 {
946   struct cgraph_edge *cs;
947
948   cs = cgraph_edge (node, stmt);
949   cs->indirect_info->param_index = param_index;
950   cs->indirect_info->anc_offset = 0;
951   cs->indirect_info->polymorphic = polymorphic;
952   if (polymorphic)
953     {
954       tree otr = gimple_call_fn (stmt);
955       tree type, token = OBJ_TYPE_REF_TOKEN (otr);
956       cs->indirect_info->otr_token = tree_low_cst (token, 1);
957       type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
958       cs->indirect_info->otr_type = type;
959     }
960 }
961
962 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
963    (described by INFO).  Currently it checks whether the call calls a pointer
964    that is a formal parameter and if so, the parameter is marked with the
965    called flag and an indirect call graph edge describing the call is created.
966    This is very simple for ordinary pointers represented in SSA but not-so-nice
967    when it comes to member pointers.  The ugly part of this function does
968    nothing more than trying to match the pattern of such a call.  An example of
969    such a pattern is the gimple dump below, the call is on the last line:
970
971      <bb 2>:
972        f$__delta_5 = f.__delta;
973        f$__pfn_24 = f.__pfn;
974        D.2496_3 = (int) f$__pfn_24;
975        D.2497_4 = D.2496_3 & 1;
976        if (D.2497_4 != 0)
977          goto <bb 3>;
978        else
979          goto <bb 4>;
980
981      <bb 3>:
982        D.2500_7 = (unsigned int) f$__delta_5;
983        D.2501_8 = &S + D.2500_7;
984        D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
985        D.2503_10 = *D.2502_9;
986        D.2504_12 = f$__pfn_24 + -1;
987        D.2505_13 = (unsigned int) D.2504_12;
988        D.2506_14 = D.2503_10 + D.2505_13;
989        D.2507_15 = *D.2506_14;
990        iftmp.11_16 = (String:: *) D.2507_15;
991
992      <bb 4>:
993        # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
994        D.2500_19 = (unsigned int) f$__delta_5;
995        D.2508_20 = &S + D.2500_19;
996        D.2493_21 = iftmp.11_1 (D.2508_20, 4);
997
998    Such patterns are results of simple calls to a member pointer:
999
1000      int doprinting (int (MyString::* f)(int) const)
1001      {
1002        MyString S ("somestring");
1003
1004        return (S.*f)(4);
1005      }
1006 */
1007
1008 static void
1009 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1010                                 struct ipa_node_params *info,
1011                                 gimple call, tree target)
1012 {
1013   gimple def;
1014   tree n1, n2;
1015   gimple d1, d2;
1016   tree rec, rec2, cond;
1017   gimple branch;
1018   int index;
1019   basic_block bb, virt_bb, join;
1020
1021   if (SSA_NAME_IS_DEFAULT_DEF (target))
1022     {
1023       tree var = SSA_NAME_VAR (target);
1024       index = ipa_get_param_decl_index (info, var);
1025       if (index >= 0)
1026         ipa_note_param_call (node, index, call, false);
1027       return;
1028     }
1029
1030   /* Now we need to try to match the complex pattern of calling a member
1031      pointer. */
1032
1033   if (!POINTER_TYPE_P (TREE_TYPE (target))
1034       || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1035     return;
1036
1037   def = SSA_NAME_DEF_STMT (target);
1038   if (gimple_code (def) != GIMPLE_PHI)
1039     return;
1040
1041   if (gimple_phi_num_args (def) != 2)
1042     return;
1043
1044   /* First, we need to check whether one of these is a load from a member
1045      pointer that is a parameter to this function. */
1046   n1 = PHI_ARG_DEF (def, 0);
1047   n2 = PHI_ARG_DEF (def, 1);
1048   if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1049     return;
1050   d1 = SSA_NAME_DEF_STMT (n1);
1051   d2 = SSA_NAME_DEF_STMT (n2);
1052
1053   if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1054     {
1055       if (ipa_get_stmt_member_ptr_load_param (d2, false))
1056         return;
1057
1058       bb = gimple_bb (d1);
1059       virt_bb = gimple_bb (d2);
1060     }
1061   else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1062     {
1063       bb = gimple_bb (d2);
1064       virt_bb = gimple_bb (d1);
1065     }
1066   else
1067     return;
1068
1069   /* Second, we need to check that the basic blocks are laid out in the way
1070      corresponding to the pattern. */
1071
1072   join = gimple_bb (def);
1073   if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1074       || single_pred (virt_bb) != bb
1075       || single_succ (virt_bb) != join)
1076     return;
1077
1078   /* Third, let's see that the branching is done depending on the least
1079      significant bit of the pfn. */
1080
1081   branch = last_stmt (bb);
1082   if (gimple_code (branch) != GIMPLE_COND)
1083     return;
1084
1085   if (gimple_cond_code (branch) != NE_EXPR
1086       || !integer_zerop (gimple_cond_rhs (branch)))
1087     return;
1088
1089   cond = gimple_cond_lhs (branch);
1090   if (!ipa_is_ssa_with_stmt_def (cond))
1091     return;
1092
1093   def = SSA_NAME_DEF_STMT (cond);
1094   if (!is_gimple_assign (def)
1095       || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1096       || !integer_onep (gimple_assign_rhs2 (def)))
1097     return;
1098
1099   cond = gimple_assign_rhs1 (def);
1100   if (!ipa_is_ssa_with_stmt_def (cond))
1101     return;
1102
1103   def = SSA_NAME_DEF_STMT (cond);
1104
1105   if (is_gimple_assign (def)
1106       && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1107     {
1108       cond = gimple_assign_rhs1 (def);
1109       if (!ipa_is_ssa_with_stmt_def (cond))
1110         return;
1111       def = SSA_NAME_DEF_STMT (cond);
1112     }
1113
1114   rec2 = ipa_get_stmt_member_ptr_load_param (def,
1115                                              (TARGET_PTRMEMFUNC_VBIT_LOCATION
1116                                               == ptrmemfunc_vbit_in_delta));
1117
1118   if (rec != rec2)
1119     return;
1120
1121   index = ipa_get_param_decl_index (info, rec);
1122   if (index >= 0 && !ipa_is_param_modified (info, index))
1123     ipa_note_param_call (node, index, call, false);
1124
1125   return;
1126 }
1127
1128 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1129    object referenced in the expression is a formal parameter of the caller
1130    (described by INFO), create a call note for the statement. */
1131
1132 static void
1133 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1134                                struct ipa_node_params *info, gimple call,
1135                                tree target)
1136 {
1137   tree obj = OBJ_TYPE_REF_OBJECT (target);
1138   tree var;
1139   int index;
1140
1141   if (TREE_CODE (obj) == ADDR_EXPR)
1142     {
1143       do
1144         {
1145           obj = TREE_OPERAND (obj, 0);
1146         }
1147       while (TREE_CODE (obj) == COMPONENT_REF);
1148       if (TREE_CODE (obj) != INDIRECT_REF)
1149         return;
1150       obj = TREE_OPERAND (obj, 0);
1151     }
1152
1153   if (TREE_CODE (obj) != SSA_NAME
1154       || !SSA_NAME_IS_DEFAULT_DEF (obj))
1155     return;
1156
1157   var = SSA_NAME_VAR (obj);
1158   index = ipa_get_param_decl_index (info, var);
1159
1160   if (index >= 0)
1161     ipa_note_param_call (node, index, call, true);
1162 }
1163
1164 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1165    of the caller (described by INFO). */
1166
1167 static void
1168 ipa_analyze_call_uses (struct cgraph_node *node,
1169                        struct ipa_node_params *info, gimple call)
1170 {
1171   tree target = gimple_call_fn (call);
1172
1173   if (TREE_CODE (target) == SSA_NAME)
1174     ipa_analyze_indirect_call_uses (node, info, call, target);
1175   else if (TREE_CODE (target) == OBJ_TYPE_REF)
1176     ipa_analyze_virtual_call_uses (node, info, call, target);
1177 }
1178
1179
1180 /* Analyze the call statement STMT with respect to formal parameters (described
1181    in INFO) of caller given by NODE.  Currently it only checks whether formal
1182    parameters are called.  */
1183
1184 static void
1185 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1186                        gimple stmt)
1187 {
1188   if (is_gimple_call (stmt))
1189     ipa_analyze_call_uses (node, info, stmt);
1190 }
1191
1192 /* Scan the function body of NODE and inspect the uses of formal parameters.
1193    Store the findings in various structures of the associated ipa_node_params
1194    structure, such as parameter flags, notes etc.  */
1195
1196 void
1197 ipa_analyze_params_uses (struct cgraph_node *node)
1198 {
1199   tree decl = node->decl;
1200   basic_block bb;
1201   struct function *func;
1202   gimple_stmt_iterator gsi;
1203   struct ipa_node_params *info = IPA_NODE_REF (node);
1204
1205   if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1206     return;
1207
1208   func = DECL_STRUCT_FUNCTION (decl);
1209   FOR_EACH_BB_FN (bb, func)
1210     {
1211       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1212         {
1213           gimple stmt = gsi_stmt (gsi);
1214           ipa_analyze_stmt_uses (node, info, stmt);
1215         }
1216     }
1217
1218   info->uses_analysis_done = 1;
1219 }
1220
1221 /* Update the jump function DST when the call graph edge correspondng to SRC is
1222    is being inlined, knowing that DST is of type ancestor and src of known
1223    type.  */
1224
1225 static void
1226 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1227                                      struct ipa_jump_func *dst)
1228 {
1229   tree new_binfo;
1230
1231   new_binfo = get_binfo_at_offset (src->value.base_binfo,
1232                                    dst->value.ancestor.offset,
1233                                    dst->value.ancestor.type);
1234   if (new_binfo)
1235     {
1236       dst->type = IPA_JF_KNOWN_TYPE;
1237       dst->value.base_binfo = new_binfo;
1238     }
1239   else
1240     dst->type = IPA_JF_UNKNOWN;
1241 }
1242
1243 /* Update the jump functions associated with call graph edge E when the call
1244    graph edge CS is being inlined, assuming that E->caller is already (possibly
1245    indirectly) inlined into CS->callee and that E has not been inlined.  */
1246
1247 static void
1248 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1249                                       struct cgraph_edge *e)
1250 {
1251   struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1252   struct ipa_edge_args *args = IPA_EDGE_REF (e);
1253   int count = ipa_get_cs_argument_count (args);
1254   int i;
1255
1256   for (i = 0; i < count; i++)
1257     {
1258       struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1259
1260       if (dst->type == IPA_JF_ANCESTOR)
1261         {
1262           struct ipa_jump_func *src;
1263
1264           /* Variable number of arguments can cause havoc if we try to access
1265              one that does not exist in the inlined edge.  So make sure we
1266              don't.  */
1267           if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1268             {
1269               dst->type = IPA_JF_UNKNOWN;
1270               continue;
1271             }
1272
1273           src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1274           if (src->type == IPA_JF_KNOWN_TYPE)
1275             combine_known_type_and_ancestor_jfs (src, dst);
1276           else if (src->type == IPA_JF_CONST)
1277             {
1278               struct ipa_jump_func kt_func;
1279
1280               kt_func.type = IPA_JF_UNKNOWN;
1281               compute_known_type_jump_func (src->value.constant, &kt_func);
1282               if (kt_func.type == IPA_JF_KNOWN_TYPE)
1283                 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1284               else
1285                 dst->type = IPA_JF_UNKNOWN;
1286             }
1287           else if (src->type == IPA_JF_PASS_THROUGH
1288                    && src->value.pass_through.operation == NOP_EXPR)
1289             dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1290           else if (src->type == IPA_JF_ANCESTOR)
1291             {
1292               dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1293               dst->value.ancestor.offset += src->value.ancestor.offset;
1294             }
1295           else
1296             dst->type = IPA_JF_UNKNOWN;
1297         }
1298       else if (dst->type == IPA_JF_PASS_THROUGH)
1299         {
1300           struct ipa_jump_func *src;
1301           /* We must check range due to calls with variable number of arguments
1302              and we cannot combine jump functions with operations.  */
1303           if (dst->value.pass_through.operation == NOP_EXPR
1304               && (dst->value.pass_through.formal_id
1305                   < ipa_get_cs_argument_count (top)))
1306             {
1307               src = ipa_get_ith_jump_func (top,
1308                                            dst->value.pass_through.formal_id);
1309               *dst = *src;
1310             }
1311           else
1312             dst->type = IPA_JF_UNKNOWN;
1313         }
1314     }
1315 }
1316
1317 /* If TARGET is an addr_expr of a function declaration, make it the destination
1318    of an indirect edge IE and return the edge.  Otherwise, return NULL.  */
1319
1320 static struct cgraph_edge *
1321 make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1322 {
1323   struct cgraph_node *callee;
1324
1325   if (TREE_CODE (target) != ADDR_EXPR)
1326     return NULL;
1327   target = TREE_OPERAND (target, 0);
1328   if (TREE_CODE (target) != FUNCTION_DECL)
1329     return NULL;
1330   callee = cgraph_node (target);
1331   if (!callee)
1332     return NULL;
1333
1334   cgraph_make_edge_direct (ie, callee);
1335   if (dump_file)
1336     {
1337       fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1338                "(%s/%i -> %s/%i) for stmt ",
1339                ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1340                cgraph_node_name (ie->caller), ie->caller->uid,
1341                cgraph_node_name (ie->callee), ie->callee->uid);
1342
1343       if (ie->call_stmt)
1344         print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1345       else
1346         fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1347     }
1348   return ie;
1349 }
1350
1351 /* Try to find a destination for indirect edge IE that corresponds to a simple
1352    call or a call of a member function pointer and where the destination is a
1353    pointer formal parameter described by jump function JFUNC.  If it can be
1354    determined, return the newly direct edge, otherwise return NULL.  */
1355
1356 static struct cgraph_edge *
1357 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1358                                   struct ipa_jump_func *jfunc)
1359 {
1360   tree target;
1361
1362   if (jfunc->type == IPA_JF_CONST)
1363     target = jfunc->value.constant;
1364   else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1365     target = jfunc->value.member_cst.pfn;
1366   else
1367     return NULL;
1368
1369   return make_edge_direct_to_target (ie, target);
1370 }
1371
1372 /* Try to find a destination for indirect edge IE that corresponds to a
1373    virtuall call based on a formal parameter which is described by jump
1374    function JFUNC and if it can be determined, make it direct and return the
1375    direct edge.  Otherwise, return NULL.  */
1376
1377 static struct cgraph_edge *
1378 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1379                                    struct ipa_jump_func *jfunc)
1380 {
1381   tree binfo, type, target;
1382   HOST_WIDE_INT token;
1383
1384   if (jfunc->type == IPA_JF_KNOWN_TYPE)
1385     binfo = jfunc->value.base_binfo;
1386   else if (jfunc->type == IPA_JF_CONST)
1387     {
1388       tree cst = jfunc->value.constant;
1389       if (TREE_CODE (cst) == ADDR_EXPR)
1390         binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1391                                                NULL_TREE);
1392       else
1393         return NULL;
1394     }
1395   else
1396     return NULL;
1397
1398   if (!binfo)
1399     return NULL;
1400
1401   token = ie->indirect_info->otr_token;
1402   type = ie->indirect_info->otr_type;
1403   binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1404   if (binfo)
1405     target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1406   else
1407     return NULL;
1408
1409   if (target)
1410     return make_edge_direct_to_target (ie, target);
1411   else
1412     return NULL;
1413 }
1414
1415 /* Update the param called notes associated with NODE when CS is being inlined,
1416    assuming NODE is (potentially indirectly) inlined into CS->callee.
1417    Moreover, if the callee is discovered to be constant, create a new cgraph
1418    edge for it.  Newly discovered indirect edges will be added to *NEW_EDGES,
1419    unless NEW_EDGES is NULL.  Return true iff a new edge(s) were created.  */
1420
1421 static bool
1422 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1423                                       struct cgraph_node *node,
1424                                       VEC (cgraph_edge_p, heap) **new_edges)
1425 {
1426   struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1427   struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1428   bool res = false;
1429
1430   ipa_check_create_edge_args ();
1431
1432   for (ie = node->indirect_calls; ie; ie = next_ie)
1433     {
1434       struct cgraph_indirect_call_info *ici = ie->indirect_info;
1435       struct ipa_jump_func *jfunc;
1436
1437       next_ie = ie->next_callee;
1438       if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1439         continue;
1440
1441       /* If we ever use indirect edges for anything other than indirect
1442          inlining, we will need to skip those with negative param_indices. */
1443       if (ici->param_index == -1)
1444         continue;
1445
1446       /* We must check range due to calls with variable number of arguments:  */
1447       if (ici->param_index >= ipa_get_cs_argument_count (top))
1448         {
1449           bitmap_set_bit (iinlining_processed_edges, ie->uid);
1450           continue;
1451         }
1452
1453       jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1454       if (jfunc->type == IPA_JF_PASS_THROUGH
1455           && jfunc->value.pass_through.operation == NOP_EXPR)
1456         ici->param_index = jfunc->value.pass_through.formal_id;
1457       else if (jfunc->type == IPA_JF_ANCESTOR)
1458         {
1459           ici->param_index = jfunc->value.ancestor.formal_id;
1460           ici->anc_offset += jfunc->value.ancestor.offset;
1461         }
1462       else
1463         /* Either we can find a destination for this edge now or never. */
1464         bitmap_set_bit (iinlining_processed_edges, ie->uid);
1465
1466       if (ici->polymorphic)
1467         new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1468       else
1469         new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1470
1471       if (new_direct_edge)
1472         {
1473           new_direct_edge->indirect_inlining_edge = 1;
1474           if (new_edges)
1475             {
1476               VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1477                              new_direct_edge);
1478               top = IPA_EDGE_REF (cs);
1479               res = true;
1480             }
1481         }
1482     }
1483
1484   return res;
1485 }
1486
1487 /* Recursively traverse subtree of NODE (including node) made of inlined
1488    cgraph_edges when CS has been inlined and invoke
1489    update_indirect_edges_after_inlining on all nodes and
1490    update_jump_functions_after_inlining on all non-inlined edges that lead out
1491    of this subtree.  Newly discovered indirect edges will be added to
1492    *NEW_EDGES, unless NEW_EDGES is NULL.  Return true iff a new edge(s) were
1493    created.  */
1494
1495 static bool
1496 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1497                                    struct cgraph_node *node,
1498                                    VEC (cgraph_edge_p, heap) **new_edges)
1499 {
1500   struct cgraph_edge *e;
1501   bool res;
1502
1503   res = update_indirect_edges_after_inlining (cs, node, new_edges);
1504
1505   for (e = node->callees; e; e = e->next_callee)
1506     if (!e->inline_failed)
1507       res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1508     else
1509       update_jump_functions_after_inlining (cs, e);
1510
1511   return res;
1512 }
1513
1514 /* Update jump functions and call note functions on inlining the call site CS.
1515    CS is expected to lead to a node already cloned by
1516    cgraph_clone_inline_nodes.  Newly discovered indirect edges will be added to
1517    *NEW_EDGES, unless NEW_EDGES is NULL.  Return true iff a new edge(s) were +
1518    created.  */
1519
1520 bool
1521 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1522                                    VEC (cgraph_edge_p, heap) **new_edges)
1523 {
1524   /* FIXME lto: We do not stream out indirect call information.  */
1525   if (flag_wpa)
1526     return false;
1527
1528   /* Do nothing if the preparation phase has not been carried out yet
1529      (i.e. during early inlining).  */
1530   if (!ipa_node_params_vector)
1531     return false;
1532   gcc_assert (ipa_edge_args_vector);
1533
1534   return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1535 }
1536
1537 /* Frees all dynamically allocated structures that the argument info points
1538    to.  */
1539
1540 void
1541 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1542 {
1543   if (args->jump_functions)
1544     ggc_free (args->jump_functions);
1545
1546   memset (args, 0, sizeof (*args));
1547 }
1548
1549 /* Free all ipa_edge structures.  */
1550
1551 void
1552 ipa_free_all_edge_args (void)
1553 {
1554   int i;
1555   struct ipa_edge_args *args;
1556
1557   for (i = 0;
1558        VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1559        i++)
1560     ipa_free_edge_args_substructures (args);
1561
1562   VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1563   ipa_edge_args_vector = NULL;
1564 }
1565
1566 /* Frees all dynamically allocated structures that the param info points
1567    to.  */
1568
1569 void
1570 ipa_free_node_params_substructures (struct ipa_node_params *info)
1571 {
1572   if (info->params)
1573     free (info->params);
1574
1575   memset (info, 0, sizeof (*info));
1576 }
1577
1578 /* Free all ipa_node_params structures.  */
1579
1580 void
1581 ipa_free_all_node_params (void)
1582 {
1583   int i;
1584   struct ipa_node_params *info;
1585
1586   for (i = 0;
1587        VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1588        i++)
1589     ipa_free_node_params_substructures (info);
1590
1591   VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1592   ipa_node_params_vector = NULL;
1593 }
1594
1595 /* Hook that is called by cgraph.c when an edge is removed.  */
1596
1597 static void
1598 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1599 {
1600   /* During IPA-CP updating we can be called on not-yet analyze clones.  */
1601   if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1602       <= (unsigned)cs->uid)
1603     return;
1604   ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1605 }
1606
1607 /* Hook that is called by cgraph.c when a node is removed.  */
1608
1609 static void
1610 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1611 {
1612   /* During IPA-CP updating we can be called on not-yet analyze clones.  */
1613   if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1614       <= (unsigned)node->uid)
1615     return;
1616   ipa_free_node_params_substructures (IPA_NODE_REF (node));
1617 }
1618
1619 /* Helper function to duplicate an array of size N that is at SRC and store a
1620    pointer to it to DST.  Nothing is done if SRC is NULL.  */
1621
1622 static void *
1623 duplicate_array (void *src, size_t n)
1624 {
1625   void *p;
1626
1627   if (!src)
1628     return NULL;
1629
1630   p = xmalloc (n);
1631   memcpy (p, src, n);
1632   return p;
1633 }
1634
1635 /* Like duplicate_array byt in GGC memory.  */
1636
1637 static void *
1638 duplicate_ggc_array (void *src, size_t n)
1639 {
1640   void *p;
1641
1642   if (!src)
1643     return NULL;
1644
1645   p = ggc_alloc (n);
1646   memcpy (p, src, n);
1647   return p;
1648 }
1649
1650 /* Hook that is called by cgraph.c when a node is duplicated.  */
1651
1652 static void
1653 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1654                            __attribute__((unused)) void *data)
1655 {
1656   struct ipa_edge_args *old_args, *new_args;
1657   int arg_count;
1658
1659   ipa_check_create_edge_args ();
1660
1661   old_args = IPA_EDGE_REF (src);
1662   new_args = IPA_EDGE_REF (dst);
1663
1664   arg_count = ipa_get_cs_argument_count (old_args);
1665   ipa_set_cs_argument_count (new_args, arg_count);
1666   new_args->jump_functions = (struct ipa_jump_func *)
1667     duplicate_ggc_array (old_args->jump_functions,
1668                          sizeof (struct ipa_jump_func) * arg_count);
1669
1670   if (iinlining_processed_edges
1671       && bitmap_bit_p (iinlining_processed_edges, src->uid))
1672     bitmap_set_bit (iinlining_processed_edges, dst->uid);
1673 }
1674
1675 /* Hook that is called by cgraph.c when a node is duplicated.  */
1676
1677 static void
1678 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1679                            __attribute__((unused)) void *data)
1680 {
1681   struct ipa_node_params *old_info, *new_info;
1682   int param_count;
1683
1684   ipa_check_create_node_params ();
1685   old_info = IPA_NODE_REF (src);
1686   new_info = IPA_NODE_REF (dst);
1687   param_count = ipa_get_param_count (old_info);
1688
1689   ipa_set_param_count (new_info, param_count);
1690   new_info->params = (struct ipa_param_descriptor *)
1691     duplicate_array (old_info->params,
1692                      sizeof (struct ipa_param_descriptor) * param_count);
1693   new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1694   new_info->count_scale = old_info->count_scale;
1695 }
1696
1697 /* Register our cgraph hooks if they are not already there.  */
1698
1699 void
1700 ipa_register_cgraph_hooks (void)
1701 {
1702   if (!edge_removal_hook_holder)
1703     edge_removal_hook_holder =
1704       cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1705   if (!node_removal_hook_holder)
1706     node_removal_hook_holder =
1707       cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1708   if (!edge_duplication_hook_holder)
1709     edge_duplication_hook_holder =
1710       cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1711   if (!node_duplication_hook_holder)
1712     node_duplication_hook_holder =
1713       cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1714 }
1715
1716 /* Unregister our cgraph hooks if they are not already there.  */
1717
1718 static void
1719 ipa_unregister_cgraph_hooks (void)
1720 {
1721   cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1722   edge_removal_hook_holder = NULL;
1723   cgraph_remove_node_removal_hook (node_removal_hook_holder);
1724   node_removal_hook_holder = NULL;
1725   cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1726   edge_duplication_hook_holder = NULL;
1727   cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1728   node_duplication_hook_holder = NULL;
1729 }
1730
1731 /* Allocate all necessary data strucutures necessary for indirect inlining.  */
1732
1733 void
1734 ipa_create_all_structures_for_iinln (void)
1735 {
1736   iinlining_processed_edges = BITMAP_ALLOC (NULL);
1737 }
1738
1739 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1740    longer needed after ipa-cp.  */
1741
1742 void
1743 ipa_free_all_structures_after_ipa_cp (void)
1744 {
1745   if (!flag_indirect_inlining)
1746     {
1747       ipa_free_all_edge_args ();
1748       ipa_free_all_node_params ();
1749       ipa_unregister_cgraph_hooks ();
1750     }
1751 }
1752
1753 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1754    longer needed after indirect inlining.  */
1755
1756 void
1757 ipa_free_all_structures_after_iinln (void)
1758 {
1759   BITMAP_FREE (iinlining_processed_edges);
1760
1761   ipa_free_all_edge_args ();
1762   ipa_free_all_node_params ();
1763   ipa_unregister_cgraph_hooks ();
1764 }
1765
1766 /* Print ipa_tree_map data structures of all functions in the
1767    callgraph to F.  */
1768
1769 void
1770 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1771 {
1772   int i, count;
1773   tree temp;
1774   struct ipa_node_params *info;
1775
1776   if (!node->analyzed)
1777     return;
1778   info = IPA_NODE_REF (node);
1779   fprintf (f, "  function  %s parameter descriptors:\n",
1780            cgraph_node_name (node));
1781   count = ipa_get_param_count (info);
1782   for (i = 0; i < count; i++)
1783     {
1784       temp = ipa_get_param (info, i);
1785       if (TREE_CODE (temp) == PARM_DECL)
1786         fprintf (f, "    param %d : %s", i,
1787                  (DECL_NAME (temp)
1788                   ? (*lang_hooks.decl_printable_name) (temp, 2)
1789                   : "(unnamed)"));
1790       if (ipa_is_param_modified (info, i))
1791         fprintf (f, " modified");
1792       if (ipa_is_param_used (info, i))
1793         fprintf (f, " used");
1794       fprintf (f, "\n");
1795     }
1796 }
1797
1798 /* Print ipa_tree_map data structures of all functions in the
1799    callgraph to F.  */
1800
1801 void
1802 ipa_print_all_params (FILE * f)
1803 {
1804   struct cgraph_node *node;
1805
1806   fprintf (f, "\nFunction parameters:\n");
1807   for (node = cgraph_nodes; node; node = node->next)
1808     ipa_print_node_params (f, node);
1809 }
1810
1811 /* Return a heap allocated vector containing formal parameters of FNDECL.  */
1812
1813 VEC(tree, heap) *
1814 ipa_get_vector_of_formal_parms (tree fndecl)
1815 {
1816   VEC(tree, heap) *args;
1817   int count;
1818   tree parm;
1819
1820   count = count_formal_params_1 (fndecl);
1821   args = VEC_alloc (tree, heap, count);
1822   for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1823     VEC_quick_push (tree, args, parm);
1824
1825   return args;
1826 }
1827
1828 /* Return a heap allocated vector containing types of formal parameters of
1829    function type FNTYPE.  */
1830
1831 static inline VEC(tree, heap) *
1832 get_vector_of_formal_parm_types (tree fntype)
1833 {
1834   VEC(tree, heap) *types;
1835   int count = 0;
1836   tree t;
1837
1838   for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1839     count++;
1840
1841   types = VEC_alloc (tree, heap, count);
1842   for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1843     VEC_quick_push (tree, types, TREE_VALUE (t));
1844
1845   return types;
1846 }
1847
1848 /* Modify the function declaration FNDECL and its type according to the plan in
1849    ADJUSTMENTS.  It also sets base fields of individual adjustments structures
1850    to reflect the actual parameters being modified which are determined by the
1851    base_index field.  */
1852
1853 void
1854 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1855                               const char *synth_parm_prefix)
1856 {
1857   VEC(tree, heap) *oparms, *otypes;
1858   tree orig_type, new_type = NULL;
1859   tree old_arg_types, t, new_arg_types = NULL;
1860   tree parm, *link = &DECL_ARGUMENTS (fndecl);
1861   int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1862   tree new_reversed = NULL;
1863   bool care_for_types, last_parm_void;
1864
1865   if (!synth_parm_prefix)
1866     synth_parm_prefix = "SYNTH";
1867
1868   oparms = ipa_get_vector_of_formal_parms (fndecl);
1869   orig_type = TREE_TYPE (fndecl);
1870   old_arg_types = TYPE_ARG_TYPES (orig_type);
1871
1872   /* The following test is an ugly hack, some functions simply don't have any
1873      arguments in their type.  This is probably a bug but well... */
1874   care_for_types = (old_arg_types != NULL_TREE);
1875   if (care_for_types)
1876     {
1877       last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1878                         == void_type_node);
1879       otypes = get_vector_of_formal_parm_types (orig_type);
1880       if (last_parm_void)
1881         gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1882       else
1883         gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1884     }
1885   else
1886     {
1887       last_parm_void = false;
1888       otypes = NULL;
1889     }
1890
1891   for (i = 0; i < len; i++)
1892     {
1893       struct ipa_parm_adjustment *adj;
1894       gcc_assert (link);
1895
1896       adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1897       parm = VEC_index (tree, oparms, adj->base_index);
1898       adj->base = parm;
1899
1900       if (adj->copy_param)
1901         {
1902           if (care_for_types)
1903             new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
1904                                                              adj->base_index),
1905                                        new_arg_types);
1906           *link = parm;
1907           link = &TREE_CHAIN (parm);
1908         }
1909       else if (!adj->remove_param)
1910         {
1911           tree new_parm;
1912           tree ptype;
1913
1914           if (adj->by_ref)
1915             ptype = build_pointer_type (adj->type);
1916           else
1917             ptype = adj->type;
1918
1919           if (care_for_types)
1920             new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
1921
1922           new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
1923                                  ptype);
1924           DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
1925
1926           DECL_ARTIFICIAL (new_parm) = 1;
1927           DECL_ARG_TYPE (new_parm) = ptype;
1928           DECL_CONTEXT (new_parm) = fndecl;
1929           TREE_USED (new_parm) = 1;
1930           DECL_IGNORED_P (new_parm) = 1;
1931           layout_decl (new_parm, 0);
1932
1933           add_referenced_var (new_parm);
1934           mark_sym_for_renaming (new_parm);
1935           adj->base = parm;
1936           adj->reduction = new_parm;
1937
1938           *link = new_parm;
1939
1940           link = &TREE_CHAIN (new_parm);
1941         }
1942     }
1943
1944   *link = NULL_TREE;
1945
1946   if (care_for_types)
1947     {
1948       new_reversed = nreverse (new_arg_types);
1949       if (last_parm_void)
1950         {
1951           if (new_reversed)
1952             TREE_CHAIN (new_arg_types) = void_list_node;
1953           else
1954             new_reversed = void_list_node;
1955         }
1956     }
1957
1958   /* Use copy_node to preserve as much as possible from original type
1959      (debug info, attribute lists etc.)
1960      Exception is METHOD_TYPEs must have THIS argument.
1961      When we are asked to remove it, we need to build new FUNCTION_TYPE
1962      instead.  */
1963   if (TREE_CODE (orig_type) != METHOD_TYPE
1964        || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
1965          && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
1966     {
1967       new_type = copy_node (orig_type);
1968       TYPE_ARG_TYPES (new_type) = new_reversed;
1969     }
1970   else
1971     {
1972       new_type
1973         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
1974                                                          new_reversed));
1975       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
1976       DECL_VINDEX (fndecl) = NULL_TREE;
1977     }
1978
1979   /* This is a new type, not a copy of an old type.  Need to reassociate
1980      variants.  We can handle everything except the main variant lazily.  */
1981   t = TYPE_MAIN_VARIANT (orig_type);
1982   if (orig_type != t)
1983     {
1984       TYPE_MAIN_VARIANT (new_type) = t;
1985       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
1986       TYPE_NEXT_VARIANT (t) = new_type;
1987     }
1988   else
1989     {
1990       TYPE_MAIN_VARIANT (new_type) = new_type;
1991       TYPE_NEXT_VARIANT (new_type) = NULL;
1992     }
1993
1994   TREE_TYPE (fndecl) = new_type;
1995   if (otypes)
1996     VEC_free (tree, heap, otypes);
1997   VEC_free (tree, heap, oparms);
1998 }
1999
2000 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2001    If this is a directly recursive call, CS must be NULL.  Otherwise it must
2002    contain the corresponding call graph edge.  */
2003
2004 void
2005 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2006                            ipa_parm_adjustment_vec adjustments)
2007 {
2008   VEC(tree, heap) *vargs;
2009   gimple new_stmt;
2010   gimple_stmt_iterator gsi;
2011   tree callee_decl;
2012   int i, len;
2013
2014   len = VEC_length (ipa_parm_adjustment_t, adjustments);
2015   vargs = VEC_alloc (tree, heap, len);
2016
2017   gsi = gsi_for_stmt (stmt);
2018   for (i = 0; i < len; i++)
2019     {
2020       struct ipa_parm_adjustment *adj;
2021
2022       adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2023
2024       if (adj->copy_param)
2025         {
2026           tree arg = gimple_call_arg (stmt, adj->base_index);
2027
2028           VEC_quick_push (tree, vargs, arg);
2029         }
2030       else if (!adj->remove_param)
2031         {
2032           tree expr, orig_expr;
2033           bool allow_ptr, repl_found;
2034
2035           orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
2036           if (TREE_CODE (expr) == ADDR_EXPR)
2037             {
2038               allow_ptr = false;
2039               expr = TREE_OPERAND (expr, 0);
2040             }
2041           else
2042             allow_ptr = true;
2043
2044           repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
2045                                              adj->offset, adj->type,
2046                                              allow_ptr);
2047           if (repl_found)
2048             {
2049               if (adj->by_ref)
2050                 expr = build_fold_addr_expr (expr);
2051             }
2052           else
2053             {
2054               tree ptrtype = build_pointer_type (adj->type);
2055               expr = orig_expr;
2056               if (!POINTER_TYPE_P (TREE_TYPE (expr)))
2057                 expr = build_fold_addr_expr (expr);
2058               if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
2059                 expr = fold_convert (ptrtype, expr);
2060               expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
2061                                   build_int_cst (sizetype,
2062                                                  adj->offset / BITS_PER_UNIT));
2063               if (!adj->by_ref)
2064                 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
2065             }
2066           expr = force_gimple_operand_gsi (&gsi, expr,
2067                                            adj->by_ref
2068                                            || is_gimple_reg_type (adj->type),
2069                                            NULL, true, GSI_SAME_STMT);
2070           VEC_quick_push (tree, vargs, expr);
2071         }
2072     }
2073
2074   if (dump_file && (dump_flags & TDF_DETAILS))
2075     {
2076       fprintf (dump_file, "replacing stmt:");
2077       print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2078     }
2079
2080   callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2081   new_stmt = gimple_build_call_vec (callee_decl, vargs);
2082   VEC_free (tree, heap, vargs);
2083   if (gimple_call_lhs (stmt))
2084     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2085
2086   gimple_set_block (new_stmt, gimple_block (stmt));
2087   if (gimple_has_location (stmt))
2088     gimple_set_location (new_stmt, gimple_location (stmt));
2089   gimple_call_copy_flags (new_stmt, stmt);
2090   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2091
2092   if (dump_file && (dump_flags & TDF_DETAILS))
2093     {
2094       fprintf (dump_file, "with stmt:");
2095       print_gimple_stmt (dump_file, new_stmt, 0, 0);
2096       fprintf (dump_file, "\n");
2097     }
2098   gsi_replace (&gsi, new_stmt, true);
2099   if (cs)
2100     cgraph_set_call_stmt (cs, new_stmt);
2101   update_ssa (TODO_update_ssa);
2102   free_dominance_info (CDI_DOMINATORS);
2103 }
2104
2105 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once.  */
2106
2107 static bool
2108 index_in_adjustments_multiple_times_p (int base_index,
2109                                        ipa_parm_adjustment_vec adjustments)
2110 {
2111   int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2112   bool one = false;
2113
2114   for (i = 0; i < len; i++)
2115     {
2116       struct ipa_parm_adjustment *adj;
2117       adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2118
2119       if (adj->base_index == base_index)
2120         {
2121           if (one)
2122             return true;
2123           else
2124             one = true;
2125         }
2126     }
2127   return false;
2128 }
2129
2130
2131 /* Return adjustments that should have the same effect on function parameters
2132    and call arguments as if they were first changed according to adjustments in
2133    INNER and then by adjustments in OUTER.  */
2134
2135 ipa_parm_adjustment_vec
2136 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2137                          ipa_parm_adjustment_vec outer)
2138 {
2139   int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2140   int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2141   int removals = 0;
2142   ipa_parm_adjustment_vec adjustments, tmp;
2143
2144   tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2145   for (i = 0; i < inlen; i++)
2146     {
2147       struct ipa_parm_adjustment *n;
2148       n = VEC_index (ipa_parm_adjustment_t, inner, i);
2149
2150       if (n->remove_param)
2151         removals++;
2152       else
2153         VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2154     }
2155
2156   adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2157   for (i = 0; i < outlen; i++)
2158     {
2159       struct ipa_parm_adjustment *r;
2160       struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2161                                                    outer, i);
2162       struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2163                                                   out->base_index);
2164
2165       gcc_assert (!in->remove_param);
2166       if (out->remove_param)
2167         {
2168           if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2169             {
2170               r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2171               memset (r, 0, sizeof (*r));
2172               r->remove_param = true;
2173             }
2174           continue;
2175         }
2176
2177       r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2178       memset (r, 0, sizeof (*r));
2179       r->base_index = in->base_index;
2180       r->type = out->type;
2181
2182       /* FIXME:  Create nonlocal value too.  */
2183
2184       if (in->copy_param && out->copy_param)
2185         r->copy_param = true;
2186       else if (in->copy_param)
2187         r->offset = out->offset;
2188       else if (out->copy_param)
2189         r->offset = in->offset;
2190       else
2191         r->offset = in->offset + out->offset;
2192     }
2193
2194   for (i = 0; i < inlen; i++)
2195     {
2196       struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2197                                                  inner, i);
2198
2199       if (n->remove_param)
2200         VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2201     }
2202
2203   VEC_free (ipa_parm_adjustment_t, heap, tmp);
2204   return adjustments;
2205 }
2206
2207 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2208    friendly way, assuming they are meant to be applied to FNDECL.  */
2209
2210 void
2211 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2212                             tree fndecl)
2213 {
2214   int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2215   bool first = true;
2216   VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2217
2218   fprintf (file, "IPA param adjustments: ");
2219   for (i = 0; i < len; i++)
2220     {
2221       struct ipa_parm_adjustment *adj;
2222       adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2223
2224       if (!first)
2225         fprintf (file, "                 ");
2226       else
2227         first = false;
2228
2229       fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2230       print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2231       if (adj->base)
2232         {
2233           fprintf (file, ", base: ");
2234           print_generic_expr (file, adj->base, 0);
2235         }
2236       if (adj->reduction)
2237         {
2238           fprintf (file, ", reduction: ");
2239           print_generic_expr (file, adj->reduction, 0);
2240         }
2241       if (adj->new_ssa_base)
2242         {
2243           fprintf (file, ", new_ssa_base: ");
2244           print_generic_expr (file, adj->new_ssa_base, 0);
2245         }
2246
2247       if (adj->copy_param)
2248         fprintf (file, ", copy_param");
2249       else if (adj->remove_param)
2250         fprintf (file, ", remove_param");
2251       else
2252         fprintf (file, ", offset %li", (long) adj->offset);
2253       if (adj->by_ref)
2254         fprintf (file, ", by_ref");
2255       print_node_brief (file, ", type: ", adj->type, 0);
2256       fprintf (file, "\n");
2257     }
2258   VEC_free (tree, heap, parms);
2259 }
2260
2261 /* Stream out jump function JUMP_FUNC to OB.  */
2262
2263 static void
2264 ipa_write_jump_function (struct output_block *ob,
2265                          struct ipa_jump_func *jump_func)
2266 {
2267   lto_output_uleb128_stream (ob->main_stream,
2268                              jump_func->type);
2269
2270   switch (jump_func->type)
2271     {
2272     case IPA_JF_UNKNOWN:
2273       break;
2274     case IPA_JF_KNOWN_TYPE:
2275       lto_output_tree (ob, jump_func->value.base_binfo, true);
2276       break;
2277     case IPA_JF_CONST:
2278       lto_output_tree (ob, jump_func->value.constant, true);
2279       break;
2280     case IPA_JF_PASS_THROUGH:
2281       lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2282       lto_output_uleb128_stream (ob->main_stream,
2283                                  jump_func->value.pass_through.formal_id);
2284       lto_output_uleb128_stream (ob->main_stream,
2285                                  jump_func->value.pass_through.operation);
2286       break;
2287     case IPA_JF_ANCESTOR:
2288       lto_output_uleb128_stream (ob->main_stream,
2289                                  jump_func->value.ancestor.offset);
2290       lto_output_tree (ob, jump_func->value.ancestor.type, true);
2291       lto_output_uleb128_stream (ob->main_stream,
2292                                  jump_func->value.ancestor.formal_id);
2293       break;
2294     case IPA_JF_CONST_MEMBER_PTR:
2295       lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2296       lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2297       break;
2298     }
2299 }
2300
2301 /* Read in jump function JUMP_FUNC from IB.  */
2302
2303 static void
2304 ipa_read_jump_function (struct lto_input_block *ib,
2305                         struct ipa_jump_func *jump_func,
2306                         struct data_in *data_in)
2307 {
2308   jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2309
2310   switch (jump_func->type)
2311     {
2312     case IPA_JF_UNKNOWN:
2313       break;
2314     case IPA_JF_KNOWN_TYPE:
2315       jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2316       break;
2317     case IPA_JF_CONST:
2318       jump_func->value.constant = lto_input_tree (ib, data_in);
2319       break;
2320     case IPA_JF_PASS_THROUGH:
2321       jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2322       jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2323       jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2324       break;
2325     case IPA_JF_ANCESTOR:
2326       jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2327       jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2328       jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2329       break;
2330     case IPA_JF_CONST_MEMBER_PTR:
2331       jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2332       jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2333       break;
2334     }
2335 }
2336
2337 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2338    relevant to indirect inlining to OB.  */
2339
2340 static void
2341 ipa_write_indirect_edge_info (struct output_block *ob,
2342                               struct cgraph_edge *cs)
2343 {
2344   struct cgraph_indirect_call_info *ii = cs->indirect_info;
2345   struct bitpack_d *bp;
2346
2347   lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2348   lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2349   bp = bitpack_create ();
2350   bp_pack_value (bp, ii->polymorphic, 1);
2351   lto_output_bitpack (ob->main_stream, bp);
2352   bitpack_delete (bp);
2353
2354   if (ii->polymorphic)
2355     {
2356       lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2357       lto_output_tree (ob, ii->otr_type, true);
2358     }
2359 }
2360
2361 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2362    relevant to indirect inlining from IB.  */
2363
2364 static void
2365 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2366                              struct data_in *data_in ATTRIBUTE_UNUSED,
2367                              struct cgraph_edge *cs)
2368 {
2369   struct cgraph_indirect_call_info *ii = cs->indirect_info;
2370   struct bitpack_d *bp;
2371
2372   ii->param_index = (int) lto_input_sleb128 (ib);
2373   ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2374   bp = lto_input_bitpack (ib);
2375   ii->polymorphic = bp_unpack_value (bp, 1);
2376   bitpack_delete (bp);
2377   if (ii->polymorphic)
2378     {
2379       ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2380       ii->otr_type = lto_input_tree (ib, data_in);
2381     }
2382 }
2383
2384 /* Stream out NODE info to OB.  */
2385
2386 static void
2387 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2388 {
2389   int node_ref;
2390   lto_cgraph_encoder_t encoder;
2391   struct ipa_node_params *info = IPA_NODE_REF (node);
2392   int j;
2393   struct cgraph_edge *e;
2394   struct bitpack_d *bp;
2395
2396   encoder = ob->decl_state->cgraph_node_encoder;
2397   node_ref = lto_cgraph_encoder_encode (encoder, node);
2398   lto_output_uleb128_stream (ob->main_stream, node_ref);
2399
2400   bp = bitpack_create ();
2401   bp_pack_value (bp, info->called_with_var_arguments, 1);
2402   bp_pack_value (bp, info->uses_analysis_done, 1);
2403   gcc_assert (info->modification_analysis_done
2404               || ipa_get_param_count (info) == 0);
2405   gcc_assert (!info->node_enqueued);
2406   gcc_assert (!info->ipcp_orig_node);
2407   for (j = 0; j < ipa_get_param_count (info); j++)
2408     {
2409       bp_pack_value (bp, info->params[j].modified, 1);
2410       bp_pack_value (bp, info->params[j].used, 1);
2411     }
2412   lto_output_bitpack (ob->main_stream, bp);
2413   bitpack_delete (bp);
2414   for (e = node->callees; e; e = e->next_callee)
2415     {
2416       struct ipa_edge_args *args = IPA_EDGE_REF (e);
2417
2418       lto_output_uleb128_stream (ob->main_stream,
2419                                  ipa_get_cs_argument_count (args));
2420       for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2421         ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2422     }
2423   for (e = node->indirect_calls; e; e = e->next_callee)
2424     ipa_write_indirect_edge_info (ob, e);
2425 }
2426
2427 /* Srtream in NODE info from IB.  */
2428
2429 static void
2430 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2431                     struct data_in *data_in)
2432 {
2433   struct ipa_node_params *info = IPA_NODE_REF (node);
2434   int k;
2435   struct cgraph_edge *e;
2436   struct bitpack_d *bp;
2437
2438   ipa_initialize_node_params (node);
2439
2440   bp = lto_input_bitpack (ib);
2441   info->called_with_var_arguments = bp_unpack_value (bp, 1);
2442   info->uses_analysis_done = bp_unpack_value (bp, 1);
2443   if (ipa_get_param_count (info) != 0)
2444     {
2445       info->modification_analysis_done = true;
2446       info->uses_analysis_done = true;
2447     }
2448   info->node_enqueued = false;
2449   for (k = 0; k < ipa_get_param_count (info); k++)
2450     {
2451       info->params[k].modified = bp_unpack_value (bp, 1);
2452       info->params[k].used = bp_unpack_value (bp, 1);
2453     }
2454   bitpack_delete (bp);
2455   for (e = node->callees; e; e = e->next_callee)
2456     {
2457       struct ipa_edge_args *args = IPA_EDGE_REF (e);
2458       int count = lto_input_uleb128 (ib);
2459
2460       ipa_set_cs_argument_count (args, count);
2461       if (!count)
2462         continue;
2463
2464       args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
2465                                           ipa_get_cs_argument_count (args));
2466       for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2467         ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2468     }
2469   for (e = node->indirect_calls; e; e = e->next_callee)
2470     ipa_read_indirect_edge_info (ib, data_in, e);
2471 }
2472
2473 /* Write jump functions for nodes in SET.  */
2474
2475 void
2476 ipa_prop_write_jump_functions (cgraph_node_set set)
2477 {
2478   struct cgraph_node *node;
2479   struct output_block *ob = create_output_block (LTO_section_jump_functions);
2480   unsigned int count = 0;
2481   cgraph_node_set_iterator csi;
2482
2483   ob->cgraph_node = NULL;
2484
2485   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2486     {
2487       node = csi_node (csi);
2488       if (node->analyzed && IPA_NODE_REF (node) != NULL)
2489         count++;
2490     }
2491
2492   lto_output_uleb128_stream (ob->main_stream, count);
2493
2494   /* Process all of the functions.  */
2495   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2496     {
2497       node = csi_node (csi);
2498       if (node->analyzed && IPA_NODE_REF (node) != NULL)
2499         ipa_write_node_info (ob, node);
2500     }
2501   lto_output_1_stream (ob->main_stream, 0);
2502   produce_asm (ob, NULL);
2503   destroy_output_block (ob);
2504 }
2505
2506 /* Read section in file FILE_DATA of length LEN with data DATA.  */
2507
2508 static void
2509 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2510                        size_t len)
2511 {
2512   const struct lto_function_header *header =
2513     (const struct lto_function_header *) data;
2514   const int32_t cfg_offset = sizeof (struct lto_function_header);
2515   const int32_t main_offset = cfg_offset + header->cfg_size;
2516   const int32_t string_offset = main_offset + header->main_size;
2517   struct data_in *data_in;
2518   struct lto_input_block ib_main;
2519   unsigned int i;
2520   unsigned int count;
2521
2522   LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2523                         header->main_size);
2524
2525   data_in =
2526     lto_data_in_create (file_data, (const char *) data + string_offset,
2527                         header->string_size, NULL);
2528   count = lto_input_uleb128 (&ib_main);
2529
2530   for (i = 0; i < count; i++)
2531     {
2532       unsigned int index;
2533       struct cgraph_node *node;
2534       lto_cgraph_encoder_t encoder;
2535
2536       index = lto_input_uleb128 (&ib_main);
2537       encoder = file_data->cgraph_node_encoder;
2538       node = lto_cgraph_encoder_deref (encoder, index);
2539       gcc_assert (node->analyzed);
2540       ipa_read_node_info (&ib_main, node, data_in);
2541     }
2542   lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2543                          len);
2544   lto_data_in_delete (data_in);
2545 }
2546
2547 /* Read ipcp jump functions.  */
2548
2549 void
2550 ipa_prop_read_jump_functions (void)
2551 {
2552   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2553   struct lto_file_decl_data *file_data;
2554   unsigned int j = 0;
2555
2556   ipa_check_create_node_params ();
2557   ipa_check_create_edge_args ();
2558   ipa_register_cgraph_hooks ();
2559
2560   while ((file_data = file_data_vec[j++]))
2561     {
2562       size_t len;
2563       const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2564
2565       if (data)
2566         ipa_prop_read_section (file_data, data, len);
2567     }
2568 }
2569
2570 /* After merging units, we can get mismatch in argument counts.
2571    Also decl merging might've rendered parameter lists obsolette.
2572    Also compute called_with_variable_arg info.  */
2573
2574 void
2575 ipa_update_after_lto_read (void)
2576 {
2577   struct cgraph_node *node;
2578   struct cgraph_edge *cs;
2579
2580   ipa_check_create_node_params ();
2581   ipa_check_create_edge_args ();
2582
2583   for (node = cgraph_nodes; node; node = node->next)
2584     if (node->analyzed)
2585       ipa_initialize_node_params (node);
2586
2587   for (node = cgraph_nodes; node; node = node->next)
2588     if (node->analyzed)
2589       for (cs = node->callees; cs; cs = cs->next_callee)
2590         {
2591           if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2592               != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2593             ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
2594         }
2595 }