Mercurial > hg > CbC > CbC_gcc

comparison gcc/lto-streamer-in.c @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Read the GIMPLE representation from a file stream. 1 /* Read the GIMPLE representation from a file stream.
2 2
3 Copyright 2009, 2010 Free Software Foundation, Inc. 3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> 4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com> 5 Re-implemented by Diego Novillo <dnovillo@google.com>
6 6
7 This file is part of GCC. 7 This file is part of GCC.
8 8
21 <http://www.gnu.org/licenses/>. */ 21 <http://www.gnu.org/licenses/>. */
22 22
23 #include "config.h" 23 #include "config.h"
24 #include "system.h" 24 #include "system.h"
25 #include "coretypes.h" 25 #include "coretypes.h"
26 #include "tm.h" 26 #include "backend.h"
27 #include "target.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "gimple.h"
31 #include "cfghooks.h"
32 #include "tree-pass.h"
33 #include "ssa.h"
34 #include "gimple-streamer.h"
27 #include "toplev.h" 35 #include "toplev.h"
28 #include "tree.h" 36 #include "gimple-iterator.h"
29 #include "expr.h" 37 #include "tree-cfg.h"
30 #include "flags.h" 38 #include "tree-into-ssa.h"
31 #include "params.h" 39 #include "tree-dfa.h"
32 #include "input.h" 40 #include "tree-ssa.h"
33 #include "hashtab.h" 41 #include "except.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
37 #include "cgraph.h" 42 #include "cgraph.h"
38 #include "function.h" 43 #include "cfgloop.h"
39 #include "ggc.h"
40 #include "diagnostic.h"
41 #include "libfuncs.h"
42 #include "except.h"
43 #include "debug.h" 44 #include "debug.h"
44 #include "vec.h" 45
45 #include "timevar.h" 46
46 #include "output.h" 47 struct freeing_string_slot_hasher : string_slot_hasher
47 #include "ipa-utils.h" 48 {
48 #include "lto-streamer.h" 49 static inline void remove (value_type *);
49 #include "tree-pass.h"
50
51 /* Data structure used to hash file names in the source_location field. */
52 struct string_slot
53 {
54 const char *s;
55 unsigned int slot_num;
56 }; 50 };
57 51
52 inline void
53 freeing_string_slot_hasher::remove (value_type *v)
54 {
55 free (v);
56 }
57
58 /* The table to hold the file names. */ 58 /* The table to hold the file names. */
59 static htab_t file_name_hash_table; 59 static hash_table<freeing_string_slot_hasher> *file_name_hash_table;
60 60
61 61
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the 62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */ 63 number of valid tag values to check. */
64 64
65 static void 65 void
66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...) 66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
67 { 67 {
68 va_list ap; 68 va_list ap;
69 int i; 69 int i;
70 70
79 va_end (ap); 79 va_end (ap);
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual)); 80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
81 } 81 }
82 82
83 83
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */ 84 /* Read LENGTH bytes from STREAM to ADDR. */
85 85
86 static void 86 void
87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1, 87 lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
88 enum LTO_tags tag2) 88 {
89 { 89 size_t i;
90 if (actual < tag1 || actual > tag2) 90 unsigned char *const buffer = (unsigned char *) addr;
91 internal_error ("bytecode stream: tag %s is not in the expected range " 91
92 "[%s, %s]", 92 for (i = 0; i < length; i++)
93 lto_tag_name (actual), 93 buffer[i] = streamer_read_uchar (ib);
94 lto_tag_name (tag1),
95 lto_tag_name (tag2));
96 }
97
98
99 /* Check that tag ACTUAL == EXPECTED. */
100
101 static void
102 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
103 {
104 if (actual != expected)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected), lto_tag_name (actual));
107 }
108
109
110 /* Return a hash code for P. */
111
112 static hashval_t
113 hash_string_slot_node (const void *p)
114 {
115 const struct string_slot *ds = (const struct string_slot *) p;
116 return (hashval_t) htab_hash_string (ds->s);
117 }
118
119
120 /* Returns nonzero if P1 and P2 are equal. */
121
122 static int
123 eq_string_slot_node (const void *p1, const void *p2)
124 {
125 const struct string_slot *ds1 = (const struct string_slot *) p1;
126 const struct string_slot *ds2 = (const struct string_slot *) p2;
127 return strcmp (ds1->s, ds2->s) == 0;
128 }
129
130
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
133
134 static const char *
135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
136 unsigned int *rlen)
137 {
138 struct lto_input_block str_tab;
139 unsigned int len;
140 unsigned int loc;
141 const char *result;
142
143 loc = lto_input_uleb128 (ib);
144 LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
145 len = lto_input_uleb128 (&str_tab);
146 *rlen = len;
147
148 if (str_tab.p + len > data_in->strings_len)
149 internal_error ("bytecode stream: string too long for the string table");
150
151 result = (const char *)(data_in->strings + str_tab.p);
152
153 return result;
154 }
155
156
157 /* Read a STRING_CST from the string table in DATA_IN using input
158 block IB. */
159
160 static tree
161 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
162 {
163 unsigned int len;
164 const char * ptr;
165 unsigned int is_null;
166
167 is_null = lto_input_uleb128 (ib);
168 if (is_null)
169 return NULL;
170
171 ptr = input_string_internal (data_in, ib, &len);
172 return build_string (len, ptr);
173 }
174
175
176 /* Read an IDENTIFIER from the string table in DATA_IN using input
177 block IB. */
178
179 static tree
180 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
181 {
182 unsigned int len;
183 const char *ptr;
184 unsigned int is_null;
185
186 is_null = lto_input_uleb128 (ib);
187 if (is_null)
188 return NULL;
189
190 ptr = input_string_internal (data_in, ib, &len);
191 return get_identifier_with_length (ptr, len);
192 }
193
194 /* Read a NULL terminated string from the string table in DATA_IN. */
195
196 static const char *
197 input_string (struct data_in *data_in, struct lto_input_block *ib)
198 {
199 unsigned int len;
200 const char *ptr;
201 unsigned int is_null;
202
203 is_null = lto_input_uleb128 (ib);
204 if (is_null)
205 return NULL;
206
207 ptr = input_string_internal (data_in, ib, &len);
208 if (ptr[len - 1] != '\0')
209 internal_error ("bytecode stream: found non-null terminated string");
210
211 return ptr;
212 }
213
214
215 /* Return the next tag in the input block IB. */
216
217 static enum LTO_tags
218 input_record_start (struct lto_input_block *ib)
219 {
220 enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
221 return tag;
222 } 94 }
223 95
224 96
225 /* Lookup STRING in file_name_hash_table. If found, return the existing 97 /* Lookup STRING in file_name_hash_table. If found, return the existing
226 string, otherwise insert STRING as the canonical version. */ 98 string, otherwise insert STRING as the canonical version. */
227 99
228 static const char * 100 static const char *
229 canon_file_name (const char *string) 101 canon_file_name (const char *string)
230 { 102 {
231 void **slot; 103 string_slot **slot;
232 struct string_slot s_slot; 104 struct string_slot s_slot;
105 size_t len = strlen (string);
106
233 s_slot.s = string; 107 s_slot.s = string;
234 108 s_slot.len = len;
235 slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT); 109
110 slot = file_name_hash_table->find_slot (&s_slot, INSERT);
236 if (*slot == NULL) 111 if (*slot == NULL)
237 { 112 {
238 size_t len;
239 char *saved_string; 113 char *saved_string;
240 struct string_slot *new_slot; 114 struct string_slot *new_slot;
241 115
242 len = strlen (string);
243 saved_string = (char *) xmalloc (len + 1); 116 saved_string = (char *) xmalloc (len + 1);
244 new_slot = XCNEW (struct string_slot); 117 new_slot = XCNEW (struct string_slot);
245 strcpy (saved_string, string); 118 memcpy (saved_string, string, len + 1);
246 new_slot->s = saved_string; 119 new_slot->s = saved_string;
120 new_slot->len = len;
247 *slot = new_slot; 121 *slot = new_slot;
248 return saved_string; 122 return saved_string;
249 } 123 }
250 else 124 else
251 { 125 {
252 struct string_slot *old_slot = (struct string_slot *) *slot; 126 struct string_slot *old_slot = *slot;
253 return old_slot->s; 127 return old_slot->s;
254 } 128 }
255 } 129 }
256 130
257 131 /* Pointer to currently alive instance of lto_location_cache. */
258 /* Clear the line info stored in DATA_IN. */ 132
259 133 lto_location_cache *lto_location_cache::current_cache;
260 static void 134
261 clear_line_info (struct data_in *data_in) 135 /* Sort locations in source order. Start with file from last application. */
262 { 136
263 if (data_in->current_file) 137 int
264 linemap_add (line_table, LC_LEAVE, false, NULL, 0); 138 lto_location_cache::cmp_loc (const void *pa, const void *pb)
265 data_in->current_file = NULL; 139 {
266 data_in->current_line = 0; 140 const cached_location *a = ((const cached_location *)pa);
267 data_in->current_col = 0; 141 const cached_location *b = ((const cached_location *)pb);
268 } 142 const char *current_file = current_cache->current_file;
269 143 int current_line = current_cache->current_line;
270 144
271 /* Read a location from input block IB. */ 145 if (a->file == current_file && b->file != current_file)
272 146 return -1;
273 static location_t 147 if (a->file != current_file && b->file == current_file)
274 lto_input_location (struct lto_input_block *ib, struct data_in *data_in) 148 return 1;
275 { 149 if (a->file == current_file && b->file == current_file)
276 expanded_location xloc; 150 {
277 151 if (a->line == current_line && b->line != current_line)
278 xloc.file = input_string (data_in, ib); 152 return -1;
279 if (xloc.file == NULL) 153 if (a->line != current_line && b->line == current_line)
280 return UNKNOWN_LOCATION; 154 return 1;
281 155 }
282 xloc.file = canon_file_name (xloc.file); 156 if (a->file != b->file)
283 xloc.line = lto_input_sleb128 (ib); 157 return strcmp (a->file, b->file);
284 xloc.column = lto_input_sleb128 (ib); 158 if (a->sysp != b->sysp)
285 xloc.sysp = lto_input_sleb128 (ib); 159 return a->sysp ? 1 : -1;
286 160 if (a->line != b->line)
287 if (data_in->current_file != xloc.file) 161 return a->line - b->line;
288 { 162 return a->col - b->col;
289 if (data_in->current_file) 163 }
290 linemap_add (line_table, LC_LEAVE, false, NULL, 0); 164
291 165 /* Apply all changes in location cache. Add locations into linemap and patch
292 linemap_add (line_table, LC_ENTER, xloc.sysp, xloc.file, xloc.line); 166 trees. */
293 } 167
294 else if (data_in->current_line != xloc.line) 168 bool
295 linemap_line_start (line_table, xloc.line, xloc.column); 169 lto_location_cache::apply_location_cache ()
296 170 {
297 data_in->current_file = xloc.file; 171 static const char *prev_file;
298 data_in->current_line = xloc.line; 172 if (!loc_cache.length ())
299 data_in->current_col = xloc.column; 173 return false;
300 174 if (loc_cache.length () > 1)
301 return linemap_position_for_column (line_table, xloc.column); 175 loc_cache.qsort (cmp_loc);
302 } 176
303 177 for (unsigned int i = 0; i < loc_cache.length (); i++)
178 {
179 struct cached_location loc = loc_cache[i];
180
181 if (current_file != loc.file)
182 linemap_add (line_table, prev_file ? LC_RENAME : LC_ENTER,
183 loc.sysp, loc.file, loc.line);
184 else if (current_line != loc.line)
185 {
186 int max = loc.col;
187
188 for (unsigned int j = i + 1; j < loc_cache.length (); j++)
189 if (loc.file != loc_cache[j].file
190 || loc.line != loc_cache[j].line)
191 break;
192 else if (max < loc_cache[j].col)
193 max = loc_cache[j].col;
194 linemap_line_start (line_table, loc.line, max + 1);
195 }
196 gcc_assert (*loc.loc == BUILTINS_LOCATION + 1);
197 if (current_file == loc.file && current_line == loc.line
198 && current_col == loc.col)
199 *loc.loc = current_loc;
200 else
201 current_loc = *loc.loc = linemap_position_for_column (line_table,
202 loc.col);
203 current_line = loc.line;
204 prev_file = current_file = loc.file;
205 current_col = loc.col;
206 }
207 loc_cache.truncate (0);
208 accepted_length = 0;
209 return true;
210 }
211
212 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
213
214 void
215 lto_location_cache::accept_location_cache ()
216 {
217 gcc_assert (current_cache == this);
218 accepted_length = loc_cache.length ();
219 }
220
221 /* Tree merging did suceed; throw away recent changes. */
222
223 void
224 lto_location_cache::revert_location_cache ()
225 {
226 loc_cache.truncate (accepted_length);
227 }
228
229 /* Read a location bitpack from input block IB and either update *LOC directly
230 or add it to the location cache.
231 It is neccesary to call apply_location_cache to get *LOC updated. */
232
233 void
234 lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
235 struct data_in *data_in)
236 {
237 static const char *stream_file;
238 static int stream_line;
239 static int stream_col;
240 static bool stream_sysp;
241 bool file_change, line_change, column_change;
242
243 gcc_assert (current_cache == this);
244
245 *loc = bp_unpack_int_in_range (bp, "location", 0, RESERVED_LOCATION_COUNT);
246
247 if (*loc < RESERVED_LOCATION_COUNT)
248 return;
249
250 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
251 ICE on it. */
252
253 file_change = bp_unpack_value (bp, 1);
254 line_change = bp_unpack_value (bp, 1);
255 column_change = bp_unpack_value (bp, 1);
256
257 if (file_change)
258 {
259 stream_file = canon_file_name (bp_unpack_string (data_in, bp));
260 stream_sysp = bp_unpack_value (bp, 1);
261 }
262
263 if (line_change)
264 stream_line = bp_unpack_var_len_unsigned (bp);
265
266 if (column_change)
267 stream_col = bp_unpack_var_len_unsigned (bp);
268
269 /* This optimization saves location cache operations druing gimple
270 streaming. */
271
272 if (current_file == stream_file && current_line == stream_line
273 && current_col == stream_col && current_sysp == stream_sysp)
274 {
275 *loc = current_loc;
276 return;
277 }
278
279 struct cached_location entry
280 = {stream_file, loc, stream_line, stream_col, stream_sysp};
281 loc_cache.safe_push (entry);
282 }
283
284 /* Read a location bitpack from input block IB and either update *LOC directly
285 or add it to the location cache.
286 It is neccesary to call apply_location_cache to get *LOC updated. */
287
288 void
289 lto_input_location (location_t *loc, struct bitpack_d *bp,
290 struct data_in *data_in)
291 {
292 data_in->location_cache.input_location (loc, bp, data_in);
293 }
294
295 /* Read location and return it instead of going through location caching.
296 This should be used only when the resulting location is not going to be
297 discarded. */
298
299 location_t
300 stream_input_location_now (struct bitpack_d *bp, struct data_in *data_in)
301 {
302 location_t loc;
303 stream_input_location (&loc, bp, data_in);
304 data_in->location_cache.apply_location_cache ();
305 return loc;
306 }
304 307
305 /* Read a reference to a tree node from DATA_IN using input block IB. 308 /* Read a reference to a tree node from DATA_IN using input block IB.
306 TAG is the expected node that should be found in IB, if TAG belongs 309 TAG is the expected node that should be found in IB, if TAG belongs
307 to one of the indexable trees, expect to read a reference index to 310 to one of the indexable trees, expect to read a reference index to
308 be looked up in one of the symbol tables, otherwise read the pysical 311 be looked up in one of the symbol tables, otherwise read the pysical
309 representation of the tree using lto_input_tree. FN is the 312 representation of the tree using stream_read_tree. FN is the
310 function scope for the read tree. */ 313 function scope for the read tree. */
311 314
312 static tree 315 tree
313 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in, 316 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
314 struct function *fn, enum LTO_tags tag) 317 struct function *fn, enum LTO_tags tag)
315 { 318 {
316 unsigned HOST_WIDE_INT ix_u; 319 unsigned HOST_WIDE_INT ix_u;
317 tree result = NULL_TREE; 320 tree result = NULL_TREE;
318 321
319 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref); 322 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_namelist_decl_ref);
320 323
321 switch (tag) 324 switch (tag)
322 { 325 {
323 case LTO_type_ref: 326 case LTO_type_ref:
324 ix_u = lto_input_uleb128 (ib); 327 ix_u = streamer_read_uhwi (ib);
325 result = lto_file_decl_data_get_type (data_in->file_data, ix_u); 328 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
326 break; 329 break;
327 330
328 case LTO_ssa_name_ref: 331 case LTO_ssa_name_ref:
329 ix_u = lto_input_uleb128 (ib); 332 ix_u = streamer_read_uhwi (ib);
330 result = VEC_index (tree, SSANAMES (fn), ix_u); 333 result = (*SSANAMES (fn))[ix_u];
331 break; 334 break;
332 335
333 case LTO_field_decl_ref: 336 case LTO_field_decl_ref:
334 ix_u = lto_input_uleb128 (ib); 337 ix_u = streamer_read_uhwi (ib);
335 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u); 338 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
336 break; 339 break;
337 340
338 case LTO_function_decl_ref: 341 case LTO_function_decl_ref:
339 ix_u = lto_input_uleb128 (ib); 342 ix_u = streamer_read_uhwi (ib);
340 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u); 343 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
341 break; 344 break;
342 345
343 case LTO_type_decl_ref: 346 case LTO_type_decl_ref:
344 ix_u = lto_input_uleb128 (ib); 347 ix_u = streamer_read_uhwi (ib);
345 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u); 348 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
346 break; 349 break;
347 350
348 case LTO_namespace_decl_ref: 351 case LTO_namespace_decl_ref:
349 ix_u = lto_input_uleb128 (ib); 352 ix_u = streamer_read_uhwi (ib);
350 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u); 353 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
351 break; 354 break;
352 355
353 case LTO_global_decl_ref: 356 case LTO_global_decl_ref:
354 case LTO_result_decl_ref: 357 case LTO_result_decl_ref:
355 case LTO_const_decl_ref: 358 case LTO_const_decl_ref:
356 case LTO_imported_decl_ref: 359 case LTO_imported_decl_ref:
357 case LTO_label_decl_ref: 360 case LTO_label_decl_ref:
358 case LTO_translation_unit_decl_ref: 361 case LTO_translation_unit_decl_ref:
359 ix_u = lto_input_uleb128 (ib); 362 case LTO_namelist_decl_ref:
363 ix_u = streamer_read_uhwi (ib);
360 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u); 364 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
361 break; 365 break;
362 366
363 default: 367 default:
364 gcc_unreachable (); 368 gcc_unreachable ();
379 { 383 {
380 eh_catch first; 384 eh_catch first;
381 enum LTO_tags tag; 385 enum LTO_tags tag;
382 386
383 *last_p = first = NULL; 387 *last_p = first = NULL;
384 tag = input_record_start (ib); 388 tag = streamer_read_record_start (ib);
385 while (tag) 389 while (tag)
386 { 390 {
387 tree list; 391 tree list;
388 eh_catch n; 392 eh_catch n;
389 393
390 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch); 394 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
391 395
392 /* Read the catch node. */ 396 /* Read the catch node. */
393 n = ggc_alloc_cleared_eh_catch_d (); 397 n = ggc_cleared_alloc<eh_catch_d> ();
394 n->type_list = lto_input_tree (ib, data_in); 398 n->type_list = stream_read_tree (ib, data_in);
395 n->filter_list = lto_input_tree (ib, data_in); 399 n->filter_list = stream_read_tree (ib, data_in);
396 n->label = lto_input_tree (ib, data_in); 400 n->label = stream_read_tree (ib, data_in);
397 401
398 /* Register all the types in N->FILTER_LIST. */ 402 /* Register all the types in N->FILTER_LIST. */
399 for (list = n->filter_list; list; list = TREE_CHAIN (list)) 403 for (list = n->filter_list; list; list = TREE_CHAIN (list))
400 add_type_for_runtime (TREE_VALUE (list)); 404 add_type_for_runtime (TREE_VALUE (list));
401 405
407 411
408 /* Set the head of the list the first time through the loop. */ 412 /* Set the head of the list the first time through the loop. */
409 if (first == NULL) 413 if (first == NULL)
410 first = n; 414 first = n;
411 415
412 tag = input_record_start (ib); 416 tag = streamer_read_record_start (ib);
413 } 417 }
414 418
415 return first; 419 return first;
416 } 420 }
417 421
424 { 428 {
425 enum LTO_tags tag; 429 enum LTO_tags tag;
426 eh_region r; 430 eh_region r;
427 431
428 /* Read the region header. */ 432 /* Read the region header. */
429 tag = input_record_start (ib); 433 tag = streamer_read_record_start (ib);
430 if (tag == LTO_null) 434 if (tag == LTO_null)
431 return NULL; 435 return NULL;
432 436
433 r = ggc_alloc_cleared_eh_region_d (); 437 r = ggc_cleared_alloc<eh_region_d> ();
434 r->index = lto_input_sleb128 (ib); 438 r->index = streamer_read_hwi (ib);
435 439
436 gcc_assert (r->index == ix); 440 gcc_assert (r->index == ix);
437 441
438 /* Read all the region pointers as region numbers. We'll fix up 442 /* Read all the region pointers as region numbers. We'll fix up
439 the pointers once the whole array has been read. */ 443 the pointers once the whole array has been read. */
440 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib); 444 r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);
441 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib); 445 r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);
442 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib); 446 r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);
443 447
444 switch (tag) 448 switch (tag)
445 { 449 {
446 case LTO_ert_cleanup: 450 case LTO_ert_cleanup:
447 r->type = ERT_CLEANUP; 451 r->type = ERT_CLEANUP;
460 case LTO_ert_allowed_exceptions: 464 case LTO_ert_allowed_exceptions:
461 { 465 {
462 tree l; 466 tree l;
463 467
464 r->type = ERT_ALLOWED_EXCEPTIONS; 468 r->type = ERT_ALLOWED_EXCEPTIONS;
465 r->u.allowed.type_list = lto_input_tree (ib, data_in); 469 r->u.allowed.type_list = stream_read_tree (ib, data_in);
466 r->u.allowed.label = lto_input_tree (ib, data_in); 470 r->u.allowed.label = stream_read_tree (ib, data_in);
467 r->u.allowed.filter = lto_input_uleb128 (ib); 471 r->u.allowed.filter = streamer_read_uhwi (ib);
468 472
469 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l)) 473 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
470 add_type_for_runtime (TREE_VALUE (l)); 474 add_type_for_runtime (TREE_VALUE (l));
471 } 475 }
472 break; 476 break;
473 477
474 case LTO_ert_must_not_throw: 478 case LTO_ert_must_not_throw:
475 r->type = ERT_MUST_NOT_THROW; 479 {
476 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in); 480 r->type = ERT_MUST_NOT_THROW;
477 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in); 481 r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);
482 bitpack_d bp = streamer_read_bitpack (ib);
483 r->u.must_not_throw.failure_loc
484 = stream_input_location_now (&bp, data_in);
485 }
478 break; 486 break;
479 487
480 default: 488 default:
481 gcc_unreachable (); 489 gcc_unreachable ();
482 } 490 }
483 491
484 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib); 492 r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
485 493
486 return r; 494 return r;
487 } 495 }
488 496
489 497
495 { 503 {
496 enum LTO_tags tag; 504 enum LTO_tags tag;
497 eh_landing_pad lp; 505 eh_landing_pad lp;
498 506
499 /* Read the landing pad header. */ 507 /* Read the landing pad header. */
500 tag = input_record_start (ib); 508 tag = streamer_read_record_start (ib);
501 if (tag == LTO_null) 509 if (tag == LTO_null)
502 return NULL; 510 return NULL;
503 511
504 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad); 512 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
505 513
506 lp = ggc_alloc_cleared_eh_landing_pad_d (); 514 lp = ggc_cleared_alloc<eh_landing_pad_d> ();
507 lp->index = lto_input_sleb128 (ib); 515 lp->index = streamer_read_hwi (ib);
508 gcc_assert (lp->index == ix); 516 gcc_assert (lp->index == ix);
509 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib); 517 lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
510 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib); 518 lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);
511 lp->post_landing_pad = lto_input_tree (ib, data_in); 519 lp->post_landing_pad = stream_read_tree (ib, data_in);
512 520
513 return lp; 521 return lp;
514 } 522 }
515 523
516 524
521 529
522 static void 530 static void
523 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region) 531 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
524 { 532 {
525 unsigned i; 533 unsigned i;
526 VEC(eh_region,gc) *eh_array = fn->eh->region_array; 534 vec<eh_region, va_gc> *eh_array = fn->eh->region_array;
527 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array; 535 vec<eh_landing_pad, va_gc> *lp_array = fn->eh->lp_array;
528 eh_region r; 536 eh_region r;
529 eh_landing_pad lp; 537 eh_landing_pad lp;
530 538
531 gcc_assert (eh_array && lp_array); 539 gcc_assert (eh_array && lp_array);
532 540
533 gcc_assert (root_region >= 0); 541 gcc_assert (root_region >= 0);
534 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region); 542 fn->eh->region_tree = (*eh_array)[root_region];
535 543
536 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \ 544 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
537 (HOST_WIDE_INT) (intptr_t) (r)) 545 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
538 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
539 (HOST_WIDE_INT) (intptr_t) (p))
540 546
541 /* Convert all the index numbers stored in pointer fields into 547 /* Convert all the index numbers stored in pointer fields into
542 pointers to the corresponding slots in the EH region array. */ 548 pointers to the corresponding slots in the EH region array. */
543 FOR_EACH_VEC_ELT (eh_region, eh_array, i, r) 549 FOR_EACH_VEC_ELT (*eh_array, i, r)
544 { 550 {
545 /* The array may contain NULL regions. */ 551 /* The array may contain NULL regions. */
546 if (r == NULL) 552 if (r == NULL)
547 continue; 553 continue;
548 554
553 FIXUP_EH_LP (r->landing_pads); 559 FIXUP_EH_LP (r->landing_pads);
554 } 560 }
555 561
556 /* Convert all the index numbers stored in pointer fields into 562 /* Convert all the index numbers stored in pointer fields into
557 pointers to the corresponding slots in the EH landing pad array. */ 563 pointers to the corresponding slots in the EH landing pad array. */
558 FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp) 564 FOR_EACH_VEC_ELT (*lp_array, i, lp)
559 { 565 {
560 /* The array may contain NULL landing pads. */ 566 /* The array may contain NULL landing pads. */
561 if (lp == NULL) 567 if (lp == NULL)
562 continue; 568 continue;
563 569
571 } 577 }
572 578
573 579
574 /* Initialize EH support. */ 580 /* Initialize EH support. */
575 581
576 static void 582 void
577 lto_init_eh (void) 583 lto_init_eh (void)
578 { 584 {
579 static bool eh_initialized_p = false; 585 static bool eh_initialized_p = false;
580 586
581 if (eh_initialized_p) 587 if (eh_initialized_p)
587 lang_dependent_init, we have to set flag_exceptions and call 593 lang_dependent_init, we have to set flag_exceptions and call
588 init_eh again to initialize the EH tables. */ 594 init_eh again to initialize the EH tables. */
589 flag_exceptions = 1; 595 flag_exceptions = 1;
590 init_eh (); 596 init_eh ();
591 597
592 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
593 true only when exceptions are enabled, this initialization is
594 never done during lang_dependent_init. */
595 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
596 if (dwarf2out_do_frame ())
597 dwarf2out_frame_init ();
598 #endif
599
600 eh_initialized_p = true; 598 eh_initialized_p = true;
601 } 599 }
602 600
603 601
604 /* Read the exception table for FN from IB using the data descriptors 602 /* Read the exception table for FN from IB using the data descriptors
609 struct function *fn) 607 struct function *fn)
610 { 608 {
611 HOST_WIDE_INT i, root_region, len; 609 HOST_WIDE_INT i, root_region, len;
612 enum LTO_tags tag; 610 enum LTO_tags tag;
613 611
614 tag = input_record_start (ib); 612 tag = streamer_read_record_start (ib);
615 if (tag == LTO_null) 613 if (tag == LTO_null)
616 return; 614 return;
617 615
618 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table); 616 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
619 617
622 machinery. */ 620 machinery. */
623 lto_init_eh (); 621 lto_init_eh ();
624 622
625 gcc_assert (fn->eh); 623 gcc_assert (fn->eh);
626 624
627 root_region = lto_input_sleb128 (ib); 625 root_region = streamer_read_hwi (ib);
628 gcc_assert (root_region == (int) root_region); 626 gcc_assert (root_region == (int) root_region);
629 627
630 /* Read the EH region array. */ 628 /* Read the EH region array. */
631 len = lto_input_sleb128 (ib); 629 len = streamer_read_hwi (ib);
632 gcc_assert (len == (int) len); 630 gcc_assert (len == (int) len);
633 if (len > 0) 631 if (len > 0)
634 { 632 {
635 VEC_safe_grow (eh_region, gc, fn->eh->region_array, len); 633 vec_safe_grow_cleared (fn->eh->region_array, len);
636 for (i = 0; i < len; i++) 634 for (i = 0; i < len; i++)
637 { 635 {
638 eh_region r = input_eh_region (ib, data_in, i); 636 eh_region r = input_eh_region (ib, data_in, i);
639 VEC_replace (eh_region, fn->eh->region_array, i, r); 637 (*fn->eh->region_array)[i] = r;
640 } 638 }
641 } 639 }
642 640
643 /* Read the landing pads. */ 641 /* Read the landing pads. */
644 len = lto_input_sleb128 (ib); 642 len = streamer_read_hwi (ib);
645 gcc_assert (len == (int) len); 643 gcc_assert (len == (int) len);
646 if (len > 0) 644 if (len > 0)
647 { 645 {
648 VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len); 646 vec_safe_grow_cleared (fn->eh->lp_array, len);
649 for (i = 0; i < len; i++) 647 for (i = 0; i < len; i++)
650 { 648 {
651 eh_landing_pad lp = input_eh_lp (ib, data_in, i); 649 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
652 VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp); 650 (*fn->eh->lp_array)[i] = lp;
653 } 651 }
654 } 652 }
655 653
656 /* Read the runtime type data. */ 654 /* Read the runtime type data. */
657 len = lto_input_sleb128 (ib); 655 len = streamer_read_hwi (ib);
658 gcc_assert (len == (int) len); 656 gcc_assert (len == (int) len);
659 if (len > 0) 657 if (len > 0)
660 { 658 {
661 VEC_safe_grow (tree, gc, fn->eh->ttype_data, len); 659 vec_safe_grow_cleared (fn->eh->ttype_data, len);
662 for (i = 0; i < len; i++) 660 for (i = 0; i < len; i++)
663 { 661 {
664 tree ttype = lto_input_tree (ib, data_in); 662 tree ttype = stream_read_tree (ib, data_in);
665 VEC_replace (tree, fn->eh->ttype_data, i, ttype); 663 (*fn->eh->ttype_data)[i] = ttype;
666 } 664 }
667 } 665 }
668 666
669 /* Read the table of action chains. */ 667 /* Read the table of action chains. */
670 len = lto_input_sleb128 (ib); 668 len = streamer_read_hwi (ib);
671 gcc_assert (len == (int) len); 669 gcc_assert (len == (int) len);
672 if (len > 0) 670 if (len > 0)
673 { 671 {
674 if (targetm.arm_eabi_unwinder) 672 if (targetm.arm_eabi_unwinder)
675 { 673 {
676 VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len); 674 vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len);
677 for (i = 0; i < len; i++) 675 for (i = 0; i < len; i++)
678 { 676 {
679 tree t = lto_input_tree (ib, data_in); 677 tree t = stream_read_tree (ib, data_in);
680 VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t); 678 (*fn->eh->ehspec_data.arm_eabi)[i] = t;
681 } 679 }
682 } 680 }
683 else 681 else
684 { 682 {
685 VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len); 683 vec_safe_grow_cleared (fn->eh->ehspec_data.other, len);
686 for (i = 0; i < len; i++) 684 for (i = 0; i < len; i++)
687 { 685 {
688 uchar c = lto_input_1_unsigned (ib); 686 uchar c = streamer_read_uchar (ib);
689 VEC_replace (uchar, fn->eh->ehspec_data.other, i, c); 687 (*fn->eh->ehspec_data.other)[i] = c;
690 } 688 }
691 } 689 }
692 } 690 }
693 691
694 /* Reconstruct the EH region tree by fixing up the peer/children 692 /* Reconstruct the EH region tree by fixing up the peer/children
695 pointers. */ 693 pointers. */
696 fixup_eh_region_pointers (fn, root_region); 694 fixup_eh_region_pointers (fn, root_region);
697 695
698 tag = input_record_start (ib); 696 tag = streamer_read_record_start (ib);
699 lto_tag_check_range (tag, LTO_null, LTO_null); 697 lto_tag_check_range (tag, LTO_null, LTO_null);
700 } 698 }
701 699
702 700
703 /* Make a new basic block with index INDEX in function FN. */ 701 /* Make a new basic block with index INDEX in function FN. */
705 static basic_block 703 static basic_block
706 make_new_block (struct function *fn, unsigned int index) 704 make_new_block (struct function *fn, unsigned int index)
707 { 705 {
708 basic_block bb = alloc_block (); 706 basic_block bb = alloc_block ();
709 bb->index = index; 707 bb->index = index;
710 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb); 708 SET_BASIC_BLOCK_FOR_FN (fn, index, bb);
711 bb->il.gimple = ggc_alloc_cleared_gimple_bb_info (); 709 n_basic_blocks_for_fn (fn)++;
712 n_basic_blocks_for_function (fn)++;
713 bb->flags = 0;
714 set_bb_seq (bb, gimple_seq_alloc ());
715 return bb; 710 return bb;
716 } 711 }
717 712
718 713
719 /* Read the CFG for function FN from input block IB. */ 714 /* Read the CFG for function FN from input block IB. */
720 715
721 static void 716 static void
722 input_cfg (struct lto_input_block *ib, struct function *fn, 717 input_cfg (struct lto_input_block *ib, struct data_in *data_in,
723 int count_materialization_scale) 718 struct function *fn)
724 { 719 {
725 unsigned int bb_count; 720 unsigned int bb_count;
726 basic_block p_bb; 721 basic_block p_bb;
727 unsigned int i; 722 unsigned int i;
728 int index; 723 int index;
729 724
730 init_empty_tree_cfg_for_function (fn); 725 init_empty_tree_cfg_for_function (fn);
731 init_ssa_operands (); 726 init_ssa_operands (fn);
732 727
733 profile_status_for_function (fn) = 728 profile_status_for_fn (fn) = streamer_read_enum (ib, profile_status_d,
734 (enum profile_status_d) lto_input_uleb128 (ib); 729 PROFILE_LAST);
735 730
736 bb_count = lto_input_uleb128 (ib); 731 bb_count = streamer_read_uhwi (ib);
737 732
738 last_basic_block_for_function (fn) = bb_count; 733 last_basic_block_for_fn (fn) = bb_count;
739 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn))) 734 if (bb_count > basic_block_info_for_fn (fn)->length ())
740 VEC_safe_grow_cleared (basic_block, gc, 735 vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count);
741 basic_block_info_for_function (fn), bb_count); 736
742 737 if (bb_count > label_to_block_map_for_fn (fn)->length ())
743 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn))) 738 vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count);
744 VEC_safe_grow_cleared (basic_block, gc, 739
745 label_to_block_map_for_function (fn), bb_count); 740 index = streamer_read_hwi (ib);
746
747 index = lto_input_sleb128 (ib);
748 while (index != -1) 741 while (index != -1)
749 { 742 {
750 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index); 743 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
751 unsigned int edge_count; 744 unsigned int edge_count;
752 745
753 if (bb == NULL) 746 if (bb == NULL)
754 bb = make_new_block (fn, index); 747 bb = make_new_block (fn, index);
755 748
756 edge_count = lto_input_uleb128 (ib); 749 edge_count = streamer_read_uhwi (ib);
757 750
758 /* Connect up the CFG. */ 751 /* Connect up the CFG. */
759 for (i = 0; i < edge_count; i++) 752 for (i = 0; i < edge_count; i++)
760 { 753 {
761 unsigned int dest_index; 754 unsigned int dest_index;
762 unsigned int edge_flags; 755 unsigned int edge_flags;
763 basic_block dest; 756 basic_block dest;
764 int probability; 757 profile_probability probability;
765 gcov_type count;
766 edge e; 758 edge e;
767 759
768 dest_index = lto_input_uleb128 (ib); 760 dest_index = streamer_read_uhwi (ib);
769 probability = (int) lto_input_sleb128 (ib); 761 probability = profile_probability::stream_in (ib);
770 count = ((gcov_type) lto_input_sleb128 (ib) * count_materialization_scale 762 edge_flags = streamer_read_uhwi (ib);
771 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE; 763
772 edge_flags = lto_input_uleb128 (ib); 764 dest = BASIC_BLOCK_FOR_FN (fn, dest_index);
773
774 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
775 765
776 if (dest == NULL) 766 if (dest == NULL)
777 dest = make_new_block (fn, dest_index); 767 dest = make_new_block (fn, dest_index);
778 768
779 e = make_edge (bb, dest, edge_flags); 769 e = make_edge (bb, dest, edge_flags);
780 e->probability = probability; 770 e->probability = probability;
781 e->count = count; 771 }
782 } 772
783 773 index = streamer_read_hwi (ib);
784 index = lto_input_sleb128 (ib); 774 }
785 } 775
786 776 p_bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
787 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn); 777 index = streamer_read_hwi (ib);
788 index = lto_input_sleb128 (ib);
789 while (index != -1) 778 while (index != -1)
790 { 779 {
791 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index); 780 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
792 bb->prev_bb = p_bb; 781 bb->prev_bb = p_bb;
793 p_bb->next_bb = bb; 782 p_bb->next_bb = bb;
794 p_bb = bb; 783 p_bb = bb;
795 index = lto_input_sleb128 (ib); 784 index = streamer_read_hwi (ib);
796 } 785 }
797 } 786
798 787 /* ??? The cfgloop interface is tied to cfun. */
799 788 gcc_assert (cfun == fn);
800 /* Read a PHI function for basic block BB in function FN. DATA_IN is 789
801 the file being read. IB is the input block to use for reading. */ 790 /* Input the loop tree. */
802 791 unsigned n_loops = streamer_read_uhwi (ib);
803 static gimple 792 if (n_loops == 0)
804 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in, 793 return;
805 struct function *fn) 794
806 { 795 struct loops *loops = ggc_cleared_alloc<struct loops> ();
807 unsigned HOST_WIDE_INT ix; 796 init_loops_structure (fn, loops, n_loops);
808 tree phi_result; 797 set_loops_for_fn (fn, loops);
809 int i, len; 798
810 gimple result; 799 /* Input each loop and associate it with its loop header so
811 800 flow_loops_find can rebuild the loop tree. */
812 ix = lto_input_uleb128 (ib); 801 for (unsigned i = 1; i < n_loops; ++i)
813 phi_result = VEC_index (tree, SSANAMES (fn), ix); 802 {
814 len = EDGE_COUNT (bb->preds); 803 int header_index = streamer_read_hwi (ib);
815 result = create_phi_node (phi_result, bb); 804 if (header_index == -1)
816 SSA_NAME_DEF_STMT (phi_result) = result; 805 {
817 806 loops->larray->quick_push (NULL);
818 /* We have to go through a lookup process here because the preds in the 807 continue;
819 reconstructed graph are generally in a different order than they 808 }
820 were in the original program. */ 809
821 for (i = 0; i < len; i++) 810 struct loop *loop = alloc_loop ();
822 { 811 loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
823 tree def = lto_input_tree (ib, data_in); 812 loop->header->loop_father = loop;
824 int src_index = lto_input_uleb128 (ib); 813
825 location_t arg_loc = lto_input_location (ib, data_in); 814 /* Read everything copy_loop_info copies. */
826 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index); 815 loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
827 816 loop->any_upper_bound = streamer_read_hwi (ib);
828 edge e = NULL; 817 if (loop->any_upper_bound)
829 int j; 818 loop->nb_iterations_upper_bound = streamer_read_widest_int (ib);
830 819 loop->any_likely_upper_bound = streamer_read_hwi (ib);
831 for (j = 0; j < len; j++) 820 if (loop->any_likely_upper_bound)
832 if (EDGE_PRED (bb, j)->src == sbb) 821 loop->nb_iterations_likely_upper_bound = streamer_read_widest_int (ib);
833 { 822 loop->any_estimate = streamer_read_hwi (ib);
834 e = EDGE_PRED (bb, j); 823 if (loop->any_estimate)
835 break; 824 loop->nb_iterations_estimate = streamer_read_widest_int (ib);
836 } 825
837 826 /* Read OMP SIMD related info. */
838 add_phi_arg (result, def, e, arg_loc); 827 loop->safelen = streamer_read_hwi (ib);
839 } 828 loop->dont_vectorize = streamer_read_hwi (ib);
840 829 loop->force_vectorize = streamer_read_hwi (ib);
841 return result; 830 loop->simduid = stream_read_tree (ib, data_in);
831
832 place_new_loop (fn, loop);
833
834 /* flow_loops_find doesn't like loops not in the tree, hook them
835 all as siblings of the tree root temporarily. */
836 flow_loop_tree_node_add (loops->tree_root, loop);
837 }
838
839 /* Rebuild the loop tree. */
840 flow_loops_find (loops);
842 } 841 }
843 842
844 843
845 /* Read the SSA names array for function FN from DATA_IN using input 844 /* Read the SSA names array for function FN from DATA_IN using input
846 block IB. */ 845 block IB. */
849 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in, 848 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
850 struct function *fn) 849 struct function *fn)
851 { 850 {
852 unsigned int i, size; 851 unsigned int i, size;
853 852
854 size = lto_input_uleb128 (ib); 853 size = streamer_read_uhwi (ib);
855 init_ssanames (fn, size); 854 init_ssanames (fn, size);
856 855
857 i = lto_input_uleb128 (ib); 856 i = streamer_read_uhwi (ib);
858 while (i) 857 while (i)
859 { 858 {
860 tree ssa_name, name; 859 tree ssa_name, name;
861 bool is_default_def; 860 bool is_default_def;
862 861
863 /* Skip over the elements that had been freed. */ 862 /* Skip over the elements that had been freed. */
864 while (VEC_length (tree, SSANAMES (fn)) < i) 863 while (SSANAMES (fn)->length () < i)
865 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE); 864 SSANAMES (fn)->quick_push (NULL_TREE);
866 865
867 is_default_def = (lto_input_1_unsigned (ib) != 0); 866 is_default_def = (streamer_read_uchar (ib) != 0);
868 name = lto_input_tree (ib, data_in); 867 name = stream_read_tree (ib, data_in);
869 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ()); 868 ssa_name = make_ssa_name_fn (fn, name, NULL);
870 869
871 if (is_default_def) 870 if (is_default_def)
872 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name); 871 {
873 872 set_ssa_default_def (cfun, SSA_NAME_VAR (ssa_name), ssa_name);
874 i = lto_input_uleb128 (ib); 873 SSA_NAME_DEF_STMT (ssa_name) = gimple_build_nop ();
875 } 874 }
876 } 875
877 876 i = streamer_read_uhwi (ib);
878 /* Read a statement with tag TAG in function FN from block IB using 877 }
879 descriptors in DATA_IN. */ 878 }
880 879
881 static gimple
882 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
883 struct function *fn, enum LTO_tags tag)
884 {
885 gimple stmt;
886 enum gimple_code code;
887 unsigned HOST_WIDE_INT num_ops;
888 size_t i;
889 struct bitpack_d bp;
890
891 code = lto_tag_to_gimple_code (tag);
892
893 /* Read the tuple header. */
894 bp = lto_input_bitpack (ib);
895 num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
896 stmt = gimple_alloc (code, num_ops);
897 stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
898 if (is_gimple_assign (stmt))
899 stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
900 stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
901 stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
902
903 /* Read location information. */
904 gimple_set_location (stmt, lto_input_location (ib, data_in));
905
906 /* Read lexical block reference. */
907 gimple_set_block (stmt, lto_input_tree (ib, data_in));
908
909 /* Read in all the operands. */
910 switch (code)
911 {
912 case GIMPLE_RESX:
913 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
914 break;
915
916 case GIMPLE_EH_MUST_NOT_THROW:
917 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
918 break;
919
920 case GIMPLE_EH_DISPATCH:
921 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
922 break;
923
924 case GIMPLE_ASM:
925 {
926 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
927 tree str;
928 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
929 stmt->gimple_asm.no = lto_input_uleb128 (ib);
930 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
931 stmt->gimple_asm.nl = lto_input_uleb128 (ib);
932 str = input_string_cst (data_in, ib);
933 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
934 }
935 /* Fallthru */
936
937 case GIMPLE_ASSIGN:
938 case GIMPLE_CALL:
939 case GIMPLE_RETURN:
940 case GIMPLE_SWITCH:
941 case GIMPLE_LABEL:
942 case GIMPLE_COND:
943 case GIMPLE_GOTO:
944 case GIMPLE_DEBUG:
945 for (i = 0; i < num_ops; i++)
946 {
947 tree op = lto_input_tree (ib, data_in);
948 gimple_set_op (stmt, i, op);
949 if (!op)
950 continue;
951
952 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
953 by decl merging. */
954 if (TREE_CODE (op) == ADDR_EXPR)
955 op = TREE_OPERAND (op, 0);
956 while (handled_component_p (op))
957 {
958 if (TREE_CODE (op) == COMPONENT_REF)
959 {
960 tree field, type, tem;
961 tree closest_match = NULL_TREE;
962 field = TREE_OPERAND (op, 1);
963 type = DECL_CONTEXT (field);
964 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
965 {
966 if (tem == field)
967 break;
968 if (DECL_NONADDRESSABLE_P (tem)
969 == DECL_NONADDRESSABLE_P (field)
970 && gimple_compare_field_offset (tem, field))
971 {
972 if (types_compatible_p (TREE_TYPE (tem),
973 TREE_TYPE (field)))
974 break;
975 else
976 closest_match = tem;
977 }
978 }
979 /* In case of type mismatches across units we can fail
980 to unify some types and thus not find a proper
981 field-decl here. */
982 if (tem == NULL_TREE)
983 {
984 /* Thus, emit a ODR violation warning. */
985 if (warning_at (gimple_location (stmt), 0,
986 "use of type %<%E%> with two mismatching "
987 "declarations at field %<%E%>",
988 type, TREE_OPERAND (op, 1)))
989 {
990 if (TYPE_FIELDS (type))
991 inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
992 "original type declared here");
993 inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
994 "field in mismatching type declared here");
995 if (TYPE_NAME (TREE_TYPE (field))
996 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
997 == TYPE_DECL))
998 inform (DECL_SOURCE_LOCATION
999 (TYPE_NAME (TREE_TYPE (field))),
1000 "type of field declared here");
1001 if (closest_match
1002 && TYPE_NAME (TREE_TYPE (closest_match))
1003 && (TREE_CODE (TYPE_NAME
1004 (TREE_TYPE (closest_match))) == TYPE_DECL))
1005 inform (DECL_SOURCE_LOCATION
1006 (TYPE_NAME (TREE_TYPE (closest_match))),
1007 "type of mismatching field declared here");
1008 }
1009 /* And finally fixup the types. */
1010 TREE_OPERAND (op, 0)
1011 = build1 (VIEW_CONVERT_EXPR, type,
1012 TREE_OPERAND (op, 0));
1013 }
1014 else
1015 TREE_OPERAND (op, 1) = tem;
1016 }
1017
1018 op = TREE_OPERAND (op, 0);
1019 }
1020 }
1021 break;
1022
1023 case GIMPLE_NOP:
1024 case GIMPLE_PREDICT:
1025 break;
1026
1027 default:
1028 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1029 lto_tag_name (tag));
1030 }
1031
1032 /* Update the properties of symbols, SSA names and labels associated
1033 with STMT. */
1034 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1035 {
1036 tree lhs = gimple_get_lhs (stmt);
1037 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1038 SSA_NAME_DEF_STMT (lhs) = stmt;
1039 }
1040 else if (code == GIMPLE_LABEL)
1041 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1042 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1043 else if (code == GIMPLE_ASM)
1044 {
1045 unsigned i;
1046
1047 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1048 {
1049 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1050 if (TREE_CODE (op) == SSA_NAME)
1051 SSA_NAME_DEF_STMT (op) = stmt;
1052 }
1053 }
1054
1055 /* Reset alias information. */
1056 if (code == GIMPLE_CALL)
1057 gimple_call_reset_alias_info (stmt);
1058
1059 /* Mark the statement modified so its operand vectors can be filled in. */
1060 gimple_set_modified (stmt, true);
1061
1062 return stmt;
1063 }
1064
1065
1066 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1067 FN is the function being processed. */
1068
1069 static void
1070 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1071 struct data_in *data_in, struct function *fn,
1072 int count_materialization_scale)
1073 {
1074 unsigned int index;
1075 basic_block bb;
1076 gimple_stmt_iterator bsi;
1077
1078 /* This routine assumes that CFUN is set to FN, as it needs to call
1079 basic GIMPLE routines that use CFUN. */
1080 gcc_assert (cfun == fn);
1081
1082 index = lto_input_uleb128 (ib);
1083 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1084
1085 bb->count = (lto_input_sleb128 (ib) * count_materialization_scale
1086 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
1087 bb->loop_depth = lto_input_sleb128 (ib);
1088 bb->frequency = lto_input_sleb128 (ib);
1089 bb->flags = lto_input_sleb128 (ib);
1090
1091 /* LTO_bb1 has statements. LTO_bb0 does not. */
1092 if (tag == LTO_bb0)
1093 return;
1094
1095 bsi = gsi_start_bb (bb);
1096 tag = input_record_start (ib);
1097 while (tag)
1098 {
1099 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1100 if (!is_gimple_debug (stmt))
1101 find_referenced_vars_in (stmt);
1102 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1103
1104 /* After the statement, expect a 0 delimiter or the EH region
1105 that the previous statement belongs to. */
1106 tag = input_record_start (ib);
1107 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1108
1109 if (tag == LTO_eh_region)
1110 {
1111 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1112 gcc_assert (region == (int) region);
1113 add_stmt_to_eh_lp (stmt, region);
1114 }
1115
1116 tag = input_record_start (ib);
1117 }
1118
1119 tag = input_record_start (ib);
1120 while (tag)
1121 {
1122 gimple phi = input_phi (ib, bb, data_in, fn);
1123 find_referenced_vars_in (phi);
1124 tag = input_record_start (ib);
1125 }
1126 }
1127 880
1128 /* Go through all NODE edges and fixup call_stmt pointers 881 /* Go through all NODE edges and fixup call_stmt pointers
1129 so they point to STMTS. */ 882 so they point to STMTS. */
1130 883
1131 static void 884 static void
1132 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts) 885 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
1133 { 886 struct function *fn)
887 {
888 #define STMT_UID_NOT_IN_RANGE(uid) \
889 (gimple_stmt_max_uid (fn) < uid || uid == 0)
890
1134 struct cgraph_edge *cedge; 891 struct cgraph_edge *cedge;
892 struct ipa_ref *ref = NULL;
893 unsigned int i;
894
1135 for (cedge = node->callees; cedge; cedge = cedge->next_callee) 895 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1136 cedge->call_stmt = stmts[cedge->lto_stmt_uid]; 896 {
897 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
898 fatal_error (input_location,
899 "Cgraph edge statement index out of range");
900 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
901 if (!cedge->call_stmt)
902 fatal_error (input_location,
903 "Cgraph edge statement index not found");
904 }
1137 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee) 905 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1138 cedge->call_stmt = stmts[cedge->lto_stmt_uid]; 906 {
1139 } 907 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
908 fatal_error (input_location,
909 "Cgraph edge statement index out of range");
910 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
911 if (!cedge->call_stmt)
912 fatal_error (input_location, "Cgraph edge statement index not found");
913 }
914 for (i = 0; node->iterate_reference (i, ref); i++)
915 if (ref->lto_stmt_uid)
916 {
917 if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
918 fatal_error (input_location,
919 "Reference statement index out of range");
920 ref->stmt = stmts[ref->lto_stmt_uid - 1];
921 if (!ref->stmt)
922 fatal_error (input_location, "Reference statement index not found");
923 }
924 }
925
1140 926
1141 /* Fixup call_stmt pointers in NODE and all clones. */ 927 /* Fixup call_stmt pointers in NODE and all clones. */
1142 928
1143 static void 929 static void
1144 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts) 930 fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
1145 { 931 {
1146 struct cgraph_node *node; 932 struct cgraph_node *node;
933 struct function *fn;
1147 934
1148 while (orig->clone_of) 935 while (orig->clone_of)
1149 orig = orig->clone_of; 936 orig = orig->clone_of;
1150 937 fn = DECL_STRUCT_FUNCTION (orig->decl);
1151 fixup_call_stmt_edges_1 (orig, stmts); 938
939 if (!orig->thunk.thunk_p)
940 fixup_call_stmt_edges_1 (orig, stmts, fn);
1152 if (orig->clones) 941 if (orig->clones)
1153 for (node = orig->clones; node != orig;) 942 for (node = orig->clones; node != orig;)
1154 { 943 {
1155 fixup_call_stmt_edges_1 (node, stmts); 944 if (!node->thunk.thunk_p)
945 fixup_call_stmt_edges_1 (node, stmts, fn);
1156 if (node->clones) 946 if (node->clones)
1157 node = node->clones; 947 node = node->clones;
1158 else if (node->next_sibling_clone) 948 else if (node->next_sibling_clone)
1159 node = node->next_sibling_clone; 949 node = node->next_sibling_clone;
1160 else 950 else
1165 node = node->next_sibling_clone; 955 node = node->next_sibling_clone;
1166 } 956 }
1167 } 957 }
1168 } 958 }
1169 959
1170 /* Read the body of function FN_DECL from DATA_IN using input block IB. */ 960
961 /* Input the base body of struct function FN from DATA_IN
962 using input block IB. */
1171 963
1172 static void 964 static void
1173 input_function (tree fn_decl, struct data_in *data_in, 965 input_struct_function_base (struct function *fn, struct data_in *data_in,
1174 struct lto_input_block *ib) 966 struct lto_input_block *ib)
1175 { 967 {
1176 struct function *fn;
1177 enum LTO_tags tag;
1178 gimple *stmts;
1179 basic_block bb;
1180 struct bitpack_d bp; 968 struct bitpack_d bp;
1181 struct cgraph_node *node;
1182 tree args, narg, oarg;
1183 int len; 969 int len;
1184 970
1185 fn = DECL_STRUCT_FUNCTION (fn_decl); 971 /* Read the static chain and non-local goto save area. */
1186 tag = input_record_start (ib); 972 fn->static_chain_decl = stream_read_tree (ib, data_in);
1187 clear_line_info (data_in); 973 fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
1188 974
1189 gimple_register_cfg_hooks (); 975 /* Read all the local symbols. */
1190 lto_tag_check (tag, LTO_function); 976 len = streamer_read_hwi (ib);
977 if (len > 0)
978 {
979 int i;
980 vec_safe_grow_cleared (fn->local_decls, len);
981 for (i = 0; i < len; i++)
982 {
983 tree t = stream_read_tree (ib, data_in);
984 (*fn->local_decls)[i] = t;
985 }
986 }
987
988 /* Input the current IL state of the function. */
989 fn->curr_properties = streamer_read_uhwi (ib);
1191 990
1192 /* Read all the attributes for FN. */ 991 /* Read all the attributes for FN. */
1193 bp = lto_input_bitpack (ib); 992 bp = streamer_read_bitpack (ib);
1194 fn->is_thunk = bp_unpack_value (&bp, 1); 993 fn->is_thunk = bp_unpack_value (&bp, 1);
1195 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1); 994 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1196 fn->after_tree_profile = bp_unpack_value (&bp, 1);
1197 fn->returns_pcc_struct = bp_unpack_value (&bp, 1); 995 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1198 fn->returns_struct = bp_unpack_value (&bp, 1); 996 fn->returns_struct = bp_unpack_value (&bp, 1);
1199 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1); 997 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
998 fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
1200 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1); 999 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1201 fn->after_inlining = bp_unpack_value (&bp, 1); 1000 fn->after_inlining = bp_unpack_value (&bp, 1);
1202 fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1203 fn->stdarg = bp_unpack_value (&bp, 1); 1001 fn->stdarg = bp_unpack_value (&bp, 1);
1204 fn->has_nonlocal_label = bp_unpack_value (&bp, 1); 1002 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1003 fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
1205 fn->calls_alloca = bp_unpack_value (&bp, 1); 1004 fn->calls_alloca = bp_unpack_value (&bp, 1);
1206 fn->calls_setjmp = bp_unpack_value (&bp, 1); 1005 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1006 fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
1007 fn->has_simduid_loops = bp_unpack_value (&bp, 1);
1207 fn->va_list_fpr_size = bp_unpack_value (&bp, 8); 1008 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1208 fn->va_list_gpr_size = bp_unpack_value (&bp, 8); 1009 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1010 fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
1209 1011
1210 /* Input the function start and end loci. */ 1012 /* Input the function start and end loci. */
1211 fn->function_start_locus = lto_input_location (ib, data_in); 1013 fn->function_start_locus = stream_input_location_now (&bp, data_in);
1212 fn->function_end_locus = lto_input_location (ib, data_in); 1014 fn->function_end_locus = stream_input_location_now (&bp, data_in);
1213 1015 }
1214 /* Input the current IL state of the function. */ 1016
1215 fn->curr_properties = lto_input_uleb128 (ib); 1017
1216 1018 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1217 /* Read the static chain and non-local goto save area. */ 1019
1218 fn->static_chain_decl = lto_input_tree (ib, data_in); 1020 static void
1219 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in); 1021 input_function (tree fn_decl, struct data_in *data_in,
1220 1022 struct lto_input_block *ib, struct lto_input_block *ib_cfg)
1221 /* Read all the local symbols. */ 1023 {
1222 len = lto_input_sleb128 (ib); 1024 struct function *fn;
1223 if (len > 0) 1025 enum LTO_tags tag;
1224 { 1026 gimple **stmts;
1225 int i; 1027 basic_block bb;
1226 VEC_safe_grow (tree, gc, fn->local_decls, len); 1028 struct cgraph_node *node;
1227 for (i = 0; i < len; i++) 1029
1228 { 1030 tag = streamer_read_record_start (ib);
1229 tree t = lto_input_tree (ib, data_in); 1031 lto_tag_check (tag, LTO_function);
1230 VEC_replace (tree, fn->local_decls, i, t); 1032
1231 } 1033 /* Read decls for parameters and args. */
1232 } 1034 DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in);
1233 1035 DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in);
1234 /* Read all function arguments. We need to re-map them here to the 1036
1235 arguments of the merged function declaration. */ 1037 /* Read debug args if available. */
1236 args = lto_input_tree (ib, data_in); 1038 unsigned n_debugargs = streamer_read_uhwi (ib);
1237 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl); 1039 if (n_debugargs)
1238 oarg && narg; 1040 {
1239 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg)) 1041 vec<tree, va_gc> **debugargs = decl_debug_args_insert (fn_decl);
1240 { 1042 vec_safe_grow (*debugargs, n_debugargs);
1241 int ix; 1043 for (unsigned i = 0; i < n_debugargs; ++i)
1242 bool res; 1044 (**debugargs)[i] = stream_read_tree (ib, data_in);
1243 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix); 1045 }
1244 gcc_assert (res); 1046
1245 /* Replace the argument in the streamer cache. */ 1047 /* Read the tree of lexical scopes for the function. */
1246 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix); 1048 DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
1247 } 1049 unsigned block_leaf_count = streamer_read_uhwi (ib);
1248 gcc_assert (!oarg && !narg); 1050 while (block_leaf_count--)
1051 stream_read_tree (ib, data_in);
1052
1053 if (!streamer_read_uhwi (ib))
1054 return;
1055
1056 push_struct_function (fn_decl);
1057 fn = DECL_STRUCT_FUNCTION (fn_decl);
1058 init_tree_ssa (fn);
1059 /* We input IL in SSA form. */
1060 cfun->gimple_df->in_ssa_p = true;
1061
1062 gimple_register_cfg_hooks ();
1063
1064 node = cgraph_node::get (fn_decl);
1065 if (!node)
1066 node = cgraph_node::create (fn_decl);
1067 input_struct_function_base (fn, data_in, ib);
1068 input_cfg (ib_cfg, data_in, fn);
1249 1069
1250 /* Read all the SSA names. */ 1070 /* Read all the SSA names. */
1251 input_ssa_names (ib, data_in, fn); 1071 input_ssa_names (ib, data_in, fn);
1252 1072
1253 /* Read the exception handling regions in the function. */ 1073 /* Read the exception handling regions in the function. */
1254 input_eh_regions (ib, data_in, fn); 1074 input_eh_regions (ib, data_in, fn);
1255 1075
1256 /* Read the tree of lexical scopes for the function. */
1257 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1258 gcc_assert (DECL_INITIAL (fn_decl)); 1076 gcc_assert (DECL_INITIAL (fn_decl));
1259 DECL_SAVED_TREE (fn_decl) = NULL_TREE; 1077 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1260 node = cgraph_node (fn_decl);
1261 1078
1262 /* Read all the basic blocks. */ 1079 /* Read all the basic blocks. */
1263 tag = input_record_start (ib); 1080 tag = streamer_read_record_start (ib);
1264 while (tag) 1081 while (tag)
1265 { 1082 {
1266 input_bb (ib, tag, data_in, fn, 1083 input_bb (ib, tag, data_in, fn,
1267 node->count_materialization_scale); 1084 node->count_materialization_scale);
1268 tag = input_record_start (ib); 1085 tag = streamer_read_record_start (ib);
1269 } 1086 }
1270 1087
1271 /* Fix up the call statements that are mentioned in the callgraph 1088 /* Fix up the call statements that are mentioned in the callgraph
1272 edges. */ 1089 edges. */
1273 renumber_gimple_stmt_uids (); 1090 set_gimple_stmt_max_uid (cfun, 0);
1274 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple)); 1091 FOR_ALL_BB_FN (bb, cfun)
1275 FOR_ALL_BB (bb) 1092 {
1276 { 1093 gimple_stmt_iterator gsi;
1277 gimple_stmt_iterator bsi = gsi_start_bb (bb); 1094 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1095 {
1096 gimple *stmt = gsi_stmt (gsi);
1097 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1098 }
1099 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1100 {
1101 gimple *stmt = gsi_stmt (gsi);
1102 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1103 }
1104 }
1105 stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
1106 FOR_ALL_BB_FN (bb, cfun)
1107 {
1108 gimple_stmt_iterator bsi = gsi_start_phis (bb);
1278 while (!gsi_end_p (bsi)) 1109 while (!gsi_end_p (bsi))
1279 { 1110 {
1280 gimple stmt = gsi_stmt (bsi); 1111 gimple *stmt = gsi_stmt (bsi);
1112 gsi_next (&bsi);
1113 stmts[gimple_uid (stmt)] = stmt;
1114 }
1115 bsi = gsi_start_bb (bb);
1116 while (!gsi_end_p (bsi))
1117 {
1118 gimple *stmt = gsi_stmt (bsi);
1119 bool remove = false;
1281 /* If we're recompiling LTO objects with debug stmts but 1120 /* If we're recompiling LTO objects with debug stmts but
1282 we're not supposed to have debug stmts, remove them now. 1121 we're not supposed to have debug stmts, remove them now.
1283 We can't remove them earlier because this would cause uid 1122 We can't remove them earlier because this would cause uid
1284 mismatches in fixups, but we can do it at this point, as 1123 mismatches in fixups, but we can do it at this point, as
1285 long as debug stmts don't require fixups. */ 1124 long as debug stmts don't require fixups.
1286 if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt)) 1125 Similarly remove all IFN_*SAN_* internal calls */
1126 if (!flag_wpa)
1127 {
1128 if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1129 remove = true;
1130 if (is_gimple_call (stmt)
1131 && gimple_call_internal_p (stmt))
1132 {
1133 switch (gimple_call_internal_fn (stmt))
1134 {
1135 case IFN_UBSAN_NULL:
1136 if ((flag_sanitize
1137 & (SANITIZE_NULL | SANITIZE_ALIGNMENT)) == 0)
1138 remove = true;
1139 break;
1140 case IFN_UBSAN_BOUNDS:
1141 if ((flag_sanitize & SANITIZE_BOUNDS) == 0)
1142 remove = true;
1143 break;
1144 case IFN_UBSAN_VPTR:
1145 if ((flag_sanitize & SANITIZE_VPTR) == 0)
1146 remove = true;
1147 break;
1148 case IFN_UBSAN_OBJECT_SIZE:
1149 if ((flag_sanitize & SANITIZE_OBJECT_SIZE) == 0)
1150 remove = true;
1151 break;
1152 case IFN_UBSAN_PTR:
1153 if ((flag_sanitize & SANITIZE_POINTER_OVERFLOW) == 0)
1154 remove = true;
1155 break;
1156 case IFN_ASAN_MARK:
1157 if ((flag_sanitize & SANITIZE_ADDRESS) == 0)
1158 remove = true;
1159 break;
1160 case IFN_TSAN_FUNC_EXIT:
1161 if ((flag_sanitize & SANITIZE_THREAD) == 0)
1162 remove = true;
1163 break;
1164 default:
1165 break;
1166 }
1167 gcc_assert (!remove || gimple_call_lhs (stmt) == NULL_TREE);
1168 }
1169 }
1170 if (remove)
1287 { 1171 {
1288 gimple_stmt_iterator gsi = bsi; 1172 gimple_stmt_iterator gsi = bsi;
1289 gsi_next (&bsi); 1173 gsi_next (&bsi);
1174 unlink_stmt_vdef (stmt);
1175 release_defs (stmt);
1290 gsi_remove (&gsi, true); 1176 gsi_remove (&gsi, true);
1291 } 1177 }
1292 else 1178 else
1293 { 1179 {
1294 gsi_next (&bsi); 1180 gsi_next (&bsi);
1300 /* Set the gimple body to the statement sequence in the entry 1186 /* Set the gimple body to the statement sequence in the entry
1301 basic block. FIXME lto, this is fairly hacky. The existence 1187 basic block. FIXME lto, this is fairly hacky. The existence
1302 of a gimple body is used by the cgraph routines, but we should 1188 of a gimple body is used by the cgraph routines, but we should
1303 really use the presence of the CFG. */ 1189 really use the presence of the CFG. */
1304 { 1190 {
1305 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs); 1191 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
1306 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest)); 1192 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1307 } 1193 }
1308 1194
1309 fixup_call_stmt_edges (node, stmts); 1195 fixup_call_stmt_edges (node, stmts);
1310 execute_all_ipa_stmt_fixups (node, stmts); 1196 execute_all_ipa_stmt_fixups (node, stmts);
1311 1197
1312 update_ssa (TODO_update_ssa_only_virtuals); 1198 update_ssa (TODO_update_ssa_only_virtuals);
1313 free_dominance_info (CDI_DOMINATORS); 1199 free_dominance_info (CDI_DOMINATORS);
1314 free_dominance_info (CDI_POST_DOMINATORS); 1200 free_dominance_info (CDI_POST_DOMINATORS);
1315 free (stmts); 1201 free (stmts);
1316 } 1202 pop_cfun ();
1317 1203 }
1318 1204
1319 /* Read initializer expressions for public statics. DATA_IN is the 1205 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1320 file being read. IB is the input block used for reading. */
1321 1206
1322 static void 1207 static void
1323 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in) 1208 input_constructor (tree var, struct data_in *data_in,
1324 { 1209 struct lto_input_block *ib)
1325 tree var; 1210 {
1326 1211 DECL_INITIAL (var) = stream_read_tree (ib, data_in);
1327 clear_line_info (data_in); 1212 }
1328 1213
1329 /* Skip over all the unreferenced globals. */ 1214
1330 do 1215 /* Read the body from DATA for function NODE and fill it in.
1331 var = lto_input_tree (ib, data_in);
1332 while (var);
1333
1334 var = lto_input_tree (ib, data_in);
1335 while (var)
1336 {
1337 const char *orig_name, *new_name;
1338 alias_pair *p;
1339
1340 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1341 p->decl = var;
1342 p->target = lto_input_tree (ib, data_in);
1343
1344 /* If the target is a static object, we may have registered a
1345 new name for it to avoid clashes between statics coming from
1346 different files. In that case, use the new name. */
1347 orig_name = IDENTIFIER_POINTER (p->target);
1348 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1349 if (strcmp (orig_name, new_name) != 0)
1350 p->target = get_identifier (new_name);
1351
1352 var = lto_input_tree (ib, data_in);
1353 }
1354 }
1355
1356
1357 /* Read the body from DATA for function FN_DECL and fill it in.
1358 FILE_DATA are the global decls and types. SECTION_TYPE is either 1216 FILE_DATA are the global decls and types. SECTION_TYPE is either
1359 LTO_section_function_body or LTO_section_static_initializer. If 1217 LTO_section_function_body or LTO_section_static_initializer. If
1360 section type is LTO_section_function_body, FN must be the decl for 1218 section type is LTO_section_function_body, FN must be the decl for
1361 that function. */ 1219 that function. */
1362 1220
1363 static void 1221 static void
1364 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl, 1222 lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
1365 const char *data, enum lto_section_type section_type) 1223 const char *data, enum lto_section_type section_type)
1366 { 1224 {
1367 const struct lto_function_header *header; 1225 const struct lto_function_header *header;
1368 struct data_in *data_in; 1226 struct data_in *data_in;
1369 int32_t cfg_offset; 1227 int cfg_offset;
1370 int32_t main_offset; 1228 int main_offset;
1371 int32_t string_offset; 1229 int string_offset;
1372 struct lto_input_block ib_cfg; 1230 tree fn_decl = node->decl;
1373 struct lto_input_block ib_main;
1374 1231
1375 header = (const struct lto_function_header *) data; 1232 header = (const struct lto_function_header *) data;
1376 cfg_offset = sizeof (struct lto_function_header); 1233 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1377 main_offset = cfg_offset + header->cfg_size; 1234 {
1378 string_offset = main_offset + header->main_size; 1235 cfg_offset = sizeof (struct lto_function_header);
1379 1236 main_offset = cfg_offset + header->cfg_size;
1380 LTO_INIT_INPUT_BLOCK (ib_cfg, 1237 string_offset = main_offset + header->main_size;
1381 data + cfg_offset, 1238 }
1382 0, 1239 else
1383 header->cfg_size); 1240 {
1384 1241 main_offset = sizeof (struct lto_function_header);
1385 LTO_INIT_INPUT_BLOCK (ib_main, 1242 string_offset = main_offset + header->main_size;
1386 data + main_offset, 1243 }
1387 0,
1388 header->main_size);
1389 1244
1390 data_in = lto_data_in_create (file_data, data + string_offset, 1245 data_in = lto_data_in_create (file_data, data + string_offset,
1391 header->string_size, NULL); 1246 header->string_size, vNULL);
1392
1393 /* Make sure the file was generated by the exact same compiler. */
1394 lto_check_version (header->lto_header.major_version,
1395 header->lto_header.minor_version);
1396 1247
1397 if (section_type == LTO_section_function_body) 1248 if (section_type == LTO_section_function_body)
1398 { 1249 {
1399 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1400 struct lto_in_decl_state *decl_state; 1250 struct lto_in_decl_state *decl_state;
1401 struct cgraph_node *node = cgraph_node (fn_decl); 1251 unsigned from;
1402 1252
1403 push_cfun (fn); 1253 gcc_checking_assert (node);
1404 init_tree_ssa (fn);
1405 1254
1406 /* Use the function's decl state. */ 1255 /* Use the function's decl state. */
1407 decl_state = lto_get_function_in_decl_state (file_data, fn_decl); 1256 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1408 gcc_assert (decl_state); 1257 gcc_assert (decl_state);
1409 file_data->current_decl_state = decl_state; 1258 file_data->current_decl_state = decl_state;
1410 1259
1411 input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1412 1260
1413 /* Set up the struct function. */ 1261 /* Set up the struct function. */
1414 input_function (fn_decl, data_in, &ib_main); 1262 from = data_in->reader_cache->nodes.length ();
1415 1263 lto_input_block ib_main (data + main_offset, header->main_size,
1416 /* We should now be in SSA. */ 1264 file_data->mode_table);
1417 cfun->gimple_df->in_ssa_p = true; 1265 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1266 {
1267 lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
1268 file_data->mode_table);
1269 input_function (fn_decl, data_in, &ib_main, &ib_cfg);
1270 }
1271 else
1272 input_constructor (fn_decl, data_in, &ib_main);
1273 data_in->location_cache.apply_location_cache ();
1274 /* And fixup types we streamed locally. */
1275 {
1276 struct streamer_tree_cache_d *cache = data_in->reader_cache;
1277 unsigned len = cache->nodes.length ();
1278 unsigned i;
1279 for (i = len; i-- > from;)
1280 {
1281 tree t = streamer_tree_cache_get_tree (cache, i);
1282 if (t == NULL_TREE)
1283 continue;
1284
1285 if (TYPE_P (t))
1286 {
1287 gcc_assert (TYPE_CANONICAL (t) == NULL_TREE);
1288 if (type_with_alias_set_p (t)
1289 && canonical_type_used_p (t))
1290 TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
1291 if (TYPE_MAIN_VARIANT (t) != t)
1292 {
1293 gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
1294 TYPE_NEXT_VARIANT (t)
1295 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
1296 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
1297 }
1298 }
1299 }
1300 }
1418 1301
1419 /* Restore decl state */ 1302 /* Restore decl state */
1420 file_data->current_decl_state = file_data->global_decl_state; 1303 file_data->current_decl_state = file_data->global_decl_state;
1421 1304 }
1422 pop_cfun (); 1305
1423 }
1424 else
1425 {
1426 input_alias_pairs (&ib_main, data_in);
1427 }
1428
1429 clear_line_info (data_in);
1430 lto_data_in_delete (data_in); 1306 lto_data_in_delete (data_in);
1431 } 1307 }
1432 1308
1433 1309
1434 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global 1310 /* Read the body of NODE using DATA. FILE_DATA holds the global
1435 decls and types. */ 1311 decls and types. */
1436 1312
1437 void 1313 void
1438 lto_input_function_body (struct lto_file_decl_data *file_data, 1314 lto_input_function_body (struct lto_file_decl_data *file_data,
1439 tree fn_decl, const char *data) 1315 struct cgraph_node *node, const char *data)
1440 { 1316 {
1441 current_function_decl = fn_decl; 1317 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1442 lto_read_body (file_data, fn_decl, data, LTO_section_function_body); 1318 }
1443 } 1319
1444 1320 /* Read the body of NODE using DATA. FILE_DATA holds the global
1445 1321 decls and types. */
1446 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1447 types. */
1448 1322
1449 void 1323 void
1450 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data, 1324 lto_input_variable_constructor (struct lto_file_decl_data *file_data,
1451 const char *data) 1325 struct varpool_node *node, const char *data)
1452 { 1326 {
1453 lto_read_body (file_data, NULL, data, LTO_section_static_initializer); 1327 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1454 } 1328 }
1455 1329
1456 1330
1457 /* Return the resolution for the decl with index INDEX from DATA_IN. */ 1331 /* Queue of acummulated decl -> DIE mappings. Similar to locations those
1458 1332 are only applied to prevailing tree nodes during tree merging. */
1459 static enum ld_plugin_symbol_resolution 1333 vec<dref_entry> dref_queue;
1460 get_resolution (struct data_in *data_in, unsigned index) 1334
1461 { 1335 /* Read the physical representation of a tree node EXPR from
1462 if (data_in->globals_resolution) 1336 input block IB using the per-file context in DATA_IN. */
1463 {
1464 ld_plugin_symbol_resolution_t ret;
1465 /* We can have references to not emitted functions in
1466 DECL_FUNCTION_PERSONALITY at least. So we can and have
1467 to indeed return LDPR_UNKNOWN in some cases. */
1468 if (VEC_length (ld_plugin_symbol_resolution_t,
1469 data_in->globals_resolution) <= index)
1470 return LDPR_UNKNOWN;
1471 ret = VEC_index (ld_plugin_symbol_resolution_t,
1472 data_in->globals_resolution,
1473 index);
1474 return ret;
1475 }
1476 else
1477 /* Delay resolution finding until decl merging. */
1478 return LDPR_UNKNOWN;
1479 }
1480
1481
1482 /* Unpack all the non-pointer fields of the TS_BASE structure of
1483 expression EXPR from bitpack BP. */
1484 1337
1485 static void 1338 static void
1486 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr) 1339 lto_read_tree_1 (struct lto_input_block *ib, struct data_in *data_in, tree expr)
1487 { 1340 {
1488 /* Note that the code for EXPR has already been unpacked to create EXPR in 1341 /* Read all the bitfield values in EXPR. Note that for LTO, we
1489 lto_materialize_tree. */ 1342 only write language-independent bitfields, so no more unpacking is
1490 if (!TYPE_P (expr)) 1343 needed. */
1491 { 1344 streamer_read_tree_bitfields (ib, data_in, expr);
1492 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1); 1345
1493 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1); 1346 /* Read all the pointer fields in EXPR. */
1494 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1); 1347 streamer_read_tree_body (ib, data_in, expr);
1495 1348
1496 /* TREE_PUBLIC is used on types to indicate that the type 1349 /* Read any LTO-specific data not read by the tree streamer. */
1497 has a TYPE_CACHED_VALUES vector. This is not streamed out, 1350 if (DECL_P (expr)
1498 so we skip it here. */ 1351 && TREE_CODE (expr) != FUNCTION_DECL
1499 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1); 1352 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1500 } 1353 DECL_INITIAL (expr) = stream_read_tree (ib, data_in);
1501 else 1354
1502 bp_unpack_value (bp, 4); 1355 /* Stream references to early generated DIEs. Keep in sync with the
1503 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1); 1356 trees handled in dwarf2out_register_external_die. */
1504 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1); 1357 if ((DECL_P (expr)
1505 if (DECL_P (expr)) 1358 && TREE_CODE (expr) != FIELD_DECL
1506 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1); 1359 && TREE_CODE (expr) != DEBUG_EXPR_DECL
1507 else if (TYPE_P (expr)) 1360 && TREE_CODE (expr) != TYPE_DECL)
1508 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1); 1361 || TREE_CODE (expr) == BLOCK)
1509 else 1362 {
1510 bp_unpack_value (bp, 1); 1363 const char *str = streamer_read_string (data_in, ib);
1511 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1); 1364 if (str)
1512 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1); 1365 {
1513 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1); 1366 unsigned HOST_WIDE_INT off = streamer_read_uhwi (ib);
1514 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1); 1367 dref_entry e = { expr, str, off };
1515 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1); 1368 dref_queue.safe_push (e);
1516 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1); 1369 }
1517 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1); 1370 }
1518 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1); 1371 }
1519 if (TYPE_P (expr)) 1372
1520 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1); 1373 /* Read the physical representation of a tree node with tag TAG from
1521 else if (TREE_CODE (expr) == SSA_NAME) 1374 input block IB using the per-file context in DATA_IN. */
1522 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1523 else
1524 bp_unpack_value (bp, 1);
1525 }
1526
1527
1528 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1529 expression EXPR from bitpack BP. */
1530
1531 static void
1532 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1533 {
1534 unsigned i;
1535 REAL_VALUE_TYPE r;
1536 REAL_VALUE_TYPE *rp;
1537
1538 r.cl = (unsigned) bp_unpack_value (bp, 2);
1539 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1540 r.sign = (unsigned) bp_unpack_value (bp, 1);
1541 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1542 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1543 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1544 for (i = 0; i < SIGSZ; i++)
1545 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1546
1547 rp = ggc_alloc_real_value ();
1548 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1549 TREE_REAL_CST_PTR (expr) = rp;
1550 }
1551
1552
1553 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1554 expression EXPR from bitpack BP. */
1555
1556 static void
1557 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1558 {
1559 struct fixed_value fv;
1560
1561 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1562 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1563 fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1564 TREE_FIXED_CST (expr) = fv;
1565 }
1566
1567
1568 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1569 of expression EXPR from bitpack BP. */
1570
1571 static void
1572 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1573 {
1574 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1575 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1576 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1577 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1578 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1579 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1580 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1581 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1582 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1583 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1584 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1585 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1586
1587 if (TREE_CODE (expr) == LABEL_DECL)
1588 {
1589 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1590 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1591
1592 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1593 force gimple_set_bb to recreate label_to_block_map. */
1594 LABEL_DECL_UID (expr) = -1;
1595 }
1596
1597 if (TREE_CODE (expr) == FIELD_DECL)
1598 {
1599 unsigned HOST_WIDE_INT off_align;
1600 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1601 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1602 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1603 SET_DECL_OFFSET_ALIGN (expr, off_align);
1604 }
1605
1606 if (TREE_CODE (expr) == RESULT_DECL
1607 || TREE_CODE (expr) == PARM_DECL
1608 || TREE_CODE (expr) == VAR_DECL)
1609 {
1610 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1611 if (TREE_CODE (expr) == VAR_DECL
1612 || TREE_CODE (expr) == PARM_DECL)
1613 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1614 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1615 }
1616 }
1617
1618
1619 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1620 of expression EXPR from bitpack BP. */
1621
1622 static void
1623 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1624 {
1625 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1626 }
1627
1628
1629 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1630 of expression EXPR from bitpack BP. */
1631
1632 static void
1633 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1634 {
1635 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1636 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1637 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1638 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1639 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1640 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1641 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1642 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1643
1644 if (TREE_CODE (expr) == VAR_DECL)
1645 {
1646 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1647 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1648 DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1649 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1650 }
1651
1652 if (VAR_OR_FUNCTION_DECL_P (expr))
1653 {
1654 priority_type p;
1655 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1656 SET_DECL_INIT_PRIORITY (expr, p);
1657 }
1658 }
1659
1660
1661 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1662 of expression EXPR from bitpack BP. */
1663
1664 static void
1665 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1666 {
1667 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1668 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1669 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1670 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1671 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1672 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1673 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1674 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1675 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1676 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1677 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1678 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1679 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1680 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1681 = (unsigned) bp_unpack_value (bp, 1);
1682 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1683 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1684 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1685 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1686 if (DECL_STATIC_DESTRUCTOR (expr))
1687 {
1688 priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1689 SET_DECL_FINI_PRIORITY (expr, p);
1690 }
1691 }
1692
1693
1694 /* Unpack all the non-pointer fields of the TS_TYPE structure
1695 of expression EXPR from bitpack BP. */
1696
1697 static void
1698 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1699 {
1700 enum machine_mode mode;
1701
1702 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1703 mode = (enum machine_mode) bp_unpack_value (bp, 8);
1704 SET_TYPE_MODE (expr, mode);
1705 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1706 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1707 TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1708 if (RECORD_OR_UNION_TYPE_P (expr))
1709 TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1710 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1711 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1712 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1713 = (unsigned) bp_unpack_value (bp, 2);
1714 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1715 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1716 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1717 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1718 }
1719
1720
1721 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1722 of expression EXPR from bitpack BP. */
1723
1724 static void
1725 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1726 {
1727 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1728 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1729 }
1730
1731 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1732 structure of expression EXPR from bitpack BP. */
1733
1734 static void
1735 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1736 {
1737 }
1738
1739 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1740
1741 static void
1742 unpack_value_fields (struct bitpack_d *bp, tree expr)
1743 {
1744 enum tree_code code;
1745
1746 code = TREE_CODE (expr);
1747
1748 /* Note that all these functions are highly sensitive to changes in
1749 the types and sizes of each of the fields being packed. */
1750 unpack_ts_base_value_fields (bp, expr);
1751
1752 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1753 unpack_ts_real_cst_value_fields (bp, expr);
1754
1755 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1756 unpack_ts_fixed_cst_value_fields (bp, expr);
1757
1758 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1759 unpack_ts_decl_common_value_fields (bp, expr);
1760
1761 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1762 unpack_ts_decl_wrtl_value_fields (bp, expr);
1763
1764 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1765 unpack_ts_decl_with_vis_value_fields (bp, expr);
1766
1767 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1768 unpack_ts_function_decl_value_fields (bp, expr);
1769
1770 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1771 unpack_ts_type_value_fields (bp, expr);
1772
1773 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1774 unpack_ts_block_value_fields (bp, expr);
1775
1776 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1777 {
1778 /* We only stream the version number of SSA names. */
1779 gcc_unreachable ();
1780 }
1781
1782 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1783 {
1784 /* This is only used by GENERIC. */
1785 gcc_unreachable ();
1786 }
1787
1788 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1789 {
1790 /* This is only used by High GIMPLE. */
1791 gcc_unreachable ();
1792 }
1793
1794 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1795 unpack_ts_translation_unit_decl_value_fields (bp, expr);
1796 }
1797
1798
1799 /* Materialize a new tree from input block IB using descriptors in
1800 DATA_IN. The code for the new tree should match TAG. Store in
1801 *IX_P the index into the reader cache where the new tree is stored. */
1802 1375
1803 static tree 1376 static tree
1804 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in, 1377 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
1805 enum LTO_tags tag, int *ix_p) 1378 enum LTO_tags tag, hashval_t hash)
1806 { 1379 {
1807 struct bitpack_d bp; 1380 /* Instantiate a new tree node. */
1808 enum tree_code code; 1381 tree result = streamer_alloc_tree (ib, data_in, tag);
1809 tree result;
1810 #ifdef LTO_STREAMER_DEBUG
1811 HOST_WIDEST_INT orig_address_in_writer;
1812 #endif
1813 HOST_WIDE_INT ix;
1814
1815 result = NULL_TREE;
1816
1817 /* Read the header of the node we are about to create. */
1818 ix = lto_input_sleb128 (ib);
1819 gcc_assert ((int) ix == ix);
1820 *ix_p = (int) ix;
1821
1822 #ifdef LTO_STREAMER_DEBUG
1823 /* Read the word representing the memory address for the tree
1824 as it was written by the writer. This is useful when
1825 debugging differences between the writer and reader. */
1826 orig_address_in_writer = lto_input_sleb128 (ib);
1827 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1828 #endif
1829
1830 code = lto_tag_to_tree_code (tag);
1831
1832 /* We should never see an SSA_NAME tree. Only the version numbers of
1833 SSA names are ever written out. See input_ssa_names. */
1834 gcc_assert (code != SSA_NAME);
1835
1836 /* Instantiate a new tree using the header data. */
1837 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1838 result = input_string_cst (data_in, ib);
1839 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1840 result = input_identifier (data_in, ib);
1841 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1842 {
1843 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1844 result = make_tree_vec (len);
1845 }
1846 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1847 {
1848 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1849 result = make_tree_binfo (len);
1850 }
1851 else
1852 {
1853 /* All other nodes can be materialized with a raw make_node
1854 call. */
1855 result = make_node (code);
1856 }
1857
1858 #ifdef LTO_STREAMER_DEBUG
1859 /* Store the original address of the tree as seen by the writer
1860 in RESULT's aux field. This is useful when debugging streaming
1861 problems. This way, a debugging session can be started on
1862 both writer and reader with a breakpoint using this address
1863 value in both. */
1864 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1865 #endif
1866
1867 /* Read the bitpack of non-pointer values from IB. */
1868 bp = lto_input_bitpack (ib);
1869
1870 /* The first word in BP contains the code of the tree that we
1871 are about to read. */
1872 code = (enum tree_code) bp_unpack_value (&bp, 16);
1873 lto_tag_check (lto_tree_code_to_tag (code), tag);
1874
1875 /* Unpack all the value fields from BP. */
1876 unpack_value_fields (&bp, result);
1877 1382
1878 /* Enter RESULT in the reader cache. This will make RESULT 1383 /* Enter RESULT in the reader cache. This will make RESULT
1879 available so that circular references in the rest of the tree 1384 available so that circular references in the rest of the tree
1880 structure can be resolved in subsequent calls to lto_input_tree. */ 1385 structure can be resolved in subsequent calls to stream_read_tree. */
1881 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix); 1386 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1387
1388 lto_read_tree_1 (ib, data_in, result);
1389
1390 /* end_marker = */ streamer_read_uchar (ib);
1882 1391
1883 return result; 1392 return result;
1884 } 1393 }
1885 1394
1886 1395
1887 /* Read a chain of tree nodes from input block IB. DATA_IN contains 1396 /* Populate the reader cache with trees materialized from the SCC
1888 tables and descriptors for the file being read. */ 1397 following in the IB, DATA_IN stream. */
1889 1398
1890 static tree 1399 hashval_t
1891 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in) 1400 lto_input_scc (struct lto_input_block *ib, struct data_in *data_in,
1892 { 1401 unsigned *len, unsigned *entry_len)
1893 int i, count; 1402 {
1894 tree first, prev, curr; 1403 /* A blob of unnamed tree nodes, fill the cache from it and
1895 1404 recurse. */
1896 first = prev = NULL_TREE; 1405 unsigned size = streamer_read_uhwi (ib);
1897 count = lto_input_sleb128 (ib); 1406 hashval_t scc_hash = streamer_read_uhwi (ib);
1898 for (i = 0; i < count; i++) 1407 unsigned scc_entry_len = 1;
1899 { 1408
1900 curr = lto_input_tree (ib, data_in); 1409 if (size == 1)
1901 if (prev) 1410 {
1902 TREE_CHAIN (prev) = curr; 1411 enum LTO_tags tag = streamer_read_record_start (ib);
1903 else 1412 lto_input_tree_1 (ib, data_in, tag, scc_hash);
1904 first = curr;
1905
1906 TREE_CHAIN (curr) = NULL_TREE;
1907 prev = curr;
1908 }
1909
1910 return first;
1911 }
1912
1913
1914 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1915 block IB. DATA_IN contains tables and descriptors for the
1916 file being read. */
1917
1918
1919 static void
1920 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1921 struct data_in *data_in, tree expr)
1922 {
1923 if (TREE_CODE (expr) != IDENTIFIER_NODE)
1924 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1925 }
1926
1927
1928 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1929 block IB. DATA_IN contains tables and descriptors for the
1930 file being read. */
1931
1932 static void
1933 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1934 struct data_in *data_in, tree expr)
1935 {
1936 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1937 }
1938
1939
1940 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1941 block IB. DATA_IN contains tables and descriptors for the
1942 file being read. */
1943
1944 static void
1945 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1946 struct data_in *data_in, tree expr)
1947 {
1948 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1949 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1950 }
1951
1952
1953 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1954 from input block IB. DATA_IN contains tables and descriptors for the
1955 file being read. */
1956
1957 static void
1958 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1959 struct data_in *data_in, tree expr)
1960 {
1961 DECL_NAME (expr) = lto_input_tree (ib, data_in);
1962 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1963 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1964 }
1965
1966
1967 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1968 input block IB. DATA_IN contains tables and descriptors for the
1969 file being read. */
1970
1971 static void
1972 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1973 struct data_in *data_in, tree expr)
1974 {
1975 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1976 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1977
1978 if (TREE_CODE (expr) != FUNCTION_DECL
1979 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1980 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1981
1982 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1983 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
1984 for early inlining so drop it on the floor instead of ICEing in
1985 dwarf2out.c. */
1986
1987 if (TREE_CODE (expr) == PARM_DECL)
1988 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1989
1990 if ((TREE_CODE (expr) == VAR_DECL
1991 || TREE_CODE (expr) == PARM_DECL)
1992 && DECL_HAS_VALUE_EXPR_P (expr))
1993 SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
1994
1995 if (TREE_CODE (expr) == VAR_DECL)
1996 {
1997 tree dexpr = lto_input_tree (ib, data_in);
1998 if (dexpr)
1999 SET_DECL_DEBUG_EXPR (expr, dexpr);
2000 }
2001 }
2002
2003
2004 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2005 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2006 file being read. */
2007
2008 static void
2009 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2010 struct data_in *data_in, tree expr)
2011 {
2012 if (TREE_CODE (expr) == FUNCTION_DECL)
2013 {
2014 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2015 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2016 }
2017 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2018 }
2019
2020
2021 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2022 from input block IB. DATA_IN contains tables and descriptors for the
2023 file being read. */
2024
2025 static void
2026 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2027 struct data_in *data_in, tree expr)
2028 {
2029 tree id;
2030
2031 id = lto_input_tree (ib, data_in);
2032 if (id)
2033 {
2034 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2035 SET_DECL_ASSEMBLER_NAME (expr, id);
2036 }
2037
2038 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2039 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2040 }
2041
2042
2043 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2044 input block IB. DATA_IN contains tables and descriptors for the
2045 file being read. */
2046
2047 static void
2048 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2049 struct data_in *data_in, tree expr)
2050 {
2051 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2052 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2053 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2054 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2055 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2056 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2057 }
2058
2059
2060 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2061 from input block IB. DATA_IN contains tables and descriptors for the
2062 file being read. */
2063
2064 static void
2065 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2066 struct data_in *data_in, tree expr)
2067 {
2068 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2069 maybe it should be handled here? */
2070 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2071 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2072 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2073
2074 /* If the file contains a function with an EH personality set,
2075 then it was compiled with -fexceptions. In that case, initialize
2076 the backend EH machinery. */
2077 if (DECL_FUNCTION_PERSONALITY (expr))
2078 lto_init_eh ();
2079 }
2080
2081
2082 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2083 block IB. DATA_IN contains tables and descriptors for the
2084 file being read. */
2085
2086 static void
2087 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2088 struct data_in *data_in, tree expr)
2089 {
2090 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2091 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2092 else if (TREE_CODE (expr) == ARRAY_TYPE)
2093 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2094 else if (RECORD_OR_UNION_TYPE_P (expr))
2095 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2096 else if (TREE_CODE (expr) == FUNCTION_TYPE
2097 || TREE_CODE (expr) == METHOD_TYPE)
2098 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2099
2100 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2101 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2102 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2103 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2104 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2105 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2106 if (!POINTER_TYPE_P (expr))
2107 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2108 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2109 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2110 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2111 during fixup. */
2112 if (RECORD_OR_UNION_TYPE_P (expr))
2113 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2114 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2115 /* TYPE_CANONICAL gets re-computed during type merging. */
2116 TYPE_CANONICAL (expr) = NULL_TREE;
2117 TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2118 }
2119
2120
2121 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2122 block IB. DATA_IN contains tables and descriptors for the
2123 file being read. */
2124
2125 static void
2126 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2127 struct data_in *data_in, tree expr)
2128 {
2129 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2130 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2131 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2132 }
2133
2134
2135 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2136 block IB. DATA_IN contains tables and descriptors for the
2137 file being read. */
2138
2139 static void
2140 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2141 struct data_in *data_in, tree expr)
2142 {
2143 int i;
2144
2145 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2146 instantiate EXPR. */
2147 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2148 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2149 }
2150
2151
2152 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2153 block IB. DATA_IN contains tables and descriptors for the
2154 file being read. */
2155
2156
2157 static void
2158 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2159 struct data_in *data_in, tree expr)
2160 {
2161 int i, length;
2162 location_t loc;
2163
2164 length = lto_input_sleb128 (ib);
2165 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2166
2167 for (i = 0; i < length; i++)
2168 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2169
2170 loc = lto_input_location (ib, data_in);
2171 SET_EXPR_LOCATION (expr, loc);
2172 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2173 }
2174
2175
2176 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2177 block IB. DATA_IN contains tables and descriptors for the
2178 file being read. */
2179
2180 static void
2181 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2182 struct data_in *data_in, tree expr)
2183 {
2184 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
2185 for early inlining so drop it on the floor instead of ICEing in
2186 dwarf2out.c. */
2187 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2188
2189 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
2190 for early inlining so drop it on the floor instead of ICEing in
2191 dwarf2out.c. */
2192
2193 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2194 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
2195 for early inlining so drop it on the floor instead of ICEing in
2196 dwarf2out.c. */
2197 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2198 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2199 /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2200 of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
2201 stream the child relationship explicitly. */
2202 if (BLOCK_SUPERCONTEXT (expr)
2203 && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2204 {
2205 BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2206 BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2207 }
2208 /* The global block is rooted at the TU decl. Hook it here to
2209 avoid the need to stream in this block during WPA time. */
2210 else if (BLOCK_SUPERCONTEXT (expr)
2211 && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
2212 DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
2213 /* The function-level block is connected at the time we read in
2214 function bodies for the same reason. */
2215 }
2216
2217
2218 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2219 block IB. DATA_IN contains tables and descriptors for the
2220 file being read. */
2221
2222 static void
2223 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2224 struct data_in *data_in, tree expr)
2225 {
2226 unsigned i, len;
2227 tree t;
2228
2229 /* Note that the number of slots in EXPR was read in
2230 lto_materialize_tree when instantiating EXPR. However, the
2231 vector is empty so we cannot rely on VEC_length to know how many
2232 elements to read. So, this list is emitted as a 0-terminated
2233 list on the writer side. */
2234 do
2235 {
2236 t = lto_input_tree (ib, data_in);
2237 if (t)
2238 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2239 }
2240 while (t);
2241
2242 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2243 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2244 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2245 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2246
2247 len = lto_input_uleb128 (ib);
2248 if (len > 0)
2249 {
2250 VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2251 for (i = 0; i < len; i++)
2252 {
2253 tree a = lto_input_tree (ib, data_in);
2254 VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2255 }
2256 }
2257
2258 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2259 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2260 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2261 }
2262
2263
2264 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2265 input block IB. DATA_IN contains tables and descriptors for the
2266 file being read. */
2267
2268 static void
2269 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2270 struct data_in *data_in, tree expr)
2271 {
2272 unsigned i, len;
2273
2274 len = lto_input_uleb128 (ib);
2275 for (i = 0; i < len; i++)
2276 {
2277 tree index, value;
2278
2279 index = lto_input_tree (ib, data_in);
2280 value = lto_input_tree (ib, data_in);
2281 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2282 }
2283 }
2284
2285
2286 /* Input a TS_TARGET_OPTION tree from IB into EXPR. */
2287
2288 static void
2289 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2290 {
2291 unsigned i, len;
2292 struct bitpack_d bp;
2293 struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2294
2295 bp = lto_input_bitpack (ib);
2296 len = sizeof (struct cl_target_option);
2297 for (i = 0; i < len; i++)
2298 ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2299 if (bp_unpack_value (&bp, 32) != 0x12345678)
2300 fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2301 }
2302
2303 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR. */
2304
2305 static void
2306 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2307 struct data_in *data_in,
2308 tree expr)
2309 {
2310 TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (input_string (data_in, ib));
2311 VEC_safe_push (tree, gc, all_translation_units, expr);
2312 }
2313
2314 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2315 input block IB. DATA_IN contains tables and descriptors for the
2316 file being read. */
2317
2318 static void
2319 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2320 tree expr)
2321 {
2322 enum tree_code code;
2323
2324 code = TREE_CODE (expr);
2325
2326 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2327 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2328
2329 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2330 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2331
2332 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2333 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2334
2335 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2336 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2337
2338 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2339 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2340
2341 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2342 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2343
2344 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2345 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2346
2347 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2348 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2349
2350 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2351 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2352
2353 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2354 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2355
2356 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2357 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2358
2359 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2360 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2361
2362 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2363 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2364
2365 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2366 {
2367 /* We only stream the version number of SSA names. */
2368 gcc_unreachable ();
2369 }
2370
2371 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2372 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2373
2374 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2375 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2376
2377 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2378 {
2379 /* This should only appear in GENERIC. */
2380 gcc_unreachable ();
2381 }
2382
2383 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2384 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2385
2386 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2387 {
2388 /* This should only appear in High GIMPLE. */
2389 gcc_unreachable ();
2390 }
2391
2392 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2393 {
2394 sorry ("optimization options not supported yet");
2395 }
2396
2397 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2398 lto_input_ts_target_option (ib, expr);
2399
2400 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2401 lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2402 }
2403
2404
2405 /* Register DECL with the global symbol table and change its
2406 name if necessary to avoid name clashes for static globals across
2407 different files. */
2408
2409 static void
2410 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2411 {
2412 tree context;
2413
2414 /* Variable has file scope, not local. Need to ensure static variables
2415 between different files don't clash unexpectedly. */
2416 if (!TREE_PUBLIC (decl)
2417 && !((context = decl_function_context (decl))
2418 && auto_var_in_fn_p (decl, context)))
2419 {
2420 /* ??? We normally pre-mangle names before we serialize them
2421 out. Here, in lto1, we do not know the language, and
2422 thus cannot do the mangling again. Instead, we just
2423 append a suffix to the mangled name. The resulting name,
2424 however, is not a properly-formed mangled name, and will
2425 confuse any attempt to unmangle it. */
2426 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2427 char *label;
2428
2429 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2430 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2431 rest_of_decl_compilation (decl, 1, 0);
2432
2433 VEC_safe_push (tree, gc, lto_global_var_decls, decl);
2434 }
2435
2436 /* If this variable has already been declared, queue the
2437 declaration for merging. */
2438 if (TREE_PUBLIC (decl))
2439 {
2440 int ix;
2441 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2442 gcc_unreachable ();
2443 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2444 data_in->file_data);
2445 }
2446 }
2447
2448
2449
2450 /* Register DECL with the global symbol table and change its
2451 name if necessary to avoid name clashes for static globals across
2452 different files. DATA_IN contains descriptors and tables for the
2453 file being read. */
2454
2455 static void
2456 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2457 {
2458 /* Need to ensure static entities between different files
2459 don't clash unexpectedly. */
2460 if (!TREE_PUBLIC (decl))
2461 {
2462 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2463 may set the assembler name where it was previously empty. */
2464 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2465
2466 /* FIXME lto: We normally pre-mangle names before we serialize
2467 them out. Here, in lto1, we do not know the language, and
2468 thus cannot do the mangling again. Instead, we just append a
2469 suffix to the mangled name. The resulting name, however, is
2470 not a properly-formed mangled name, and will confuse any
2471 attempt to unmangle it. */
2472 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2473 char *label;
2474
2475 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2476 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2477
2478 /* We may arrive here with the old assembler name not set
2479 if the function body is not needed, e.g., it has been
2480 inlined away and does not appear in the cgraph. */
2481 if (old_assembler_name)
2482 {
2483 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2484
2485 /* Make the original assembler name available for later use.
2486 We may have used it to indicate the section within its
2487 object file where the function body may be found.
2488 FIXME lto: Find a better way to maintain the function decl
2489 to body section mapping so we don't need this hack. */
2490 lto_record_renamed_decl (data_in->file_data,
2491 IDENTIFIER_POINTER (old_assembler_name),
2492 IDENTIFIER_POINTER (new_assembler_name));
2493
2494 /* Also register the reverse mapping so that we can find the
2495 new name given to an existing assembler name (used when
2496 restoring alias pairs in input_constructors_or_inits. */
2497 lto_record_renamed_decl (data_in->file_data,
2498 IDENTIFIER_POINTER (new_assembler_name),
2499 IDENTIFIER_POINTER (old_assembler_name));
2500 }
2501 }
2502
2503 /* If this variable has already been declared, queue the
2504 declaration for merging. */
2505 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2506 {
2507 int ix;
2508 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2509 gcc_unreachable ();
2510 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2511 data_in->file_data);
2512 }
2513 }
2514
2515
2516 /* Read an index IX from input block IB and return the tree node at
2517 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2518
2519 static tree
2520 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2521 {
2522 HOST_WIDE_INT ix;
2523 tree result;
2524 enum LTO_tags expected_tag;
2525 unsigned HOST_WIDE_INT orig_offset;
2526
2527 ix = lto_input_sleb128 (ib);
2528 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2529
2530 orig_offset = lto_input_uleb128 (ib);
2531 gcc_assert (orig_offset == (unsigned) orig_offset);
2532
2533 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2534 if (result == NULL_TREE)
2535 {
2536 /* We have not yet read the cache slot IX. Go to the offset
2537 in the stream where the physical tree node is, and materialize
2538 it from there. */
2539 struct lto_input_block fwd_ib;
2540
2541 /* If we are trying to go back in the stream, something is wrong.
2542 We should've read the node at the earlier position already. */
2543 if (ib->p >= orig_offset)
2544 internal_error ("bytecode stream: tried to jump backwards in the "
2545 "stream");
2546
2547 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2548 result = lto_input_tree (&fwd_ib, data_in);
2549 }
2550
2551 gcc_assert (result
2552 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2553
2554 return result;
2555 }
2556
2557
2558 /* Read a code and class from input block IB and return the
2559 corresponding builtin. DATA_IN is as in lto_input_tree. */
2560
2561 static tree
2562 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2563 {
2564 enum built_in_class fclass;
2565 enum built_in_function fcode;
2566 const char *asmname;
2567 tree result;
2568 int ix;
2569
2570 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2571 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2572
2573 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2574
2575 ix = lto_input_sleb128 (ib);
2576 gcc_assert (ix == (int) ix);
2577
2578 if (fclass == BUILT_IN_NORMAL)
2579 {
2580 gcc_assert (fcode < END_BUILTINS);
2581 result = built_in_decls[fcode];
2582 gcc_assert (result);
2583 }
2584 else if (fclass == BUILT_IN_MD)
2585 {
2586 result = targetm.builtin_decl (fcode, true);
2587 if (!result || result == error_mark_node)
2588 fatal_error ("target specific builtin not available");
2589 } 1413 }
2590 else 1414 else
2591 gcc_unreachable (); 1415 {
2592 1416 unsigned int first = data_in->reader_cache->nodes.length ();
2593 asmname = input_string (data_in, ib); 1417 tree result;
2594 if (asmname) 1418
2595 set_builtin_user_assembler_name (result, asmname); 1419 scc_entry_len = streamer_read_uhwi (ib);
2596 1420
2597 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix); 1421 /* Materialize size trees by reading their headers. */
2598 1422 for (unsigned i = 0; i < size; ++i)
2599 return result; 1423 {
2600 } 1424 enum LTO_tags tag = streamer_read_record_start (ib);
2601 1425 if (tag == LTO_null
2602 1426 || (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2603 /* Read the physical representation of a tree node with tag TAG from 1427 || tag == LTO_tree_pickle_reference
2604 input block IB using the per-file context in DATA_IN. */ 1428 || tag == LTO_integer_cst
2605 1429 || tag == LTO_tree_scc)
2606 static tree 1430 gcc_unreachable ();
2607 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in, 1431
2608 enum LTO_tags tag) 1432 result = streamer_alloc_tree (ib, data_in, tag);
2609 { 1433 streamer_tree_cache_append (data_in->reader_cache, result, 0);
2610 tree result; 1434 }
2611 int ix; 1435
2612 1436 /* Read the tree bitpacks and references. */
2613 result = lto_materialize_tree (ib, data_in, tag, &ix); 1437 for (unsigned i = 0; i < size; ++i)
2614 1438 {
2615 /* Read all the pointer fields in RESULT. */ 1439 result = streamer_tree_cache_get_tree (data_in->reader_cache,
2616 lto_input_tree_pointers (ib, data_in, result); 1440 first + i);
2617 1441 lto_read_tree_1 (ib, data_in, result);
2618 /* We should never try to instantiate an MD or NORMAL builtin here. */ 1442 /* end_marker = */ streamer_read_uchar (ib);
2619 if (TREE_CODE (result) == FUNCTION_DECL) 1443 }
2620 gcc_assert (!lto_stream_as_builtin_p (result)); 1444 }
2621 1445
2622 if (TREE_CODE (result) == VAR_DECL) 1446 *len = size;
2623 lto_register_var_decl_in_symtab (data_in, result); 1447 *entry_len = scc_entry_len;
2624 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result)) 1448 return scc_hash;
2625 lto_register_function_decl_in_symtab (data_in, result);
2626
2627 /* end_marker = */ lto_input_1_unsigned (ib);
2628
2629 #ifdef LTO_STREAMER_DEBUG
2630 /* Remove the mapping to RESULT's original address set by
2631 lto_materialize_tree. */
2632 lto_orig_address_remove (result);
2633 #endif
2634
2635 return result;
2636 }
2637
2638
2639 /* Read and INTEGER_CST node from input block IB using the per-file
2640 context in DATA_IN. */
2641
2642 static tree
2643 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2644 {
2645 tree result, type;
2646 HOST_WIDE_INT low, high;
2647 bool overflow_p;
2648
2649 type = lto_input_tree (ib, data_in);
2650 overflow_p = (lto_input_1_unsigned (ib) != 0);
2651 low = lto_input_uleb128 (ib);
2652 high = lto_input_uleb128 (ib);
2653 result = build_int_cst_wide (type, low, high);
2654
2655 /* If the original constant had overflown, build a replica of RESULT to
2656 avoid modifying the shared constant returned by build_int_cst_wide. */
2657 if (overflow_p)
2658 {
2659 result = copy_node (result);
2660 TREE_OVERFLOW (result) = 1;
2661 }
2662
2663 return result;
2664 } 1449 }
2665 1450
2666 1451
2667 /* Read a tree from input block IB using the per-file context in 1452 /* Read a tree from input block IB using the per-file context in
2668 DATA_IN. This context is used, for example, to resolve references 1453 DATA_IN. This context is used, for example, to resolve references
2669 to previously read nodes. */ 1454 to previously read nodes. */
2670 1455
2671 tree 1456 tree
2672 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in) 1457 lto_input_tree_1 (struct lto_input_block *ib, struct data_in *data_in,
2673 { 1458 enum LTO_tags tag, hashval_t hash)
2674 enum LTO_tags tag; 1459 {
2675 tree result; 1460 tree result;
2676 1461
2677 tag = input_record_start (ib);
2678 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS); 1462 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2679 1463
2680 if (tag == LTO_null) 1464 if (tag == LTO_null)
2681 result = NULL_TREE; 1465 result = NULL_TREE;
2682 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref) 1466 else if (tag >= LTO_field_decl_ref && tag <= LTO_namelist_decl_ref)
2683 { 1467 {
2684 /* If TAG is a reference to an indexable tree, the next value 1468 /* If TAG is a reference to an indexable tree, the next value
2685 in IB is the index into the table where we expect to find 1469 in IB is the index into the table where we expect to find
2686 that tree. */ 1470 that tree. */
2687 result = lto_input_tree_ref (ib, data_in, cfun, tag); 1471 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2688 } 1472 }
2689 else if (tag == LTO_tree_pickle_reference) 1473 else if (tag == LTO_tree_pickle_reference)
2690 { 1474 {
2691 /* If TAG is a reference to a previously read tree, look it up in 1475 /* If TAG is a reference to a previously read tree, look it up in
2692 the reader cache. */ 1476 the reader cache. */
2693 result = lto_get_pickled_tree (ib, data_in); 1477 result = streamer_get_pickled_tree (ib, data_in);
2694 } 1478 }
2695 else if (tag == LTO_builtin_decl) 1479 else if (tag == LTO_integer_cst)
2696 { 1480 {
2697 /* If we are going to read a built-in function, all we need is 1481 /* For shared integer constants in singletons we can use the
2698 the code and class. */ 1482 existing tree integer constant merging code. */
2699 result = lto_get_builtin_tree (ib, data_in); 1483 tree type = stream_read_tree (ib, data_in);
2700 } 1484 unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
2701 else if (tag == lto_tree_code_to_tag (INTEGER_CST)) 1485 unsigned HOST_WIDE_INT i;
2702 { 1486 HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
2703 /* For integer constants we only need the type and its hi/low 1487
2704 words. */ 1488 for (i = 0; i < len; i++)
2705 result = lto_input_integer_cst (ib, data_in); 1489 a[i] = streamer_read_hwi (ib);
2706 } 1490 gcc_assert (TYPE_PRECISION (type) <= MAX_BITSIZE_MODE_ANY_INT);
1491 result = wide_int_to_tree (type, wide_int::from_array
1492 (a, len, TYPE_PRECISION (type)));
1493 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1494 }
1495 else if (tag == LTO_tree_scc)
1496 gcc_unreachable ();
2707 else 1497 else
2708 { 1498 {
2709 /* Otherwise, materialize a new node from IB. */ 1499 /* Otherwise, materialize a new node from IB. */
2710 result = lto_read_tree (ib, data_in, tag); 1500 result = lto_read_tree (ib, data_in, tag, hash);
2711 } 1501 }
2712 1502
2713 return result; 1503 return result;
2714 } 1504 }
2715 1505
1506 tree
1507 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1508 {
1509 enum LTO_tags tag;
1510
1511 /* Input and skip SCCs. */
1512 while ((tag = streamer_read_record_start (ib)) == LTO_tree_scc)
1513 {
1514 unsigned len, entry_len;
1515 lto_input_scc (ib, data_in, &len, &entry_len);
1516
1517 /* Register DECLs with the debuginfo machinery. */
1518 while (!dref_queue.is_empty ())
1519 {
1520 dref_entry e = dref_queue.pop ();
1521 debug_hooks->register_external_die (e.decl, e.sym, e.off);
1522 }
1523 }
1524 return lto_input_tree_1 (ib, data_in, tag, 0);
1525 }
1526
1527
1528 /* Input toplevel asms. */
1529
1530 void
1531 lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1532 {
1533 size_t len;
1534 const char *data = lto_get_section_data (file_data, LTO_section_asm,
1535 NULL, &len);
1536 const struct lto_simple_header_with_strings *header
1537 = (const struct lto_simple_header_with_strings *) data;
1538 int string_offset;
1539 struct data_in *data_in;
1540 tree str;
1541
1542 if (! data)
1543 return;
1544
1545 string_offset = sizeof (*header) + header->main_size;
1546
1547 lto_input_block ib (data + sizeof (*header), header->main_size,
1548 file_data->mode_table);
1549
1550 data_in = lto_data_in_create (file_data, data + string_offset,
1551 header->string_size, vNULL);
1552
1553 while ((str = streamer_read_string_cst (data_in, &ib)))
1554 {
1555 asm_node *node = symtab->finalize_toplevel_asm (str);
1556 node->order = streamer_read_hwi (&ib) + order_base;
1557 if (node->order >= symtab->order)
1558 symtab->order = node->order + 1;
1559 }
1560
1561 lto_data_in_delete (data_in);
1562
1563 lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1564 }
1565
1566
1567 /* Input mode table. */
1568
1569 void
1570 lto_input_mode_table (struct lto_file_decl_data *file_data)
1571 {
1572 size_t len;
1573 const char *data = lto_get_section_data (file_data, LTO_section_mode_table,
1574 NULL, &len);
1575 if (! data)
1576 {
1577 internal_error ("cannot read LTO mode table from %s",
1578 file_data->file_name);
1579 return;
1580 }
1581
1582 unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << 8);
1583 file_data->mode_table = table;
1584 const struct lto_simple_header_with_strings *header
1585 = (const struct lto_simple_header_with_strings *) data;
1586 int string_offset;
1587 struct data_in *data_in;
1588 string_offset = sizeof (*header) + header->main_size;
1589
1590 lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
1591 data_in = lto_data_in_create (file_data, data + string_offset,
1592 header->string_size, vNULL);
1593 bitpack_d bp = streamer_read_bitpack (&ib);
1594
1595 table[VOIDmode] = VOIDmode;
1596 table[BLKmode] = BLKmode;
1597 unsigned int m;
1598 while ((m = bp_unpack_value (&bp, 8)) != VOIDmode)
1599 {
1600 enum mode_class mclass
1601 = bp_unpack_enum (&bp, mode_class, MAX_MODE_CLASS);
1602 unsigned int size = bp_unpack_value (&bp, 8);
1603 unsigned int prec = bp_unpack_value (&bp, 16);
1604 machine_mode inner = (machine_mode) bp_unpack_value (&bp, 8);
1605 unsigned int nunits = bp_unpack_value (&bp, 8);
1606 unsigned int ibit = 0, fbit = 0;
1607 unsigned int real_fmt_len = 0;
1608 const char *real_fmt_name = NULL;
1609 switch (mclass)
1610 {
1611 case MODE_FRACT:
1612 case MODE_UFRACT:
1613 case MODE_ACCUM:
1614 case MODE_UACCUM:
1615 ibit = bp_unpack_value (&bp, 8);
1616 fbit = bp_unpack_value (&bp, 8);
1617 break;
1618 case MODE_FLOAT:
1619 case MODE_DECIMAL_FLOAT:
1620 real_fmt_name = bp_unpack_indexed_string (data_in, &bp,
1621 &real_fmt_len);
1622 break;
1623 default:
1624 break;
1625 }
1626 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1627 if not found, fallback to all modes. */
1628 int pass;
1629 for (pass = 0; pass < 2; pass++)
1630 for (machine_mode mr = pass ? VOIDmode
1631 : GET_CLASS_NARROWEST_MODE (mclass);
1632 pass ? mr < MAX_MACHINE_MODE : mr != VOIDmode;
1633 pass ? mr = (machine_mode) (mr + 1)
1634 : mr = GET_MODE_WIDER_MODE (mr).else_void ())
1635 if (GET_MODE_CLASS (mr) != mclass
1636 || GET_MODE_SIZE (mr) != size
1637 || GET_MODE_PRECISION (mr) != prec
1638 || (inner == m
1639 ? GET_MODE_INNER (mr) != mr
1640 : GET_MODE_INNER (mr) != table[(int) inner])
1641 || GET_MODE_IBIT (mr) != ibit
1642 || GET_MODE_FBIT (mr) != fbit
1643 || GET_MODE_NUNITS (mr) != nunits)
1644 continue;
1645 else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT)
1646 && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0)
1647 continue;
1648 else
1649 {
1650 table[m] = mr;
1651 pass = 2;
1652 break;
1653 }
1654 unsigned int mname_len;
1655 const char *mname = bp_unpack_indexed_string (data_in, &bp, &mname_len);
1656 if (pass == 2)
1657 {
1658 switch (mclass)
1659 {
1660 case MODE_VECTOR_INT:
1661 case MODE_VECTOR_FLOAT:
1662 case MODE_VECTOR_FRACT:
1663 case MODE_VECTOR_UFRACT:
1664 case MODE_VECTOR_ACCUM:
1665 case MODE_VECTOR_UACCUM:
1666 /* For unsupported vector modes just use BLKmode,
1667 if the scalar mode is supported. */
1668 if (table[(int) inner] != VOIDmode)
1669 {
1670 table[m] = BLKmode;
1671 break;
1672 }
1673 /* FALLTHRU */
1674 default:
1675 fatal_error (UNKNOWN_LOCATION, "unsupported mode %s\n", mname);
1676 break;
1677 }
1678 }
1679 }
1680 lto_data_in_delete (data_in);
1681
1682 lto_free_section_data (file_data, LTO_section_mode_table, NULL, data, len);
1683 }
1684
2716 1685
2717 /* Initialization for the LTO reader. */ 1686 /* Initialization for the LTO reader. */
2718 1687
2719 void 1688 void
2720 lto_init_reader (void) 1689 lto_reader_init (void)
2721 { 1690 {
2722 lto_streamer_init (); 1691 lto_streamer_init ();
2723 1692 file_name_hash_table
2724 memset (&lto_stats, 0, sizeof (lto_stats)); 1693 = new hash_table<freeing_string_slot_hasher> (37);
2725 bitmap_obstack_initialize (NULL);
2726
2727 file_name_hash_table = htab_create (37, hash_string_slot_node,
2728 eq_string_slot_node, free);
2729
2730 gimple_register_cfg_hooks ();
2731 } 1694 }
2732 1695
2733 1696
2734 /* Create a new data_in object for FILE_DATA. STRINGS is the string 1697 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2735 table to use with LEN strings. RESOLUTIONS is the vector of linker 1698 table to use with LEN strings. RESOLUTIONS is the vector of linker
2736 resolutions (NULL if not using a linker plugin). */ 1699 resolutions (NULL if not using a linker plugin). */
2737 1700
2738 struct data_in * 1701 struct data_in *
2739 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings, 1702 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2740 unsigned len, 1703 unsigned len,
2741 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions) 1704 vec<ld_plugin_symbol_resolution_t> resolutions)
2742 { 1705 {
2743 struct data_in *data_in = XCNEW (struct data_in); 1706 struct data_in *data_in = new (struct data_in);
2744 data_in->file_data = file_data; 1707 data_in->file_data = file_data;
2745 data_in->strings = strings; 1708 data_in->strings = strings;
2746 data_in->strings_len = len; 1709 data_in->strings_len = len;
2747 data_in->globals_resolution = resolutions; 1710 data_in->globals_resolution = resolutions;
2748 data_in->reader_cache = lto_streamer_cache_create (); 1711 data_in->reader_cache = streamer_tree_cache_create (false, false, true);
2749
2750 return data_in; 1712 return data_in;
2751 } 1713 }
2752 1714
2753 1715
2754 /* Remove DATA_IN. */ 1716 /* Remove DATA_IN. */
2755 1717
2756 void 1718 void
2757 lto_data_in_delete (struct data_in *data_in) 1719 lto_data_in_delete (struct data_in *data_in)
2758 { 1720 {
2759 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution); 1721 data_in->globals_resolution.release ();
2760 lto_streamer_cache_delete (data_in->reader_cache); 1722 streamer_tree_cache_delete (data_in->reader_cache);
2761 free (data_in->labels); 1723 delete data_in;
2762 free (data_in); 1724 }
2763 }