1 /* Routines for reading GIMPLE from a file stream.
2
3 Copyright (C) 2011-2014 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 "basic-block.h"
28 #include "tree-ssa-alias.h"
29 #include "internal-fn.h"
30 #include "tree-eh.h"
31 #include "gimple-expr.h"
32 #include "is-a.h"
33 #include "gimple.h"
34 #include "gimple-iterator.h"
35 #include "gimple-ssa.h"
36 #include "tree-phinodes.h"
37 #include "stringpool.h"
38 #include "tree-ssanames.h"
39 #include "data-streamer.h"
40 #include "tree-streamer.h"
41 #include "gimple-streamer.h"
42 #include "value-prof.h"
43
44 /* Read a PHI function for basic block BB in function FN. DATA_IN is
45 the file being read. IB is the input block to use for reading. */
46
47 static gimple
input_phi(struct lto_input_block * ib,basic_block bb,struct data_in * data_in,struct function * fn)48 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
49 struct function *fn)
50 {
51 unsigned HOST_WIDE_INT ix;
52 tree phi_result;
53 int i, len;
54 gimple result;
55
56 ix = streamer_read_uhwi (ib);
57 phi_result = (*SSANAMES (fn))[ix];
58 len = EDGE_COUNT (bb->preds);
59 result = create_phi_node (phi_result, bb);
60
61 /* We have to go through a lookup process here because the preds in the
62 reconstructed graph are generally in a different order than they
63 were in the original program. */
64 for (i = 0; i < len; i++)
65 {
66 tree def = stream_read_tree (ib, data_in);
67 int src_index = streamer_read_uhwi (ib);
68 bitpack_d bp = streamer_read_bitpack (ib);
69 location_t arg_loc = stream_input_location (&bp, data_in);
70 basic_block sbb = BASIC_BLOCK_FOR_FN (fn, src_index);
71
72 edge e = NULL;
73 int j;
74
75 for (j = 0; j < len; j++)
76 if (EDGE_PRED (bb, j)->src == sbb)
77 {
78 e = EDGE_PRED (bb, j);
79 break;
80 }
81
82 add_phi_arg (result, def, e, arg_loc);
83 }
84
85 return result;
86 }
87
88
89 /* Read a statement with tag TAG in function FN from block IB using
90 descriptors in DATA_IN. */
91
92 static gimple
input_gimple_stmt(struct lto_input_block * ib,struct data_in * data_in,enum LTO_tags tag)93 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
94 enum LTO_tags tag)
95 {
96 gimple stmt;
97 enum gimple_code code;
98 unsigned HOST_WIDE_INT num_ops;
99 size_t i;
100 struct bitpack_d bp;
101 bool has_hist;
102
103 code = lto_tag_to_gimple_code (tag);
104
105 /* Read the tuple header. */
106 bp = streamer_read_bitpack (ib);
107 num_ops = bp_unpack_var_len_unsigned (&bp);
108 stmt = gimple_alloc (code, num_ops);
109 stmt->no_warning = bp_unpack_value (&bp, 1);
110 if (is_gimple_assign (stmt))
111 stmt->nontemporal_move = bp_unpack_value (&bp, 1);
112 stmt->has_volatile_ops = bp_unpack_value (&bp, 1);
113 has_hist = bp_unpack_value (&bp, 1);
114 stmt->subcode = bp_unpack_var_len_unsigned (&bp);
115
116 /* Read location information. */
117 gimple_set_location (stmt, stream_input_location (&bp, data_in));
118
119 /* Read lexical block reference. */
120 gimple_set_block (stmt, stream_read_tree (ib, data_in));
121
122 /* Read in all the operands. */
123 switch (code)
124 {
125 case GIMPLE_RESX:
126 gimple_resx_set_region (stmt, streamer_read_hwi (ib));
127 break;
128
129 case GIMPLE_EH_MUST_NOT_THROW:
130 gimple_eh_must_not_throw_set_fndecl (stmt, stream_read_tree (ib, data_in));
131 break;
132
133 case GIMPLE_EH_DISPATCH:
134 gimple_eh_dispatch_set_region (stmt, streamer_read_hwi (ib));
135 break;
136
137 case GIMPLE_ASM:
138 {
139 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
140 gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm> (stmt);
141 tree str;
142 asm_stmt->ni = streamer_read_uhwi (ib);
143 asm_stmt->no = streamer_read_uhwi (ib);
144 asm_stmt->nc = streamer_read_uhwi (ib);
145 asm_stmt->nl = streamer_read_uhwi (ib);
146 str = streamer_read_string_cst (data_in, ib);
147 asm_stmt->string = TREE_STRING_POINTER (str);
148 }
149 /* Fallthru */
150
151 case GIMPLE_ASSIGN:
152 case GIMPLE_CALL:
153 case GIMPLE_RETURN:
154 case GIMPLE_SWITCH:
155 case GIMPLE_LABEL:
156 case GIMPLE_COND:
157 case GIMPLE_GOTO:
158 case GIMPLE_DEBUG:
159 for (i = 0; i < num_ops; i++)
160 {
161 tree *opp, op = stream_read_tree (ib, data_in);
162 gimple_set_op (stmt, i, op);
163 if (!op)
164 continue;
165
166 opp = gimple_op_ptr (stmt, i);
167 if (TREE_CODE (*opp) == ADDR_EXPR)
168 opp = &TREE_OPERAND (*opp, 0);
169 while (handled_component_p (*opp))
170 opp = &TREE_OPERAND (*opp, 0);
171 /* At LTO output time we wrap all global decls in MEM_REFs to
172 allow seamless replacement with prevailing decls. Undo this
173 here if the prevailing decl allows for this.
174 ??? Maybe we should simply fold all stmts. */
175 if (TREE_CODE (*opp) == MEM_REF
176 && TREE_CODE (TREE_OPERAND (*opp, 0)) == ADDR_EXPR
177 && integer_zerop (TREE_OPERAND (*opp, 1))
178 && (TREE_THIS_VOLATILE (*opp)
179 == TREE_THIS_VOLATILE
180 (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0)))
181 && !TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (*opp, 1)))
182 && (TREE_TYPE (*opp)
183 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (*opp, 1))))
184 && (TREE_TYPE (*opp)
185 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0))))
186 *opp = TREE_OPERAND (TREE_OPERAND (*opp, 0), 0);
187 }
188 if (is_gimple_call (stmt))
189 {
190 if (gimple_call_internal_p (stmt))
191 gimple_call_set_internal_fn
192 (stmt, streamer_read_enum (ib, internal_fn, IFN_LAST));
193 else
194 gimple_call_set_fntype (stmt, stream_read_tree (ib, data_in));
195 }
196 break;
197
198 case GIMPLE_NOP:
199 case GIMPLE_PREDICT:
200 break;
201
202 case GIMPLE_TRANSACTION:
203 gimple_transaction_set_label (stmt, stream_read_tree (ib, data_in));
204 break;
205
206 default:
207 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
208 lto_tag_name (tag));
209 }
210
211 /* Update the properties of symbols, SSA names and labels associated
212 with STMT. */
213 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
214 {
215 tree lhs = gimple_get_lhs (stmt);
216 if (lhs && TREE_CODE (lhs) == SSA_NAME)
217 SSA_NAME_DEF_STMT (lhs) = stmt;
218 }
219 else if (code == GIMPLE_ASM)
220 {
221 unsigned i;
222
223 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
224 {
225 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
226 if (TREE_CODE (op) == SSA_NAME)
227 SSA_NAME_DEF_STMT (op) = stmt;
228 }
229 }
230
231 /* Reset alias information. */
232 if (code == GIMPLE_CALL)
233 gimple_call_reset_alias_info (stmt);
234
235 /* Mark the statement modified so its operand vectors can be filled in. */
236 gimple_set_modified (stmt, true);
237 if (has_hist)
238 stream_in_histogram_value (ib, stmt);
239
240 return stmt;
241 }
242
243
244 /* Read a basic block with tag TAG from DATA_IN using input block IB.
245 FN is the function being processed. */
246
247 void
input_bb(struct lto_input_block * ib,enum LTO_tags tag,struct data_in * data_in,struct function * fn,int count_materialization_scale)248 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
249 struct data_in *data_in, struct function *fn,
250 int count_materialization_scale)
251 {
252 unsigned int index;
253 basic_block bb;
254 gimple_stmt_iterator bsi;
255
256 /* This routine assumes that CFUN is set to FN, as it needs to call
257 basic GIMPLE routines that use CFUN. */
258 gcc_assert (cfun == fn);
259
260 index = streamer_read_uhwi (ib);
261 bb = BASIC_BLOCK_FOR_FN (fn, index);
262
263 bb->count = apply_scale (streamer_read_gcov_count (ib),
264 count_materialization_scale);
265 bb->frequency = streamer_read_hwi (ib);
266 bb->flags = streamer_read_hwi (ib);
267
268 /* LTO_bb1 has statements. LTO_bb0 does not. */
269 if (tag == LTO_bb0)
270 return;
271
272 bsi = gsi_start_bb (bb);
273 tag = streamer_read_record_start (ib);
274 while (tag)
275 {
276 gimple stmt = input_gimple_stmt (ib, data_in, tag);
277 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
278
279 /* After the statement, expect a 0 delimiter or the EH region
280 that the previous statement belongs to. */
281 tag = streamer_read_record_start (ib);
282 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
283
284 if (tag == LTO_eh_region)
285 {
286 HOST_WIDE_INT region = streamer_read_hwi (ib);
287 gcc_assert (region == (int) region);
288 add_stmt_to_eh_lp (stmt, region);
289 }
290
291 tag = streamer_read_record_start (ib);
292 }
293
294 tag = streamer_read_record_start (ib);
295 while (tag)
296 {
297 input_phi (ib, bb, data_in, fn);
298 tag = streamer_read_record_start (ib);
299 }
300 }
301