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 2305698 : string_for_index (class data_in *data_in, unsigned int loc, unsigned int *rlen)
39 : {
40 2305698 : unsigned int len;
41 2305698 : const char *result;
42 :
43 2305698 : if (!loc)
44 : {
45 1084716 : *rlen = 0;
46 1084716 : return NULL;
47 : }
48 :
49 : /* Get the string stored at location LOC in DATA_IN->STRINGS. */
50 1220982 : lto_input_block str_tab (data_in->strings, loc - 1, data_in->strings_len, NULL);
51 1220982 : len = streamer_read_uhwi (&str_tab);
52 1220982 : *rlen = len;
53 :
54 1220982 : if (str_tab.p + len > data_in->strings_len)
55 0 : internal_error ("bytecode stream: string too long for the string table");
56 :
57 1220982 : result = (const char *)(data_in->strings + str_tab.p);
58 :
59 1220982 : 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 1853820 : streamer_read_indexed_string (class data_in *data_in,
68 : class lto_input_block *ib, unsigned int *rlen)
69 : {
70 1853820 : 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 941779 : streamer_read_string (class data_in *data_in, class lto_input_block *ib)
78 : {
79 941779 : unsigned int len;
80 941779 : const char *ptr;
81 :
82 941779 : ptr = streamer_read_indexed_string (data_in, ib, &len);
83 941779 : if (!ptr)
84 : return NULL;
85 46230 : 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 451878 : bp_unpack_indexed_string (class data_in *data_in,
97 : struct bitpack_d *bp, unsigned int *rlen)
98 : {
99 451878 : 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 451878 : bp_unpack_string (class data_in *data_in, struct bitpack_d *bp)
107 : {
108 451878 : unsigned int len;
109 451878 : const char *ptr;
110 :
111 451878 : ptr = bp_unpack_indexed_string (data_in, bp, &len);
112 451878 : if (!ptr)
113 : return NULL;
114 262711 : 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 70010623 : streamer_read_uhwi (class lto_input_block *ib)
125 : {
126 70010623 : unsigned HOST_WIDE_INT result;
127 70010623 : int shift;
128 70010623 : unsigned HOST_WIDE_INT byte;
129 70010623 : unsigned int p = ib->p;
130 70010623 : unsigned int len = ib->len;
131 :
132 70010623 : const char *data = ib->data;
133 70010623 : result = data[p++];
134 70010623 : if ((result & 0x80) != 0)
135 : {
136 17506100 : result &= 0x7f;
137 17506100 : shift = 7;
138 51183661 : do
139 : {
140 51183661 : byte = data[p++];
141 51183661 : result |= (byte & 0x7f) << shift;
142 51183661 : shift += 7;
143 : }
144 51183661 : while ((byte & 0x80) != 0);
145 : }
146 :
147 : /* We check for section overrun after the fact for performance reason. */
148 70010623 : if (p > len)
149 0 : lto_section_overrun (ib);
150 :
151 70010623 : ib->p = p;
152 70010623 : return result;
153 : }
154 :
155 :
156 : /* Read a HOST_WIDE_INT number from IB. */
157 :
158 : HOST_WIDE_INT
159 31915102 : streamer_read_hwi (class lto_input_block *ib)
160 : {
161 31915102 : HOST_WIDE_INT result = 0;
162 31915102 : int shift = 0;
163 50252797 : unsigned HOST_WIDE_INT byte;
164 :
165 50252797 : while (true)
166 : {
167 50252797 : byte = streamer_read_uchar (ib);
168 50252797 : result |= (byte & 0x7f) << shift;
169 50252797 : shift += 7;
170 50252797 : if ((byte & 0x80) == 0)
171 : {
172 31915102 : if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
173 4414478 : result |= - (HOST_WIDE_INT_1U << shift);
174 :
175 31915102 : 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 57696 : streamer_read_poly_int64 (class lto_input_block *ib)
193 : {
194 57696 : using coeff_type = poly_int_traits<poly_int64>::coeff_type;
195 57696 : 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 1556319 : streamer_read_gcov_count (class lto_input_block *ib)
202 : {
203 1556319 : gcov_type ret = streamer_read_hwi (ib);
204 1556319 : 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 440301 : 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 440301 : value_range_kind kind = streamer_read_enum (ib, value_range_kind, VR_LAST);
222 440301 : gcc_checking_assert (kind != VR_UNDEFINED);
223 440301 : tree type = stream_read_tree (ib, data_in);
224 :
225 : // Initialize the value_range to the correct type.
226 440301 : vr.set_range_class (type);
227 :
228 440301 : if (is_a <irange> (vr))
229 : {
230 244347 : irange &r = as_a <irange> (vr);
231 244347 : r.set_undefined ();
232 244347 : unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib);
233 748854 : for (unsigned i = 0; i < num_pairs; ++i)
234 : {
235 260160 : wide_int lb = streamer_read_wide_int (ib);
236 260160 : wide_int ub = streamer_read_wide_int (ib);
237 260160 : int_range<2> tmp (type, lb, ub);
238 260160 : r.union_ (tmp);
239 260202 : }
240 244347 : wide_int value = streamer_read_wide_int (ib);
241 244347 : wide_int mask = streamer_read_wide_int (ib);
242 244347 : irange_bitmask bm (value, mask);
243 244347 : r.update_bitmask (bm);
244 244347 : return;
245 244389 : }
246 195954 : 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 195529 : if (is_a <prange> (vr))
275 : {
276 195529 : prange &r = as_a <prange> (vr);
277 195529 : wide_int lb = streamer_read_wide_int (ib);
278 195529 : wide_int ub = streamer_read_wide_int (ib);
279 195529 : r.set (type, lb, ub);
280 195529 : wide_int value = streamer_read_wide_int (ib);
281 195529 : wide_int mask = streamer_read_wide_int (ib);
282 195529 : irange_bitmask bm (value, mask);
283 195529 : r.update_bitmask (bm);
284 195529 : return;
285 195529 : }
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 1792745 : streamer_read_wide_int (class lto_input_block *ib)
294 : {
295 1792745 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
296 1792745 : int i;
297 1792745 : int prec = streamer_read_uhwi (ib);
298 1792745 : int len = streamer_read_uhwi (ib);
299 1792745 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
300 12 : a = XALLOCAVEC (HOST_WIDE_INT, len);
301 3593545 : for (i = 0; i < len; i++)
302 1800800 : a[i] = streamer_read_hwi (ib);
303 1792745 : 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 93251 : streamer_read_widest_int (class lto_input_block *ib)
311 : {
312 93251 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
313 93251 : int i;
314 93251 : int prec ATTRIBUTE_UNUSED = streamer_read_uhwi (ib);
315 93251 : int len = streamer_read_uhwi (ib);
316 93251 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
317 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
318 187538 : for (i = 0; i < len; i++)
319 94287 : a[i] = streamer_read_hwi (ib);
320 93251 : return widest_int::from_array (a, len);
321 : }
322 :
|
