Line data Source code
1 : /* Routines for restoring various data types from a file stream. This deals
2 : with various data types like strings, integers, enums, etc.
3 :
4 : Copyright (C) 2011-2026 Free Software Foundation, Inc.
5 : Contributed by Diego Novillo <dnovillo@google.com>
6 :
7 : This file is part of GCC.
8 :
9 : GCC is free software; you can redistribute it and/or modify it under
10 : the terms of the GNU General Public License as published by the Free
11 : Software Foundation; either version 3, or (at your option) any later
12 : version.
13 :
14 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 : for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with GCC; see the file COPYING3. If not see
21 : <http://www.gnu.org/licenses/>. */
22 :
23 : #include "config.h"
24 : #include "system.h"
25 : #include "coretypes.h"
26 : #include "backend.h"
27 : #include "tree.h"
28 : #include "gimple.h"
29 : #include "cgraph.h"
30 : #include "data-streamer.h"
31 : #include "value-range.h"
32 : #include "streamer-hooks.h"
33 :
34 : /* Read a string from the string table in DATA_IN using input block
35 : IB. Write the length to RLEN. */
36 :
37 : static const char *
38 2288033 : string_for_index (class data_in *data_in, unsigned int loc, unsigned int *rlen)
39 : {
40 2288033 : unsigned int len;
41 2288033 : const char *result;
42 :
43 2288033 : if (!loc)
44 : {
45 1077068 : *rlen = 0;
46 1077068 : return NULL;
47 : }
48 :
49 : /* Get the string stored at location LOC in DATA_IN->STRINGS. */
50 1210965 : lto_input_block str_tab (data_in->strings, loc - 1, data_in->strings_len, NULL);
51 1210965 : len = streamer_read_uhwi (&str_tab);
52 1210965 : *rlen = len;
53 :
54 1210965 : if (str_tab.p + len > data_in->strings_len)
55 0 : internal_error ("bytecode stream: string too long for the string table");
56 :
57 1210965 : result = (const char *)(data_in->strings + str_tab.p);
58 :
59 1210965 : return result;
60 : }
61 :
62 :
63 : /* Read a string from the string table in DATA_IN using input block
64 : IB. Write the length to RLEN. */
65 :
66 : const char *
67 1836293 : streamer_read_indexed_string (class data_in *data_in,
68 : class lto_input_block *ib, unsigned int *rlen)
69 : {
70 1836293 : return string_for_index (data_in, streamer_read_uhwi (ib), rlen);
71 : }
72 :
73 :
74 : /* Read a NULL terminated string from the string table in DATA_IN. */
75 :
76 : const char *
77 933231 : streamer_read_string (class data_in *data_in, class lto_input_block *ib)
78 : {
79 933231 : unsigned int len;
80 933231 : const char *ptr;
81 :
82 933231 : ptr = streamer_read_indexed_string (data_in, ib, &len);
83 933231 : if (!ptr)
84 : return NULL;
85 46206 : if (ptr[len - 1] != '\0')
86 0 : internal_error ("bytecode stream: found non-null terminated string");
87 :
88 : return ptr;
89 : }
90 :
91 :
92 : /* Read a string from the string table in DATA_IN using the bitpack BP.
93 : Write the length to RLEN. */
94 :
95 : const char *
96 451740 : bp_unpack_indexed_string (class data_in *data_in,
97 : struct bitpack_d *bp, unsigned int *rlen)
98 : {
99 451740 : return string_for_index (data_in, bp_unpack_var_len_unsigned (bp), rlen);
100 : }
101 :
102 :
103 : /* Read a NULL terminated string from the string table in DATA_IN. */
104 :
105 : const char *
106 451740 : bp_unpack_string (class data_in *data_in, struct bitpack_d *bp)
107 : {
108 451740 : unsigned int len;
109 451740 : const char *ptr;
110 :
111 451740 : ptr = bp_unpack_indexed_string (data_in, bp, &len);
112 451740 : if (!ptr)
113 : return NULL;
114 261697 : if (ptr[len - 1] != '\0')
115 0 : internal_error ("bytecode stream: found non-null terminated string");
116 :
117 : return ptr;
118 : }
119 :
120 :
121 : /* Read an unsigned HOST_WIDE_INT number from IB. */
122 :
123 : unsigned HOST_WIDE_INT
124 69689397 : streamer_read_uhwi (class lto_input_block *ib)
125 : {
126 69689397 : unsigned HOST_WIDE_INT result;
127 69689397 : int shift;
128 69689397 : unsigned HOST_WIDE_INT byte;
129 69689397 : unsigned int p = ib->p;
130 69689397 : unsigned int len = ib->len;
131 :
132 69689397 : const char *data = ib->data;
133 69689397 : result = data[p++];
134 69689397 : if ((result & 0x80) != 0)
135 : {
136 17448325 : result &= 0x7f;
137 17448325 : shift = 7;
138 50886203 : do
139 : {
140 50886203 : byte = data[p++];
141 50886203 : result |= (byte & 0x7f) << shift;
142 50886203 : shift += 7;
143 : }
144 50886203 : while ((byte & 0x80) != 0);
145 : }
146 :
147 : /* We check for section overrun after the fact for performance reason. */
148 69689397 : if (p > len)
149 0 : lto_section_overrun (ib);
150 :
151 69689397 : ib->p = p;
152 69689397 : return result;
153 : }
154 :
155 :
156 : /* Read a HOST_WIDE_INT number from IB. */
157 :
158 : HOST_WIDE_INT
159 31656503 : streamer_read_hwi (class lto_input_block *ib)
160 : {
161 31656503 : HOST_WIDE_INT result = 0;
162 31656503 : int shift = 0;
163 49855131 : unsigned HOST_WIDE_INT byte;
164 :
165 49855131 : while (true)
166 : {
167 49855131 : byte = streamer_read_uchar (ib);
168 49855131 : result |= (byte & 0x7f) << shift;
169 49855131 : shift += 7;
170 49855131 : if ((byte & 0x80) == 0)
171 : {
172 31656503 : if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
173 4387469 : result |= - (HOST_WIDE_INT_1U << shift);
174 :
175 31656503 : return result;
176 : }
177 : }
178 : }
179 :
180 : /* Read a poly_uint64 from IB. */
181 :
182 : poly_uint64
183 0 : streamer_read_poly_uint64 (class lto_input_block *ib)
184 : {
185 0 : using coeff_type = poly_int_traits<poly_uint64>::coeff_type;
186 0 : return poly_int_read_common<coeff_type> (streamer_read_uhwi, ib);
187 : }
188 :
189 : /* Read a poly_int64 from IB. */
190 :
191 : poly_int64
192 57096 : streamer_read_poly_int64 (class lto_input_block *ib)
193 : {
194 57096 : using coeff_type = poly_int_traits<poly_int64>::coeff_type;
195 57096 : return poly_int_read_common<coeff_type> (streamer_read_hwi, ib);
196 : }
197 :
198 : /* Read gcov_type value from IB. */
199 :
200 : gcov_type
201 1549141 : streamer_read_gcov_count (class lto_input_block *ib)
202 : {
203 1549141 : gcov_type ret = streamer_read_hwi (ib);
204 1549141 : return ret;
205 : }
206 :
207 : /* Read REAL_VALUE_TYPE from IB. */
208 :
209 : void
210 1468 : streamer_read_real_value (class lto_input_block *ib, REAL_VALUE_TYPE *r)
211 : {
212 1468 : struct bitpack_d bp = streamer_read_bitpack (ib);
213 1468 : bp_unpack_real_value (&bp, r);
214 1468 : }
215 :
216 : void
217 438679 : streamer_read_value_range (class lto_input_block *ib, data_in *data_in,
218 : value_range &vr)
219 : {
220 : // Read the common fields to all vranges.
221 438679 : value_range_kind kind = streamer_read_enum (ib, value_range_kind, VR_LAST);
222 438679 : gcc_checking_assert (kind != VR_UNDEFINED);
223 438679 : tree type = stream_read_tree (ib, data_in);
224 :
225 : // Initialize the value_range to the correct type.
226 438679 : vr.set_range_class (type);
227 :
228 438679 : if (is_a <irange> (vr))
229 : {
230 243106 : irange &r = as_a <irange> (vr);
231 243106 : r.set_undefined ();
232 243106 : unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib);
233 744026 : for (unsigned i = 0; i < num_pairs; ++i)
234 : {
235 257814 : wide_int lb = streamer_read_wide_int (ib);
236 257814 : wide_int ub = streamer_read_wide_int (ib);
237 257814 : int_range<2> tmp (type, lb, ub);
238 257814 : r.union_ (tmp);
239 257856 : }
240 243106 : wide_int value = streamer_read_wide_int (ib);
241 243106 : wide_int mask = streamer_read_wide_int (ib);
242 243106 : irange_bitmask bm (value, mask);
243 243106 : r.update_bitmask (bm);
244 243106 : return;
245 243148 : }
246 195573 : if (is_a <frange> (vr))
247 : {
248 425 : frange &r = as_a <frange> (vr);
249 :
250 : // Stream in NAN bits.
251 425 : struct bitpack_d bp = streamer_read_bitpack (ib);
252 425 : bool pos_nan = (bool) bp_unpack_value (&bp, 1);
253 425 : bool neg_nan = (bool) bp_unpack_value (&bp, 1);
254 425 : nan_state nan (pos_nan, neg_nan);
255 :
256 425 : if (kind == VR_NAN)
257 3 : r.set_nan (type, nan);
258 : else
259 : {
260 422 : r.set_undefined ();
261 422 : unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib);
262 1578 : for (unsigned i = 0; i < num_pairs; ++i)
263 : {
264 734 : REAL_VALUE_TYPE lb, ub;
265 734 : streamer_read_real_value (ib, &lb);
266 734 : streamer_read_real_value (ib, &ub);
267 734 : frange tmp;
268 734 : tmp.set (type, lb, ub, nan);
269 734 : r.union_ (tmp);
270 734 : }
271 : }
272 425 : return;
273 : }
274 195148 : if (is_a <prange> (vr))
275 : {
276 195148 : prange &r = as_a <prange> (vr);
277 195148 : wide_int lb = streamer_read_wide_int (ib);
278 195148 : wide_int ub = streamer_read_wide_int (ib);
279 195148 : r.set (type, lb, ub);
280 195148 : wide_int value = streamer_read_wide_int (ib);
281 195148 : wide_int mask = streamer_read_wide_int (ib);
282 195148 : irange_bitmask bm (value, mask);
283 195148 : r.update_bitmask (bm);
284 195148 : return;
285 195148 : }
286 0 : gcc_unreachable ();
287 : }
288 :
289 : /* Read the physical representation of a wide_int val from
290 : input block IB. */
291 :
292 : wide_int
293 1784045 : streamer_read_wide_int (class lto_input_block *ib)
294 : {
295 1784045 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
296 1784045 : int i;
297 1784045 : int prec = streamer_read_uhwi (ib);
298 1784045 : int len = streamer_read_uhwi (ib);
299 1784045 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
300 12 : a = XALLOCAVEC (HOST_WIDE_INT, len);
301 3576133 : for (i = 0; i < len; i++)
302 1792088 : a[i] = streamer_read_hwi (ib);
303 1784045 : return wide_int::from_array (a, len, prec);
304 : }
305 :
306 : /* Read the physical representation of a widest_int val from
307 : input block IB. */
308 :
309 : widest_int
310 92644 : streamer_read_widest_int (class lto_input_block *ib)
311 : {
312 92644 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
313 92644 : int i;
314 92644 : int prec ATTRIBUTE_UNUSED = streamer_read_uhwi (ib);
315 92644 : int len = streamer_read_uhwi (ib);
316 92644 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
317 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
318 186314 : for (i = 0; i < len; i++)
319 93670 : a[i] = streamer_read_hwi (ib);
320 92644 : return widest_int::from_array (a, len);
321 : }
322 :
|
