OSDN Git Service

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