1 /* Generic streaming support for various data types.
3 Copyright (C) 2011-2023 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #ifndef GCC_DATA_STREAMER_H
23 #define GCC_DATA_STREAMER_H
25 #include "lto-streamer.h"
27 /* Data structures used to pack values and bitflags into a vector of
28 words. Used to stream values of a fixed number of bits in a space
30 static unsigned const BITS_PER_BITPACK_WORD
= HOST_BITS_PER_WIDE_INT
;
32 typedef unsigned HOST_WIDE_INT bitpack_word_t
;
36 /* The position of the first unused or unconsumed bit in the word. */
39 /* The current word we are (un)packing. */
42 /* The lto_output_stream or the lto_input_block we are streaming to/from. */
46 /* In data-streamer.cc */
47 void bp_pack_var_len_unsigned (struct bitpack_d
*, unsigned HOST_WIDE_INT
);
48 void bp_pack_var_len_int (struct bitpack_d
*, HOST_WIDE_INT
);
49 void bp_pack_real_value (struct bitpack_d
*, const REAL_VALUE_TYPE
*);
50 void bp_unpack_real_value (struct bitpack_d
*, REAL_VALUE_TYPE
*);
51 unsigned HOST_WIDE_INT
bp_unpack_var_len_unsigned (struct bitpack_d
*);
52 HOST_WIDE_INT
bp_unpack_var_len_int (struct bitpack_d
*);
54 /* In data-streamer-out.cc */
55 void streamer_write_zero (struct output_block
*);
56 void streamer_write_uhwi (struct output_block
*, unsigned HOST_WIDE_INT
);
57 void streamer_write_hwi (struct output_block
*, HOST_WIDE_INT
);
58 void streamer_write_poly_uint64 (struct output_block
*, poly_uint64
);
59 void streamer_write_poly_int64 (struct output_block
*, poly_int64
);
60 void streamer_write_gcov_count (struct output_block
*, gcov_type
);
61 void streamer_write_string (struct output_block
*, struct lto_output_stream
*,
63 void streamer_write_string_with_length (struct output_block
*,
64 struct lto_output_stream
*,
65 const char *, unsigned int, bool);
66 void bp_pack_string_with_length (struct output_block
*, struct bitpack_d
*,
67 const char *, unsigned int, bool);
68 void bp_pack_string (struct output_block
*, struct bitpack_d
*,
70 void streamer_write_uhwi_stream (struct lto_output_stream
*,
71 unsigned HOST_WIDE_INT
);
72 void streamer_write_hwi_stream (struct lto_output_stream
*, HOST_WIDE_INT
);
73 void streamer_write_gcov_count_stream (struct lto_output_stream
*, gcov_type
);
74 void streamer_write_data_stream (struct lto_output_stream
*, const void *,
76 void streamer_write_wide_int (struct output_block
*, const wide_int
&);
77 void streamer_write_widest_int (struct output_block
*, const widest_int
&);
79 /* In data-streamer-in.cc */
80 const char *streamer_read_string (class data_in
*, class lto_input_block
*);
81 const char *streamer_read_indexed_string (class data_in
*,
82 class lto_input_block
*,
84 const char *bp_unpack_indexed_string (class data_in
*, struct bitpack_d
*,
86 const char *bp_unpack_string (class data_in
*, struct bitpack_d
*);
87 unsigned HOST_WIDE_INT
streamer_read_uhwi (class lto_input_block
*);
88 HOST_WIDE_INT
streamer_read_hwi (class lto_input_block
*);
89 poly_uint64
streamer_read_poly_uint64 (class lto_input_block
*);
90 poly_int64
streamer_read_poly_int64 (class lto_input_block
*);
91 gcov_type
streamer_read_gcov_count (class lto_input_block
*);
92 wide_int
streamer_read_wide_int (class lto_input_block
*);
93 widest_int
streamer_read_widest_int (class lto_input_block
*);
95 /* Returns a new bit-packing context for bit-packing into S. */
96 inline struct bitpack_d
97 bitpack_create (struct lto_output_stream
*s
)
102 bp
.stream
= (void *)s
;
106 /* Pack the NBITS bit sized value VAL into the bit-packing context BP. */
108 bp_pack_value (struct bitpack_d
*bp
, bitpack_word_t val
, unsigned nbits
)
110 bitpack_word_t word
= bp
->word
;
113 /* Verify that VAL fits in the NBITS. */
114 gcc_checking_assert (nbits
== BITS_PER_BITPACK_WORD
115 || !(val
& ~(((bitpack_word_t
)1<<nbits
)-1)));
117 /* If val does not fit into the current bitpack word switch to the
119 if (pos
+ nbits
> BITS_PER_BITPACK_WORD
)
121 streamer_write_uhwi_stream ((struct lto_output_stream
*) bp
->stream
,
135 /* Pack VAL into the bit-packing context BP, using NBITS for each
138 bp_pack_poly_value (struct bitpack_d
*bp
,
139 const poly_int
<NUM_POLY_INT_COEFFS
, bitpack_word_t
> &val
,
142 for (int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
143 bp_pack_value (bp
, val
.coeffs
[i
], nbits
);
146 /* Finishes bit-packing of BP. */
148 streamer_write_bitpack (struct bitpack_d
*bp
)
150 streamer_write_uhwi_stream ((struct lto_output_stream
*) bp
->stream
,
156 /* Returns a new bit-packing context for bit-unpacking from IB. */
157 inline struct bitpack_d
158 streamer_read_bitpack (class lto_input_block
*ib
)
161 bp
.word
= streamer_read_uhwi (ib
);
163 bp
.stream
= (void *)ib
;
167 /* Unpacks NBITS bits from the bit-packing context BP and returns them. */
168 inline bitpack_word_t
169 bp_unpack_value (struct bitpack_d
*bp
, unsigned nbits
)
171 bitpack_word_t mask
, val
;
174 mask
= (nbits
== BITS_PER_BITPACK_WORD
175 ? (bitpack_word_t
) -1
176 : ((bitpack_word_t
) 1 << nbits
) - 1);
178 /* If there are not continuous nbits in the current bitpack word
179 switch to the next one. */
180 if (pos
+ nbits
> BITS_PER_BITPACK_WORD
)
183 = streamer_read_uhwi ((class lto_input_block
*)bp
->stream
);
189 bp
->pos
= pos
+ nbits
;
194 /* Unpacks a polynomial value from the bit-packing context BP in which each
195 coefficient has NBITS bits. */
196 inline poly_int
<NUM_POLY_INT_COEFFS
, bitpack_word_t
>
197 bp_unpack_poly_value (struct bitpack_d
*bp
, unsigned nbits
)
199 poly_int_pod
<NUM_POLY_INT_COEFFS
, bitpack_word_t
> x
;
200 for (int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
201 x
.coeffs
[i
] = bp_unpack_value (bp
, nbits
);
206 /* Write a character to the output block. */
209 streamer_write_char_stream (struct lto_output_stream
*obs
, char c
)
212 if (obs
->left_in_block
== 0)
213 lto_append_block (obs
);
215 /* Write the actual character. */
216 char *current_pointer
= obs
->current_pointer
;
217 *(current_pointer
++) = c
;
218 obs
->current_pointer
= current_pointer
;
220 obs
->left_in_block
--;
224 /* Read byte from the input block. */
227 streamer_read_uchar (class lto_input_block
*ib
)
229 if (ib
->p
>= ib
->len
)
230 lto_section_overrun (ib
);
231 return (ib
->data
[ib
->p
++]);
234 /* Output VAL into OBS and verify it is in range MIN...MAX that is supposed
235 to be compile time constant.
236 Be host independent, limit range to 31bits. */
239 streamer_write_hwi_in_range (struct lto_output_stream
*obs
,
244 HOST_WIDE_INT range
= max
- min
;
246 gcc_checking_assert (val
>= min
&& val
<= max
&& range
> 0
247 && range
< 0x7fffffff);
250 streamer_write_uhwi_stream (obs
, (unsigned HOST_WIDE_INT
) val
);
253 /* Input VAL into OBS and verify it is in range MIN...MAX that is supposed
254 to be compile time constant. PURPOSE is used for error reporting. */
257 streamer_read_hwi_in_range (class lto_input_block
*ib
,
262 HOST_WIDE_INT range
= max
- min
;
263 unsigned HOST_WIDE_INT uval
= streamer_read_uhwi (ib
);
265 gcc_checking_assert (range
> 0 && range
< 0x7fffffff);
267 HOST_WIDE_INT val
= (HOST_WIDE_INT
) (uval
+ (unsigned HOST_WIDE_INT
) min
);
268 if (val
< min
|| val
> max
)
269 lto_value_range_error (purpose
, val
, min
, max
);
273 /* Output VAL into BP and verify it is in range MIN...MAX that is supposed
274 to be compile time constant.
275 Be host independent, limit range to 31bits. */
278 bp_pack_int_in_range (struct bitpack_d
*bp
,
283 HOST_WIDE_INT range
= max
- min
;
284 int nbits
= floor_log2 (range
) + 1;
286 gcc_checking_assert (val
>= min
&& val
<= max
&& range
> 0
287 && range
< 0x7fffffff);
290 bp_pack_value (bp
, val
, nbits
);
293 /* Input VAL into BP and verify it is in range MIN...MAX that is supposed
294 to be compile time constant. PURPOSE is used for error reporting. */
297 bp_unpack_int_in_range (struct bitpack_d
*bp
,
302 HOST_WIDE_INT range
= max
- min
;
303 int nbits
= floor_log2 (range
) + 1;
304 HOST_WIDE_INT val
= bp_unpack_value (bp
, nbits
);
306 gcc_checking_assert (range
> 0 && range
< 0x7fffffff);
308 if (val
< min
|| val
> max
)
309 lto_value_range_error (purpose
, val
, min
, max
);
313 /* Output VAL of type "enum enum_name" into OBS.
314 Assume range 0...ENUM_LAST - 1. */
315 #define streamer_write_enum(obs,enum_name,enum_last,val) \
316 streamer_write_hwi_in_range ((obs), 0, (int)(enum_last) - 1, (int)(val))
318 /* Input enum of type "enum enum_name" from IB.
319 Assume range 0...ENUM_LAST - 1. */
320 #define streamer_read_enum(ib,enum_name,enum_last) \
321 (enum enum_name)streamer_read_hwi_in_range ((ib), #enum_name, 0, \
322 (int)(enum_last) - 1)
324 /* Output VAL of type "enum enum_name" into BP.
325 Assume range 0...ENUM_LAST - 1. */
326 #define bp_pack_enum(bp,enum_name,enum_last,val) \
327 bp_pack_int_in_range ((bp), 0, (int)(enum_last) - 1, (int)(val))
329 /* Input enum of type "enum enum_name" from BP.
330 Assume range 0...ENUM_LAST - 1. */
331 #define bp_unpack_enum(bp,enum_name,enum_last) \
332 (enum enum_name)bp_unpack_int_in_range ((bp), #enum_name, 0, \
333 (int)(enum_last) - 1)
335 /* Output the start of a record with TAG to output block OB. */
338 streamer_write_record_start (struct output_block
*ob
, enum LTO_tags tag
)
340 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
, tag
);
343 /* Return the next tag in the input block IB. */
346 streamer_read_record_start (class lto_input_block
*ib
)
348 return streamer_read_enum (ib
, LTO_tags
, LTO_NUM_TAGS
);
351 #endif /* GCC_DATA_STREAMER_H */