OSDN Git Service

2011-11-09 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / gimple-streamer-in.c
1 /* Routines for reading GIMPLE from a file stream.
2
3    Copyright 2011 Free Software Foundation, Inc.
4    Contributed by Diego Novillo <dnovillo@google.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "diagnostic.h"
26 #include "tree.h"
27 #include "tree-flow.h"
28 #include "data-streamer.h"
29 #include "tree-streamer.h"
30 #include "gimple-streamer.h"
31
32 /* Read a PHI function for basic block BB in function FN.  DATA_IN is
33    the file being read.  IB is the input block to use for reading.  */
34
35 static gimple
36 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
37            struct function *fn)
38 {
39   unsigned HOST_WIDE_INT ix;
40   tree phi_result;
41   int i, len;
42   gimple result;
43
44   ix = streamer_read_uhwi (ib);
45   phi_result = VEC_index (tree, SSANAMES (fn), ix);
46   len = EDGE_COUNT (bb->preds);
47   result = create_phi_node (phi_result, bb);
48   SSA_NAME_DEF_STMT (phi_result) = result;
49
50   /* We have to go through a lookup process here because the preds in the
51      reconstructed graph are generally in a different order than they
52      were in the original program.  */
53   for (i = 0; i < len; i++)
54     {
55       tree def = stream_read_tree (ib, data_in);
56       int src_index = streamer_read_uhwi (ib);
57       location_t arg_loc = lto_input_location (ib, data_in);
58       basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
59
60       edge e = NULL;
61       int j;
62
63       for (j = 0; j < len; j++)
64         if (EDGE_PRED (bb, j)->src == sbb)
65           {
66             e = EDGE_PRED (bb, j);
67             break;
68           }
69
70       add_phi_arg (result, def, e, arg_loc);
71     }
72
73   return result;
74 }
75
76
77 /* Read a statement with tag TAG in function FN from block IB using
78    descriptors in DATA_IN.  */
79
80 static gimple
81 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
82                    struct function *fn, enum LTO_tags tag)
83 {
84   gimple stmt;
85   enum gimple_code code;
86   unsigned HOST_WIDE_INT num_ops;
87   size_t i;
88   struct bitpack_d bp;
89
90   code = lto_tag_to_gimple_code (tag);
91
92   /* Read the tuple header.  */
93   bp = streamer_read_bitpack (ib);
94   num_ops = bp_unpack_var_len_unsigned (&bp);
95   stmt = gimple_alloc (code, num_ops);
96   stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
97   if (is_gimple_assign (stmt))
98     stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
99   stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
100   stmt->gsbase.subcode = bp_unpack_var_len_unsigned (&bp);
101
102   /* Read location information.  */
103   gimple_set_location (stmt, lto_input_location (ib, data_in));
104
105   /* Read lexical block reference.  */
106   gimple_set_block (stmt, stream_read_tree (ib, data_in));
107
108   /* Read in all the operands.  */
109   switch (code)
110     {
111     case GIMPLE_RESX:
112       gimple_resx_set_region (stmt, streamer_read_hwi (ib));
113       break;
114
115     case GIMPLE_EH_MUST_NOT_THROW:
116       gimple_eh_must_not_throw_set_fndecl (stmt, stream_read_tree (ib, data_in));
117       break;
118
119     case GIMPLE_EH_DISPATCH:
120       gimple_eh_dispatch_set_region (stmt, streamer_read_hwi (ib));
121       break;
122
123     case GIMPLE_ASM:
124       {
125         /* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
126         tree str;
127         stmt->gimple_asm.ni = streamer_read_uhwi (ib);
128         stmt->gimple_asm.no = streamer_read_uhwi (ib);
129         stmt->gimple_asm.nc = streamer_read_uhwi (ib);
130         stmt->gimple_asm.nl = streamer_read_uhwi (ib);
131         str = streamer_read_string_cst (data_in, ib);
132         stmt->gimple_asm.string = TREE_STRING_POINTER (str);
133       }
134       /* Fallthru  */
135
136     case GIMPLE_ASSIGN:
137     case GIMPLE_CALL:
138     case GIMPLE_RETURN:
139     case GIMPLE_SWITCH:
140     case GIMPLE_LABEL:
141     case GIMPLE_COND:
142     case GIMPLE_GOTO:
143     case GIMPLE_DEBUG:
144       for (i = 0; i < num_ops; i++)
145         {
146           tree op = stream_read_tree (ib, data_in);
147           gimple_set_op (stmt, i, op);
148           if (!op)
149             continue;
150
151           /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
152              by decl merging.  */
153           if (TREE_CODE (op) == ADDR_EXPR)
154             op = TREE_OPERAND (op, 0);
155           while (handled_component_p (op))
156             {
157               if (TREE_CODE (op) == COMPONENT_REF)
158                 {
159                   tree field, type, tem;
160                   tree closest_match = NULL_TREE;
161                   field = TREE_OPERAND (op, 1);
162                   type = DECL_CONTEXT (field);
163                   for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
164                     {
165                       if (tem == field)
166                         break;
167                       if (DECL_NONADDRESSABLE_P (tem)
168                           == DECL_NONADDRESSABLE_P (field)
169                           && gimple_compare_field_offset (tem, field))
170                         {
171                           if (types_compatible_p (TREE_TYPE (tem),
172                                                   TREE_TYPE (field)))
173                             break;
174                           else
175                             closest_match = tem;
176                         }
177                     }
178                   /* In case of type mismatches across units we can fail
179                      to unify some types and thus not find a proper
180                      field-decl here.  */
181                   if (tem == NULL_TREE)
182                     {
183                       /* Thus, emit a ODR violation warning.  */
184                       if (warning_at (gimple_location (stmt), 0,
185                                       "use of type %<%E%> with two mismatching "
186                                       "declarations at field %<%E%>",
187                                       type, TREE_OPERAND (op, 1)))
188                         {
189                           if (TYPE_FIELDS (type))
190                             inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
191                                     "original type declared here");
192                           inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
193                                   "field in mismatching type declared here");
194                           if (TYPE_NAME (TREE_TYPE (field))
195                               && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
196                                   == TYPE_DECL))
197                             inform (DECL_SOURCE_LOCATION
198                                       (TYPE_NAME (TREE_TYPE (field))),
199                                     "type of field declared here");
200                           if (closest_match
201                               && TYPE_NAME (TREE_TYPE (closest_match))
202                               && (TREE_CODE (TYPE_NAME
203                                    (TREE_TYPE (closest_match))) == TYPE_DECL))
204                             inform (DECL_SOURCE_LOCATION
205                                       (TYPE_NAME (TREE_TYPE (closest_match))),
206                                     "type of mismatching field declared here");
207                         }
208                       /* And finally fixup the types.  */
209                       TREE_OPERAND (op, 0)
210                         = build1 (VIEW_CONVERT_EXPR, type,
211                                   TREE_OPERAND (op, 0));
212                     }
213                   else
214                     TREE_OPERAND (op, 1) = tem;
215                 }
216
217               op = TREE_OPERAND (op, 0);
218             }
219         }
220       if (is_gimple_call (stmt))
221         {
222           tree fndecl;
223           if (gimple_call_internal_p (stmt))
224             gimple_call_set_internal_fn
225               (stmt, streamer_read_enum (ib, internal_fn, IFN_LAST));
226           else
227             gimple_call_set_fntype (stmt, stream_read_tree (ib, data_in));
228           /* Update the non-inlinable flag conservatively.  */
229           fndecl = gimple_call_fndecl (stmt);
230           if (fndecl
231               && !gimple_call_cannot_inline_p (stmt)
232               && !gimple_check_call_matching_types (stmt, fndecl))
233             gimple_call_set_cannot_inline (stmt, true);
234         }
235       break;
236
237     case GIMPLE_NOP:
238     case GIMPLE_PREDICT:
239       break;
240
241     default:
242       internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
243                       lto_tag_name (tag));
244     }
245
246   /* Update the properties of symbols, SSA names and labels associated
247      with STMT.  */
248   if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
249     {
250       tree lhs = gimple_get_lhs (stmt);
251       if (lhs && TREE_CODE (lhs) == SSA_NAME)
252         SSA_NAME_DEF_STMT (lhs) = stmt;
253     }
254   else if (code == GIMPLE_LABEL)
255     gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
256                 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
257   else if (code == GIMPLE_ASM)
258     {
259       unsigned i;
260
261       for (i = 0; i < gimple_asm_noutputs (stmt); i++)
262         {
263           tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
264           if (TREE_CODE (op) == SSA_NAME)
265             SSA_NAME_DEF_STMT (op) = stmt;
266         }
267     }
268
269   /* Reset alias information.  */
270   if (code == GIMPLE_CALL)
271     gimple_call_reset_alias_info (stmt);
272
273   /* Mark the statement modified so its operand vectors can be filled in.  */
274   gimple_set_modified (stmt, true);
275
276   return stmt;
277 }
278
279
280 /* Read a basic block with tag TAG from DATA_IN using input block IB.
281    FN is the function being processed.  */
282
283 void
284 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
285           struct data_in *data_in, struct function *fn,
286           int count_materialization_scale)
287 {
288   unsigned int index;
289   basic_block bb;
290   gimple_stmt_iterator bsi;
291
292   /* This routine assumes that CFUN is set to FN, as it needs to call
293      basic GIMPLE routines that use CFUN.  */
294   gcc_assert (cfun == fn);
295
296   index = streamer_read_uhwi (ib);
297   bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
298
299   bb->count = (streamer_read_hwi (ib) * count_materialization_scale
300                + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
301   bb->loop_depth = streamer_read_hwi (ib);
302   bb->frequency = streamer_read_hwi (ib);
303   bb->flags = streamer_read_hwi (ib);
304
305   /* LTO_bb1 has statements.  LTO_bb0 does not.  */
306   if (tag == LTO_bb0)
307     return;
308
309   bsi = gsi_start_bb (bb);
310   tag = streamer_read_record_start (ib);
311   while (tag)
312     {
313       gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
314       if (!is_gimple_debug (stmt))
315         find_referenced_vars_in (stmt);
316       gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
317
318       /* After the statement, expect a 0 delimiter or the EH region
319          that the previous statement belongs to.  */
320       tag = streamer_read_record_start (ib);
321       lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
322
323       if (tag == LTO_eh_region)
324         {
325           HOST_WIDE_INT region = streamer_read_hwi (ib);
326           gcc_assert (region == (int) region);
327           add_stmt_to_eh_lp (stmt, region);
328         }
329
330       tag = streamer_read_record_start (ib);
331     }
332
333   tag = streamer_read_record_start (ib);
334   while (tag)
335     {
336       gimple phi = input_phi (ib, bb, data_in, fn);
337       find_referenced_vars_in (phi);
338       tag = streamer_read_record_start (ib);
339     }
340 }