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 2386826 : string_for_index (class data_in *data_in, unsigned int loc, unsigned int *rlen)
39 : {
40 2386826 : unsigned int len;
41 2386826 : const char *result;
42 :
43 2386826 : if (!loc)
44 : {
45 1062558 : *rlen = 0;
46 1062558 : return NULL;
47 : }
48 :
49 : /* Get the string stored at location LOC in DATA_IN->STRINGS. */
50 1324268 : lto_input_block str_tab (data_in->strings, loc - 1, data_in->strings_len, NULL);
51 1324268 : len = streamer_read_uhwi (&str_tab);
52 1324268 : *rlen = len;
53 :
54 1324268 : if (str_tab.p + len > data_in->strings_len)
55 0 : internal_error ("bytecode stream: string too long for the string table");
56 :
57 1324268 : result = (const char *)(data_in->strings + str_tab.p);
58 :
59 1324268 : 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 1810207 : streamer_read_indexed_string (class data_in *data_in,
68 : class lto_input_block *ib, unsigned int *rlen)
69 : {
70 1810207 : 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 920413 : streamer_read_string (class data_in *data_in, class lto_input_block *ib)
78 : {
79 920413 : unsigned int len;
80 920413 : const char *ptr;
81 :
82 920413 : ptr = streamer_read_indexed_string (data_in, ib, &len);
83 920413 : if (!ptr)
84 : return NULL;
85 45891 : 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 576619 : bp_unpack_indexed_string (class data_in *data_in,
97 : struct bitpack_d *bp, unsigned int *rlen)
98 : {
99 576619 : 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 576619 : bp_unpack_string (class data_in *data_in, struct bitpack_d *bp)
107 : {
108 576619 : unsigned int len;
109 576619 : const char *ptr;
110 :
111 576619 : ptr = bp_unpack_indexed_string (data_in, bp, &len);
112 576619 : if (!ptr)
113 : return NULL;
114 388583 : 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 68971440 : streamer_read_uhwi (class lto_input_block *ib)
125 : {
126 68971440 : unsigned HOST_WIDE_INT result;
127 68971440 : int shift;
128 68971440 : unsigned HOST_WIDE_INT byte;
129 68971440 : unsigned int p = ib->p;
130 68971440 : unsigned int len = ib->len;
131 :
132 68971440 : const char *data = ib->data;
133 68971440 : result = data[p++];
134 68971440 : if ((result & 0x80) != 0)
135 : {
136 16135191 : result &= 0x7f;
137 16135191 : shift = 7;
138 44123693 : do
139 : {
140 44123693 : byte = data[p++];
141 44123693 : result |= (byte & 0x7f) << shift;
142 44123693 : shift += 7;
143 : }
144 44123693 : while ((byte & 0x80) != 0);
145 : }
146 :
147 : /* We check for section overrun after the fact for performance reason. */
148 68971440 : if (p > len)
149 0 : lto_section_overrun (ib);
150 :
151 68971440 : ib->p = p;
152 68971440 : return result;
153 : }
154 :
155 :
156 : /* Read a HOST_WIDE_INT number from IB. */
157 :
158 : HOST_WIDE_INT
159 31277336 : streamer_read_hwi (class lto_input_block *ib)
160 : {
161 31277336 : HOST_WIDE_INT result = 0;
162 31277336 : int shift = 0;
163 49290122 : unsigned HOST_WIDE_INT byte;
164 :
165 49290122 : while (true)
166 : {
167 49290122 : byte = streamer_read_uchar (ib);
168 49290122 : result |= (byte & 0x7f) << shift;
169 49290122 : shift += 7;
170 49290122 : if ((byte & 0x80) == 0)
171 : {
172 31277336 : if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
173 4358031 : result |= - (HOST_WIDE_INT_1U << shift);
174 :
175 31277336 : 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 55632 : streamer_read_poly_int64 (class lto_input_block *ib)
193 : {
194 55632 : using coeff_type = poly_int_traits<poly_int64>::coeff_type;
195 55632 : 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 1542128 : streamer_read_gcov_count (class lto_input_block *ib)
202 : {
203 1542128 : gcov_type ret = streamer_read_hwi (ib);
204 1542128 : return ret;
205 : }
206 :
207 : /* Read REAL_VALUE_TYPE from IB. */
208 :
209 : void
210 832 : streamer_read_real_value (class lto_input_block *ib, REAL_VALUE_TYPE *r)
211 : {
212 832 : struct bitpack_d bp = streamer_read_bitpack (ib);
213 832 : bp_unpack_real_value (&bp, r);
214 832 : }
215 :
216 : void
217 437133 : 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 437133 : value_range_kind kind = streamer_read_enum (ib, value_range_kind, VR_LAST);
222 437133 : gcc_checking_assert (kind != VR_UNDEFINED);
223 437133 : tree type = stream_read_tree (ib, data_in);
224 :
225 : // Initialize the value_range to the correct type.
226 437133 : vr.set_type (type);
227 :
228 437133 : if (is_a <irange> (vr))
229 : {
230 241967 : irange &r = as_a <irange> (vr);
231 241967 : r.set_undefined ();
232 241967 : unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib);
233 498001 : for (unsigned i = 0; i < num_pairs; ++i)
234 : {
235 256034 : wide_int lb = streamer_read_wide_int (ib);
236 256034 : wide_int ub = streamer_read_wide_int (ib);
237 256034 : int_range<2> tmp (type, lb, ub);
238 256034 : r.union_ (tmp);
239 256036 : }
240 241967 : wide_int value = streamer_read_wide_int (ib);
241 241967 : wide_int mask = streamer_read_wide_int (ib);
242 241967 : irange_bitmask bm (value, mask);
243 241967 : r.update_bitmask (bm);
244 241967 : return;
245 241969 : }
246 195166 : if (is_a <frange> (vr))
247 : {
248 419 : frange &r = as_a <frange> (vr);
249 :
250 : // Stream in NAN bits.
251 419 : struct bitpack_d bp = streamer_read_bitpack (ib);
252 419 : bool pos_nan = (bool) bp_unpack_value (&bp, 1);
253 419 : bool neg_nan = (bool) bp_unpack_value (&bp, 1);
254 419 : nan_state nan (pos_nan, neg_nan);
255 :
256 419 : if (kind == VR_NAN)
257 3 : r.set_nan (type, nan);
258 : else
259 : {
260 416 : REAL_VALUE_TYPE lb, ub;
261 416 : streamer_read_real_value (ib, &lb);
262 416 : streamer_read_real_value (ib, &ub);
263 416 : r.set (type, lb, ub, nan);
264 : }
265 419 : return;
266 : }
267 194747 : if (is_a <prange> (vr))
268 : {
269 194747 : prange &r = as_a <prange> (vr);
270 194747 : wide_int lb = streamer_read_wide_int (ib);
271 194747 : wide_int ub = streamer_read_wide_int (ib);
272 194747 : r.set (type, lb, ub);
273 194747 : wide_int value = streamer_read_wide_int (ib);
274 194747 : wide_int mask = streamer_read_wide_int (ib);
275 194747 : irange_bitmask bm (value, mask);
276 194747 : r.update_bitmask (bm);
277 194747 : return;
278 194747 : }
279 0 : gcc_unreachable ();
280 : }
281 :
282 : /* Read the physical representation of a wide_int val from
283 : input block IB. */
284 :
285 : wide_int
286 1776603 : streamer_read_wide_int (class lto_input_block *ib)
287 : {
288 1776603 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
289 1776603 : int i;
290 1776603 : int prec = streamer_read_uhwi (ib);
291 1776603 : int len = streamer_read_uhwi (ib);
292 1776603 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
293 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
294 3560455 : for (i = 0; i < len; i++)
295 1783852 : a[i] = streamer_read_hwi (ib);
296 1776603 : return wide_int::from_array (a, len, prec);
297 : }
298 :
299 : /* Read the physical representation of a widest_int val from
300 : input block IB. */
301 :
302 : widest_int
303 92393 : streamer_read_widest_int (class lto_input_block *ib)
304 : {
305 92393 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
306 92393 : int i;
307 92393 : int prec ATTRIBUTE_UNUSED = streamer_read_uhwi (ib);
308 92393 : int len = streamer_read_uhwi (ib);
309 92393 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
310 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
311 185814 : for (i = 0; i < len; i++)
312 93421 : a[i] = streamer_read_hwi (ib);
313 92393 : return widest_int::from_array (a, len);
314 : }
315 :
|
