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 2395033 : string_for_index (class data_in *data_in, unsigned int loc, unsigned int *rlen)
39 : {
40 2395033 : unsigned int len;
41 2395033 : const char *result;
42 :
43 2395033 : if (!loc)
44 : {
45 1065494 : *rlen = 0;
46 1065494 : return NULL;
47 : }
48 :
49 : /* Get the string stored at location LOC in DATA_IN->STRINGS. */
50 1329539 : lto_input_block str_tab (data_in->strings, loc - 1, data_in->strings_len, NULL);
51 1329539 : len = streamer_read_uhwi (&str_tab);
52 1329539 : *rlen = len;
53 :
54 1329539 : if (str_tab.p + len > data_in->strings_len)
55 0 : internal_error ("bytecode stream: string too long for the string table");
56 :
57 1329539 : result = (const char *)(data_in->strings + str_tab.p);
58 :
59 1329539 : 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 1816852 : streamer_read_indexed_string (class data_in *data_in,
68 : class lto_input_block *ib, unsigned int *rlen)
69 : {
70 1816852 : 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 923532 : streamer_read_string (class data_in *data_in, class lto_input_block *ib)
78 : {
79 923532 : unsigned int len;
80 923532 : const char *ptr;
81 :
82 923532 : ptr = streamer_read_indexed_string (data_in, ib, &len);
83 923532 : if (!ptr)
84 : return NULL;
85 46009 : 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 578181 : bp_unpack_indexed_string (class data_in *data_in,
97 : struct bitpack_d *bp, unsigned int *rlen)
98 : {
99 578181 : 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 578181 : bp_unpack_string (class data_in *data_in, struct bitpack_d *bp)
107 : {
108 578181 : unsigned int len;
109 578181 : const char *ptr;
110 :
111 578181 : ptr = bp_unpack_indexed_string (data_in, bp, &len);
112 578181 : if (!ptr)
113 : return NULL;
114 390210 : 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 69118319 : streamer_read_uhwi (class lto_input_block *ib)
125 : {
126 69118319 : unsigned HOST_WIDE_INT result;
127 69118319 : int shift;
128 69118319 : unsigned HOST_WIDE_INT byte;
129 69118319 : unsigned int p = ib->p;
130 69118319 : unsigned int len = ib->len;
131 :
132 69118319 : const char *data = ib->data;
133 69118319 : result = data[p++];
134 69118319 : if ((result & 0x80) != 0)
135 : {
136 16166815 : result &= 0x7f;
137 16166815 : shift = 7;
138 44244145 : do
139 : {
140 44244145 : byte = data[p++];
141 44244145 : result |= (byte & 0x7f) << shift;
142 44244145 : shift += 7;
143 : }
144 44244145 : while ((byte & 0x80) != 0);
145 : }
146 :
147 : /* We check for section overrun after the fact for performance reason. */
148 69118319 : if (p > len)
149 0 : lto_section_overrun (ib);
150 :
151 69118319 : ib->p = p;
152 69118319 : return result;
153 : }
154 :
155 :
156 : /* Read a HOST_WIDE_INT number from IB. */
157 :
158 : HOST_WIDE_INT
159 31388799 : streamer_read_hwi (class lto_input_block *ib)
160 : {
161 31388799 : HOST_WIDE_INT result = 0;
162 31388799 : int shift = 0;
163 49462007 : unsigned HOST_WIDE_INT byte;
164 :
165 49462007 : while (true)
166 : {
167 49462007 : byte = streamer_read_uchar (ib);
168 49462007 : result |= (byte & 0x7f) << shift;
169 49462007 : shift += 7;
170 49462007 : if ((byte & 0x80) == 0)
171 : {
172 31388799 : if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
173 4367774 : result |= - (HOST_WIDE_INT_1U << shift);
174 :
175 31388799 : 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 56436 : streamer_read_poly_int64 (class lto_input_block *ib)
193 : {
194 56436 : using coeff_type = poly_int_traits<poly_int64>::coeff_type;
195 56436 : 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 1543903 : streamer_read_gcov_count (class lto_input_block *ib)
202 : {
203 1543903 : gcov_type ret = streamer_read_hwi (ib);
204 1543903 : 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 437774 : 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 437774 : value_range_kind kind = streamer_read_enum (ib, value_range_kind, VR_LAST);
222 437774 : gcc_checking_assert (kind != VR_UNDEFINED);
223 437774 : tree type = stream_read_tree (ib, data_in);
224 :
225 : // Initialize the value_range to the correct type.
226 437774 : vr.set_type (type);
227 :
228 437774 : if (is_a <irange> (vr))
229 : {
230 242364 : irange &r = as_a <irange> (vr);
231 242364 : r.set_undefined ();
232 242364 : unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib);
233 498841 : for (unsigned i = 0; i < num_pairs; ++i)
234 : {
235 256477 : wide_int lb = streamer_read_wide_int (ib);
236 256477 : wide_int ub = streamer_read_wide_int (ib);
237 256477 : int_range<2> tmp (type, lb, ub);
238 256477 : r.union_ (tmp);
239 256519 : }
240 242364 : wide_int value = streamer_read_wide_int (ib);
241 242364 : wide_int mask = streamer_read_wide_int (ib);
242 242364 : irange_bitmask bm (value, mask);
243 242364 : r.update_bitmask (bm);
244 242364 : return;
245 242406 : }
246 195410 : 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 194991 : if (is_a <prange> (vr))
268 : {
269 194991 : prange &r = as_a <prange> (vr);
270 194991 : wide_int lb = streamer_read_wide_int (ib);
271 194991 : wide_int ub = streamer_read_wide_int (ib);
272 194991 : r.set (type, lb, ub);
273 194991 : wide_int value = streamer_read_wide_int (ib);
274 194991 : wide_int mask = streamer_read_wide_int (ib);
275 194991 : irange_bitmask bm (value, mask);
276 194991 : r.update_bitmask (bm);
277 194991 : return;
278 194991 : }
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 1779259 : streamer_read_wide_int (class lto_input_block *ib)
287 : {
288 1779259 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
289 1779259 : int i;
290 1779259 : int prec = streamer_read_uhwi (ib);
291 1779259 : int len = streamer_read_uhwi (ib);
292 1779259 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
293 12 : a = XALLOCAVEC (HOST_WIDE_INT, len);
294 3566211 : for (i = 0; i < len; i++)
295 1786952 : a[i] = streamer_read_hwi (ib);
296 1779259 : 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 92401 : streamer_read_widest_int (class lto_input_block *ib)
304 : {
305 92401 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
306 92401 : int i;
307 92401 : int prec ATTRIBUTE_UNUSED = streamer_read_uhwi (ib);
308 92401 : int len = streamer_read_uhwi (ib);
309 92401 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
310 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
311 185830 : for (i = 0; i < len; i++)
312 93429 : a[i] = streamer_read_hwi (ib);
313 92401 : return widest_int::from_array (a, len);
314 : }
315 :
|
