1/* Routines for saving various data types to a file stream. This deals
2 with various data types like strings, integers, enums, etc.
3
4 Copyright (C) 2011-2024 Free Software Foundation, Inc.
5 Contributed by Diego Novillo <dnovillo@google.com>
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 3, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along 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
35/* Adds a new block to output stream OBS. */
36
37void
38lto_append_block (struct lto_output_stream *obs)
39{
40 struct lto_char_ptr_base *new_block;
41
42 gcc_assert (obs->left_in_block == 0);
43
44 if (obs->first_block == NULL)
45 {
46 /* This is the first time the stream has been written
47 into. */
48 obs->block_size = 1024;
49 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
50 obs->first_block = new_block;
51 }
52 else
53 {
54 struct lto_char_ptr_base *tptr;
55 /* Get a new block that is twice as big as the last block
56 and link it into the list. */
57 obs->block_size *= 2;
58 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
59 /* The first bytes of the block are reserved as a pointer to
60 the next block. Set the chain of the full block to the
61 pointer to the new block. */
62 tptr = obs->current_block;
63 tptr->ptr = (char *) new_block;
64 }
65
66 /* Set the place for the next char at the first position after the
67 chain to the next block. */
68 obs->current_pointer
69 = ((char *) new_block) + sizeof (struct lto_char_ptr_base);
70 obs->current_block = new_block;
71 /* Null out the newly allocated block's pointer to the next block. */
72 new_block->ptr = NULL;
73 obs->left_in_block = obs->block_size - sizeof (struct lto_char_ptr_base);
74}
75
76
77/* Return index used to reference STRING of LEN characters in the string table
78 in OB. The string might or might not include a trailing '\0'.
79 Then put the index onto the INDEX_STREAM.
80 When PERSISTENT is set, the string S is supposed to not change during
81 duration of the OB and thus OB can keep pointer into it. */
82
83static unsigned
84streamer_string_index (struct output_block *ob, const char *s, unsigned int len,
85 bool persistent)
86{
87 struct string_slot **slot;
88 struct string_slot s_slot;
89
90 s_slot.s = s;
91 s_slot.len = len;
92 s_slot.slot_num = 0;
93
94 slot = ob->string_hash_table->find_slot (value: &s_slot, insert: INSERT);
95 if (*slot == NULL)
96 {
97 struct lto_output_stream *string_stream = ob->string_stream;
98 unsigned int start = string_stream->total_size;
99 struct string_slot *new_slot = XOBNEW (&ob->obstack, struct string_slot);
100 const char *string;
101
102 if (!persistent)
103 {
104 char *tmp;
105 string = tmp = XOBNEWVEC (&ob->obstack, char, len);
106 memcpy (dest: tmp, src: s, n: len);
107 }
108 else
109 string = s;
110
111 new_slot->s = string;
112 new_slot->len = len;
113 new_slot->slot_num = start;
114 *slot = new_slot;
115 streamer_write_uhwi_stream (string_stream, len);
116 streamer_write_data_stream (string_stream, string, len);
117 return start + 1;
118 }
119 else
120 {
121 struct string_slot *old_slot = *slot;
122 return old_slot->slot_num + 1;
123 }
124}
125
126
127/* Output STRING of LEN characters to the string table in OB. The
128 string might or might not include a trailing '\0'. Then put the
129 index onto the INDEX_STREAM.
130 When PERSISTENT is set, the string S is supposed to not change during
131 duration of the OB and thus OB can keep pointer into it. */
132
133void
134streamer_write_string_with_length (struct output_block *ob,
135 struct lto_output_stream *index_stream,
136 const char *s, unsigned int len,
137 bool persistent)
138{
139 if (s)
140 streamer_write_uhwi_stream (index_stream,
141 streamer_string_index (ob, s, len, persistent));
142 else
143 streamer_write_char_stream (obs: index_stream, c: 0);
144}
145
146
147/* Output the '\0' terminated STRING to the string
148 table in OB. Then put the index onto the INDEX_STREAM.
149 When PERSISTENT is set, the string S is supposed to not change during
150 duration of the OB and thus OB can keep pointer into it. */
151
152void
153streamer_write_string (struct output_block *ob,
154 struct lto_output_stream *index_stream,
155 const char *string, bool persistent)
156{
157 if (string)
158 streamer_write_string_with_length (ob, index_stream, s: string,
159 len: strlen (s: string) + 1,
160 persistent);
161 else
162 streamer_write_char_stream (obs: index_stream, c: 0);
163}
164
165
166/* Output STRING of LEN characters to the string table in OB. Then
167 put the index into BP.
168 When PERSISTENT is set, the string S is supposed to not change during
169 duration of the OB and thus OB can keep pointer into it. */
170
171void
172bp_pack_string_with_length (struct output_block *ob, struct bitpack_d *bp,
173 const char *s, unsigned int len, bool persistent)
174{
175 unsigned index = 0;
176 if (s)
177 index = streamer_string_index (ob, s, len, persistent);
178 bp_pack_var_len_unsigned (bp, index);
179}
180
181
182/* Output the '\0' terminated STRING to the string
183 table in OB. Then put the index onto the bitpack BP.
184 When PERSISTENT is set, the string S is supposed to not change during
185 duration of the OB and thus OB can keep pointer into it. */
186
187void
188bp_pack_string (struct output_block *ob, struct bitpack_d *bp,
189 const char *s, bool persistent)
190{
191 unsigned index = 0;
192 if (s)
193 index = streamer_string_index (ob, s, len: strlen (s: s) + 1, persistent);
194 bp_pack_var_len_unsigned (bp, index);
195}
196
197
198
199/* Write a zero to the output stream. */
200
201void
202streamer_write_zero (struct output_block *ob)
203{
204 streamer_write_char_stream (obs: ob->main_stream, c: 0);
205}
206
207
208/* Write an unsigned HOST_WIDE_INT value WORK to OB->main_stream. */
209
210void
211streamer_write_uhwi (struct output_block *ob, unsigned HOST_WIDE_INT work)
212{
213 streamer_write_uhwi_stream (ob->main_stream, work);
214}
215
216
217/* Write a HOST_WIDE_INT value WORK to OB->main_stream. */
218
219void
220streamer_write_hwi (struct output_block *ob, HOST_WIDE_INT work)
221{
222 streamer_write_hwi_stream (ob->main_stream, work);
223}
224
225/* Write a poly_uint64 value WORK to OB->main_stream. */
226
227void
228streamer_write_poly_uint64 (struct output_block *ob, poly_uint64 work)
229{
230 for (int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
231 streamer_write_uhwi_stream (ob->main_stream, work.coeffs[i]);
232}
233
234/* Write a poly_int64 value WORK to OB->main_stream. */
235
236void
237streamer_write_poly_int64 (struct output_block *ob, poly_int64 work)
238{
239 for (int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
240 streamer_write_hwi_stream (ob->main_stream, work.coeffs[i]);
241}
242
243/* Write a gcov counter value WORK to OB->main_stream. */
244
245void
246streamer_write_gcov_count (struct output_block *ob, gcov_type work)
247{
248 streamer_write_gcov_count_stream (ob->main_stream, work);
249}
250
251/* Write an unsigned HOST_WIDE_INT value WORK to OBS. */
252
253void
254streamer_write_uhwi_stream (struct lto_output_stream *obs,
255 unsigned HOST_WIDE_INT work)
256{
257 if (obs->left_in_block == 0)
258 lto_append_block (obs);
259 char *current_pointer = obs->current_pointer;
260 unsigned int left_in_block = obs->left_in_block;
261 unsigned int size = 0;
262 do
263 {
264 unsigned int byte = (work & 0x7f);
265 work >>= 7;
266 if (work != 0)
267 /* More bytes to follow. */
268 byte |= 0x80;
269
270 *(current_pointer++) = byte;
271 left_in_block--;
272 size++;
273 }
274 while (work != 0 && left_in_block > 0);
275 if (work != 0)
276 {
277 obs->left_in_block = 0;
278 lto_append_block (obs);
279 current_pointer = obs->current_pointer;
280 left_in_block = obs->left_in_block;
281 do
282 {
283 unsigned int byte = (work & 0x7f);
284 work >>= 7;
285 if (work != 0)
286 /* More bytes to follow. */
287 byte |= 0x80;
288
289 *(current_pointer++) = byte;
290 left_in_block--;
291 size++;
292 }
293 while (work != 0);
294 }
295 obs->current_pointer = current_pointer;
296 obs->left_in_block = left_in_block;
297 obs->total_size += size;
298}
299
300
301/* Write a HOST_WIDE_INT value WORK to OBS. */
302
303void
304streamer_write_hwi_stream (struct lto_output_stream *obs, HOST_WIDE_INT work)
305{
306 if (obs->left_in_block == 0)
307 lto_append_block (obs);
308 char *current_pointer = obs->current_pointer;
309 unsigned int left_in_block = obs->left_in_block;
310 unsigned int size = 0;
311 bool more;
312 do
313 {
314 unsigned int byte = (work & 0x7f);
315 /* If the lower 7-bits are sign-extended 0 or -1 we are finished. */
316 work >>= 6;
317 more = !(work == 0 || work == -1);
318 if (more)
319 {
320 /* More bits to follow. */
321 work >>= 1;
322 byte |= 0x80;
323 }
324
325 *(current_pointer++) = byte;
326 left_in_block--;
327 size++;
328 }
329 while (more && left_in_block > 0);
330 if (more)
331 {
332 obs->left_in_block = 0;
333 lto_append_block (obs);
334 current_pointer = obs->current_pointer;
335 left_in_block = obs->left_in_block;
336 do
337 {
338 unsigned int byte = (work & 0x7f);
339 work >>= 6;
340 more = !(work == 0 || work == -1);
341 if (more)
342 {
343 work >>= 1;
344 byte |= 0x80;
345 }
346
347 *(current_pointer++) = byte;
348 left_in_block--;
349 size++;
350 }
351 while (more);
352 }
353 obs->current_pointer = current_pointer;
354 obs->left_in_block = left_in_block;
355 obs->total_size += size;
356}
357
358/* Write a GCOV counter value WORK to OBS. */
359
360void
361streamer_write_gcov_count_stream (struct lto_output_stream *obs, gcov_type work)
362{
363 gcc_assert ((HOST_WIDE_INT) work == work);
364 streamer_write_hwi_stream (obs, work);
365}
366
367/* Write raw DATA of length LEN to the output block OB. */
368
369void
370streamer_write_data_stream (struct lto_output_stream *obs, const void *data,
371 size_t len)
372{
373 while (len)
374 {
375 size_t copy;
376
377 /* No space left. */
378 if (obs->left_in_block == 0)
379 lto_append_block (obs);
380
381 /* Determine how many bytes to copy in this loop. */
382 if (len <= obs->left_in_block)
383 copy = len;
384 else
385 copy = obs->left_in_block;
386
387 /* Copy the data and do bookkeeping. */
388 memcpy (dest: obs->current_pointer, src: data, n: copy);
389 obs->current_pointer += copy;
390 obs->total_size += copy;
391 obs->left_in_block -= copy;
392 data = (const char *) data + copy;
393 len -= copy;
394 }
395}
396
397/* Write REAL_VALUE_TYPE into OB. */
398
399void
400streamer_write_real_value (struct output_block *ob, const REAL_VALUE_TYPE *r)
401{
402 bitpack_d bp = bitpack_create (s: ob->main_stream);
403 bp_pack_real_value (&bp, r);
404 streamer_write_bitpack (bp: &bp);
405}
406
407void
408streamer_write_vrange (struct output_block *ob, const vrange &v)
409{
410 gcc_checking_assert (!v.undefined_p ());
411
412 // Write the common fields to all vranges.
413 value_range_kind kind = v.m_kind;
414 streamer_write_enum (ob->main_stream, value_range_kind, VR_LAST, kind);
415 stream_write_tree (ob, v.type (), true);
416
417 if (is_a <irange> (v))
418 {
419 const irange &r = as_a <irange> (v);
420 streamer_write_uhwi (ob, work: r.num_pairs ());
421 for (unsigned i = 0; i < r.num_pairs (); ++i)
422 {
423 streamer_write_wide_int (ob, r.lower_bound (pair: i));
424 streamer_write_wide_int (ob, r.upper_bound (pair: i));
425 }
426 // TODO: We could avoid streaming out the value if the mask is -1.
427 irange_bitmask bm = r.get_bitmask ();
428 streamer_write_wide_int (ob, bm.value ());
429 streamer_write_wide_int (ob, bm.mask ());
430 return;
431 }
432 if (is_a <frange> (v))
433 {
434 const frange &r = as_a <frange> (v);
435
436 // Stream out NAN bits.
437 bitpack_d bp = bitpack_create (s: ob->main_stream);
438 nan_state nan = r.get_nan_state ();
439 bp_pack_value (bp: &bp, val: nan.pos_p (), nbits: 1);
440 bp_pack_value (bp: &bp, val: nan.neg_p (), nbits: 1);
441 streamer_write_bitpack (bp: &bp);
442
443 // Stream out bounds.
444 if (kind != VR_NAN)
445 {
446 REAL_VALUE_TYPE lb = r.lower_bound ();
447 REAL_VALUE_TYPE ub = r.upper_bound ();
448 streamer_write_real_value (ob, r: &lb);
449 streamer_write_real_value (ob, r: &ub);
450 }
451 return;
452 }
453 gcc_unreachable ();
454}
455
456/* Emit the physical representation of wide_int VAL to output block OB. */
457
458void
459streamer_write_wide_int (struct output_block *ob, const wide_int &val)
460{
461 int len = val.get_len ();
462
463 streamer_write_uhwi (ob, work: val.get_precision ());
464 streamer_write_uhwi (ob, work: len);
465 for (int i = 0; i < len; i++)
466 streamer_write_hwi (ob, work: val.elt (i));
467}
468
469/* Emit the physical representation of widest_int W to output block OB. */
470
471void
472streamer_write_widest_int (struct output_block *ob,
473 const widest_int &w)
474{
475 int len = w.get_len ();
476
477 streamer_write_uhwi (ob, work: w.get_precision ());
478 streamer_write_uhwi (ob, work: len);
479 for (int i = 0; i < len; i++)
480 streamer_write_hwi (ob, work: w.elt (i));
481}
482
483

source code of gcc/data-streamer-out.cc