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