1 /* Generic streaming support for various data types.
3 Copyright (C) 2011-2019 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.c */
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 unsigned HOST_WIDE_INT
bp_unpack_var_len_unsigned (struct bitpack_d
*);
50 HOST_WIDE_INT
bp_unpack_var_len_int (struct bitpack_d
*);
52 /* In data-streamer-out.c */
53 void streamer_write_zero (struct output_block
*);
54 void streamer_write_uhwi (struct output_block
*, unsigned HOST_WIDE_INT
);
55 void streamer_write_hwi (struct output_block
*, HOST_WIDE_INT
);
56 void streamer_write_poly_uint64 (struct output_block
*, poly_uint64
);
57 void streamer_write_gcov_count (struct output_block
*, gcov_type
);
58 void streamer_write_string (struct output_block
*, struct lto_output_stream
*,
60 void streamer_write_string_with_length (struct output_block
*,
61 struct lto_output_stream
*,
62 const char *, unsigned int, bool);
63 void bp_pack_string_with_length (struct output_block
*, struct bitpack_d
*,
64 const char *, unsigned int, bool);
65 void bp_pack_string (struct output_block
*, struct bitpack_d
*,
67 void streamer_write_uhwi_stream (struct lto_output_stream
*,
68 unsigned HOST_WIDE_INT
);
69 void streamer_write_hwi_stream (struct lto_output_stream
*, HOST_WIDE_INT
);
70 void streamer_write_gcov_count_stream (struct lto_output_stream
*, gcov_type
);
71 void streamer_write_data_stream (struct lto_output_stream
*, const void *,
73 void streamer_write_wide_int (struct output_block
*, const wide_int
&);
74 void streamer_write_widest_int (struct output_block
*, const widest_int
&);
76 /* In data-streamer-in.c */
77 const char *streamer_read_string (class data_in
*, class lto_input_block
*);
78 const char *streamer_read_indexed_string (class data_in
*,
79 class lto_input_block
*,
81 const char *bp_unpack_indexed_string (class data_in
*, struct bitpack_d
*,
83 const char *bp_unpack_string (class data_in
*, struct bitpack_d
*);
84 unsigned HOST_WIDE_INT
streamer_read_uhwi (class lto_input_block
*);
85 HOST_WIDE_INT
streamer_read_hwi (class lto_input_block
*);
86 poly_uint64
streamer_read_poly_uint64 (class lto_input_block
*);
87 gcov_type
streamer_read_gcov_count (class lto_input_block
*);
88 wide_int
streamer_read_wide_int (class lto_input_block
*);
89 widest_int
streamer_read_widest_int (class lto_input_block
*);
91 /* Returns a new bit-packing context for bit-packing into S. */
92 static inline struct bitpack_d
93 bitpack_create (struct lto_output_stream
*s
)
98 bp
.stream
= (void *)s
;
102 /* Pack the NBITS bit sized value VAL into the bit-packing context BP. */
104 bp_pack_value (struct bitpack_d
*bp
, bitpack_word_t val
, unsigned nbits
)
106 bitpack_word_t word
= bp
->word
;
109 /* Verify that VAL fits in the NBITS. */
110 gcc_checking_assert (nbits
== BITS_PER_BITPACK_WORD
111 || !(val
& ~(((bitpack_word_t
)1<<nbits
)-1)));
113 /* If val does not fit into the current bitpack word switch to the
115 if (pos
+ nbits
> BITS_PER_BITPACK_WORD
)
117 streamer_write_uhwi_stream ((struct lto_output_stream
*) bp
->stream
,
131 /* Pack VAL into the bit-packing context BP, using NBITS for each
134 bp_pack_poly_value (struct bitpack_d
*bp
,
135 const poly_int
<NUM_POLY_INT_COEFFS
, bitpack_word_t
> &val
,
138 for (int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
139 bp_pack_value (bp
, val
.coeffs
[i
], nbits
);
142 /* Finishes bit-packing of BP. */
144 streamer_write_bitpack (struct bitpack_d
*bp
)
146 streamer_write_uhwi_stream ((struct lto_output_stream
*) bp
->stream
,
152 /* Returns a new bit-packing context for bit-unpacking from IB. */
153 static inline struct bitpack_d
154 streamer_read_bitpack (class lto_input_block
*ib
)
157 bp
.word
= streamer_read_uhwi (ib
);
159 bp
.stream
= (void *)ib
;
163 /* Unpacks NBITS bits from the bit-packing context BP and returns them. */
164 static inline bitpack_word_t
165 bp_unpack_value (struct bitpack_d
*bp
, unsigned nbits
)
167 bitpack_word_t mask
, val
;
170 mask
= (nbits
== BITS_PER_BITPACK_WORD
171 ? (bitpack_word_t
) -1
172 : ((bitpack_word_t
) 1 << nbits
) - 1);
174 /* If there are not continuous nbits in the current bitpack word
175 switch to the next one. */
176 if (pos
+ nbits
> BITS_PER_BITPACK_WORD
)
179 = streamer_read_uhwi ((class lto_input_block
*)bp
->stream
);
185 bp
->pos
= pos
+ nbits
;
190 /* Unpacks a polynomial value from the bit-packing context BP in which each
191 coefficient has NBITS bits. */
192 static inline poly_int
<NUM_POLY_INT_COEFFS
, bitpack_word_t
>
193 bp_unpack_poly_value (struct bitpack_d
*bp
, unsigned nbits
)
195 poly_int_pod
<NUM_POLY_INT_COEFFS
, bitpack_word_t
> x
;
196 for (int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
197 x
.coeffs
[i
] = bp_unpack_value (bp
, nbits
);
202 /* Write a character to the output block. */
205 streamer_write_char_stream (struct lto_output_stream
*obs
, char c
)
208 if (obs
->left_in_block
== 0)
209 lto_append_block (obs
);
211 /* Write the actual character. */
212 char *current_pointer
= obs
->current_pointer
;
213 *(current_pointer
++) = c
;
214 obs
->current_pointer
= current_pointer
;
216 obs
->left_in_block
--;
220 /* Read byte from the input block. */
222 static inline unsigned char
223 streamer_read_uchar (class lto_input_block
*ib
)
225 if (ib
->p
>= ib
->len
)
226 lto_section_overrun (ib
);
227 return (ib
->data
[ib
->p
++]);
230 /* Output VAL into OBS and verify it is in range MIN...MAX that is supposed
231 to be compile time constant.
232 Be host independent, limit range to 31bits. */
235 streamer_write_hwi_in_range (struct lto_output_stream
*obs
,
240 HOST_WIDE_INT range
= max
- min
;
242 gcc_checking_assert (val
>= min
&& val
<= max
&& range
> 0
243 && range
< 0x7fffffff);
246 streamer_write_uhwi_stream (obs
, (unsigned HOST_WIDE_INT
) val
);
249 /* Input VAL into OBS and verify it is in range MIN...MAX that is supposed
250 to be compile time constant. PURPOSE is used for error reporting. */
252 static inline HOST_WIDE_INT
253 streamer_read_hwi_in_range (class lto_input_block
*ib
,
258 HOST_WIDE_INT range
= max
- min
;
259 unsigned HOST_WIDE_INT uval
= streamer_read_uhwi (ib
);
261 gcc_checking_assert (range
> 0 && range
< 0x7fffffff);
263 HOST_WIDE_INT val
= (HOST_WIDE_INT
) (uval
+ (unsigned HOST_WIDE_INT
) min
);
264 if (val
< min
|| val
> max
)
265 lto_value_range_error (purpose
, val
, min
, max
);
269 /* Output VAL into BP and verify it is in range MIN...MAX that is supposed
270 to be compile time constant.
271 Be host independent, limit range to 31bits. */
274 bp_pack_int_in_range (struct bitpack_d
*bp
,
279 HOST_WIDE_INT range
= max
- min
;
280 int nbits
= floor_log2 (range
) + 1;
282 gcc_checking_assert (val
>= min
&& val
<= max
&& range
> 0
283 && range
< 0x7fffffff);
286 bp_pack_value (bp
, val
, nbits
);
289 /* Input VAL into BP and verify it is in range MIN...MAX that is supposed
290 to be compile time constant. PURPOSE is used for error reporting. */
292 static inline HOST_WIDE_INT
293 bp_unpack_int_in_range (struct bitpack_d
*bp
,
298 HOST_WIDE_INT range
= max
- min
;
299 int nbits
= floor_log2 (range
) + 1;
300 HOST_WIDE_INT val
= bp_unpack_value (bp
, nbits
);
302 gcc_checking_assert (range
> 0 && range
< 0x7fffffff);
304 if (val
< min
|| val
> max
)
305 lto_value_range_error (purpose
, val
, min
, max
);
309 /* Output VAL of type "enum enum_name" into OBS.
310 Assume range 0...ENUM_LAST - 1. */
311 #define streamer_write_enum(obs,enum_name,enum_last,val) \
312 streamer_write_hwi_in_range ((obs), 0, (int)(enum_last) - 1, (int)(val))
314 /* Input enum of type "enum enum_name" from IB.
315 Assume range 0...ENUM_LAST - 1. */
316 #define streamer_read_enum(ib,enum_name,enum_last) \
317 (enum enum_name)streamer_read_hwi_in_range ((ib), #enum_name, 0, \
318 (int)(enum_last) - 1)
320 /* Output VAL of type "enum enum_name" into BP.
321 Assume range 0...ENUM_LAST - 1. */
322 #define bp_pack_enum(bp,enum_name,enum_last,val) \
323 bp_pack_int_in_range ((bp), 0, (int)(enum_last) - 1, (int)(val))
325 /* Input enum of type "enum enum_name" from BP.
326 Assume range 0...ENUM_LAST - 1. */
327 #define bp_unpack_enum(bp,enum_name,enum_last) \
328 (enum enum_name)bp_unpack_int_in_range ((bp), #enum_name, 0, \
329 (int)(enum_last) - 1)
331 /* Output the start of a record with TAG to output block OB. */
334 streamer_write_record_start (struct output_block
*ob
, enum LTO_tags tag
)
336 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
, tag
);
339 /* Return the next tag in the input block IB. */
341 static inline enum LTO_tags
342 streamer_read_record_start (class lto_input_block
*ib
)
344 return streamer_read_enum (ib
, LTO_tags
, LTO_NUM_TAGS
);
347 #endif /* GCC_DATA_STREAMER_H */