Branch data Line data Source code
1 : : /* C++ modules. Experimental!
2 : : Copyright (C) 2017-2024 Free Software Foundation, Inc.
3 : : Written by Nathan Sidwell <nathan@acm.org> while at FaceBook
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : /* Comments in this file have a non-negligible chance of being wrong
22 : : or at least inaccurate. Due to (a) my misunderstanding, (b)
23 : : ambiguities that I have interpretted differently to original intent
24 : : (c) changes in the specification, (d) my poor wording, (e) source
25 : : changes. */
26 : :
27 : : /* (Incomplete) Design Notes
28 : :
29 : : A hash table contains all module names. Imported modules are
30 : : present in a modules array, which by construction places an
31 : : import's dependencies before the import itself. The single
32 : : exception is the current TU, which always occupies slot zero (even
33 : : when it is not a module).
34 : :
35 : : Imported decls occupy an entity_ary, an array of binding_slots, indexed
36 : : by importing module and index within that module. A flat index is
37 : : used, as each module reserves a contiguous range of indices.
38 : : Initially each slot indicates the CMI section containing the
39 : : streamed decl. When the decl is imported it will point to the decl
40 : : itself.
41 : :
42 : : Additionally each imported decl is mapped in the entity_map via its
43 : : DECL_UID to the flat index in the entity_ary. Thus we can locate
44 : : the index for any imported decl by using this map and then
45 : : de-flattening the index via a binary seach of the module vector.
46 : : Cross-module references are by (remapped) module number and
47 : : module-local index.
48 : :
49 : : Each importable DECL contains several flags. The simple set are
50 : : DECL_MODULE_EXPORT_P, DECL_MODULE_PURVIEW_P, DECL_MODULE_ATTACH_P
51 : : and DECL_MODULE_IMPORT_P. The first indicates whether it is
52 : : exported, the second whether it is in module or header-unit
53 : : purview. The third indicates it is attached to the named module in
54 : : whose purview it resides and the fourth indicates whether it was an
55 : : import into this TU or not. DECL_MODULE_ATTACH_P will be false for
56 : : all decls in a header-unit, and for those in a named module inside
57 : : a linkage declaration.
58 : :
59 : : The more detailed flags are DECL_MODULE_PARTITION_P,
60 : : DECL_MODULE_ENTITY_P. The first is set in a primary interface unit
61 : : on decls that were read from module partitions (these will have
62 : : DECL_MODULE_IMPORT_P set too). Such decls will be streamed out to
63 : : the primary's CMI. DECL_MODULE_ENTITY_P is set when an entity is
64 : : imported, even if it matched a non-imported entity. Such a decl
65 : : will not have DECL_MODULE_IMPORT_P set, even though it has an entry
66 : : in the entity map and array.
67 : :
68 : : Header units are module-like.
69 : :
70 : : For namespace-scope lookup, the decls for a particular module are
71 : : held located in a sparse array hanging off the binding of the name.
72 : : This is partitioned into two: a few fixed slots at the start
73 : : followed by the sparse slots afterwards. By construction we only
74 : : need to append new slots to the end -- there is never a need to
75 : : insert in the middle. The fixed slots are MODULE_SLOT_CURRENT for
76 : : the current TU (regardless of whether it is a module or not),
77 : : MODULE_SLOT_GLOBAL and MODULE_SLOT_PARTITION. These latter two
78 : : slots are used for merging entities across the global module and
79 : : module partitions respectively. MODULE_SLOT_PARTITION is only
80 : : present in a module. Neither of those two slots is searched during
81 : : name lookup -- they are internal use only. This vector is created
82 : : lazily once we require it, if there is only a declaration from the
83 : : current TU, a regular binding is present. It is converted on
84 : : demand.
85 : :
86 : : OPTIMIZATION: Outside of the current TU, we only need ADL to work.
87 : : We could optimize regular lookup for the current TU by glomming all
88 : : the visible decls on its slot. Perhaps wait until design is a
89 : : little more settled though.
90 : :
91 : : There is only one instance of each extern-linkage namespace. It
92 : : appears in every module slot that makes it visible. It also
93 : : appears in MODULE_SLOT_GLOBAL. (It is an ODR violation if they
94 : : collide with some other global module entity.) We also have an
95 : : optimization that shares the slot for adjacent modules that declare
96 : : the same such namespace.
97 : :
98 : : A module interface compilation produces a Compiled Module Interface
99 : : (CMI). The format used is Encapsulated Lazy Records Of Numbered
100 : : Declarations, which is essentially ELF's section encapsulation. (As
101 : : all good nerds are aware, Elrond is half Elf.) Some sections are
102 : : named, and contain information about the module as a whole (indices
103 : : etc), and other sections are referenced by number. Although I
104 : : don't defend against actively hostile CMIs, there is some
105 : : checksumming involved to verify data integrity. When dumping out
106 : : an interface, we generate a graph of all the
107 : : independently-redeclarable DECLS that are needed, and the decls
108 : : they reference. From that we determine the strongly connected
109 : : components (SCC) within this TU. Each SCC is dumped to a separate
110 : : numbered section of the CMI. We generate a binding table section,
111 : : mapping each namespace&name to a defining section. This allows
112 : : lazy loading.
113 : :
114 : : Lazy loading employs mmap to map a read-only image of the CMI.
115 : : It thus only occupies address space and is paged in on demand,
116 : : backed by the CMI file itself. If mmap is unavailable, regular
117 : : FILEIO is used. Also, there's a bespoke ELF reader/writer here,
118 : : which implements just the section table and sections (including
119 : : string sections) of a 32-bit ELF in host byte-order. You can of
120 : : course inspect it with readelf. I figured 32-bit is sufficient,
121 : : for a single module. I detect running out of section numbers, but
122 : : do not implement the ELF overflow mechanism. At least you'll get
123 : : an error if that happens.
124 : :
125 : : We do not separate declarations and definitions. My guess is that
126 : : if you refer to the declaration, you'll also need the definition
127 : : (template body, inline function, class definition etc). But this
128 : : does mean we can get larger SCCs than if we separated them. It is
129 : : unclear whether this is a win or not.
130 : :
131 : : Notice that we embed section indices into the contents of other
132 : : sections. Thus random manipulation of the CMI file by ELF tools
133 : : may well break it. The kosher way would probably be to introduce
134 : : indirection via section symbols, but that would require defining a
135 : : relocation type.
136 : :
137 : : Notice that lazy loading of one module's decls can cause lazy
138 : : loading of other decls in the same or another module. Clearly we
139 : : want to avoid loops. In a correct program there can be no loops in
140 : : the module dependency graph, and the above-mentioned SCC algorithm
141 : : places all intra-module circular dependencies in the same SCC. It
142 : : also orders the SCCs wrt each other, so dependent SCCs come first.
143 : : As we load dependent modules first, we know there can be no
144 : : reference to a higher-numbered module, and because we write out
145 : : dependent SCCs first, likewise for SCCs within the module. This
146 : : allows us to immediately detect broken references. When loading,
147 : : we must ensure the rest of the compiler doesn't cause some
148 : : unconnected load to occur (for instance, instantiate a template).
149 : :
150 : : Classes used:
151 : :
152 : : dumper - logger
153 : :
154 : : data - buffer
155 : :
156 : : bytes_in : data - scalar reader
157 : : bytes_out : data - scalar writer
158 : :
159 : : bytes_in::bits_in - bit stream reader
160 : : bytes_out::bits_out - bit stream writer
161 : :
162 : : elf - ELROND format
163 : : elf_in : elf - ELROND reader
164 : : elf_out : elf - ELROND writer
165 : :
166 : : trees_in : bytes_in - tree reader
167 : : trees_out : bytes_out - tree writer
168 : :
169 : : depset - dependency set
170 : : depset::hash - hash table of depsets
171 : : depset::tarjan - SCC determinator
172 : :
173 : : uidset<T> - set T's related to a UID
174 : : uidset<T>::hash hash table of uidset<T>
175 : :
176 : : loc_spans - location map data
177 : :
178 : : module_state - module object
179 : :
180 : : slurping - data needed during loading
181 : :
182 : : macro_import - imported macro data
183 : : macro_export - exported macro data
184 : :
185 : : The ELROND objects use mmap, for both reading and writing. If mmap
186 : : is unavailable, fileno IO is used to read and write blocks of data.
187 : :
188 : : The mapper object uses fileno IO to communicate with the server or
189 : : program. */
190 : :
191 : : /* In expermental (trunk) sources, MODULE_VERSION is a #define passed
192 : : in from the Makefile. It records the modification date of the
193 : : source directory -- that's the only way to stay sane. In release
194 : : sources, we (plan to) use the compiler's major.minor versioning.
195 : : While the format might not change between at minor versions, it
196 : : seems simplest to tie the two together. There's no concept of
197 : : inter-version compatibility. */
198 : : #define IS_EXPERIMENTAL(V) ((V) >= (1U << 20))
199 : : #define MODULE_MAJOR(V) ((V) / 10000)
200 : : #define MODULE_MINOR(V) ((V) % 10000)
201 : : #define EXPERIMENT(A,B) (IS_EXPERIMENTAL (MODULE_VERSION) ? (A) : (B))
202 : : #ifndef MODULE_VERSION
203 : : #include "bversion.h"
204 : : #define MODULE_VERSION (BUILDING_GCC_MAJOR * 10000U + BUILDING_GCC_MINOR)
205 : : #elif !IS_EXPERIMENTAL (MODULE_VERSION)
206 : : #error "This is not the version I was looking for."
207 : : #endif
208 : :
209 : : #define _DEFAULT_SOURCE 1 /* To get TZ field of struct tm, if available. */
210 : : #include "config.h"
211 : : #define INCLUDE_MEMORY
212 : : #define INCLUDE_STRING
213 : : #define INCLUDE_VECTOR
214 : : #include "system.h"
215 : : #include "coretypes.h"
216 : : #include "cp-tree.h"
217 : : #include "timevar.h"
218 : : #include "stringpool.h"
219 : : #include "dumpfile.h"
220 : : #include "bitmap.h"
221 : : #include "cgraph.h"
222 : : #include "varasm.h"
223 : : #include "tree-iterator.h"
224 : : #include "cpplib.h"
225 : : #include "mkdeps.h"
226 : : #include "incpath.h"
227 : : #include "libiberty.h"
228 : : #include "stor-layout.h"
229 : : #include "version.h"
230 : : #include "tree-diagnostic.h"
231 : : #include "toplev.h"
232 : : #include "opts.h"
233 : : #include "attribs.h"
234 : : #include "intl.h"
235 : : #include "langhooks.h"
236 : : /* This TU doesn't need or want to see the networking. */
237 : : #define CODY_NETWORKING 0
238 : : #include "mapper-client.h"
239 : : #include <zlib.h> // for crc32, crc32_combine
240 : :
241 : : #if 0 // 1 for testing no mmap
242 : : #define MAPPED_READING 0
243 : : #define MAPPED_WRITING 0
244 : : #else
245 : : #if HAVE_MMAP_FILE && _POSIX_MAPPED_FILES > 0
246 : : /* mmap, munmap. */
247 : : #define MAPPED_READING 1
248 : : #if HAVE_SYSCONF && defined (_SC_PAGE_SIZE)
249 : : /* msync, sysconf (_SC_PAGE_SIZE), ftruncate */
250 : : /* posix_fallocate used if available. */
251 : : #define MAPPED_WRITING 1
252 : : #else
253 : : #define MAPPED_WRITING 0
254 : : #endif
255 : : #else
256 : : #define MAPPED_READING 0
257 : : #define MAPPED_WRITING 0
258 : : #endif
259 : : #endif
260 : :
261 : : /* Some open(2) flag differences, what a colourful world it is! */
262 : : #if defined (O_CLOEXEC)
263 : : // OK
264 : : #elif defined (_O_NOINHERIT)
265 : : /* Windows' _O_NOINHERIT matches O_CLOEXEC flag */
266 : : #define O_CLOEXEC _O_NOINHERIT
267 : : #else
268 : : #define O_CLOEXEC 0
269 : : #endif
270 : : #if defined (O_BINARY)
271 : : // Ok?
272 : : #elif defined (_O_BINARY)
273 : : /* Windows' open(2) call defaults to text! */
274 : : #define O_BINARY _O_BINARY
275 : : #else
276 : : #define O_BINARY 0
277 : : #endif
278 : :
279 : 330675 : static inline cpp_hashnode *cpp_node (tree id)
280 : : {
281 : 330675 : return CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (id));
282 : : }
283 : :
284 : 226232 : static inline tree identifier (const cpp_hashnode *node)
285 : : {
286 : : /* HT_NODE() expands to node->ident that HT_IDENT_TO_GCC_IDENT()
287 : : then subtracts a nonzero constant, deriving a pointer to
288 : : a different member than ident. That's strictly undefined
289 : : and detected by -Warray-bounds. Suppress it. See PR 101372. */
290 : 226232 : #pragma GCC diagnostic push
291 : 226232 : #pragma GCC diagnostic ignored "-Warray-bounds"
292 : 226232 : return HT_IDENT_TO_GCC_IDENT (HT_NODE (const_cast<cpp_hashnode *> (node)));
293 : 226232 : #pragma GCC diagnostic pop
294 : : }
295 : :
296 : : /* Id for dumping module information. */
297 : : int module_dump_id;
298 : :
299 : : /* We have a special module owner. */
300 : : #define MODULE_UNKNOWN (~0U) /* Not yet known. */
301 : :
302 : : /* Prefix for section names. */
303 : : #define MOD_SNAME_PFX ".gnu.c++"
304 : :
305 : : /* Format a version for user consumption. */
306 : :
307 : : typedef char verstr_t[32];
308 : : static void
309 : 3208 : version2string (unsigned version, verstr_t &out)
310 : : {
311 : 3208 : unsigned major = MODULE_MAJOR (version);
312 : 3208 : unsigned minor = MODULE_MINOR (version);
313 : :
314 : 3208 : if (IS_EXPERIMENTAL (version))
315 : 3208 : sprintf (out, "%04u/%02u/%02u-%02u:%02u%s",
316 : 3208 : 2000 + major / 10000, (major / 100) % 100, (major % 100),
317 : : minor / 100, minor % 100,
318 : : EXPERIMENT ("", " (experimental)"));
319 : : else
320 : 0 : sprintf (out, "%u.%u", major, minor);
321 : 3208 : }
322 : :
323 : : /* Include files to note translation for. */
324 : : static vec<const char *, va_heap, vl_embed> *note_includes;
325 : :
326 : : /* Modules to note CMI pathames. */
327 : : static vec<const char *, va_heap, vl_embed> *note_cmis;
328 : :
329 : : /* Traits to hash an arbitrary pointer. Entries are not deletable,
330 : : and removal is a noop (removal needed upon destruction). */
331 : : template <typename T>
332 : : struct nodel_ptr_hash : pointer_hash<T>, typed_noop_remove <T *> {
333 : : /* Nothing is deletable. Everything is insertable. */
334 : : static bool is_deleted (T *) { return false; }
335 : : static void mark_deleted (T *) { gcc_unreachable (); }
336 : : };
337 : :
338 : : /* Map from pointer to signed integer. */
339 : : typedef simple_hashmap_traits<nodel_ptr_hash<void>, int> ptr_int_traits;
340 : : typedef hash_map<void *,signed,ptr_int_traits> ptr_int_hash_map;
341 : :
342 : : /********************************************************************/
343 : : /* Basic streaming & ELF. Serialization is usually via mmap. For
344 : : writing we slide a buffer over the output file, syncing it
345 : : approproiately. For reading we simply map the whole file (as a
346 : : file-backed read-only map -- it's just address space, leaving the
347 : : OS pager to deal with getting the data to us). Some buffers need
348 : : to be more conventional malloc'd contents. */
349 : :
350 : : /* Variable length buffer. */
351 : :
352 : : namespace {
353 : : class data {
354 : : public:
355 : 2126 : class allocator {
356 : : public:
357 : : /* Tools tend to moan if the dtor's not virtual. */
358 : 94278 : virtual ~allocator () {}
359 : :
360 : : public:
361 : : void grow (data &obj, unsigned needed, bool exact);
362 : : void shrink (data &obj);
363 : :
364 : : public:
365 : : virtual char *grow (char *ptr, unsigned needed);
366 : : virtual void shrink (char *ptr);
367 : : };
368 : :
369 : : public:
370 : : char *buffer; /* Buffer being transferred. */
371 : : /* Although size_t would be the usual size, we know we never get
372 : : more than 4GB of buffer -- because that's the limit of the
373 : : encapsulation format. And if you need bigger imports, you're
374 : : doing it wrong. */
375 : : unsigned size; /* Allocated size of buffer. */
376 : : unsigned pos; /* Position in buffer. */
377 : :
378 : : public:
379 : 1089527 : data ()
380 : 1089527 : :buffer (NULL), size (0), pos (0)
381 : : {
382 : : }
383 : 1100329 : ~data ()
384 : : {
385 : : /* Make sure the derived and/or using class know what they're
386 : : doing. */
387 : 1100329 : gcc_checking_assert (!buffer);
388 : 1100329 : }
389 : :
390 : : protected:
391 : 777214262 : char *use (unsigned count)
392 : : {
393 : 777214262 : if (size < pos + count)
394 : : return NULL;
395 : 777214262 : char *res = &buffer[pos];
396 : 777214262 : pos += count;
397 : 371805004 : return res;
398 : : }
399 : :
400 : : unsigned calc_crc (unsigned) const;
401 : :
402 : : public:
403 : 55613250 : void unuse (unsigned count)
404 : : {
405 : 55613250 : pos -= count;
406 : 20872 : }
407 : :
408 : : public:
409 : : static allocator simple_memory;
410 : : };
411 : : } // anon namespace
412 : :
413 : : /* The simple data allocator. */
414 : : data::allocator data::simple_memory;
415 : :
416 : : /* Grow buffer to at least size NEEDED. */
417 : :
418 : : void
419 : 866708 : data::allocator::grow (data &obj, unsigned needed, bool exact)
420 : : {
421 : 866708 : gcc_checking_assert (needed ? needed > obj.size : !obj.size);
422 : 866708 : if (!needed)
423 : : /* Pick a default size. */
424 : 364986 : needed = EXPERIMENT (100, 1000);
425 : :
426 : 866708 : if (!exact)
427 : 860564 : needed *= 2;
428 : 866708 : obj.buffer = grow (obj.buffer, needed);
429 : 866708 : if (obj.buffer)
430 : 866708 : obj.size = needed;
431 : : else
432 : 0 : obj.pos = obj.size = 0;
433 : 866708 : }
434 : :
435 : : /* Free a buffer. */
436 : :
437 : : void
438 : 375628 : data::allocator::shrink (data &obj)
439 : : {
440 : 0 : shrink (obj.buffer);
441 : 375628 : obj.buffer = NULL;
442 : 375628 : obj.size = 0;
443 : 0 : }
444 : :
445 : : char *
446 : 8382 : data::allocator::grow (char *ptr, unsigned needed)
447 : : {
448 : 8382 : return XRESIZEVAR (char, ptr, needed);
449 : : }
450 : :
451 : : void
452 : 10630 : data::allocator::shrink (char *ptr)
453 : : {
454 : 10630 : XDELETEVEC (ptr);
455 : 10630 : }
456 : :
457 : : /* Calculate the crc32 of the buffer. Note the CRC is stored in the
458 : : first 4 bytes, so don't include them. */
459 : :
460 : : unsigned
461 : 730550 : data::calc_crc (unsigned l) const
462 : : {
463 : 730550 : return crc32 (0, (unsigned char *)buffer + 4, l - 4);
464 : : }
465 : :
466 : : class elf_in;
467 : :
468 : : /* Byte stream reader. */
469 : :
470 : : namespace {
471 : : class bytes_in : public data {
472 : : typedef data parent;
473 : :
474 : : protected:
475 : : bool overrun; /* Sticky read-too-much flag. */
476 : :
477 : : public:
478 : 373018 : bytes_in ()
479 : 373018 : : parent (), overrun (false)
480 : : {
481 : : }
482 : 375181 : ~bytes_in ()
483 : : {
484 : 9716 : }
485 : :
486 : : public:
487 : : /* Begin reading a named section. */
488 : : bool begin (location_t loc, elf_in *src, const char *name);
489 : : /* Begin reading a numbered section with optional name. */
490 : : bool begin (location_t loc, elf_in *src, unsigned, const char * = NULL);
491 : : /* Complete reading a buffer. Propagate errors and return true on
492 : : success. */
493 : : bool end (elf_in *src);
494 : : /* Return true if there is unread data. */
495 : 2749185 : bool more_p () const
496 : : {
497 : 2749185 : return pos != size;
498 : : }
499 : :
500 : : public:
501 : : /* Start reading at OFFSET. */
502 : 302 : void random_access (unsigned offset)
503 : : {
504 : 302 : if (offset > size)
505 : 0 : set_overrun ();
506 : 302 : pos = offset;
507 : : }
508 : :
509 : : public:
510 : 2316369 : void align (unsigned boundary)
511 : : {
512 : 2316369 : if (unsigned pad = pos & (boundary - 1))
513 : 4485941 : read (boundary - pad);
514 : : }
515 : :
516 : : public:
517 : 405409258 : const char *read (unsigned count)
518 : : {
519 : 2169572 : char *ptr = use (count);
520 : 405409258 : if (!ptr)
521 : 0 : set_overrun ();
522 : 333883497 : return ptr;
523 : : }
524 : :
525 : : public:
526 : : bool check_crc () const;
527 : : /* We store the CRC in the first 4 bytes, using host endianness. */
528 : 373957 : unsigned get_crc () const
529 : : {
530 : 373957 : return *(const unsigned *)&buffer[0];
531 : : }
532 : :
533 : : public:
534 : : /* Manipulate the overrun flag. */
535 : 226881419 : bool get_overrun () const
536 : : {
537 : 226881419 : return overrun;
538 : : }
539 : 14 : void set_overrun ()
540 : : {
541 : 14 : overrun = true;
542 : 0 : }
543 : :
544 : : public:
545 : : unsigned u32 (); /* Read uncompressed integer. */
546 : :
547 : : public:
548 : : int c () ATTRIBUTE_UNUSED; /* Read a char. */
549 : : int i (); /* Read a signed int. */
550 : : unsigned u (); /* Read an unsigned int. */
551 : : size_t z (); /* Read a size_t. */
552 : : HOST_WIDE_INT wi (); /* Read a HOST_WIDE_INT. */
553 : : unsigned HOST_WIDE_INT wu (); /* Read an unsigned HOST_WIDE_INT. */
554 : : const char *str (size_t * = NULL); /* Read a string. */
555 : : const void *buf (size_t); /* Read a fixed-length buffer. */
556 : : cpp_hashnode *cpp_node (); /* Read a cpp node. */
557 : :
558 : : struct bits_in;
559 : : bits_in stream_bits ();
560 : : };
561 : : } // anon namespace
562 : :
563 : : /* Verify the buffer's CRC is correct. */
564 : :
565 : : bool
566 : 371690 : bytes_in::check_crc () const
567 : : {
568 : 371690 : if (size < 4)
569 : : return false;
570 : :
571 : 371690 : unsigned c_crc = calc_crc (size);
572 : 371690 : if (c_crc != get_crc ())
573 : : return false;
574 : :
575 : : return true;
576 : : }
577 : :
578 : : class elf_out;
579 : :
580 : : /* Byte stream writer. */
581 : :
582 : : namespace {
583 : : class bytes_out : public data {
584 : : typedef data parent;
585 : :
586 : : public:
587 : : allocator *memory; /* Obtainer of memory. */
588 : :
589 : : public:
590 : 712098 : bytes_out (allocator *memory)
591 : 712098 : : parent (), memory (memory)
592 : : {
593 : : }
594 : 712098 : ~bytes_out ()
595 : : {
596 : 729976 : }
597 : :
598 : : public:
599 : 778590065 : bool streaming_p () const
600 : : {
601 : 778590065 : return memory != NULL;
602 : : }
603 : :
604 : : public:
605 : : void set_crc (unsigned *crc_ptr);
606 : :
607 : : public:
608 : : /* Begin writing, maybe reserve space for CRC. */
609 : : void begin (bool need_crc = true);
610 : : /* Finish writing. Spill to section by number. */
611 : : unsigned end (elf_out *, unsigned, unsigned *crc_ptr = NULL);
612 : :
613 : : public:
614 : 2351011 : void align (unsigned boundary)
615 : : {
616 : 2351011 : if (unsigned pad = pos & (boundary - 1))
617 : 2206636 : write (boundary - pad);
618 : 2351011 : }
619 : :
620 : : public:
621 : 371805004 : char *write (unsigned count, bool exact = false)
622 : : {
623 : 371805004 : if (size < pos + count)
624 : 491284 : memory->grow (*this, pos + count, exact);
625 : 371805004 : return use (count);
626 : : }
627 : :
628 : : public:
629 : : void u32 (unsigned); /* Write uncompressed integer. */
630 : :
631 : : public:
632 : : void c (unsigned char) ATTRIBUTE_UNUSED; /* Write unsigned char. */
633 : : void i (int); /* Write signed int. */
634 : : void u (unsigned); /* Write unsigned int. */
635 : : void z (size_t s); /* Write size_t. */
636 : : void wi (HOST_WIDE_INT); /* Write HOST_WIDE_INT. */
637 : : void wu (unsigned HOST_WIDE_INT); /* Write unsigned HOST_WIDE_INT. */
638 : 18520 : void str (const char *ptr)
639 : : {
640 : 18520 : str (ptr, strlen (ptr));
641 : 18520 : }
642 : 430226 : void cpp_node (const cpp_hashnode *node)
643 : : {
644 : 430226 : str ((const char *)NODE_NAME (node), NODE_LEN (node));
645 : 17435 : }
646 : : void str (const char *, size_t); /* Write string of known length. */
647 : : void buf (const void *, size_t); /* Write fixed length buffer. */
648 : : void *buf (size_t); /* Create a writable buffer */
649 : :
650 : : struct bits_out;
651 : : bits_out stream_bits ();
652 : :
653 : : public:
654 : : /* Format a NUL-terminated raw string. */
655 : : void printf (const char *, ...) ATTRIBUTE_PRINTF_2;
656 : : void print_time (const char *, const tm *, const char *);
657 : :
658 : : public:
659 : : /* Dump instrumentation. */
660 : : static void instrument ();
661 : :
662 : : protected:
663 : : /* Instrumentation. */
664 : : static unsigned spans[4];
665 : : static unsigned lengths[4];
666 : : };
667 : : } // anon namespace
668 : :
669 : : /* Finish bit packet. Rewind the bytes not used. */
670 : :
671 : : static unsigned
672 : 55571664 : bit_flush (data& bits, uint32_t& bit_val, unsigned& bit_pos)
673 : : {
674 : 55571664 : gcc_assert (bit_pos);
675 : 55571664 : unsigned bytes = (bit_pos + 7) / 8;
676 : 55571664 : bits.unuse (4 - bytes);
677 : 55571664 : bit_pos = 0;
678 : 55571664 : bit_val = 0;
679 : 55571664 : return bytes;
680 : : }
681 : :
682 : : /* Bit stream reader (RAII-enabled). Bools are packed into bytes. You
683 : : cannot mix bools and non-bools. Use bflush to flush the current stream
684 : : of bools on demand. Upon destruction bflush is called.
685 : :
686 : : When reading, we don't know how many bools we'll read in. So read
687 : : 4 bytes-worth, and then rewind when flushing if we didn't need them
688 : : all. You can't have a block of bools closer than 4 bytes to the
689 : : end of the buffer.
690 : :
691 : : Both bits_in and bits_out maintain the necessary state for bit packing,
692 : : and since these objects are locally constructed the compiler can more
693 : : easily track their state across consecutive reads/writes and optimize
694 : : away redundant buffering checks. */
695 : :
696 : : struct bytes_in::bits_in {
697 : : bytes_in& in;
698 : : uint32_t bit_val = 0;
699 : : unsigned bit_pos = 0;
700 : :
701 : 22058036 : bits_in (bytes_in& in)
702 : 22058036 : : in (in)
703 : : { }
704 : :
705 : 22058036 : ~bits_in ()
706 : : {
707 : 20558876 : bflush ();
708 : 22058036 : }
709 : :
710 : : bits_in(bits_in&&) = default;
711 : : bits_in(const bits_in&) = delete;
712 : : bits_in& operator=(const bits_in&) = delete;
713 : :
714 : : /* Completed a block of bools. */
715 : 45944917 : void bflush ()
716 : : {
717 : 45944917 : if (bit_pos)
718 : 25386041 : bit_flush (in, bit_val, bit_pos);
719 : 45944917 : }
720 : :
721 : : /* Read one bit. */
722 : 765455601 : bool b ()
723 : : {
724 : 765455601 : if (!bit_pos)
725 : 33417628 : bit_val = in.u32 ();
726 : 765455601 : bool x = (bit_val >> bit_pos) & 1;
727 : 765455601 : bit_pos = (bit_pos + 1) % 32;
728 : 765455601 : return x;
729 : : }
730 : : };
731 : :
732 : : /* Factory function for bits_in. */
733 : :
734 : : bytes_in::bits_in
735 : 22058036 : bytes_in::stream_bits ()
736 : : {
737 : 22058036 : return bits_in (*this);
738 : : }
739 : :
740 : : /* Bit stream writer (RAII-enabled), counterpart to bits_in. */
741 : :
742 : : struct bytes_out::bits_out {
743 : : bytes_out& out;
744 : : uint32_t bit_val = 0;
745 : : unsigned bit_pos = 0;
746 : : char is_set = -1;
747 : :
748 : 19877996 : bits_out (bytes_out& out)
749 : 19877996 : : out (out)
750 : : { }
751 : :
752 : 19877996 : ~bits_out ()
753 : : {
754 : 113073 : bflush ();
755 : : }
756 : :
757 : : bits_out(bits_out&&) = default;
758 : : bits_out(const bits_out&) = delete;
759 : : bits_out& operator=(const bits_out&) = delete;
760 : :
761 : : /* Completed a block of bools. */
762 : 41382357 : void bflush ()
763 : : {
764 : 41382357 : if (bit_pos)
765 : : {
766 : 22877851 : out.u32 (bit_val);
767 : 22877851 : out.lengths[2] += bit_flush (out, bit_val, bit_pos);
768 : : }
769 : 41382357 : out.spans[2]++;
770 : 41382357 : is_set = -1;
771 : 41382357 : }
772 : :
773 : : /* Write one bit.
774 : :
775 : : It may be worth optimizing for most bools being zero. Some kind of
776 : : run-length encoding? */
777 : 686718472 : void b (bool x)
778 : : {
779 : 686718472 : if (is_set != x)
780 : : {
781 : 72489783 : is_set = x;
782 : 72489783 : out.spans[x]++;
783 : : }
784 : 686718472 : out.lengths[x]++;
785 : 686718472 : bit_val |= unsigned (x) << bit_pos++;
786 : 686718472 : if (bit_pos == 32)
787 : : {
788 : 7307772 : out.u32 (bit_val);
789 : 7307772 : out.lengths[2] += bit_flush (out, bit_val, bit_pos);
790 : : }
791 : 686718472 : }
792 : : };
793 : :
794 : : /* Factory function for bits_out. */
795 : :
796 : : bytes_out::bits_out
797 : 19877996 : bytes_out::stream_bits ()
798 : : {
799 : 19877996 : return bits_out (*this);
800 : : }
801 : :
802 : : /* Instrumentation. */
803 : : unsigned bytes_out::spans[4];
804 : : unsigned bytes_out::lengths[4];
805 : :
806 : : /* If CRC_PTR non-null, set the CRC of the buffer. Mix the CRC into
807 : : that pointed to by CRC_PTR. */
808 : :
809 : : void
810 : 360898 : bytes_out::set_crc (unsigned *crc_ptr)
811 : : {
812 : 360898 : if (crc_ptr)
813 : : {
814 : 358860 : gcc_checking_assert (pos >= 4);
815 : :
816 : 358860 : unsigned crc = calc_crc (pos);
817 : 358860 : unsigned accum = *crc_ptr;
818 : : /* Only mix the existing *CRC_PTR if it is non-zero. */
819 : 358860 : accum = accum ? crc32_combine (accum, crc, pos - 4) : crc;
820 : 358860 : *crc_ptr = accum;
821 : :
822 : : /* Buffer will be sufficiently aligned. */
823 : 358860 : *(unsigned *)buffer = crc;
824 : : }
825 : 360898 : }
826 : :
827 : : /* Exactly 4 bytes. Used internally for bool packing and a few other
828 : : places. We can't simply use uint32_t because (a) alignment and
829 : : (b) we need little-endian for the bool streaming rewinding to make
830 : : sense. */
831 : :
832 : : void
833 : 30192236 : bytes_out::u32 (unsigned val)
834 : : {
835 : 30192236 : if (char *ptr = write (4))
836 : : {
837 : 30192236 : ptr[0] = val;
838 : 30192236 : ptr[1] = val >> 8;
839 : 30192236 : ptr[2] = val >> 16;
840 : 30192236 : ptr[3] = val >> 24;
841 : : }
842 : 30192236 : }
843 : :
844 : : unsigned
845 : 33424751 : bytes_in::u32 ()
846 : : {
847 : 33424751 : unsigned val = 0;
848 : 33424751 : if (const char *ptr = read (4))
849 : : {
850 : 33424751 : val |= (unsigned char)ptr[0];
851 : 33424751 : val |= (unsigned char)ptr[1] << 8;
852 : 33424751 : val |= (unsigned char)ptr[2] << 16;
853 : 33424751 : val |= (unsigned char)ptr[3] << 24;
854 : : }
855 : :
856 : 33424751 : return val;
857 : : }
858 : :
859 : : /* Chars are unsigned and written as single bytes. */
860 : :
861 : : void
862 : 0 : bytes_out::c (unsigned char v)
863 : : {
864 : 0 : if (char *ptr = write (1))
865 : 0 : *ptr = v;
866 : 0 : }
867 : :
868 : : int
869 : 0 : bytes_in::c ()
870 : : {
871 : 0 : int v = 0;
872 : 0 : if (const char *ptr = read (1))
873 : 0 : v = (unsigned char)ptr[0];
874 : 0 : return v;
875 : : }
876 : :
877 : : /* Ints 7-bit as a byte. Otherwise a 3bit count of following bytes in
878 : : big-endian form. 4 bits are in the first byte. */
879 : :
880 : : void
881 : 123460540 : bytes_out::i (int v)
882 : : {
883 : 123460540 : if (char *ptr = write (1))
884 : : {
885 : 123460540 : if (v <= 0x3f && v >= -0x40)
886 : 97050544 : *ptr = v & 0x7f;
887 : : else
888 : : {
889 : 26409996 : unsigned bytes = 0;
890 : 26409996 : int probe;
891 : 26409996 : if (v >= 0)
892 : 0 : for (probe = v >> 8; probe > 0x7; probe >>= 8)
893 : 0 : bytes++;
894 : : else
895 : 41607851 : for (probe = v >> 8; probe < -0x8; probe >>= 8)
896 : 15197855 : bytes++;
897 : 26409996 : *ptr = 0x80 | bytes << 4 | (probe & 0xf);
898 : 26409996 : if ((ptr = write (++bytes)))
899 : 68017847 : for (; bytes--; v >>= 8)
900 : 41607851 : ptr[bytes] = v & 0xff;
901 : : }
902 : : }
903 : 123460540 : }
904 : :
905 : : int
906 : 139739577 : bytes_in::i ()
907 : : {
908 : 139739577 : int v = 0;
909 : 139739577 : if (const char *ptr = read (1))
910 : : {
911 : 139739577 : v = *ptr & 0xff;
912 : 139739577 : if (v & 0x80)
913 : : {
914 : 30620495 : unsigned bytes = (v >> 4) & 0x7;
915 : 30620495 : v &= 0xf;
916 : 30620495 : if (v & 0x8)
917 : 30620495 : v |= -1 ^ 0x7;
918 : : /* unsigned necessary due to left shifts of -ve values. */
919 : 30620495 : unsigned uv = unsigned (v);
920 : 30620495 : if ((ptr = read (++bytes)))
921 : 79957317 : while (bytes--)
922 : 49336822 : uv = (uv << 8) | (*ptr++ & 0xff);
923 : 30620495 : v = int (uv);
924 : : }
925 : 109119082 : else if (v & 0x40)
926 : 15340362 : v |= -1 ^ 0x3f;
927 : : }
928 : :
929 : 139739577 : return v;
930 : : }
931 : :
932 : : void
933 : 147901859 : bytes_out::u (unsigned v)
934 : : {
935 : 147901859 : if (char *ptr = write (1))
936 : : {
937 : 147901859 : if (v <= 0x7f)
938 : 111970676 : *ptr = v;
939 : : else
940 : : {
941 : 35931183 : unsigned bytes = 0;
942 : 35931183 : unsigned probe;
943 : 86313533 : for (probe = v >> 8; probe > 0xf; probe >>= 8)
944 : 50382350 : bytes++;
945 : 35931183 : *ptr = 0x80 | bytes << 4 | probe;
946 : 35931183 : if ((ptr = write (++bytes)))
947 : 122244716 : for (; bytes--; v >>= 8)
948 : 86313533 : ptr[bytes] = v & 0xff;
949 : : }
950 : : }
951 : 147901859 : }
952 : :
953 : : unsigned
954 : 155332460 : bytes_in::u ()
955 : : {
956 : 155332460 : unsigned v = 0;
957 : :
958 : 155332460 : if (const char *ptr = read (1))
959 : : {
960 : 155332460 : v = *ptr & 0xff;
961 : 155332460 : if (v & 0x80)
962 : : {
963 : 38457510 : unsigned bytes = (v >> 4) & 0x7;
964 : 38457510 : v &= 0xf;
965 : 38457510 : if ((ptr = read (++bytes)))
966 : 128957274 : while (bytes--)
967 : 90499764 : v = (v << 8) | (*ptr++ & 0xff);
968 : : }
969 : : }
970 : :
971 : 155332460 : return v;
972 : : }
973 : :
974 : : void
975 : 3047777 : bytes_out::wi (HOST_WIDE_INT v)
976 : : {
977 : 3047777 : if (char *ptr = write (1))
978 : : {
979 : 3047777 : if (v <= 0x3f && v >= -0x40)
980 : 2785597 : *ptr = v & 0x7f;
981 : : else
982 : : {
983 : 262180 : unsigned bytes = 0;
984 : 262180 : HOST_WIDE_INT probe;
985 : 262180 : if (v >= 0)
986 : 346245 : for (probe = v >> 8; probe > 0x7; probe >>= 8)
987 : 87016 : bytes++;
988 : : else
989 : 9564 : for (probe = v >> 8; probe < -0x8; probe >>= 8)
990 : 6613 : bytes++;
991 : 262180 : *ptr = 0x80 | bytes << 4 | (probe & 0xf);
992 : 262180 : if ((ptr = write (++bytes)))
993 : 617989 : for (; bytes--; v >>= 8)
994 : 355809 : ptr[bytes] = v & 0xff;
995 : : }
996 : : }
997 : 3047777 : }
998 : :
999 : : HOST_WIDE_INT
1000 : 3070340 : bytes_in::wi ()
1001 : : {
1002 : 3070340 : HOST_WIDE_INT v = 0;
1003 : 3070340 : if (const char *ptr = read (1))
1004 : : {
1005 : 3070340 : v = *ptr & 0xff;
1006 : 3070340 : if (v & 0x80)
1007 : : {
1008 : 278184 : unsigned bytes = (v >> 4) & 0x7;
1009 : 278184 : v &= 0xf;
1010 : 278184 : if (v & 0x8)
1011 : 3330 : v |= -1 ^ 0x7;
1012 : : /* unsigned necessary due to left shifts of -ve values. */
1013 : 278184 : unsigned HOST_WIDE_INT uv = (unsigned HOST_WIDE_INT) v;
1014 : 278184 : if ((ptr = read (++bytes)))
1015 : 652056 : while (bytes--)
1016 : 373872 : uv = (uv << 8) | (*ptr++ & 0xff);
1017 : 278184 : v = (HOST_WIDE_INT) uv;
1018 : : }
1019 : 2792156 : else if (v & 0x40)
1020 : 14622 : v |= -1 ^ 0x3f;
1021 : : }
1022 : :
1023 : 3070340 : return v;
1024 : : }
1025 : :
1026 : : /* unsigned wide ints are just written as signed wide ints. */
1027 : :
1028 : : inline void
1029 : 3046701 : bytes_out::wu (unsigned HOST_WIDE_INT v)
1030 : : {
1031 : 3046701 : wi ((HOST_WIDE_INT) v);
1032 : : }
1033 : :
1034 : : inline unsigned HOST_WIDE_INT
1035 : 3069144 : bytes_in::wu ()
1036 : : {
1037 : 5350087 : return (unsigned HOST_WIDE_INT) wi ();
1038 : : }
1039 : :
1040 : : /* size_t written as unsigned or unsigned wide int. */
1041 : :
1042 : : inline void
1043 : 2308897 : bytes_out::z (size_t s)
1044 : : {
1045 : 2308897 : if (sizeof (s) == sizeof (unsigned))
1046 : : u (s);
1047 : : else
1048 : 4563567 : wu (s);
1049 : : }
1050 : :
1051 : : inline size_t
1052 : 2280913 : bytes_in::z ()
1053 : : {
1054 : 2280913 : if (sizeof (size_t) == sizeof (unsigned))
1055 : : return u ();
1056 : : else
1057 : 4561826 : return wu ();
1058 : : }
1059 : :
1060 : : /* Buffer simply memcpied. */
1061 : : void *
1062 : 2351011 : bytes_out::buf (size_t len)
1063 : : {
1064 : 2351011 : align (sizeof (void *) * 2);
1065 : 2351011 : return write (len);
1066 : : }
1067 : :
1068 : : void
1069 : 2280787 : bytes_out::buf (const void *src, size_t len)
1070 : : {
1071 : 2280787 : if (void *ptr = buf (len))
1072 : 2280787 : memcpy (ptr, src, len);
1073 : 2280787 : }
1074 : :
1075 : : const void *
1076 : 2316369 : bytes_in::buf (size_t len)
1077 : : {
1078 : 2316369 : align (sizeof (void *) * 2);
1079 : 2316369 : const char *ptr = read (len);
1080 : :
1081 : 2316369 : return ptr;
1082 : : }
1083 : :
1084 : : /* strings as an size_t length, followed by the buffer. Make sure
1085 : : there's a NUL terminator on read. */
1086 : :
1087 : : void
1088 : 2308897 : bytes_out::str (const char *string, size_t len)
1089 : : {
1090 : 2254670 : z (len);
1091 : 2254670 : if (len)
1092 : : {
1093 : 2254670 : gcc_checking_assert (!string[len]);
1094 : 2254670 : buf (string, len + 1);
1095 : : }
1096 : 54227 : }
1097 : :
1098 : : const char *
1099 : 2280913 : bytes_in::str (size_t *len_p)
1100 : : {
1101 : 2280913 : size_t len = z ();
1102 : :
1103 : : /* We're about to trust some user data. */
1104 : 2280913 : if (overrun)
1105 : 0 : len = 0;
1106 : 2280913 : if (len_p)
1107 : 2277991 : *len_p = len;
1108 : 2280913 : const char *str = NULL;
1109 : 2280913 : if (len)
1110 : : {
1111 : 2280765 : str = reinterpret_cast<const char *> (buf (len + 1));
1112 : 2280765 : if (!str || str[len])
1113 : : {
1114 : 0 : set_overrun ();
1115 : 0 : str = NULL;
1116 : : }
1117 : : }
1118 : 0 : return str ? str : "";
1119 : : }
1120 : :
1121 : : cpp_hashnode *
1122 : 330823 : bytes_in::cpp_node ()
1123 : : {
1124 : 330823 : size_t len;
1125 : 330823 : const char *s = str (&len);
1126 : 330823 : if (!len)
1127 : : return NULL;
1128 : 330675 : return ::cpp_node (get_identifier_with_length (s, len));
1129 : : }
1130 : :
1131 : : /* Format a string directly to the buffer, including a terminating
1132 : : NUL. Intended for human consumption. */
1133 : :
1134 : : void
1135 : 20872 : bytes_out::printf (const char *format, ...)
1136 : : {
1137 : 20872 : va_list args;
1138 : : /* Exercise buffer expansion. */
1139 : 20872 : size_t len = EXPERIMENT (10, 500);
1140 : :
1141 : 41586 : while (char *ptr = write (len))
1142 : : {
1143 : 41586 : va_start (args, format);
1144 : 41586 : size_t actual = vsnprintf (ptr, len, format, args) + 1;
1145 : 41586 : va_end (args);
1146 : 41586 : if (actual <= len)
1147 : : {
1148 : 20872 : unuse (len - actual);
1149 : 20872 : break;
1150 : : }
1151 : 20714 : unuse (len);
1152 : 20714 : len = actual;
1153 : 20714 : }
1154 : 20872 : }
1155 : :
1156 : : void
1157 : 4076 : bytes_out::print_time (const char *kind, const tm *time, const char *tz)
1158 : : {
1159 : 4076 : printf ("%stime: %4u/%02u/%02u %02u:%02u:%02u %s",
1160 : 4076 : kind, time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
1161 : 4076 : time->tm_hour, time->tm_min, time->tm_sec, tz);
1162 : 4076 : }
1163 : :
1164 : : /* Encapsulated Lazy Records Of Named Declarations.
1165 : : Header: Stunningly Elf32_Ehdr-like
1166 : : Sections: Sectional data
1167 : : [1-N) : User data sections
1168 : : N .strtab : strings, stunningly ELF STRTAB-like
1169 : : Index: Section table, stunningly ELF32_Shdr-like. */
1170 : :
1171 : : class elf {
1172 : : protected:
1173 : : /* Constants used within the format. */
1174 : : enum private_constants {
1175 : : /* File kind. */
1176 : : ET_NONE = 0,
1177 : : EM_NONE = 0,
1178 : : OSABI_NONE = 0,
1179 : :
1180 : : /* File format. */
1181 : : EV_CURRENT = 1,
1182 : : CLASS32 = 1,
1183 : : DATA2LSB = 1,
1184 : : DATA2MSB = 2,
1185 : :
1186 : : /* Section numbering. */
1187 : : SHN_UNDEF = 0,
1188 : : SHN_LORESERVE = 0xff00,
1189 : : SHN_XINDEX = 0xffff,
1190 : :
1191 : : /* Section types. */
1192 : : SHT_NONE = 0, /* No contents. */
1193 : : SHT_PROGBITS = 1, /* Random bytes. */
1194 : : SHT_STRTAB = 3, /* A string table. */
1195 : :
1196 : : /* Section flags. */
1197 : : SHF_NONE = 0x00, /* Nothing. */
1198 : : SHF_STRINGS = 0x20, /* NUL-Terminated strings. */
1199 : :
1200 : : /* I really hope we do not get CMI files larger than 4GB. */
1201 : : MY_CLASS = CLASS32,
1202 : : /* It is host endianness that is relevant. */
1203 : : MY_ENDIAN = DATA2LSB
1204 : : #ifdef WORDS_BIGENDIAN
1205 : : ^ DATA2LSB ^ DATA2MSB
1206 : : #endif
1207 : : };
1208 : :
1209 : : public:
1210 : : /* Constants visible to users. */
1211 : : enum public_constants {
1212 : : /* Special error codes. Breaking layering a bit. */
1213 : : E_BAD_DATA = -1, /* Random unexpected data errors. */
1214 : : E_BAD_LAZY = -2, /* Badly ordered laziness. */
1215 : : E_BAD_IMPORT = -3 /* A nested import failed. */
1216 : : };
1217 : :
1218 : : protected:
1219 : : /* File identification. On-disk representation. */
1220 : : struct ident {
1221 : : uint8_t magic[4]; /* 0x7f, 'E', 'L', 'F' */
1222 : : uint8_t klass; /* 4:CLASS32 */
1223 : : uint8_t data; /* 5:DATA2[LM]SB */
1224 : : uint8_t version; /* 6:EV_CURRENT */
1225 : : uint8_t osabi; /* 7:OSABI_NONE */
1226 : : uint8_t abiver; /* 8: 0 */
1227 : : uint8_t pad[7]; /* 9-15 */
1228 : : };
1229 : : /* File header. On-disk representation. */
1230 : : struct header {
1231 : : struct ident ident;
1232 : : uint16_t type; /* ET_NONE */
1233 : : uint16_t machine; /* EM_NONE */
1234 : : uint32_t version; /* EV_CURRENT */
1235 : : uint32_t entry; /* 0 */
1236 : : uint32_t phoff; /* 0 */
1237 : : uint32_t shoff; /* Section Header Offset in file */
1238 : : uint32_t flags;
1239 : : uint16_t ehsize; /* ELROND Header SIZE -- sizeof (header) */
1240 : : uint16_t phentsize; /* 0 */
1241 : : uint16_t phnum; /* 0 */
1242 : : uint16_t shentsize; /* Section Header SIZE -- sizeof (section) */
1243 : : uint16_t shnum; /* Section Header NUM */
1244 : : uint16_t shstrndx; /* Section Header STRing iNDeX */
1245 : : };
1246 : : /* File section. On-disk representation. */
1247 : : struct section {
1248 : : uint32_t name; /* String table offset. */
1249 : : uint32_t type; /* SHT_* */
1250 : : uint32_t flags; /* SHF_* */
1251 : : uint32_t addr; /* 0 */
1252 : : uint32_t offset; /* OFFSET in file */
1253 : : uint32_t size; /* SIZE of section */
1254 : : uint32_t link; /* 0 */
1255 : : uint32_t info; /* 0 */
1256 : : uint32_t addralign; /* 0 */
1257 : : uint32_t entsize; /* ENTry SIZE, usually 0 */
1258 : : };
1259 : :
1260 : : protected:
1261 : : data hdr; /* The header. */
1262 : : data sectab; /* The section table. */
1263 : : data strtab; /* String table. */
1264 : : int fd; /* File descriptor we're reading or writing. */
1265 : : int err; /* Sticky error code. */
1266 : :
1267 : : public:
1268 : : /* Construct from STREAM. E is errno if STREAM NULL. */
1269 : 4411 : elf (int fd, int e)
1270 : 8822 : :hdr (), sectab (), strtab (), fd (fd), err (fd >= 0 ? 0 : e)
1271 : : {}
1272 : 4350 : ~elf ()
1273 : : {
1274 : 4350 : gcc_checking_assert (fd < 0 && !hdr.buffer
1275 : : && !sectab.buffer && !strtab.buffer);
1276 : 4350 : }
1277 : :
1278 : : public:
1279 : : /* Return the error, if we have an error. */
1280 : 741059 : int get_error () const
1281 : : {
1282 : 741059 : return err;
1283 : : }
1284 : : /* Set the error, unless it's already been set. */
1285 : 20 : void set_error (int e = E_BAD_DATA)
1286 : : {
1287 : 20 : if (!err)
1288 : 13 : err = e;
1289 : 0 : }
1290 : : /* Get an error string. */
1291 : : const char *get_error (const char *) const;
1292 : :
1293 : : public:
1294 : : /* Begin reading/writing file. Return false on error. */
1295 : 4311 : bool begin () const
1296 : : {
1297 : 4311 : return !get_error ();
1298 : : }
1299 : : /* Finish reading/writing file. Return false on error. */
1300 : : bool end ();
1301 : : };
1302 : :
1303 : : /* Return error string. */
1304 : :
1305 : : const char *
1306 : 31 : elf::get_error (const char *name) const
1307 : : {
1308 : 31 : if (!name)
1309 : : return "Unknown CMI mapping";
1310 : :
1311 : 31 : switch (err)
1312 : : {
1313 : 0 : case 0:
1314 : 0 : gcc_unreachable ();
1315 : : case E_BAD_DATA:
1316 : : return "Bad file data";
1317 : 6 : case E_BAD_IMPORT:
1318 : 6 : return "Bad import dependency";
1319 : 0 : case E_BAD_LAZY:
1320 : 0 : return "Bad lazy ordering";
1321 : 18 : default:
1322 : 18 : return xstrerror (err);
1323 : : }
1324 : : }
1325 : :
1326 : : /* Finish file, return true if there's an error. */
1327 : :
1328 : : bool
1329 : 6211 : elf::end ()
1330 : : {
1331 : : /* Close the stream and free the section table. */
1332 : 6211 : if (fd >= 0 && close (fd))
1333 : 0 : set_error (errno);
1334 : 6211 : fd = -1;
1335 : :
1336 : 6211 : return !get_error ();
1337 : : }
1338 : :
1339 : : /* ELROND reader. */
1340 : :
1341 : : class elf_in : public elf {
1342 : : typedef elf parent;
1343 : :
1344 : : private:
1345 : : /* For freezing & defrosting. */
1346 : : #if !defined (HOST_LACKS_INODE_NUMBERS)
1347 : : dev_t device;
1348 : : ino_t inode;
1349 : : #endif
1350 : :
1351 : : public:
1352 : 2285 : elf_in (int fd, int e)
1353 : 4570 : :parent (fd, e)
1354 : : {
1355 : : }
1356 : 2224 : ~elf_in ()
1357 : : {
1358 : 2224 : }
1359 : :
1360 : : public:
1361 : 360634 : bool is_frozen () const
1362 : : {
1363 : 18 : return fd < 0 && hdr.pos;
1364 : : }
1365 : 18 : bool is_freezable () const
1366 : : {
1367 : 9 : return fd >= 0 && hdr.pos;
1368 : : }
1369 : : void freeze ();
1370 : : bool defrost (const char *);
1371 : :
1372 : : /* If BYTES is in the mmapped area, allocate a new buffer for it. */
1373 : 0 : void preserve (bytes_in &bytes ATTRIBUTE_UNUSED)
1374 : : {
1375 : : #if MAPPED_READING
1376 : 0 : if (hdr.buffer && bytes.buffer >= hdr.buffer
1377 : 0 : && bytes.buffer < hdr.buffer + hdr.pos)
1378 : : {
1379 : 0 : char *buf = bytes.buffer;
1380 : 0 : bytes.buffer = data::simple_memory.grow (NULL, bytes.size);
1381 : 0 : memcpy (bytes.buffer, buf, bytes.size);
1382 : : }
1383 : : #endif
1384 : 0 : }
1385 : : /* If BYTES is not in SELF's mmapped area, free it. SELF might be
1386 : : NULL. */
1387 : 927 : static void release (elf_in *self ATTRIBUTE_UNUSED, bytes_in &bytes)
1388 : : {
1389 : : #if MAPPED_READING
1390 : 927 : if (!(self && self->hdr.buffer && bytes.buffer >= self->hdr.buffer
1391 : 927 : && bytes.buffer < self->hdr.buffer + self->hdr.pos))
1392 : : #endif
1393 : 0 : data::simple_memory.shrink (bytes.buffer);
1394 : 927 : bytes.buffer = NULL;
1395 : 927 : bytes.size = 0;
1396 : 927 : }
1397 : :
1398 : : public:
1399 : 376224 : static void grow (data &data, unsigned needed)
1400 : : {
1401 : 376224 : gcc_checking_assert (!data.buffer);
1402 : : #if !MAPPED_READING
1403 : : data.buffer = XNEWVEC (char, needed);
1404 : : #endif
1405 : 376224 : data.size = needed;
1406 : 376224 : }
1407 : 381151 : static void shrink (data &data)
1408 : : {
1409 : : #if !MAPPED_READING
1410 : : XDELETEVEC (data.buffer);
1411 : : #endif
1412 : 381151 : data.buffer = NULL;
1413 : 381151 : data.size = 0;
1414 : 0 : }
1415 : :
1416 : : public:
1417 : 373957 : const section *get_section (unsigned s) const
1418 : : {
1419 : 373957 : if (s * sizeof (section) < sectab.size)
1420 : 373957 : return reinterpret_cast<const section *>
1421 : 373957 : (§ab.buffer[s * sizeof (section)]);
1422 : : else
1423 : : return NULL;
1424 : : }
1425 : : unsigned get_section_limit () const
1426 : : {
1427 : : return sectab.size / sizeof (section);
1428 : : }
1429 : :
1430 : : protected:
1431 : : const char *read (data *, unsigned, unsigned);
1432 : :
1433 : : public:
1434 : : /* Read section by number. */
1435 : 373957 : bool read (data *d, const section *s)
1436 : : {
1437 : 373957 : return s && read (d, s->offset, s->size);
1438 : : }
1439 : :
1440 : : /* Find section by name. */
1441 : : unsigned find (const char *name);
1442 : : /* Find section by index. */
1443 : : const section *find (unsigned snum, unsigned type = SHT_PROGBITS);
1444 : :
1445 : : public:
1446 : : /* Release the string table, when we're done with it. */
1447 : 6333 : void release ()
1448 : : {
1449 : 6333 : shrink (strtab);
1450 : 30 : }
1451 : :
1452 : : public:
1453 : : bool begin (location_t);
1454 : 4085 : bool end ()
1455 : : {
1456 : 4085 : release ();
1457 : : #if MAPPED_READING
1458 : 4085 : if (hdr.buffer)
1459 : 2224 : munmap (hdr.buffer, hdr.pos);
1460 : 4085 : hdr.buffer = NULL;
1461 : : #endif
1462 : 4085 : shrink (sectab);
1463 : :
1464 : 4085 : return parent::end ();
1465 : : }
1466 : :
1467 : : public:
1468 : : /* Return string name at OFFSET. Checks OFFSET range. Always
1469 : : returns non-NULL. We know offset 0 is an empty string. */
1470 : 356240 : const char *name (unsigned offset)
1471 : : {
1472 : 712480 : return &strtab.buffer[offset < strtab.size ? offset : 0];
1473 : : }
1474 : : };
1475 : :
1476 : : /* ELROND writer. */
1477 : :
1478 : : class elf_out : public elf, public data::allocator {
1479 : : typedef elf parent;
1480 : : /* Desired section alignment on disk. */
1481 : : static const int SECTION_ALIGN = 16;
1482 : :
1483 : : private:
1484 : : ptr_int_hash_map identtab; /* Map of IDENTIFIERS to strtab offsets. */
1485 : : unsigned pos; /* Write position in file. */
1486 : : #if MAPPED_WRITING
1487 : : unsigned offset; /* Offset of the mapping. */
1488 : : unsigned extent; /* Length of mapping. */
1489 : : unsigned page_size; /* System page size. */
1490 : : #endif
1491 : :
1492 : : public:
1493 : 2126 : elf_out (int fd, int e)
1494 : 4176 : :parent (fd, e), identtab (500), pos (0)
1495 : : {
1496 : : #if MAPPED_WRITING
1497 : 2126 : offset = extent = 0;
1498 : 2126 : page_size = sysconf (_SC_PAGE_SIZE);
1499 : 2126 : if (page_size < SECTION_ALIGN)
1500 : : /* Something really strange. */
1501 : 0 : set_error (EINVAL);
1502 : : #endif
1503 : 2126 : }
1504 : 2126 : ~elf_out ()
1505 : 2126 : {
1506 : 2126 : data::simple_memory.shrink (hdr);
1507 : 2126 : data::simple_memory.shrink (sectab);
1508 : 2126 : data::simple_memory.shrink (strtab);
1509 : 2126 : }
1510 : :
1511 : : #if MAPPED_WRITING
1512 : : private:
1513 : : void create_mapping (unsigned ext, bool extending = true);
1514 : : void remove_mapping ();
1515 : : #endif
1516 : :
1517 : : protected:
1518 : : using allocator::grow;
1519 : : char *grow (char *, unsigned needed) final override;
1520 : : #if MAPPED_WRITING
1521 : : using allocator::shrink;
1522 : : void shrink (char *) final override;
1523 : : #endif
1524 : :
1525 : : public:
1526 : 4308 : unsigned get_section_limit () const
1527 : : {
1528 : 4308 : return sectab.pos / sizeof (section);
1529 : : }
1530 : :
1531 : : protected:
1532 : : unsigned add (unsigned type, unsigned name = 0,
1533 : : unsigned off = 0, unsigned size = 0, unsigned flags = SHF_NONE);
1534 : : unsigned write (const data &);
1535 : : #if MAPPED_WRITING
1536 : : unsigned write (const bytes_out &);
1537 : : #endif
1538 : :
1539 : : public:
1540 : : /* IDENTIFIER to strtab offset. */
1541 : : unsigned name (tree ident);
1542 : : /* String literal to strtab offset. */
1543 : : unsigned name (const char *n);
1544 : : /* Qualified name of DECL to strtab offset. */
1545 : : unsigned qualified_name (tree decl, bool is_defn);
1546 : :
1547 : : private:
1548 : : unsigned strtab_write (const char *s, unsigned l);
1549 : : void strtab_write (tree decl, int);
1550 : :
1551 : : public:
1552 : : /* Add a section with contents or strings. */
1553 : : unsigned add (const bytes_out &, bool string_p, unsigned name);
1554 : :
1555 : : public:
1556 : : /* Begin and end writing. */
1557 : : bool begin ();
1558 : : bool end ();
1559 : : };
1560 : :
1561 : : /* Begin reading section NAME (of type PROGBITS) from SOURCE.
1562 : : Data always checked for CRC. */
1563 : :
1564 : : bool
1565 : 13315 : bytes_in::begin (location_t loc, elf_in *source, const char *name)
1566 : : {
1567 : 13315 : unsigned snum = source->find (name);
1568 : :
1569 : 13315 : return begin (loc, source, snum, name);
1570 : : }
1571 : :
1572 : : /* Begin reading section numbered SNUM with NAME (may be NULL). */
1573 : :
1574 : : bool
1575 : 371690 : bytes_in::begin (location_t loc, elf_in *source, unsigned snum, const char *name)
1576 : : {
1577 : 371690 : if (!source->read (this, source->find (snum))
1578 : 371690 : || !size || !check_crc ())
1579 : : {
1580 : 0 : source->set_error (elf::E_BAD_DATA);
1581 : 0 : source->shrink (*this);
1582 : 0 : if (name)
1583 : 0 : error_at (loc, "section %qs is missing or corrupted", name);
1584 : : else
1585 : 0 : error_at (loc, "section #%u is missing or corrupted", snum);
1586 : 0 : return false;
1587 : : }
1588 : 371690 : pos = 4;
1589 : 371690 : return true;
1590 : : }
1591 : :
1592 : : /* Finish reading a section. */
1593 : :
1594 : : bool
1595 : 370733 : bytes_in::end (elf_in *src)
1596 : : {
1597 : 370733 : if (more_p ())
1598 : 7 : set_overrun ();
1599 : 370733 : if (overrun)
1600 : 7 : src->set_error ();
1601 : :
1602 : 370733 : src->shrink (*this);
1603 : :
1604 : 370733 : return !overrun;
1605 : : }
1606 : :
1607 : : /* Begin writing buffer. */
1608 : :
1609 : : void
1610 : 360898 : bytes_out::begin (bool need_crc)
1611 : : {
1612 : 0 : if (need_crc)
1613 : 0 : pos = 4;
1614 : 0 : memory->grow (*this, 0, false);
1615 : 347120 : }
1616 : :
1617 : : /* Finish writing buffer. Stream out to SINK as named section NAME.
1618 : : Return section number or 0 on failure. If CRC_PTR is true, crc
1619 : : the data. Otherwise it is a string section. */
1620 : :
1621 : : unsigned
1622 : 360898 : bytes_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
1623 : : {
1624 : 360898 : lengths[3] += pos;
1625 : 360898 : spans[3]++;
1626 : :
1627 : 360898 : set_crc (crc_ptr);
1628 : 360898 : unsigned sec_num = sink->add (*this, !crc_ptr, name);
1629 : 360898 : memory->shrink (*this);
1630 : :
1631 : 360898 : return sec_num;
1632 : : }
1633 : :
1634 : : /* Close and open the file, without destroying it. */
1635 : :
1636 : : void
1637 : 9 : elf_in::freeze ()
1638 : : {
1639 : 9 : gcc_checking_assert (!is_frozen ());
1640 : : #if MAPPED_READING
1641 : 9 : if (munmap (hdr.buffer, hdr.pos) < 0)
1642 : 0 : set_error (errno);
1643 : : #endif
1644 : 9 : if (close (fd) < 0)
1645 : 0 : set_error (errno);
1646 : 9 : fd = -1;
1647 : 9 : }
1648 : :
1649 : : bool
1650 : 9 : elf_in::defrost (const char *name)
1651 : : {
1652 : 9 : gcc_checking_assert (is_frozen ());
1653 : 9 : struct stat stat;
1654 : :
1655 : 9 : fd = open (name, O_RDONLY | O_CLOEXEC | O_BINARY);
1656 : 9 : if (fd < 0 || fstat (fd, &stat) < 0)
1657 : 0 : set_error (errno);
1658 : : else
1659 : : {
1660 : 9 : bool ok = hdr.pos == unsigned (stat.st_size);
1661 : : #ifndef HOST_LACKS_INODE_NUMBERS
1662 : 9 : if (device != stat.st_dev
1663 : 9 : || inode != stat.st_ino)
1664 : : ok = false;
1665 : : #endif
1666 : 9 : if (!ok)
1667 : 0 : set_error (EMFILE);
1668 : : #if MAPPED_READING
1669 : 0 : if (ok)
1670 : : {
1671 : 9 : char *mapping = reinterpret_cast<char *>
1672 : 9 : (mmap (NULL, hdr.pos, PROT_READ, MAP_SHARED, fd, 0));
1673 : 9 : if (mapping == MAP_FAILED)
1674 : 0 : fail:
1675 : 0 : set_error (errno);
1676 : : else
1677 : : {
1678 : 9 : if (madvise (mapping, hdr.pos, MADV_RANDOM))
1679 : 0 : goto fail;
1680 : :
1681 : : /* These buffers are never NULL in this case. */
1682 : 9 : strtab.buffer = mapping + strtab.pos;
1683 : 9 : sectab.buffer = mapping + sectab.pos;
1684 : 9 : hdr.buffer = mapping;
1685 : : }
1686 : : }
1687 : : #endif
1688 : : }
1689 : :
1690 : 9 : return !get_error ();
1691 : : }
1692 : :
1693 : : /* Read at current position into BUFFER. Return true on success. */
1694 : :
1695 : : const char *
1696 : 376224 : elf_in::read (data *data, unsigned pos, unsigned length)
1697 : : {
1698 : : #if MAPPED_READING
1699 : 376224 : if (pos + length > hdr.pos)
1700 : : {
1701 : 0 : set_error (EINVAL);
1702 : 0 : return NULL;
1703 : : }
1704 : : #else
1705 : : if (pos != ~0u && lseek (fd, pos, SEEK_SET) < 0)
1706 : : {
1707 : : set_error (errno);
1708 : : return NULL;
1709 : : }
1710 : : #endif
1711 : 376224 : grow (*data, length);
1712 : : #if MAPPED_READING
1713 : 376224 : data->buffer = hdr.buffer + pos;
1714 : : #else
1715 : : if (::read (fd, data->buffer, data->size) != ssize_t (length))
1716 : : {
1717 : : set_error (errno);
1718 : : shrink (*data);
1719 : : return NULL;
1720 : : }
1721 : : #endif
1722 : :
1723 : 376224 : return data->buffer;
1724 : : }
1725 : :
1726 : : /* Read section SNUM of TYPE. Return section pointer or NULL on error. */
1727 : :
1728 : : const elf::section *
1729 : 373957 : elf_in::find (unsigned snum, unsigned type)
1730 : : {
1731 : 373957 : const section *sec = get_section (snum);
1732 : 373957 : if (!snum || !sec || sec->type != type)
1733 : 0 : return NULL;
1734 : : return sec;
1735 : : }
1736 : :
1737 : : /* Find a section NAME and TYPE. Return section number, or zero on
1738 : : failure. */
1739 : :
1740 : : unsigned
1741 : 13341 : elf_in::find (const char *sname)
1742 : : {
1743 : 78107 : for (unsigned pos = sectab.size; pos -= sizeof (section); )
1744 : : {
1745 : 78107 : const section *sec
1746 : 78107 : = reinterpret_cast<const section *> (§ab.buffer[pos]);
1747 : :
1748 : 156214 : if (0 == strcmp (sname, name (sec->name)))
1749 : 13341 : return pos / sizeof (section);
1750 : : }
1751 : :
1752 : : return 0;
1753 : : }
1754 : :
1755 : : /* Begin reading file. Verify header. Pull in section and string
1756 : : tables. Return true on success. */
1757 : :
1758 : : bool
1759 : 2267 : elf_in::begin (location_t loc)
1760 : : {
1761 : 2267 : if (!parent::begin ())
1762 : : return false;
1763 : :
1764 : 2267 : struct stat stat;
1765 : 2267 : unsigned size = 0;
1766 : 2267 : if (!fstat (fd, &stat))
1767 : : {
1768 : : #if !defined (HOST_LACKS_INODE_NUMBERS)
1769 : 2267 : device = stat.st_dev;
1770 : 2267 : inode = stat.st_ino;
1771 : : #endif
1772 : : /* Never generate files > 4GB, check we've not been given one. */
1773 : 2267 : if (stat.st_size == unsigned (stat.st_size))
1774 : 2267 : size = unsigned (stat.st_size);
1775 : : }
1776 : :
1777 : : #if MAPPED_READING
1778 : : /* MAP_SHARED so that the file is backing store. If someone else
1779 : : concurrently writes it, they're wrong. */
1780 : 2267 : void *mapping = mmap (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
1781 : 2267 : if (mapping == MAP_FAILED)
1782 : : {
1783 : 0 : fail:
1784 : 0 : set_error (errno);
1785 : 0 : return false;
1786 : : }
1787 : : /* We'll be hopping over this randomly. Some systems declare the
1788 : : first parm as char *, and other declare it as void *. */
1789 : 2267 : if (madvise (reinterpret_cast <char *> (mapping), size, MADV_RANDOM))
1790 : 0 : goto fail;
1791 : :
1792 : 2267 : hdr.buffer = (char *)mapping;
1793 : : #else
1794 : : read (&hdr, 0, sizeof (header));
1795 : : #endif
1796 : 2267 : hdr.pos = size; /* Record size of the file. */
1797 : :
1798 : 2267 : const header *h = reinterpret_cast<const header *> (hdr.buffer);
1799 : 2267 : if (!h)
1800 : : return false;
1801 : :
1802 : 2267 : if (h->ident.magic[0] != 0x7f
1803 : : || h->ident.magic[1] != 'E'
1804 : : || h->ident.magic[2] != 'L'
1805 : 2267 : || h->ident.magic[3] != 'F')
1806 : : {
1807 : 0 : error_at (loc, "not Encapsulated Lazy Records of Named Declarations");
1808 : 0 : failed:
1809 : 0 : shrink (hdr);
1810 : 0 : return false;
1811 : : }
1812 : :
1813 : : /* We expect a particular format -- the ELF is not intended to be
1814 : : distributable. */
1815 : 2267 : if (h->ident.klass != MY_CLASS
1816 : : || h->ident.data != MY_ENDIAN
1817 : 2267 : || h->ident.version != EV_CURRENT
1818 : : || h->type != ET_NONE
1819 : 2267 : || h->machine != EM_NONE
1820 : 2267 : || h->ident.osabi != OSABI_NONE)
1821 : : {
1822 : 0 : error_at (loc, "unexpected encapsulation format or type");
1823 : 0 : goto failed;
1824 : : }
1825 : :
1826 : 2267 : int e = -1;
1827 : 2267 : if (!h->shoff || h->shentsize != sizeof (section))
1828 : : {
1829 : 0 : malformed:
1830 : 0 : set_error (e);
1831 : 0 : error_at (loc, "encapsulation is malformed");
1832 : 0 : goto failed;
1833 : : }
1834 : :
1835 : 2267 : unsigned strndx = h->shstrndx;
1836 : 2267 : unsigned shnum = h->shnum;
1837 : 2267 : if (shnum == SHN_XINDEX)
1838 : : {
1839 : 0 : if (!read (§ab, h->shoff, sizeof (section)))
1840 : : {
1841 : 0 : section_table_fail:
1842 : 0 : e = errno;
1843 : 0 : goto malformed;
1844 : : }
1845 : 0 : shnum = get_section (0)->size;
1846 : : /* Freeing does mean we'll re-read it in the case we're not
1847 : : mapping, but this is going to be rare. */
1848 : 0 : shrink (sectab);
1849 : : }
1850 : :
1851 : 2267 : if (!shnum)
1852 : 0 : goto malformed;
1853 : :
1854 : 2267 : if (!read (§ab, h->shoff, shnum * sizeof (section)))
1855 : 0 : goto section_table_fail;
1856 : :
1857 : 2267 : if (strndx == SHN_XINDEX)
1858 : 0 : strndx = get_section (0)->link;
1859 : :
1860 : 2267 : if (!read (&strtab, find (strndx, SHT_STRTAB)))
1861 : 0 : goto malformed;
1862 : :
1863 : : /* The string table should be at least one byte, with NUL chars
1864 : : at either end. */
1865 : 2267 : if (!(strtab.size && !strtab.buffer[0]
1866 : 2267 : && !strtab.buffer[strtab.size - 1]))
1867 : 0 : goto malformed;
1868 : :
1869 : : #if MAPPED_READING
1870 : : /* Record the offsets of the section and string tables. */
1871 : 2267 : sectab.pos = h->shoff;
1872 : 2267 : strtab.pos = shnum * sizeof (section);
1873 : : #else
1874 : : shrink (hdr);
1875 : : #endif
1876 : :
1877 : 2267 : return true;
1878 : : }
1879 : :
1880 : : /* Create a new mapping. */
1881 : :
1882 : : #if MAPPED_WRITING
1883 : : void
1884 : 2925 : elf_out::create_mapping (unsigned ext, bool extending)
1885 : : {
1886 : : #ifndef HAVE_POSIX_FALLOCATE
1887 : : #define posix_fallocate(fd,off,len) ftruncate (fd, off + len)
1888 : : #endif
1889 : 2925 : void *mapping = MAP_FAILED;
1890 : 2925 : if (extending && ext < 1024 * 1024)
1891 : : {
1892 : 2612 : if (!posix_fallocate (fd, offset, ext * 2))
1893 : 2612 : mapping = mmap (NULL, ext * 2, PROT_READ | PROT_WRITE,
1894 : 2612 : MAP_SHARED, fd, offset);
1895 : 2612 : if (mapping != MAP_FAILED)
1896 : : ext *= 2;
1897 : : }
1898 : 2612 : if (mapping == MAP_FAILED)
1899 : : {
1900 : 313 : if (!extending || !posix_fallocate (fd, offset, ext))
1901 : 313 : mapping = mmap (NULL, ext, PROT_READ | PROT_WRITE,
1902 : 313 : MAP_SHARED, fd, offset);
1903 : 313 : if (mapping == MAP_FAILED)
1904 : : {
1905 : 0 : set_error (errno);
1906 : : mapping = NULL;
1907 : : ext = 0;
1908 : : }
1909 : : }
1910 : : #undef posix_fallocate
1911 : 2925 : hdr.buffer = (char *)mapping;
1912 : 2925 : extent = ext;
1913 : 2925 : }
1914 : : #endif
1915 : :
1916 : : /* Flush out the current mapping. */
1917 : :
1918 : : #if MAPPED_WRITING
1919 : : void
1920 : 2931 : elf_out::remove_mapping ()
1921 : : {
1922 : 2931 : if (hdr.buffer)
1923 : : {
1924 : : /* MS_ASYNC dtrt with the removed mapping, including a
1925 : : subsequent overlapping remap. */
1926 : 2925 : if (msync (hdr.buffer, extent, MS_ASYNC)
1927 : 2925 : || munmap (hdr.buffer, extent))
1928 : : /* We're somewhat screwed at this point. */
1929 : 0 : set_error (errno);
1930 : : }
1931 : :
1932 : 2931 : hdr.buffer = NULL;
1933 : 2931 : }
1934 : : #endif
1935 : :
1936 : : /* Grow a mapping of PTR to be NEEDED bytes long. This gets
1937 : : interesting if the new size grows the EXTENT. */
1938 : :
1939 : : char *
1940 : 858326 : elf_out::grow (char *data, unsigned needed)
1941 : : {
1942 : 858326 : if (!data)
1943 : : {
1944 : : /* First allocation, check we're aligned. */
1945 : 364998 : gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)));
1946 : : #if MAPPED_WRITING
1947 : 364998 : data = hdr.buffer + (pos - offset);
1948 : : #endif
1949 : : }
1950 : :
1951 : : #if MAPPED_WRITING
1952 : 858326 : unsigned off = data - hdr.buffer;
1953 : 858326 : if (off + needed > extent)
1954 : : {
1955 : : /* We need to grow the mapping. */
1956 : 759 : unsigned lwm = off & ~(page_size - 1);
1957 : 759 : unsigned hwm = (off + needed + page_size - 1) & ~(page_size - 1);
1958 : :
1959 : 759 : gcc_checking_assert (hwm > extent);
1960 : :
1961 : 759 : remove_mapping ();
1962 : :
1963 : 759 : offset += lwm;
1964 : 759 : create_mapping (extent < hwm - lwm ? hwm - lwm : extent);
1965 : :
1966 : 759 : data = hdr.buffer + (off - lwm);
1967 : : }
1968 : : #else
1969 : : data = allocator::grow (data, needed);
1970 : : #endif
1971 : :
1972 : 858326 : return data;
1973 : : }
1974 : :
1975 : : #if MAPPED_WRITING
1976 : : /* Shrinking is a NOP. */
1977 : : void
1978 : 364998 : elf_out::shrink (char *)
1979 : : {
1980 : 364998 : }
1981 : : #endif
1982 : :
1983 : : /* Write S of length L to the strtab buffer. L must include the ending
1984 : : NUL, if that's what you want. */
1985 : :
1986 : : unsigned
1987 : 1620121 : elf_out::strtab_write (const char *s, unsigned l)
1988 : : {
1989 : 1620121 : if (strtab.pos + l > strtab.size)
1990 : 1022 : data::simple_memory.grow (strtab, strtab.pos + l, false);
1991 : 1620121 : memcpy (strtab.buffer + strtab.pos, s, l);
1992 : 1620121 : unsigned res = strtab.pos;
1993 : 1620121 : strtab.pos += l;
1994 : 1620121 : return res;
1995 : : }
1996 : :
1997 : : /* Write qualified name of decl. INNER >0 if this is a definition, <0
1998 : : if this is a qualifier of an outer name. */
1999 : :
2000 : : void
2001 : 645269 : elf_out::strtab_write (tree decl, int inner)
2002 : : {
2003 : 645269 : tree ctx = CP_DECL_CONTEXT (decl);
2004 : 645269 : if (TYPE_P (ctx))
2005 : 6364 : ctx = TYPE_NAME (ctx);
2006 : 645269 : if (ctx != global_namespace)
2007 : 313304 : strtab_write (ctx, -1);
2008 : :
2009 : 645269 : tree name = DECL_NAME (decl);
2010 : 645269 : if (!name)
2011 : 0 : name = DECL_ASSEMBLER_NAME_RAW (decl);
2012 : 645269 : strtab_write (IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
2013 : :
2014 : 645269 : if (inner)
2015 : 445723 : strtab_write (&"::{}"[inner+1], 2);
2016 : 645269 : }
2017 : :
2018 : : /* Map IDENTIFIER IDENT to strtab offset. Inserts into strtab if not
2019 : : already there. */
2020 : :
2021 : : unsigned
2022 : 193118 : elf_out::name (tree ident)
2023 : : {
2024 : 193118 : unsigned res = 0;
2025 : 193118 : if (ident)
2026 : : {
2027 : 193118 : bool existed;
2028 : 193118 : int *slot = &identtab.get_or_insert (ident, &existed);
2029 : 193118 : if (!existed)
2030 : 346304 : *slot = strtab_write (IDENTIFIER_POINTER (ident),
2031 : 173152 : IDENTIFIER_LENGTH (ident) + 1);
2032 : 193118 : res = *slot;
2033 : : }
2034 : 193118 : return res;
2035 : : }
2036 : :
2037 : : /* Map LITERAL to strtab offset. Does not detect duplicates and
2038 : : expects LITERAL to remain live until strtab is written out. */
2039 : :
2040 : : unsigned
2041 : 24012 : elf_out::name (const char *literal)
2042 : : {
2043 : 24012 : return strtab_write (literal, strlen (literal) + 1);
2044 : : }
2045 : :
2046 : : /* Map a DECL's qualified name to strtab offset. Does not detect
2047 : : duplicates. */
2048 : :
2049 : : unsigned
2050 : 331965 : elf_out::qualified_name (tree decl, bool is_defn)
2051 : : {
2052 : 331965 : gcc_checking_assert (DECL_P (decl) && decl != global_namespace);
2053 : 331965 : unsigned result = strtab.pos;
2054 : :
2055 : 331965 : strtab_write (decl, is_defn);
2056 : 331965 : strtab_write ("", 1);
2057 : :
2058 : 331965 : return result;
2059 : : }
2060 : :
2061 : : /* Add section to file. Return section number. TYPE & NAME identify
2062 : : the section. OFF and SIZE identify the file location of its
2063 : : data. FLAGS contains additional info. */
2064 : :
2065 : : unsigned
2066 : 364992 : elf_out::add (unsigned type, unsigned name, unsigned off, unsigned size,
2067 : : unsigned flags)
2068 : : {
2069 : 364992 : gcc_checking_assert (!(off & (SECTION_ALIGN - 1)));
2070 : 364992 : if (sectab.pos + sizeof (section) > sectab.size)
2071 : 3272 : data::simple_memory.grow (sectab, sectab.pos + sizeof (section), false);
2072 : 364992 : section *sec = reinterpret_cast<section *> (sectab.buffer + sectab.pos);
2073 : 364992 : memset (sec, 0, sizeof (section));
2074 : 364992 : sec->type = type;
2075 : 364992 : sec->flags = flags;
2076 : 364992 : sec->name = name;
2077 : 364992 : sec->offset = off;
2078 : 364992 : sec->size = size;
2079 : 364992 : if (flags & SHF_STRINGS)
2080 : 4088 : sec->entsize = 1;
2081 : :
2082 : 364992 : unsigned res = sectab.pos;
2083 : 364992 : sectab.pos += sizeof (section);
2084 : 364992 : return res / sizeof (section);
2085 : : }
2086 : :
2087 : : /* Pad to the next alignment boundary, then write BUFFER to disk.
2088 : : Return the position of the start of the write, or zero on failure. */
2089 : :
2090 : : unsigned
2091 : 8194 : elf_out::write (const data &buffer)
2092 : : {
2093 : : #if MAPPED_WRITING
2094 : : /* HDR is always mapped. */
2095 : 8194 : if (&buffer != &hdr)
2096 : : {
2097 : 4100 : bytes_out out (this);
2098 : 4100 : grow (out, buffer.pos, true);
2099 : 4100 : if (out.buffer)
2100 : 4100 : memcpy (out.buffer, buffer.buffer, buffer.pos);
2101 : 4100 : shrink (out);
2102 : 4100 : }
2103 : : else
2104 : : /* We should have been aligned during the first allocation. */
2105 : 4094 : gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)));
2106 : : #else
2107 : : if (::write (fd, buffer.buffer, buffer.pos) != ssize_t (buffer.pos))
2108 : : {
2109 : : set_error (errno);
2110 : : return 0;
2111 : : }
2112 : : #endif
2113 : 8194 : unsigned res = pos;
2114 : 8194 : pos += buffer.pos;
2115 : :
2116 : 8194 : if (unsigned padding = -pos & (SECTION_ALIGN - 1))
2117 : : {
2118 : : #if !MAPPED_WRITING
2119 : : /* Align the section on disk, should help the necessary copies.
2120 : : fseeking to extend is non-portable. */
2121 : : static char zero[SECTION_ALIGN];
2122 : : if (::write (fd, &zero, padding) != ssize_t (padding))
2123 : : set_error (errno);
2124 : : #endif
2125 : 7131 : pos += padding;
2126 : : }
2127 : 8194 : return res;
2128 : : }
2129 : :
2130 : : /* Write a streaming buffer. It must be using us as an allocator. */
2131 : :
2132 : : #if MAPPED_WRITING
2133 : : unsigned
2134 : 360898 : elf_out::write (const bytes_out &buf)
2135 : : {
2136 : 360898 : gcc_checking_assert (buf.memory == this);
2137 : : /* A directly mapped buffer. */
2138 : 360898 : gcc_checking_assert (buf.buffer - hdr.buffer >= 0
2139 : : && buf.buffer - hdr.buffer + buf.size <= extent);
2140 : 360898 : unsigned res = pos;
2141 : 360898 : pos += buf.pos;
2142 : :
2143 : : /* Align up. We're not going to advance into the next page. */
2144 : 360898 : pos += -pos & (SECTION_ALIGN - 1);
2145 : :
2146 : 360898 : return res;
2147 : : }
2148 : : #endif
2149 : :
2150 : : /* Write data and add section. STRING_P is true for a string
2151 : : section, false for PROGBITS. NAME identifies the section (0 is the
2152 : : empty name). DATA is the contents. Return section number or 0 on
2153 : : failure (0 is the undef section). */
2154 : :
2155 : : unsigned
2156 : 360898 : elf_out::add (const bytes_out &data, bool string_p, unsigned name)
2157 : : {
2158 : 360898 : unsigned off = write (data);
2159 : :
2160 : 721796 : return add (string_p ? SHT_STRTAB : SHT_PROGBITS, name,
2161 : 360898 : off, data.pos, string_p ? SHF_STRINGS : SHF_NONE);
2162 : : }
2163 : :
2164 : : /* Begin writing the file. Initialize the section table and write an
2165 : : empty header. Return false on failure. */
2166 : :
2167 : : bool
2168 : 2044 : elf_out::begin ()
2169 : : {
2170 : 2044 : if (!parent::begin ())
2171 : : return false;
2172 : :
2173 : : /* Let the allocators pick a default. */
2174 : 2044 : data::simple_memory.grow (strtab, 0, false);
2175 : 2044 : data::simple_memory.grow (sectab, 0, false);
2176 : :
2177 : : /* The string table starts with an empty string. */
2178 : 2044 : name ("");
2179 : :
2180 : : /* Create the UNDEF section. */
2181 : 2044 : add (SHT_NONE);
2182 : :
2183 : : #if MAPPED_WRITING
2184 : : /* Start a mapping. */
2185 : 2044 : create_mapping (EXPERIMENT (page_size,
2186 : : (32767 + page_size) & ~(page_size - 1)));
2187 : 2044 : if (!hdr.buffer)
2188 : : return false;
2189 : : #endif
2190 : :
2191 : : /* Write an empty header. */
2192 : 2044 : grow (hdr, sizeof (header), true);
2193 : 2044 : header *h = reinterpret_cast<header *> (hdr.buffer);
2194 : 2044 : memset (h, 0, sizeof (header));
2195 : 2044 : hdr.pos = hdr.size;
2196 : 2044 : write (hdr);
2197 : 2044 : return !get_error ();
2198 : : }
2199 : :
2200 : : /* Finish writing the file. Write out the string & section tables.
2201 : : Fill in the header. Return true on error. */
2202 : :
2203 : : bool
2204 : 2126 : elf_out::end ()
2205 : : {
2206 : 2126 : if (fd >= 0)
2207 : : {
2208 : : /* Write the string table. */
2209 : 2050 : unsigned strnam = name (".strtab");
2210 : 2050 : unsigned stroff = write (strtab);
2211 : 2050 : unsigned strndx = add (SHT_STRTAB, strnam, stroff, strtab.pos,
2212 : : SHF_STRINGS);
2213 : :
2214 : : /* Store escape values in section[0]. */
2215 : 2050 : if (strndx >= SHN_LORESERVE)
2216 : : {
2217 : 0 : reinterpret_cast<section *> (sectab.buffer)->link = strndx;
2218 : 0 : strndx = SHN_XINDEX;
2219 : : }
2220 : 2050 : unsigned shnum = sectab.pos / sizeof (section);
2221 : 2050 : if (shnum >= SHN_LORESERVE)
2222 : : {
2223 : 0 : reinterpret_cast<section *> (sectab.buffer)->size = shnum;
2224 : 0 : shnum = SHN_XINDEX;
2225 : : }
2226 : :
2227 : 2050 : unsigned shoff = write (sectab);
2228 : :
2229 : : #if MAPPED_WRITING
2230 : 2050 : if (offset)
2231 : : {
2232 : 122 : remove_mapping ();
2233 : 122 : offset = 0;
2234 : 122 : create_mapping ((sizeof (header) + page_size - 1) & ~(page_size - 1),
2235 : : false);
2236 : : }
2237 : 2050 : unsigned length = pos;
2238 : : #else
2239 : : if (lseek (fd, 0, SEEK_SET) < 0)
2240 : : set_error (errno);
2241 : : #endif
2242 : : /* Write header. */
2243 : 2050 : if (!get_error ())
2244 : : {
2245 : : /* Write the correct header now. */
2246 : 2050 : header *h = reinterpret_cast<header *> (hdr.buffer);
2247 : 2050 : h->ident.magic[0] = 0x7f;
2248 : 2050 : h->ident.magic[1] = 'E'; /* Elrond */
2249 : 2050 : h->ident.magic[2] = 'L'; /* is an */
2250 : 2050 : h->ident.magic[3] = 'F'; /* elf. */
2251 : 2050 : h->ident.klass = MY_CLASS;
2252 : 2050 : h->ident.data = MY_ENDIAN;
2253 : 2050 : h->ident.version = EV_CURRENT;
2254 : 2050 : h->ident.osabi = OSABI_NONE;
2255 : 2050 : h->type = ET_NONE;
2256 : 2050 : h->machine = EM_NONE;
2257 : 2050 : h->version = EV_CURRENT;
2258 : 2050 : h->shoff = shoff;
2259 : 2050 : h->ehsize = sizeof (header);
2260 : 2050 : h->shentsize = sizeof (section);
2261 : 2050 : h->shnum = shnum;
2262 : 2050 : h->shstrndx = strndx;
2263 : :
2264 : 2050 : pos = 0;
2265 : 2050 : write (hdr);
2266 : : }
2267 : :
2268 : : #if MAPPED_WRITING
2269 : 2050 : remove_mapping ();
2270 : 2050 : if (ftruncate (fd, length))
2271 : 0 : set_error (errno);
2272 : : #endif
2273 : : }
2274 : :
2275 : 2126 : data::simple_memory.shrink (sectab);
2276 : 2126 : data::simple_memory.shrink (strtab);
2277 : :
2278 : 2126 : return parent::end ();
2279 : : }
2280 : :
2281 : : /********************************************************************/
2282 : :
2283 : : /* A dependency set. This is used during stream out to determine the
2284 : : connectivity of the graph. Every namespace-scope declaration that
2285 : : needs writing has a depset. The depset is filled with the (depsets
2286 : : of) declarations within this module that it references. For a
2287 : : declaration that'll generally be named types. For definitions
2288 : : it'll also be declarations in the body.
2289 : :
2290 : : From that we can convert the graph to a DAG, via determining the
2291 : : Strongly Connected Clusters. Each cluster is streamed
2292 : : independently, and thus we achieve lazy loading.
2293 : :
2294 : : Other decls that get a depset are namespaces themselves and
2295 : : unnameable declarations. */
2296 : :
2297 : : class depset {
2298 : : private:
2299 : : tree entity; /* Entity, or containing namespace. */
2300 : : uintptr_t discriminator; /* Flags or identifier. */
2301 : :
2302 : : public:
2303 : : /* The kinds of entity the depset could describe. The ordering is
2304 : : significant, see entity_kind_name. */
2305 : : enum entity_kind
2306 : : {
2307 : : EK_DECL, /* A decl. */
2308 : : EK_SPECIALIZATION, /* A specialization. */
2309 : : EK_PARTIAL, /* A partial specialization. */
2310 : : EK_USING, /* A using declaration (at namespace scope). */
2311 : : EK_NAMESPACE, /* A namespace. */
2312 : : EK_REDIRECT, /* Redirect to a template_decl. */
2313 : : EK_EXPLICIT_HWM,
2314 : : EK_BINDING = EK_EXPLICIT_HWM, /* Implicitly encoded. */
2315 : : EK_FOR_BINDING, /* A decl being inserted for a binding. */
2316 : : EK_INNER_DECL, /* A decl defined outside of its imported
2317 : : context. */
2318 : : EK_DIRECT_HWM = EK_PARTIAL + 1,
2319 : :
2320 : : EK_BITS = 3 /* Only need to encode below EK_EXPLICIT_HWM. */
2321 : : };
2322 : :
2323 : : private:
2324 : : /* Placement of bit fields in discriminator. */
2325 : : enum disc_bits
2326 : : {
2327 : : DB_ZERO_BIT, /* Set to disambiguate identifier from flags */
2328 : : DB_SPECIAL_BIT, /* First dep slot is special. */
2329 : : DB_KIND_BIT, /* Kind of the entity. */
2330 : : DB_KIND_BITS = EK_BITS,
2331 : : DB_DEFN_BIT = DB_KIND_BIT + DB_KIND_BITS,
2332 : : DB_IS_MEMBER_BIT, /* Is an out-of-class member. */
2333 : : DB_IS_INTERNAL_BIT, /* It is an (erroneous)
2334 : : internal-linkage entity. */
2335 : : DB_REFS_INTERNAL_BIT, /* Refers to an internal-linkage
2336 : : entity. */
2337 : : DB_IMPORTED_BIT, /* An imported entity. */
2338 : : DB_UNREACHED_BIT, /* A yet-to-be reached entity. */
2339 : : DB_HIDDEN_BIT, /* A hidden binding. */
2340 : : /* The following bits are not independent, but enumerating them is
2341 : : awkward. */
2342 : : DB_TYPE_SPEC_BIT, /* Specialization in the type table. */
2343 : : DB_FRIEND_SPEC_BIT, /* An instantiated template friend. */
2344 : : };
2345 : :
2346 : : public:
2347 : : /* The first slot is special for EK_SPECIALIZATIONS it is a
2348 : : spec_entry pointer. It is not relevant for the SCC
2349 : : determination. */
2350 : : vec<depset *> deps; /* Depsets we reference. */
2351 : :
2352 : : public:
2353 : : unsigned cluster; /* Strongly connected cluster, later entity number */
2354 : : unsigned section; /* Section written to. */
2355 : : /* During SCC construction, section is lowlink, until the depset is
2356 : : removed from the stack. See Tarjan algorithm for details. */
2357 : :
2358 : : private:
2359 : : /* Construction via factories. Destruction via hash traits. */
2360 : : depset (tree entity);
2361 : : ~depset ();
2362 : :
2363 : : public:
2364 : : static depset *make_binding (tree, tree);
2365 : : static depset *make_entity (tree, entity_kind, bool = false);
2366 : : /* Late setting a binding name -- /then/ insert into hash! */
2367 : : inline void set_binding_name (tree name)
2368 : : {
2369 : : gcc_checking_assert (!get_name ());
2370 : : discriminator = reinterpret_cast<uintptr_t> (name);
2371 : : }
2372 : :
2373 : : private:
2374 : 2855053 : template<unsigned I> void set_flag_bit ()
2375 : : {
2376 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2377 : 2855053 : discriminator |= 1u << I;
2378 : 925245 : }
2379 : 454089 : template<unsigned I> void clear_flag_bit ()
2380 : : {
2381 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2382 : 454089 : discriminator &= ~(1u << I);
2383 : 454089 : }
2384 : 511417408 : template<unsigned I> bool get_flag_bit () const
2385 : : {
2386 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2387 : 581130476 : return bool ((discriminator >> I) & 1);
2388 : : }
2389 : :
2390 : : public:
2391 : 499937407 : bool is_binding () const
2392 : : {
2393 : 71092402 : return !get_flag_bit<DB_ZERO_BIT> ();
2394 : : }
2395 : 306078585 : entity_kind get_entity_kind () const
2396 : : {
2397 : 26175 : if (is_binding ())
2398 : : return EK_BINDING;
2399 : 231019296 : return entity_kind ((discriminator >> DB_KIND_BIT) & ((1u << EK_BITS) - 1));
2400 : : }
2401 : : const char *entity_kind_name () const;
2402 : :
2403 : : public:
2404 : 9271490 : bool has_defn () const
2405 : : {
2406 : 774 : return get_flag_bit<DB_DEFN_BIT> ();
2407 : : }
2408 : :
2409 : : public:
2410 : : /* This class-member is defined here, but the class was imported. */
2411 : 1375981 : bool is_member () const
2412 : : {
2413 : 1375981 : gcc_checking_assert (get_entity_kind () == EK_DECL);
2414 : 1375981 : return get_flag_bit<DB_IS_MEMBER_BIT> ();
2415 : : }
2416 : : public:
2417 : 5824898 : bool is_internal () const
2418 : : {
2419 : 5824898 : return get_flag_bit<DB_IS_INTERNAL_BIT> ();
2420 : : }
2421 : 1487023 : bool refs_internal () const
2422 : : {
2423 : 1487023 : return get_flag_bit<DB_REFS_INTERNAL_BIT> ();
2424 : : }
2425 : 29465801 : bool is_import () const
2426 : : {
2427 : 9407248 : return get_flag_bit<DB_IMPORTED_BIT> ();
2428 : : }
2429 : 17743893 : bool is_unreached () const
2430 : : {
2431 : 1240176 : return get_flag_bit<DB_UNREACHED_BIT> ();
2432 : : }
2433 : 1527236 : bool is_hidden () const
2434 : : {
2435 : 1527236 : return get_flag_bit<DB_HIDDEN_BIT> ();
2436 : : }
2437 : 1508373 : bool is_type_spec () const
2438 : : {
2439 : 1508373 : return get_flag_bit<DB_TYPE_SPEC_BIT> ();
2440 : : }
2441 : 1508373 : bool is_friend_spec () const
2442 : : {
2443 : 1508373 : return get_flag_bit<DB_FRIEND_SPEC_BIT> ();
2444 : : }
2445 : :
2446 : : public:
2447 : : /* We set these bit outside of depset. */
2448 : 5328 : void set_hidden_binding ()
2449 : : {
2450 : 5328 : set_flag_bit<DB_HIDDEN_BIT> ();
2451 : 5328 : }
2452 : 30 : void clear_hidden_binding ()
2453 : : {
2454 : 30 : clear_flag_bit<DB_HIDDEN_BIT> ();
2455 : 30 : }
2456 : :
2457 : : public:
2458 : 11480001 : bool is_special () const
2459 : : {
2460 : 11480001 : return get_flag_bit<DB_SPECIAL_BIT> ();
2461 : : }
2462 : 1929808 : void set_special ()
2463 : : {
2464 : 1929808 : set_flag_bit<DB_SPECIAL_BIT> ();
2465 : 0 : }
2466 : :
2467 : : public:
2468 : 139279617 : tree get_entity () const
2469 : : {
2470 : 139279617 : return entity;
2471 : : }
2472 : 25989955 : tree get_name () const
2473 : : {
2474 : 25989955 : gcc_checking_assert (is_binding ());
2475 : 25989955 : return reinterpret_cast <tree> (discriminator);
2476 : : }
2477 : :
2478 : : public:
2479 : : /* Traits for a hash table of pointers to bindings. */
2480 : : struct traits {
2481 : : /* Each entry is a pointer to a depset. */
2482 : : typedef depset *value_type;
2483 : : /* We lookup by container:maybe-identifier pair. */
2484 : : typedef std::pair<tree,tree> compare_type;
2485 : :
2486 : : static const bool empty_zero_p = true;
2487 : :
2488 : : /* hash and equality for compare_type. */
2489 : 17434227 : inline static hashval_t hash (const compare_type &p)
2490 : : {
2491 : 17434227 : hashval_t h = pointer_hash<tree_node>::hash (p.first);
2492 : 17434227 : if (p.second)
2493 : : {
2494 : 238903 : hashval_t nh = IDENTIFIER_HASH_VALUE (p.second);
2495 : 238903 : h = iterative_hash_hashval_t (h, nh);
2496 : : }
2497 : 17434227 : return h;
2498 : : }
2499 : 80198823 : inline static bool equal (const value_type b, const compare_type &p)
2500 : : {
2501 : 80198823 : if (b->entity != p.first)
2502 : : return false;
2503 : :
2504 : 12356408 : if (p.second)
2505 : 26610 : return b->discriminator == reinterpret_cast<uintptr_t> (p.second);
2506 : : else
2507 : 12329798 : return !b->is_binding ();
2508 : : }
2509 : :
2510 : : /* (re)hasher for a binding itself. */
2511 : 61530865 : inline static hashval_t hash (const value_type b)
2512 : : {
2513 : 61530865 : hashval_t h = pointer_hash<tree_node>::hash (b->entity);
2514 : 61530865 : if (b->is_binding ())
2515 : : {
2516 : 6087187 : hashval_t nh = IDENTIFIER_HASH_VALUE (b->get_name ());
2517 : 6087187 : h = iterative_hash_hashval_t (h, nh);
2518 : : }
2519 : 61530865 : return h;
2520 : : }
2521 : :
2522 : : /* Empty via NULL. */
2523 : 0 : static inline void mark_empty (value_type &p) {p = NULL;}
2524 : : static inline bool is_empty (value_type p) {return !p;}
2525 : :
2526 : : /* Nothing is deletable. Everything is insertable. */
2527 : : static bool is_deleted (value_type) { return false; }
2528 : : static void mark_deleted (value_type) { gcc_unreachable (); }
2529 : :
2530 : : /* We own the entities in the hash table. */
2531 : 2891757 : static void remove (value_type p)
2532 : : {
2533 : 2891757 : delete (p);
2534 : 2891757 : }
2535 : : };
2536 : :
2537 : : public:
2538 : : class hash : public hash_table<traits> {
2539 : : typedef traits::compare_type key_t;
2540 : : typedef hash_table<traits> parent;
2541 : :
2542 : : public:
2543 : : vec<depset *> worklist; /* Worklist of decls to walk. */
2544 : : hash *chain; /* Original table. */
2545 : : depset *current; /* Current depset being depended. */
2546 : : unsigned section; /* When writing out, the section. */
2547 : : bool reached_unreached; /* We reached an unreached entity. */
2548 : :
2549 : : public:
2550 : 347100 : hash (size_t size, hash *c = NULL)
2551 : 694200 : : parent (size), chain (c), current (NULL), section (0),
2552 : 347100 : reached_unreached (false)
2553 : : {
2554 : 347100 : worklist.create (size);
2555 : 347100 : }
2556 : 347100 : ~hash ()
2557 : : {
2558 : 2044 : worklist.release ();
2559 : 347100 : }
2560 : :
2561 : : public:
2562 : 51457673 : bool is_key_order () const
2563 : : {
2564 : 51457673 : return chain != NULL;
2565 : : }
2566 : :
2567 : : private:
2568 : : depset **entity_slot (tree entity, bool = true);
2569 : : depset **binding_slot (tree ctx, tree name, bool = true);
2570 : : depset *maybe_add_declaration (tree decl);
2571 : :
2572 : : public:
2573 : : depset *find_dependency (tree entity);
2574 : : depset *find_binding (tree ctx, tree name);
2575 : : depset *make_dependency (tree decl, entity_kind);
2576 : : void add_dependency (depset *);
2577 : :
2578 : : public:
2579 : : void add_mergeable (depset *);
2580 : : depset *add_dependency (tree decl, entity_kind);
2581 : : void add_namespace_context (depset *, tree ns);
2582 : :
2583 : : private:
2584 : : static bool add_binding_entity (tree, WMB_Flags, void *);
2585 : :
2586 : : public:
2587 : : bool add_namespace_entities (tree ns, bitmap partitions);
2588 : : void add_specializations (bool decl_p);
2589 : : void add_partial_entities (vec<tree, va_gc> *);
2590 : : void add_class_entities (vec<tree, va_gc> *);
2591 : :
2592 : : private:
2593 : : void add_deduction_guides (tree decl);
2594 : :
2595 : : public:
2596 : : void find_dependencies (module_state *);
2597 : : bool finalize_dependencies ();
2598 : : vec<depset *> connect ();
2599 : : };
2600 : :
2601 : : public:
2602 : : struct tarjan {
2603 : : vec<depset *> result;
2604 : : vec<depset *> stack;
2605 : : unsigned index;
2606 : :
2607 : 347094 : tarjan (unsigned size)
2608 : 347094 : : index (0)
2609 : : {
2610 : 347094 : result.create (size);
2611 : 347094 : stack.create (50);
2612 : 347094 : }
2613 : 347094 : ~tarjan ()
2614 : : {
2615 : 347094 : gcc_assert (!stack.length ());
2616 : 347094 : stack.release ();
2617 : 347094 : }
2618 : :
2619 : : public:
2620 : : void connect (depset *);
2621 : : };
2622 : : };
2623 : :
2624 : : inline
2625 : 2891757 : depset::depset (tree entity)
2626 : 2891757 : :entity (entity), discriminator (0), cluster (0), section (0)
2627 : : {
2628 : 2891757 : deps.create (0);
2629 : : }
2630 : :
2631 : : inline
2632 : 2891757 : depset::~depset ()
2633 : : {
2634 : 2891757 : deps.release ();
2635 : 2891757 : }
2636 : :
2637 : : const char *
2638 : 230388 : depset::entity_kind_name () const
2639 : : {
2640 : : /* Same order as entity_kind. */
2641 : 230388 : static const char *const names[] =
2642 : : {"decl", "specialization", "partial", "using",
2643 : : "namespace", "redirect", "binding"};
2644 : 230388 : entity_kind kind = get_entity_kind ();
2645 : 230193 : gcc_checking_assert (kind < ARRAY_SIZE (names));
2646 : 230388 : return names[kind];
2647 : : }
2648 : :
2649 : : /* Create a depset for a namespace binding NS::NAME. */
2650 : :
2651 : 190733 : depset *depset::make_binding (tree ns, tree name)
2652 : : {
2653 : 190733 : depset *binding = new depset (ns);
2654 : :
2655 : 190733 : binding->discriminator = reinterpret_cast <uintptr_t> (name);
2656 : :
2657 : 190733 : return binding;
2658 : : }
2659 : :
2660 : 2701024 : depset *depset::make_entity (tree entity, entity_kind ek, bool is_defn)
2661 : : {
2662 : 2701024 : depset *r = new depset (entity);
2663 : :
2664 : 2701024 : r->discriminator = ((1 << DB_ZERO_BIT)
2665 : 2701024 : | (ek << DB_KIND_BIT)
2666 : 2701024 : | is_defn << DB_DEFN_BIT);
2667 : :
2668 : 2701024 : return r;
2669 : : }
2670 : :
2671 : : class pending_key
2672 : : {
2673 : : public:
2674 : : tree ns;
2675 : : tree id;
2676 : : };
2677 : :
2678 : : template<>
2679 : : struct default_hash_traits<pending_key>
2680 : : {
2681 : : using value_type = pending_key;
2682 : :
2683 : : static const bool empty_zero_p = false;
2684 : 46196289 : static hashval_t hash (const value_type &k)
2685 : : {
2686 : 46196289 : hashval_t h = IDENTIFIER_HASH_VALUE (k.id);
2687 : 46196289 : h = iterative_hash_hashval_t (DECL_UID (k.ns), h);
2688 : :
2689 : 46196289 : return h;
2690 : : }
2691 : 12092964 : static bool equal (const value_type &k, const value_type &l)
2692 : : {
2693 : 12092964 : return k.ns == l.ns && k.id == l.id;
2694 : : }
2695 : 206541 : static void mark_empty (value_type &k)
2696 : : {
2697 : 206541 : k.ns = k.id = NULL_TREE;
2698 : : }
2699 : 4900 : static void mark_deleted (value_type &k)
2700 : : {
2701 : 4900 : k.ns = NULL_TREE;
2702 : 4900 : gcc_checking_assert (k.id);
2703 : 4900 : }
2704 : 351361717 : static bool is_empty (const value_type &k)
2705 : : {
2706 : 351312281 : return k.ns == NULL_TREE && k.id == NULL_TREE;
2707 : : }
2708 : 16219211 : static bool is_deleted (const value_type &k)
2709 : : {
2710 : 16219211 : return k.ns == NULL_TREE && k.id != NULL_TREE;
2711 : : }
2712 : : static void remove (value_type &)
2713 : : {
2714 : : }
2715 : : };
2716 : :
2717 : : typedef hash_map<pending_key, auto_vec<unsigned>> pending_map_t;
2718 : :
2719 : : /* Not-loaded entities that are keyed to a namespace-scope
2720 : : identifier. See module_state::write_pendings for details. */
2721 : : pending_map_t *pending_table;
2722 : :
2723 : : /* Decls that need some post processing once a batch of lazy loads has
2724 : : completed. */
2725 : : vec<tree, va_heap, vl_embed> *post_load_decls;
2726 : :
2727 : : /* Some entities are keyed to another entitity for ODR purposes.
2728 : : For example, at namespace scope, 'inline auto var = []{};', that
2729 : : lambda is keyed to 'var', and follows its ODRness. */
2730 : : typedef hash_map<tree, auto_vec<tree>> keyed_map_t;
2731 : : static keyed_map_t *keyed_table;
2732 : :
2733 : : /* Instantiations of temploid friends imported from another module
2734 : : need to be attached to the same module as the temploid. This maps
2735 : : these decls to the temploid they are instantiated them, as there is
2736 : : no other easy way to get this information. */
2737 : : static GTY((cache)) decl_tree_cache_map *imported_temploid_friends;
2738 : :
2739 : : /********************************************************************/
2740 : : /* Tree streaming. The tree streaming is very specific to the tree
2741 : : structures themselves. A tag indicates the kind of tree being
2742 : : streamed. -ve tags indicate backreferences to already-streamed
2743 : : trees. Backreferences are auto-numbered. */
2744 : :
2745 : : /* Tree tags. */
2746 : : enum tree_tag {
2747 : : tt_null, /* NULL_TREE. */
2748 : : tt_fixed, /* Fixed vector index. */
2749 : :
2750 : : tt_node, /* By-value node. */
2751 : : tt_decl, /* By-value mergeable decl. */
2752 : : tt_tpl_parm, /* Template parm. */
2753 : :
2754 : : /* The ordering of the following 4 is relied upon in
2755 : : trees_out::tree_node. */
2756 : : tt_id, /* Identifier node. */
2757 : : tt_conv_id, /* Conversion operator name. */
2758 : : tt_anon_id, /* Anonymous name. */
2759 : : tt_lambda_id, /* Lambda name. */
2760 : :
2761 : : tt_typedef_type, /* A (possibly implicit) typedefed type. */
2762 : : tt_derived_type, /* A type derived from another type. */
2763 : : tt_variant_type, /* A variant of another type. */
2764 : :
2765 : : tt_tinfo_var, /* Typeinfo object. */
2766 : : tt_tinfo_typedef, /* Typeinfo typedef. */
2767 : : tt_ptrmem_type, /* Pointer to member type. */
2768 : : tt_nttp_var, /* NTTP_OBJECT VAR_DECL. */
2769 : :
2770 : : tt_parm, /* Function parameter or result. */
2771 : : tt_enum_value, /* An enum value. */
2772 : : tt_enum_decl, /* An enum decl. */
2773 : : tt_data_member, /* Data member/using-decl. */
2774 : :
2775 : : tt_binfo, /* A BINFO. */
2776 : : tt_vtable, /* A vtable. */
2777 : : tt_thunk, /* A thunk. */
2778 : : tt_clone_ref,
2779 : :
2780 : : tt_entity, /* A extra-cluster entity. */
2781 : :
2782 : : tt_template, /* The TEMPLATE_RESULT of a template. */
2783 : : };
2784 : :
2785 : : enum walk_kind {
2786 : : WK_none, /* No walk to do (a back- or fixed-ref happened). */
2787 : : WK_normal, /* Normal walk (by-name if possible). */
2788 : :
2789 : : WK_value, /* By-value walk. */
2790 : : };
2791 : :
2792 : : enum merge_kind
2793 : : {
2794 : : MK_unique, /* Known unique. */
2795 : : MK_named, /* Found by CTX, NAME + maybe_arg types etc. */
2796 : : MK_field, /* Found by CTX and index on TYPE_FIELDS */
2797 : : MK_vtable, /* Found by CTX and index on TYPE_VTABLES */
2798 : : MK_as_base, /* Found by CTX. */
2799 : :
2800 : : MK_partial,
2801 : :
2802 : : MK_enum, /* Found by CTX, & 1stMemberNAME. */
2803 : : MK_keyed, /* Found by key & index. */
2804 : : MK_local_type, /* Found by CTX, index. */
2805 : :
2806 : : MK_friend_spec, /* Like named, but has a tmpl & args too. */
2807 : : MK_local_friend, /* Found by CTX, index. */
2808 : :
2809 : : MK_indirect_lwm = MK_enum,
2810 : :
2811 : : /* Template specialization kinds below. These are all found via
2812 : : primary template and specialization args. */
2813 : : MK_template_mask = 0x10, /* A template specialization. */
2814 : :
2815 : : MK_tmpl_decl_mask = 0x4, /* In decl table. */
2816 : :
2817 : : MK_tmpl_tmpl_mask = 0x1, /* We want TEMPLATE_DECL. */
2818 : :
2819 : : MK_type_spec = MK_template_mask,
2820 : : MK_decl_spec = MK_template_mask | MK_tmpl_decl_mask,
2821 : :
2822 : : MK_hwm = 0x20
2823 : : };
2824 : : /* This is more than a debugging array. NULLs are used to determine
2825 : : an invalid merge_kind number. */
2826 : : static char const *const merge_kind_name[MK_hwm] =
2827 : : {
2828 : : "unique", "named", "field", "vtable", /* 0...3 */
2829 : : "asbase", "partial", "enum", "attached", /* 4...7 */
2830 : :
2831 : : "local type", "friend spec", "local friend", NULL, /* 8...11 */
2832 : : NULL, NULL, NULL, NULL,
2833 : :
2834 : : "type spec", "type tmpl spec", /* 16,17 type (template). */
2835 : : NULL, NULL,
2836 : :
2837 : : "decl spec", "decl tmpl spec", /* 20,21 decl (template). */
2838 : : NULL, NULL,
2839 : : NULL, NULL, NULL, NULL,
2840 : : NULL, NULL, NULL, NULL,
2841 : : };
2842 : :
2843 : : /* Mergeable entity location data. */
2844 : : struct merge_key {
2845 : : cp_ref_qualifier ref_q : 2;
2846 : : unsigned index;
2847 : :
2848 : : tree ret; /* Return type, if appropriate. */
2849 : : tree args; /* Arg types, if appropriate. */
2850 : :
2851 : : tree constraints; /* Constraints. */
2852 : :
2853 : 3389106 : merge_key ()
2854 : 3389106 : :ref_q (REF_QUAL_NONE), index (0),
2855 : 3389106 : ret (NULL_TREE), args (NULL_TREE),
2856 : 3389106 : constraints (NULL_TREE)
2857 : : {
2858 : : }
2859 : : };
2860 : :
2861 : : /* Hashmap of merged duplicates. Usually decls, but can contain
2862 : : BINFOs. */
2863 : : typedef hash_map<tree,uintptr_t,
2864 : : simple_hashmap_traits<nodel_ptr_hash<tree_node>,uintptr_t> >
2865 : : duplicate_hash_map;
2866 : :
2867 : : /* Data needed for post-processing. */
2868 : : struct post_process_data {
2869 : : tree decl;
2870 : : location_t start_locus;
2871 : : location_t end_locus;
2872 : : };
2873 : :
2874 : : /* Tree stream reader. Note that reading a stream doesn't mark the
2875 : : read trees with TREE_VISITED. Thus it's quite safe to have
2876 : : multiple concurrent readers. Which is good, because lazy
2877 : : loading.
2878 : :
2879 : : It's important that trees_in/out have internal linkage so that the
2880 : : compiler knows core_bools, lang_type_bools and lang_decl_bools have
2881 : : only a single caller (tree_node_bools) and inlines them appropriately. */
2882 : : namespace {
2883 : : class trees_in : public bytes_in {
2884 : : typedef bytes_in parent;
2885 : :
2886 : : private:
2887 : : module_state *state; /* Module being imported. */
2888 : : vec<tree> back_refs; /* Back references. */
2889 : : duplicate_hash_map *duplicates; /* Map from existings to duplicate. */
2890 : : vec<post_process_data> post_decls; /* Decls to post process. */
2891 : : unsigned unused; /* Inhibit any interior TREE_USED
2892 : : marking. */
2893 : :
2894 : : public:
2895 : : trees_in (module_state *);
2896 : : ~trees_in ();
2897 : :
2898 : : public:
2899 : : int insert (tree);
2900 : : tree back_ref (int);
2901 : :
2902 : : private:
2903 : : tree start (unsigned = 0);
2904 : :
2905 : : public:
2906 : : /* Needed for binfo writing */
2907 : : bool core_bools (tree, bits_in&);
2908 : :
2909 : : private:
2910 : : /* Stream tree_core, lang_decl_specific and lang_type_specific
2911 : : bits. */
2912 : : bool core_vals (tree);
2913 : : bool lang_type_bools (tree, bits_in&);
2914 : : bool lang_type_vals (tree);
2915 : : bool lang_decl_bools (tree, bits_in&);
2916 : : bool lang_decl_vals (tree);
2917 : : bool lang_vals (tree);
2918 : : bool tree_node_bools (tree);
2919 : : bool tree_node_vals (tree);
2920 : : tree tree_value ();
2921 : : tree decl_value ();
2922 : : tree tpl_parm_value ();
2923 : :
2924 : : private:
2925 : : tree chained_decls (); /* Follow DECL_CHAIN. */
2926 : : vec<tree, va_heap> *vec_chained_decls ();
2927 : : vec<tree, va_gc> *tree_vec (); /* vec of tree. */
2928 : : vec<tree_pair_s, va_gc> *tree_pair_vec (); /* vec of tree_pair. */
2929 : : tree tree_list (bool has_purpose);
2930 : :
2931 : : public:
2932 : : /* Read a tree node. */
2933 : : tree tree_node (bool is_use = false);
2934 : :
2935 : : private:
2936 : : bool install_entity (tree decl);
2937 : : tree tpl_parms (unsigned &tpl_levels);
2938 : : bool tpl_parms_fini (tree decl, unsigned tpl_levels);
2939 : : bool tpl_header (tree decl, unsigned *tpl_levels);
2940 : : int fn_parms_init (tree);
2941 : : void fn_parms_fini (int tag, tree fn, tree existing, bool has_defn);
2942 : : unsigned add_indirect_tpl_parms (tree);
2943 : : public:
2944 : : bool add_indirects (tree);
2945 : :
2946 : : public:
2947 : : /* Serialize various definitions. */
2948 : : bool read_definition (tree decl);
2949 : :
2950 : : private:
2951 : : bool is_matching_decl (tree existing, tree decl, bool is_typedef);
2952 : : static bool install_implicit_member (tree decl);
2953 : : bool read_function_def (tree decl, tree maybe_template);
2954 : : bool read_var_def (tree decl, tree maybe_template);
2955 : : bool read_class_def (tree decl, tree maybe_template);
2956 : : bool read_enum_def (tree decl, tree maybe_template);
2957 : :
2958 : : public:
2959 : : tree decl_container ();
2960 : : tree key_mergeable (int tag, merge_kind, tree decl, tree inner, tree type,
2961 : : tree container, bool is_attached,
2962 : : bool is_imported_temploid_friend);
2963 : : unsigned binfo_mergeable (tree *);
2964 : :
2965 : : private:
2966 : : tree key_local_type (const merge_key&, tree, tree);
2967 : : uintptr_t *find_duplicate (tree existing);
2968 : : void register_duplicate (tree decl, tree existing);
2969 : : /* Mark as an already diagnosed bad duplicate. */
2970 : 21 : void unmatched_duplicate (tree existing)
2971 : : {
2972 : 42 : *find_duplicate (existing) |= 1;
2973 : 21 : }
2974 : :
2975 : : public:
2976 : 272778 : bool is_duplicate (tree decl)
2977 : : {
2978 : 545556 : return find_duplicate (decl) != NULL;
2979 : : }
2980 : 230018 : tree maybe_duplicate (tree decl)
2981 : : {
2982 : 230018 : if (uintptr_t *dup = find_duplicate (decl))
2983 : 17053 : return reinterpret_cast<tree> (*dup & ~uintptr_t (1));
2984 : : return decl;
2985 : : }
2986 : : tree odr_duplicate (tree decl, bool has_defn);
2987 : :
2988 : : public:
2989 : : /* Return the decls to postprocess. */
2990 : : const vec<post_process_data>& post_process ()
2991 : : {
2992 : : return post_decls;
2993 : : }
2994 : : private:
2995 : : /* Register DATA for postprocessing. */
2996 : 135135 : void post_process (post_process_data data)
2997 : : {
2998 : 135135 : post_decls.safe_push (data);
2999 : : }
3000 : :
3001 : : private:
3002 : : void assert_definition (tree, bool installing);
3003 : : };
3004 : : } // anon namespace
3005 : :
3006 : 361017 : trees_in::trees_in (module_state *state)
3007 : 361017 : :parent (), state (state), unused (0)
3008 : : {
3009 : 361017 : duplicates = NULL;
3010 : 361017 : back_refs.create (500);
3011 : 361017 : post_decls.create (0);
3012 : 361017 : }
3013 : :
3014 : 361017 : trees_in::~trees_in ()
3015 : : {
3016 : 573195 : delete (duplicates);
3017 : 361017 : back_refs.release ();
3018 : 361017 : post_decls.release ();
3019 : 361017 : }
3020 : :
3021 : : /* Tree stream writer. */
3022 : : namespace {
3023 : : class trees_out : public bytes_out {
3024 : : typedef bytes_out parent;
3025 : :
3026 : : private:
3027 : : module_state *state; /* The module we are writing. */
3028 : : ptr_int_hash_map tree_map; /* Trees to references */
3029 : : depset::hash *dep_hash; /* Dependency table. */
3030 : : int ref_num; /* Back reference number. */
3031 : : unsigned section;
3032 : : #if CHECKING_P
3033 : : int importedness; /* Checker that imports not occurring
3034 : : inappropriately. +ve imports ok,
3035 : : -ve imports not ok. */
3036 : : #endif
3037 : :
3038 : : public:
3039 : : trees_out (allocator *, module_state *, depset::hash &deps, unsigned sec = 0);
3040 : : ~trees_out ();
3041 : :
3042 : : private:
3043 : : void mark_trees ();
3044 : : void unmark_trees ();
3045 : :
3046 : : public:
3047 : : /* Hey, let's ignore the well known STL iterator idiom. */
3048 : : void begin ();
3049 : : unsigned end (elf_out *sink, unsigned name, unsigned *crc_ptr);
3050 : : void end ();
3051 : :
3052 : : public:
3053 : : enum tags
3054 : : {
3055 : : tag_backref = -1, /* Upper bound on the backrefs. */
3056 : : tag_value = 0, /* Write by value. */
3057 : : tag_fixed /* Lower bound on the fixed trees. */
3058 : : };
3059 : :
3060 : : public:
3061 : 25557312 : bool is_key_order () const
3062 : : {
3063 : 25557312 : return dep_hash->is_key_order ();
3064 : : }
3065 : :
3066 : : public:
3067 : : int insert (tree, walk_kind = WK_normal);
3068 : :
3069 : : private:
3070 : : void start (tree, bool = false);
3071 : :
3072 : : private:
3073 : : walk_kind ref_node (tree);
3074 : : public:
3075 : : int get_tag (tree);
3076 : 690112 : void set_importing (int i ATTRIBUTE_UNUSED)
3077 : : {
3078 : : #if CHECKING_P
3079 : 690112 : importedness = i;
3080 : : #endif
3081 : : }
3082 : :
3083 : : private:
3084 : : void core_bools (tree, bits_out&);
3085 : : void core_vals (tree);
3086 : : void lang_type_bools (tree, bits_out&);
3087 : : void lang_type_vals (tree);
3088 : : void lang_decl_bools (tree, bits_out&);
3089 : : void lang_decl_vals (tree);
3090 : : void lang_vals (tree);
3091 : : void tree_node_bools (tree);
3092 : : void tree_node_vals (tree);
3093 : :
3094 : : private:
3095 : : void chained_decls (tree);
3096 : : void vec_chained_decls (tree);
3097 : : void tree_vec (vec<tree, va_gc> *);
3098 : : void tree_pair_vec (vec<tree_pair_s, va_gc> *);
3099 : : void tree_list (tree, bool has_purpose);
3100 : :
3101 : : public:
3102 : : /* Mark a node for by-value walking. */
3103 : : void mark_by_value (tree);
3104 : :
3105 : : public:
3106 : : void tree_node (tree);
3107 : :
3108 : : private:
3109 : : void install_entity (tree decl, depset *);
3110 : : void tpl_parms (tree parms, unsigned &tpl_levels);
3111 : : void tpl_parms_fini (tree decl, unsigned tpl_levels);
3112 : : void fn_parms_fini (tree) {}
3113 : : unsigned add_indirect_tpl_parms (tree);
3114 : : public:
3115 : : void add_indirects (tree);
3116 : : void fn_parms_init (tree);
3117 : : void tpl_header (tree decl, unsigned *tpl_levels);
3118 : :
3119 : : public:
3120 : : merge_kind get_merge_kind (tree decl, depset *maybe_dep);
3121 : : tree decl_container (tree decl);
3122 : : void key_mergeable (int tag, merge_kind, tree decl, tree inner,
3123 : : tree container, depset *maybe_dep);
3124 : : void binfo_mergeable (tree binfo);
3125 : :
3126 : : private:
3127 : : void key_local_type (merge_key&, tree, tree);
3128 : : bool decl_node (tree, walk_kind ref);
3129 : : void type_node (tree);
3130 : : void tree_value (tree);
3131 : : void tpl_parm_value (tree);
3132 : :
3133 : : public:
3134 : : void decl_value (tree, depset *);
3135 : :
3136 : : public:
3137 : : /* Serialize various definitions. */
3138 : : void write_definition (tree decl);
3139 : : void mark_declaration (tree decl, bool do_defn);
3140 : :
3141 : : private:
3142 : : void mark_function_def (tree decl);
3143 : : void mark_var_def (tree decl);
3144 : : void mark_class_def (tree decl);
3145 : : void mark_enum_def (tree decl);
3146 : : void mark_class_member (tree decl, bool do_defn = true);
3147 : : void mark_binfos (tree type);
3148 : :
3149 : : private:
3150 : : void write_var_def (tree decl);
3151 : : void write_function_def (tree decl);
3152 : : void write_class_def (tree decl);
3153 : : void write_enum_def (tree decl);
3154 : :
3155 : : private:
3156 : : static void assert_definition (tree);
3157 : :
3158 : : public:
3159 : : static void instrument ();
3160 : :
3161 : : private:
3162 : : /* Tree instrumentation. */
3163 : : static unsigned tree_val_count;
3164 : : static unsigned decl_val_count;
3165 : : static unsigned back_ref_count;
3166 : : static unsigned null_count;
3167 : : };
3168 : : } // anon namespace
3169 : :
3170 : : /* Instrumentation counters. */
3171 : : unsigned trees_out::tree_val_count;
3172 : : unsigned trees_out::decl_val_count;
3173 : : unsigned trees_out::back_ref_count;
3174 : : unsigned trees_out::null_count;
3175 : :
3176 : 694220 : trees_out::trees_out (allocator *mem, module_state *state, depset::hash &deps,
3177 : 694220 : unsigned section)
3178 : 1388440 : :parent (mem), state (state), tree_map (500),
3179 : 694220 : dep_hash (&deps), ref_num (0), section (section)
3180 : : {
3181 : : #if CHECKING_P
3182 : 694220 : importedness = 0;
3183 : : #endif
3184 : 694220 : }
3185 : :
3186 : 694220 : trees_out::~trees_out ()
3187 : : {
3188 : 694220 : }
3189 : :
3190 : : /********************************************************************/
3191 : : /* Location. We're aware of the line-map concept and reproduce it
3192 : : here. Each imported module allocates a contiguous span of ordinary
3193 : : maps, and of macro maps. adhoc maps are serialized by contents,
3194 : : not pre-allocated. The scattered linemaps of a module are
3195 : : coalesced when writing. */
3196 : :
3197 : :
3198 : : /* I use half-open [first,second) ranges. */
3199 : : typedef std::pair<unsigned,unsigned> range_t;
3200 : :
3201 : : /* A range of locations. */
3202 : : typedef std::pair<location_t,location_t> loc_range_t;
3203 : :
3204 : : /* Spans of the line maps that are occupied by this TU. I.e. not
3205 : : within imports. Only extended when in an interface unit.
3206 : : Interval zero corresponds to the forced header linemap(s). This
3207 : : is a singleton object. */
3208 : :
3209 : : class loc_spans {
3210 : : public:
3211 : : /* An interval of line maps. The line maps here represent a contiguous
3212 : : non-imported range. */
3213 : 4486 : struct span {
3214 : : loc_range_t ordinary; /* Ordinary map location range. */
3215 : : loc_range_t macro; /* Macro map location range. */
3216 : : int ordinary_delta; /* Add to ordinary loc to get serialized loc. */
3217 : : int macro_delta; /* Likewise for macro loc. */
3218 : : };
3219 : :
3220 : : private:
3221 : : vec<span> *spans;
3222 : :
3223 : : public:
3224 : : loc_spans ()
3225 : : /* Do not preallocate spans, as that causes
3226 : : --enable-detailed-mem-stats problems. */
3227 : : : spans (nullptr)
3228 : : {
3229 : : }
3230 : 92152 : ~loc_spans ()
3231 : : {
3232 : 92152 : delete spans;
3233 : 92152 : }
3234 : :
3235 : : public:
3236 : 232 : span &operator[] (unsigned ix)
3237 : : {
3238 : 464 : return (*spans)[ix];
3239 : : }
3240 : : unsigned length () const
3241 : : {
3242 : : return spans->length ();
3243 : : }
3244 : :
3245 : : public:
3246 : 11585 : bool init_p () const
3247 : : {
3248 : 11585 : return spans != nullptr;
3249 : : }
3250 : : /* Initializer. */
3251 : : void init (const line_maps *lmaps, const line_map_ordinary *map);
3252 : :
3253 : : /* Slightly skewed preprocessed files can cause us to miss an
3254 : : initialization in some places. Fallback initializer. */
3255 : 4356 : void maybe_init ()
3256 : : {
3257 : 4356 : if (!init_p ())
3258 : 6 : init (line_table, nullptr);
3259 : 4356 : }
3260 : :
3261 : : public:
3262 : : enum {
3263 : : SPAN_RESERVED = 0, /* Reserved (fixed) locations. */
3264 : : SPAN_FIRST = 1, /* LWM of locations to stream */
3265 : : SPAN_MAIN = 2 /* Main file and onwards. */
3266 : : };
3267 : :
3268 : : public:
3269 : 421197 : location_t main_start () const
3270 : : {
3271 : 421197 : return (*spans)[SPAN_MAIN].ordinary.first;
3272 : : }
3273 : :
3274 : : public:
3275 : : void open (location_t);
3276 : : void close ();
3277 : :
3278 : : public:
3279 : : /* Propagate imported linemaps to us, if needed. */
3280 : : bool maybe_propagate (module_state *import, location_t loc);
3281 : :
3282 : : public:
3283 : : const span *ordinary (location_t);
3284 : : const span *macro (location_t);
3285 : : };
3286 : :
3287 : : static loc_spans spans;
3288 : :
3289 : : /* Information about ordinary locations we stream out. */
3290 : : struct ord_loc_info
3291 : : {
3292 : : const line_map_ordinary *src; // line map we're based on
3293 : : unsigned offset; // offset to this line
3294 : : unsigned span; // number of locs we span
3295 : : unsigned remap; // serialization
3296 : :
3297 : 303608473 : static int compare (const void *a_, const void *b_)
3298 : : {
3299 : 303608473 : auto *a = static_cast<const ord_loc_info *> (a_);
3300 : 303608473 : auto *b = static_cast<const ord_loc_info *> (b_);
3301 : :
3302 : 303608473 : if (a->src != b->src)
3303 : 70041559 : return a->src < b->src ? -1 : +1;
3304 : :
3305 : : // Ensure no overlap
3306 : 256281077 : gcc_checking_assert (a->offset + a->span <= b->offset
3307 : : || b->offset + b->span <= a->offset);
3308 : :
3309 : 256281077 : gcc_checking_assert (a->offset != b->offset);
3310 : 256281077 : return a->offset < b->offset ? -1 : +1;
3311 : : }
3312 : : };
3313 : : struct ord_loc_traits
3314 : : {
3315 : : typedef ord_loc_info value_type;
3316 : : typedef value_type compare_type;
3317 : :
3318 : : static const bool empty_zero_p = false;
3319 : :
3320 : 133477752 : static hashval_t hash (const value_type &v)
3321 : : {
3322 : 113023995 : auto h = pointer_hash<const line_map_ordinary>::hash (v.src);
3323 : 133477752 : return iterative_hash_hashval_t (v.offset, h);
3324 : : }
3325 : 147537607 : static bool equal (const value_type &v, const compare_type p)
3326 : : {
3327 : 147537607 : return v.src == p.src && v.offset == p.offset;
3328 : : }
3329 : :
3330 : 8614519 : static void mark_empty (value_type &v)
3331 : : {
3332 : 8614519 : v.src = nullptr;
3333 : : }
3334 : 428729263 : static bool is_empty (value_type &v)
3335 : : {
3336 : 428729263 : return !v.src;
3337 : : }
3338 : :
3339 : : static bool is_deleted (value_type &) { return false; }
3340 : : static void mark_deleted (value_type &) { gcc_unreachable (); }
3341 : :
3342 : : static void remove (value_type &) {}
3343 : : };
3344 : : /* Table keyed by ord_loc_info, used for noting. */
3345 : : static hash_table<ord_loc_traits> *ord_loc_table;
3346 : : /* Sorted vector, used for writing. */
3347 : : static vec<ord_loc_info> *ord_loc_remap;
3348 : :
3349 : : /* Information about macro locations we stream out. */
3350 : : struct macro_loc_info
3351 : : {
3352 : : const line_map_macro *src; // original expansion
3353 : : unsigned remap; // serialization
3354 : :
3355 : 13341854 : static int compare (const void *a_, const void *b_)
3356 : : {
3357 : 13341854 : auto *a = static_cast<const macro_loc_info *> (a_);
3358 : 13341854 : auto *b = static_cast<const macro_loc_info *> (b_);
3359 : :
3360 : 13341854 : gcc_checking_assert (MAP_START_LOCATION (a->src)
3361 : : != MAP_START_LOCATION (b->src));
3362 : 13341854 : if (MAP_START_LOCATION (a->src) < MAP_START_LOCATION (b->src))
3363 : : return -1;
3364 : : else
3365 : 6454590 : return +1;
3366 : : }
3367 : : };
3368 : : struct macro_loc_traits
3369 : : {
3370 : : typedef macro_loc_info value_type;
3371 : : typedef const line_map_macro *compare_type;
3372 : :
3373 : : static const bool empty_zero_p = false;
3374 : :
3375 : 13926285 : static hashval_t hash (compare_type p)
3376 : : {
3377 : 13926285 : return pointer_hash<const line_map_macro>::hash (p);
3378 : : }
3379 : 11888414 : static hashval_t hash (const value_type &v)
3380 : : {
3381 : 11888414 : return hash (v.src);
3382 : : }
3383 : : static bool equal (const value_type &v, const compare_type p)
3384 : : {
3385 : : return v.src == p;
3386 : : }
3387 : :
3388 : 695878 : static void mark_empty (value_type &v)
3389 : : {
3390 : 695878 : v.src = nullptr;
3391 : : }
3392 : 42283496 : static bool is_empty (value_type &v)
3393 : : {
3394 : 42283496 : return !v.src;
3395 : : }
3396 : :
3397 : : static bool is_deleted (value_type &) { return false; }
3398 : : static void mark_deleted (value_type &) { gcc_unreachable (); }
3399 : :
3400 : : static void remove (value_type &) {}
3401 : : };
3402 : : /* Table keyed by line_map_macro, used for noting. */
3403 : : static hash_table<macro_loc_traits> *macro_loc_table;
3404 : : /* Sorted vector, used for writing. */
3405 : : static vec<macro_loc_info> *macro_loc_remap;
3406 : :
3407 : : /* Indirection to allow bsearching imports by ordinary location. */
3408 : : static vec<module_state *> *ool;
3409 : :
3410 : : /********************************************************************/
3411 : : /* Data needed by a module during the process of loading. */
3412 : : struct GTY(()) slurping {
3413 : :
3414 : : /* Remap import's module numbering to our numbering. Values are
3415 : : shifted by 1. Bit0 encodes if the import is direct. */
3416 : : vec<unsigned, va_heap, vl_embed> *
3417 : : GTY((skip)) remap; /* Module owner remapping. */
3418 : :
3419 : : elf_in *GTY((skip)) from; /* The elf loader. */
3420 : :
3421 : : /* This map is only for header imports themselves -- the global
3422 : : headers bitmap hold it for the current TU. */
3423 : : bitmap headers; /* Transitive set of direct imports, including
3424 : : self. Used for macro visibility and
3425 : : priority. */
3426 : :
3427 : : /* These objects point into the mmapped area, unless we're not doing
3428 : : that, or we got frozen or closed. In those cases they point to
3429 : : buffers we own. */
3430 : : bytes_in macro_defs; /* Macro definitions. */
3431 : : bytes_in macro_tbl; /* Macro table. */
3432 : :
3433 : : /* Location remapping. first->ordinary, second->macro. */
3434 : : range_t GTY((skip)) loc_deltas;
3435 : :
3436 : : unsigned current; /* Section currently being loaded. */
3437 : : unsigned remaining; /* Number of lazy sections yet to read. */
3438 : : unsigned lru; /* An LRU counter. */
3439 : :
3440 : : public:
3441 : : slurping (elf_in *);
3442 : : ~slurping ();
3443 : :
3444 : : public:
3445 : : /* Close the ELF file, if it's open. */
3446 : 4085 : void close ()
3447 : : {
3448 : 4085 : if (from)
3449 : : {
3450 : 2224 : from->end ();
3451 : 4448 : delete from;
3452 : 2224 : from = NULL;
3453 : : }
3454 : 4085 : }
3455 : :
3456 : : public:
3457 : : void release_macros ();
3458 : :
3459 : : public:
3460 : 2267 : void alloc_remap (unsigned size)
3461 : : {
3462 : 2267 : gcc_assert (!remap);
3463 : 2267 : vec_safe_reserve (remap, size);
3464 : 4829 : for (unsigned ix = size; ix--;)
3465 : 2562 : remap->quick_push (0);
3466 : 2267 : }
3467 : 1769207 : unsigned remap_module (unsigned owner)
3468 : : {
3469 : 1769207 : if (owner < remap->length ())
3470 : 1769207 : return (*remap)[owner] >> 1;
3471 : : return 0;
3472 : : }
3473 : :
3474 : : public:
3475 : : /* GC allocation. But we must explicitly delete it. */
3476 : 2285 : static void *operator new (size_t x)
3477 : : {
3478 : 4570 : return ggc_alloc_atomic (x);
3479 : : }
3480 : 2224 : static void operator delete (void *p)
3481 : : {
3482 : 2224 : ggc_free (p);
3483 : 2224 : }
3484 : : };
3485 : :
3486 : 2285 : slurping::slurping (elf_in *from)
3487 : 2285 : : remap (NULL), from (from),
3488 : 2285 : headers (BITMAP_GGC_ALLOC ()), macro_defs (), macro_tbl (),
3489 : 2285 : loc_deltas (0, 0),
3490 : 2285 : current (~0u), remaining (0), lru (0)
3491 : : {
3492 : 2285 : }
3493 : :
3494 : 2224 : slurping::~slurping ()
3495 : : {
3496 : 2224 : vec_free (remap);
3497 : 2224 : remap = NULL;
3498 : 2224 : release_macros ();
3499 : 2224 : close ();
3500 : 2224 : }
3501 : :
3502 : 4085 : void slurping::release_macros ()
3503 : : {
3504 : 4085 : if (macro_defs.size)
3505 : 748 : elf_in::release (from, macro_defs);
3506 : 4085 : if (macro_tbl.size)
3507 : 0 : elf_in::release (from, macro_tbl);
3508 : 4085 : }
3509 : :
3510 : : /* Flags for extensions that end up being streamed. */
3511 : :
3512 : : enum streamed_extensions {
3513 : : SE_OPENMP = 1 << 0,
3514 : : SE_BITS = 1
3515 : : };
3516 : :
3517 : : /* Counter indices. */
3518 : : enum module_state_counts
3519 : : {
3520 : : MSC_sec_lwm,
3521 : : MSC_sec_hwm,
3522 : : MSC_pendings,
3523 : : MSC_entities,
3524 : : MSC_namespaces,
3525 : : MSC_bindings,
3526 : : MSC_macros,
3527 : : MSC_inits,
3528 : : MSC_HWM
3529 : : };
3530 : :
3531 : : /********************************************************************/
3532 : : struct module_state_config;
3533 : :
3534 : : /* Increasing levels of loadedness. */
3535 : : enum module_loadedness {
3536 : : ML_NONE, /* Not loaded. */
3537 : : ML_CONFIG, /* Config loaed. */
3538 : : ML_PREPROCESSOR, /* Preprocessor loaded. */
3539 : : ML_LANGUAGE, /* Language loaded. */
3540 : : };
3541 : :
3542 : : /* Increasing levels of directness (toplevel) of import. */
3543 : : enum module_directness {
3544 : : MD_NONE, /* Not direct. */
3545 : : MD_PARTITION_DIRECT, /* Direct import of a partition. */
3546 : : MD_DIRECT, /* Direct import. */
3547 : : MD_PURVIEW_DIRECT, /* direct import in purview. */
3548 : : };
3549 : :
3550 : : /* State of a particular module. */
3551 : :
3552 : : class GTY((chain_next ("%h.parent"), for_user)) module_state {
3553 : : public:
3554 : : /* We always import & export ourselves. */
3555 : : bitmap imports; /* Transitive modules we're importing. */
3556 : : bitmap exports; /* Subset of that, that we're exporting. */
3557 : :
3558 : : module_state *parent;
3559 : : tree name; /* Name of the module. */
3560 : :
3561 : : slurping *slurp; /* Data for loading. */
3562 : :
3563 : : const char *flatname; /* Flatname of module. */
3564 : : char *filename; /* CMI Filename */
3565 : :
3566 : : /* Indices into the entity_ary. */
3567 : : unsigned entity_lwm;
3568 : : unsigned entity_num;
3569 : :
3570 : : /* Location ranges for this module. adhoc-locs are decomposed, so
3571 : : don't have a range. */
3572 : : loc_range_t GTY((skip)) ordinary_locs;
3573 : : loc_range_t GTY((skip)) macro_locs; // [lwm,num)
3574 : :
3575 : : /* LOC is first set too the importing location. When initially
3576 : : loaded it refers to a module loc whose parent is the importing
3577 : : location. */
3578 : : location_t loc; /* Location referring to module itself. */
3579 : : unsigned crc; /* CRC we saw reading it in. */
3580 : :
3581 : : unsigned mod; /* Module owner number. */
3582 : : unsigned remap; /* Remapping during writing. */
3583 : :
3584 : : unsigned short subst; /* Mangle subst if !0. */
3585 : :
3586 : : /* How loaded this module is. */
3587 : : enum module_loadedness loadedness : 2;
3588 : :
3589 : : bool module_p : 1; /* /The/ module of this TU. */
3590 : : bool header_p : 1; /* Is a header unit. */
3591 : : bool interface_p : 1; /* An interface. */
3592 : : bool partition_p : 1; /* A partition. */
3593 : :
3594 : : /* How directly this module is imported. */
3595 : : enum module_directness directness : 2;
3596 : :
3597 : : bool exported_p : 1; /* directness != MD_NONE && exported. */
3598 : : bool cmi_noted_p : 1; /* We've told the user about the CMI, don't
3599 : : do it again */
3600 : : bool active_init_p : 1; /* This module's global initializer needs
3601 : : calling. */
3602 : : bool inform_cmi_p : 1; /* Inform of a read/write. */
3603 : : bool visited_p : 1; /* A walk-once flag. */
3604 : : /* Record extensions emitted or permitted. */
3605 : : unsigned extensions : SE_BITS;
3606 : : /* 14 bits used, 2 bits remain */
3607 : :
3608 : : public:
3609 : : module_state (tree name, module_state *, bool);
3610 : : ~module_state ();
3611 : :
3612 : : public:
3613 : 2284 : void release ()
3614 : : {
3615 : 2284 : imports = exports = NULL;
3616 : 2284 : slurped ();
3617 : 2224 : }
3618 : 4145 : void slurped ()
3619 : : {
3620 : 4145 : delete slurp;
3621 : 4145 : slurp = NULL;
3622 : 4145 : }
3623 : 2109698 : elf_in *from () const
3624 : : {
3625 : 2109698 : return slurp->from;
3626 : : }
3627 : :
3628 : : public:
3629 : : /* Kind of this module. */
3630 : 216502 : bool is_module () const
3631 : : {
3632 : 216502 : return module_p;
3633 : : }
3634 : 2901288 : bool is_header () const
3635 : : {
3636 : 2901288 : return header_p;
3637 : : }
3638 : 438 : bool is_interface () const
3639 : : {
3640 : 438 : return interface_p;
3641 : : }
3642 : 1109405 : bool is_partition () const
3643 : : {
3644 : 1109405 : return partition_p;
3645 : : }
3646 : :
3647 : : /* How this module is used in the current TU. */
3648 : 30 : bool is_exported () const
3649 : : {
3650 : 30 : return exported_p;
3651 : : }
3652 : 15686 : bool is_direct () const
3653 : : {
3654 : 15686 : return directness >= MD_DIRECT;
3655 : : }
3656 : 216 : bool is_purview_direct () const
3657 : : {
3658 : 216 : return directness == MD_PURVIEW_DIRECT;
3659 : : }
3660 : 318 : bool is_partition_direct () const
3661 : : {
3662 : 318 : return directness == MD_PARTITION_DIRECT;
3663 : : }
3664 : :
3665 : : public:
3666 : : /* Is this a real module? */
3667 : 12618 : bool has_location () const
3668 : : {
3669 : 12618 : return loc != UNKNOWN_LOCATION;
3670 : : }
3671 : :
3672 : : public:
3673 : : bool check_not_purview (location_t loc);
3674 : :
3675 : : public:
3676 : : void mangle (bool include_partition);
3677 : :
3678 : : public:
3679 : : void set_import (module_state const *, bool is_export);
3680 : : void announce (const char *) const;
3681 : :
3682 : : public:
3683 : : /* Read and write module. */
3684 : : bool write_begin (elf_out *to, cpp_reader *,
3685 : : module_state_config &, unsigned &crc);
3686 : : void write_end (elf_out *to, cpp_reader *,
3687 : : module_state_config &, unsigned &crc);
3688 : : bool read_initial (cpp_reader *);
3689 : : bool read_preprocessor (bool);
3690 : : bool read_language (bool);
3691 : :
3692 : : public:
3693 : : /* Read a section. */
3694 : : bool load_section (unsigned snum, binding_slot *mslot);
3695 : : /* Lazily read a section. */
3696 : : bool lazy_load (unsigned index, binding_slot *mslot);
3697 : :
3698 : : public:
3699 : : /* Juggle a limited number of file numbers. */
3700 : : static void freeze_an_elf ();
3701 : : bool maybe_defrost ();
3702 : :
3703 : : public:
3704 : : void maybe_completed_reading ();
3705 : : bool check_read (bool outermost, bool ok);
3706 : :
3707 : : private:
3708 : : /* The README, for human consumption. */
3709 : : void write_readme (elf_out *to, cpp_reader *, const char *dialect);
3710 : : void write_env (elf_out *to);
3711 : :
3712 : : private:
3713 : : /* Import tables. */
3714 : : void write_imports (bytes_out &cfg, bool direct);
3715 : : unsigned read_imports (bytes_in &cfg, cpp_reader *, line_maps *maps);
3716 : :
3717 : : private:
3718 : : void write_imports (elf_out *to, unsigned *crc_ptr);
3719 : : bool read_imports (cpp_reader *, line_maps *);
3720 : :
3721 : : private:
3722 : : void write_partitions (elf_out *to, unsigned, unsigned *crc_ptr);
3723 : : bool read_partitions (unsigned);
3724 : :
3725 : : private:
3726 : : void write_config (elf_out *to, struct module_state_config &, unsigned crc);
3727 : : bool read_config (struct module_state_config &);
3728 : : static void write_counts (elf_out *to, unsigned [MSC_HWM], unsigned *crc_ptr);
3729 : : bool read_counts (unsigned *);
3730 : :
3731 : : public:
3732 : : void note_cmi_name ();
3733 : :
3734 : : private:
3735 : : static unsigned write_bindings (elf_out *to, vec<depset *> depsets,
3736 : : unsigned *crc_ptr);
3737 : : bool read_bindings (unsigned count, unsigned lwm, unsigned hwm);
3738 : :
3739 : : static void write_namespace (bytes_out &sec, depset *ns_dep);
3740 : : tree read_namespace (bytes_in &sec);
3741 : :
3742 : : void write_namespaces (elf_out *to, vec<depset *> spaces,
3743 : : unsigned, unsigned *crc_ptr);
3744 : : bool read_namespaces (unsigned);
3745 : :
3746 : : void intercluster_seed (trees_out &sec, unsigned index, depset *dep);
3747 : : unsigned write_cluster (elf_out *to, depset *depsets[], unsigned size,
3748 : : depset::hash &, unsigned *counts, unsigned *crc_ptr);
3749 : : bool read_cluster (unsigned snum);
3750 : :
3751 : : private:
3752 : : unsigned write_inits (elf_out *to, depset::hash &, unsigned *crc_ptr);
3753 : : bool read_inits (unsigned count);
3754 : :
3755 : : private:
3756 : : unsigned write_pendings (elf_out *to, vec<depset *> depsets,
3757 : : depset::hash &, unsigned *crc_ptr);
3758 : : bool read_pendings (unsigned count);
3759 : :
3760 : : private:
3761 : : void write_entities (elf_out *to, vec<depset *> depsets,
3762 : : unsigned count, unsigned *crc_ptr);
3763 : : bool read_entities (unsigned count, unsigned lwm, unsigned hwm);
3764 : :
3765 : : private:
3766 : : void write_init_maps ();
3767 : : range_t write_prepare_maps (module_state_config *, bool);
3768 : : bool read_prepare_maps (const module_state_config *);
3769 : :
3770 : : void write_ordinary_maps (elf_out *to, range_t &,
3771 : : bool, unsigned *crc_ptr);
3772 : : bool read_ordinary_maps (unsigned, unsigned);
3773 : : void write_macro_maps (elf_out *to, range_t &, unsigned *crc_ptr);
3774 : : bool read_macro_maps (unsigned);
3775 : :
3776 : : private:
3777 : : void write_define (bytes_out &, const cpp_macro *);
3778 : : cpp_macro *read_define (bytes_in &, cpp_reader *) const;
3779 : : vec<cpp_hashnode *> *prepare_macros (cpp_reader *);
3780 : : unsigned write_macros (elf_out *to, vec<cpp_hashnode *> *, unsigned *crc_ptr);
3781 : : bool read_macros ();
3782 : : void install_macros ();
3783 : :
3784 : : public:
3785 : : void import_macros ();
3786 : :
3787 : : public:
3788 : : static void undef_macro (cpp_reader *, location_t, cpp_hashnode *);
3789 : : static cpp_macro *deferred_macro (cpp_reader *, location_t, cpp_hashnode *);
3790 : :
3791 : : public:
3792 : : static bool note_location (location_t);
3793 : : static void write_location (bytes_out &, location_t);
3794 : : location_t read_location (bytes_in &) const;
3795 : :
3796 : : public:
3797 : : void set_flatname ();
3798 : 37889 : const char *get_flatname () const
3799 : : {
3800 : 37889 : return flatname;
3801 : : }
3802 : : location_t imported_from () const;
3803 : :
3804 : : public:
3805 : : void set_filename (const Cody::Packet &);
3806 : : bool do_import (cpp_reader *, bool outermost);
3807 : : };
3808 : :
3809 : : /* Hash module state by name. This cannot be a member of
3810 : : module_state, because of GTY restrictions. We never delete from
3811 : : the hash table, but ggc_ptr_hash doesn't support that
3812 : : simplification. */
3813 : :
3814 : : struct module_state_hash : ggc_ptr_hash<module_state> {
3815 : : typedef std::pair<tree,uintptr_t> compare_type; /* {name,parent} */
3816 : :
3817 : : static inline hashval_t hash (const value_type m);
3818 : : static inline hashval_t hash (const compare_type &n);
3819 : : static inline bool equal (const value_type existing,
3820 : : const compare_type &candidate);
3821 : : };
3822 : :
3823 : 8491 : module_state::module_state (tree name, module_state *parent, bool partition)
3824 : 8491 : : imports (BITMAP_GGC_ALLOC ()), exports (BITMAP_GGC_ALLOC ()),
3825 : 8491 : parent (parent), name (name), slurp (NULL),
3826 : 8491 : flatname (NULL), filename (NULL),
3827 : 8491 : entity_lwm (~0u >> 1), entity_num (0),
3828 : 8491 : ordinary_locs (0, 0), macro_locs (0, 0),
3829 : 8491 : loc (UNKNOWN_LOCATION),
3830 : 8491 : crc (0), mod (MODULE_UNKNOWN), remap (0), subst (0)
3831 : : {
3832 : 8491 : loadedness = ML_NONE;
3833 : :
3834 : 8491 : module_p = header_p = interface_p = partition_p = false;
3835 : :
3836 : 8491 : directness = MD_NONE;
3837 : 8491 : exported_p = false;
3838 : :
3839 : 8491 : cmi_noted_p = false;
3840 : 8491 : active_init_p = false;
3841 : :
3842 : 8491 : partition_p = partition;
3843 : :
3844 : 8491 : inform_cmi_p = false;
3845 : 8491 : visited_p = false;
3846 : :
3847 : 8491 : extensions = 0;
3848 : 8491 : if (name && TREE_CODE (name) == STRING_CST)
3849 : : {
3850 : 1592 : header_p = true;
3851 : :
3852 : 1592 : const char *string = TREE_STRING_POINTER (name);
3853 : 1592 : gcc_checking_assert (string[0] == '.'
3854 : : ? IS_DIR_SEPARATOR (string[1])
3855 : : : IS_ABSOLUTE_PATH (string));
3856 : : }
3857 : :
3858 : 8491 : gcc_checking_assert (!(parent && header_p));
3859 : 8491 : }
3860 : :
3861 : 60 : module_state::~module_state ()
3862 : : {
3863 : 60 : release ();
3864 : 60 : }
3865 : :
3866 : : /* Hash module state. */
3867 : : static hashval_t
3868 : 12125 : module_name_hash (const_tree name)
3869 : : {
3870 : 12125 : if (TREE_CODE (name) == STRING_CST)
3871 : 2969 : return htab_hash_string (TREE_STRING_POINTER (name));
3872 : : else
3873 : 9156 : return IDENTIFIER_HASH_VALUE (name);
3874 : : }
3875 : :
3876 : : hashval_t
3877 : 3103 : module_state_hash::hash (const value_type m)
3878 : : {
3879 : 3103 : hashval_t ph = pointer_hash<void>::hash
3880 : 3103 : (reinterpret_cast<void *> (reinterpret_cast<uintptr_t> (m->parent)
3881 : 3103 : | m->is_partition ()));
3882 : 3103 : hashval_t nh = module_name_hash (m->name);
3883 : 3103 : return iterative_hash_hashval_t (ph, nh);
3884 : : }
3885 : :
3886 : : /* Hash a name. */
3887 : : hashval_t
3888 : 9022 : module_state_hash::hash (const compare_type &c)
3889 : : {
3890 : 9022 : hashval_t ph = pointer_hash<void>::hash (reinterpret_cast<void *> (c.second));
3891 : 9022 : hashval_t nh = module_name_hash (c.first);
3892 : :
3893 : 9022 : return iterative_hash_hashval_t (ph, nh);
3894 : : }
3895 : :
3896 : : bool
3897 : 6115 : module_state_hash::equal (const value_type existing,
3898 : : const compare_type &candidate)
3899 : : {
3900 : 6115 : uintptr_t ep = (reinterpret_cast<uintptr_t> (existing->parent)
3901 : 6115 : | existing->is_partition ());
3902 : 6115 : if (ep != candidate.second)
3903 : : return false;
3904 : :
3905 : : /* Identifier comparison is by pointer. If the string_csts happen
3906 : : to be the same object, then they're equal too. */
3907 : 5100 : if (existing->name == candidate.first)
3908 : : return true;
3909 : :
3910 : : /* If neither are string csts, they can't be equal. */
3911 : 1087 : if (TREE_CODE (candidate.first) != STRING_CST
3912 : 436 : || TREE_CODE (existing->name) != STRING_CST)
3913 : : return false;
3914 : :
3915 : : /* String equality. */
3916 : 381 : if (TREE_STRING_LENGTH (existing->name)
3917 : 381 : == TREE_STRING_LENGTH (candidate.first)
3918 : 381 : && !memcmp (TREE_STRING_POINTER (existing->name),
3919 : 378 : TREE_STRING_POINTER (candidate.first),
3920 : 378 : TREE_STRING_LENGTH (existing->name)))
3921 : 122 : return true;
3922 : :
3923 : : return false;
3924 : : }
3925 : :
3926 : : /********************************************************************/
3927 : : /* Global state */
3928 : :
3929 : : /* Mapper name. */
3930 : : static const char *module_mapper_name;
3931 : :
3932 : : /* Deferred import queue (FIFO). */
3933 : : static vec<module_state *, va_heap, vl_embed> *pending_imports;
3934 : :
3935 : : /* CMI repository path and workspace. */
3936 : : static char *cmi_repo;
3937 : : static size_t cmi_repo_length;
3938 : : static char *cmi_path;
3939 : : static size_t cmi_path_alloc;
3940 : :
3941 : : /* Count of available and loaded clusters. */
3942 : : static unsigned available_clusters;
3943 : : static unsigned loaded_clusters;
3944 : :
3945 : : /* What the current TU is. */
3946 : : unsigned module_kind;
3947 : :
3948 : : /* Global trees. */
3949 : : static const std::pair<tree *, unsigned> global_tree_arys[] =
3950 : : {
3951 : : std::pair<tree *, unsigned> (sizetype_tab, stk_type_kind_last),
3952 : : std::pair<tree *, unsigned> (integer_types, itk_none),
3953 : : std::pair<tree *, unsigned> (global_trees, TI_MODULE_HWM),
3954 : : std::pair<tree *, unsigned> (c_global_trees, CTI_MODULE_HWM),
3955 : : std::pair<tree *, unsigned> (cp_global_trees, CPTI_MODULE_HWM),
3956 : : std::pair<tree *, unsigned> (NULL, 0)
3957 : : };
3958 : : static GTY(()) vec<tree, va_gc> *fixed_trees;
3959 : : static unsigned global_crc;
3960 : :
3961 : : /* Lazy loading can open many files concurrently, there are
3962 : : per-process limits on that. We pay attention to the process limit,
3963 : : and attempt to increase it when we run out. Otherwise we use an
3964 : : LRU scheme to figure out who to flush. Note that if the import
3965 : : graph /depth/ exceeds lazy_limit, we'll exceed the limit. */
3966 : : static unsigned lazy_lru; /* LRU counter. */
3967 : : static unsigned lazy_open; /* Number of open modules */
3968 : : static unsigned lazy_limit; /* Current limit of open modules. */
3969 : : static unsigned lazy_hard_limit; /* Hard limit on open modules. */
3970 : : /* Account for source, assembler and dump files & directory searches.
3971 : : We don't keep the source file's open, so we don't have to account
3972 : : for #include depth. I think dump files are opened and closed per
3973 : : pass, but ICBW. */
3974 : : #define LAZY_HEADROOM 15 /* File descriptor headroom. */
3975 : :
3976 : : /* Vector of module state. Indexed by OWNER. Has at least 2 slots. */
3977 : : static GTY(()) vec<module_state *, va_gc> *modules;
3978 : :
3979 : : /* Hash of module state, findable by {name, parent}. */
3980 : : static GTY(()) hash_table<module_state_hash> *modules_hash;
3981 : :
3982 : : /* Map of imported entities. We map DECL_UID to index of entity
3983 : : vector. */
3984 : : typedef hash_map<unsigned/*UID*/, unsigned/*index*/,
3985 : : simple_hashmap_traits<int_hash<unsigned,0>, unsigned>
3986 : : > entity_map_t;
3987 : : static entity_map_t *entity_map;
3988 : : /* Doesn't need GTYing, because any tree referenced here is also
3989 : : findable by, symbol table, specialization table, return type of
3990 : : reachable function. */
3991 : : static vec<binding_slot, va_heap, vl_embed> *entity_ary;
3992 : :
3993 : : /* Members entities of imported classes that are defined in this TU.
3994 : : These are where the entity's context is not from the current TU.
3995 : : We need to emit the definition (but not the enclosing class).
3996 : :
3997 : : We could find these by walking ALL the imported classes that we
3998 : : could provide a member definition. But that's expensive,
3999 : : especially when you consider lazy implicit member declarations,
4000 : : which could be ANY imported class. */
4001 : : static GTY(()) vec<tree, va_gc> *class_members;
4002 : :
4003 : : /* The same problem exists for class template partial
4004 : : specializations. Now that we have constraints, the invariant of
4005 : : expecting them in the instantiation table no longer holds. One of
4006 : : the constrained partial specializations will be there, but the
4007 : : others not so much. It's not even an unconstrained partial
4008 : : spacialization in the table :( so any partial template declaration
4009 : : is added to this list too. */
4010 : : static GTY(()) vec<tree, va_gc> *partial_specializations;
4011 : :
4012 : : /********************************************************************/
4013 : :
4014 : : /* Our module mapper (created lazily). */
4015 : : module_client *mapper;
4016 : :
4017 : : static module_client *make_mapper (location_t loc, class mkdeps *deps);
4018 : 36274 : inline module_client *get_mapper (location_t loc, class mkdeps *deps)
4019 : : {
4020 : 36274 : auto *res = mapper;
4021 : 263 : if (!res)
4022 : 3604 : res = make_mapper (loc, deps);
4023 : 36274 : return res;
4024 : : }
4025 : :
4026 : : /********************************************************************/
4027 : : static tree
4028 : 396848 : get_clone_target (tree decl)
4029 : : {
4030 : 396848 : tree target;
4031 : :
4032 : 396848 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4033 : : {
4034 : 43608 : tree res_orig = DECL_CLONED_FUNCTION (DECL_TEMPLATE_RESULT (decl));
4035 : :
4036 : 43608 : target = DECL_TI_TEMPLATE (res_orig);
4037 : : }
4038 : : else
4039 : 353240 : target = DECL_CLONED_FUNCTION (decl);
4040 : :
4041 : 396848 : gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (target));
4042 : :
4043 : 396848 : return target;
4044 : : }
4045 : :
4046 : : /* Like FOR_EACH_CLONE, but will walk cloned templates. */
4047 : : #define FOR_EVERY_CLONE(CLONE, FN) \
4048 : : if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)); \
4049 : : else \
4050 : : for (CLONE = DECL_CHAIN (FN); \
4051 : : CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
4052 : : CLONE = DECL_CHAIN (CLONE))
4053 : :
4054 : : /* It'd be nice if USE_TEMPLATE was a field of template_info
4055 : : (a) it'd solve the enum case dealt with below,
4056 : : (b) both class templates and decl templates would store this in the
4057 : : same place
4058 : : (c) this function wouldn't need the by-ref arg, which is annoying. */
4059 : :
4060 : : static tree
4061 : 176807399 : node_template_info (tree decl, int &use)
4062 : : {
4063 : 176807399 : tree ti = NULL_TREE;
4064 : 176807399 : int use_tpl = -1;
4065 : 176807399 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
4066 : : {
4067 : 20166841 : tree type = TREE_TYPE (decl);
4068 : :
4069 : 20166841 : ti = TYPE_TEMPLATE_INFO (type);
4070 : 20166841 : if (ti)
4071 : : {
4072 : 4932460 : if (TYPE_LANG_SPECIFIC (type))
4073 : 4925570 : use_tpl = CLASSTYPE_USE_TEMPLATE (type);
4074 : : else
4075 : : {
4076 : : /* An enum, where we don't explicitly encode use_tpl.
4077 : : If the containing context (a type or a function), is
4078 : : an ({im,ex}plicit) instantiation, then this is too.
4079 : : If it's a partial or explicit specialization, then
4080 : : this is not!. */
4081 : 6890 : tree ctx = CP_DECL_CONTEXT (decl);
4082 : 6890 : if (TYPE_P (ctx))
4083 : 6755 : ctx = TYPE_NAME (ctx);
4084 : 6890 : node_template_info (ctx, use);
4085 : 6890 : use_tpl = use != 2 ? use : 0;
4086 : : }
4087 : : }
4088 : : }
4089 : 156640558 : else if (DECL_LANG_SPECIFIC (decl)
4090 : 156640558 : && (VAR_P (decl)
4091 : : || TREE_CODE (decl) == TYPE_DECL
4092 : : || TREE_CODE (decl) == FUNCTION_DECL
4093 : : || TREE_CODE (decl) == FIELD_DECL
4094 : : || TREE_CODE (decl) == CONCEPT_DECL
4095 : : || TREE_CODE (decl) == TEMPLATE_DECL))
4096 : : {
4097 : 85243392 : use_tpl = DECL_USE_TEMPLATE (decl);
4098 : 85243392 : ti = DECL_TEMPLATE_INFO (decl);
4099 : : }
4100 : :
4101 : 176807399 : use = use_tpl;
4102 : 176807399 : return ti;
4103 : : }
4104 : :
4105 : : /* Find the index in entity_ary for an imported DECL. It should
4106 : : always be there, but bugs can cause it to be missing, and that can
4107 : : crash the crash reporting -- let's not do that! When streaming
4108 : : out we place entities from this module there too -- with negated
4109 : : indices. */
4110 : :
4111 : : static unsigned
4112 : 1546046 : import_entity_index (tree decl, bool null_ok = false)
4113 : : {
4114 : 1546046 : if (unsigned *slot = entity_map->get (DECL_UID (decl)))
4115 : 1546031 : return *slot;
4116 : :
4117 : 15 : gcc_checking_assert (null_ok);
4118 : : return ~(~0u >> 1);
4119 : : }
4120 : :
4121 : : /* Find the module for an imported entity at INDEX in the entity ary.
4122 : : There must be one. */
4123 : :
4124 : : static module_state *
4125 : 33609 : import_entity_module (unsigned index)
4126 : : {
4127 : 33609 : if (index > ~(~0u >> 1))
4128 : : /* This is an index for an exported entity. */
4129 : 18 : return (*modules)[0];
4130 : :
4131 : : /* Do not include the current TU (not an off-by-one error). */
4132 : 33591 : unsigned pos = 1;
4133 : 33591 : unsigned len = modules->length () - pos;
4134 : 73951 : while (len)
4135 : : {
4136 : 40360 : unsigned half = len / 2;
4137 : 40360 : module_state *probe = (*modules)[pos + half];
4138 : 40360 : if (index < probe->entity_lwm)
4139 : : len = half;
4140 : 33703 : else if (index < probe->entity_lwm + probe->entity_num)
4141 : 33591 : return probe;
4142 : : else
4143 : : {
4144 : 112 : pos += half + 1;
4145 : 112 : len = len - (half + 1);
4146 : : }
4147 : : }
4148 : 0 : gcc_unreachable ();
4149 : : }
4150 : :
4151 : :
4152 : : /********************************************************************/
4153 : : /* A dumping machinery. */
4154 : :
4155 : : class dumper {
4156 : : public:
4157 : : enum {
4158 : : LOCATION = TDF_LINENO, /* -lineno:Source location streaming. */
4159 : : DEPEND = TDF_GRAPH, /* -graph:Dependency graph construction. */
4160 : : CLUSTER = TDF_BLOCKS, /* -blocks:Clusters. */
4161 : : TREE = TDF_UID, /* -uid:Tree streaming. */
4162 : : MERGE = TDF_ALIAS, /* -alias:Mergeable Entities. */
4163 : : ELF = TDF_ASMNAME, /* -asmname:Elf data. */
4164 : : MACRO = TDF_VOPS /* -vops:Macros. */
4165 : : };
4166 : :
4167 : : private:
4168 : : struct impl {
4169 : : typedef vec<module_state *, va_heap, vl_embed> stack_t;
4170 : :
4171 : : FILE *stream; /* Dump stream. */
4172 : : unsigned indent; /* Local indentation. */
4173 : : bool bol; /* Beginning of line. */
4174 : : stack_t stack; /* Trailing array of module_state. */
4175 : :
4176 : : bool nested_name (tree); /* Dump a name following DECL_CONTEXT. */
4177 : : };
4178 : :
4179 : : public:
4180 : : /* The dumper. */
4181 : : impl *dumps;
4182 : : dump_flags_t flags;
4183 : :
4184 : : public:
4185 : : /* Push/pop module state dumping. */
4186 : : unsigned push (module_state *);
4187 : : void pop (unsigned);
4188 : :
4189 : : public:
4190 : : /* Change local indentation. */
4191 : 449979935 : void indent ()
4192 : : {
4193 : 282 : if (dumps)
4194 : 7076265 : dumps->indent++;
4195 : : }
4196 : 449979935 : void outdent ()
4197 : : {
4198 : 449979935 : if (dumps)
4199 : : {
4200 : 7076265 : gcc_checking_assert (dumps->indent);
4201 : 7076265 : dumps->indent--;
4202 : : }
4203 : 449979935 : }
4204 : :
4205 : : public:
4206 : : /* Is dump enabled?. */
4207 : 298680068 : bool operator () (int mask = 0)
4208 : : {
4209 : 7985370 : if (!dumps || !dumps->stream)
4210 : : return false;
4211 : 3210688 : if (mask && !(mask & flags))
4212 : 29148 : return false;
4213 : : return true;
4214 : : }
4215 : : /* Dump some information. */
4216 : : bool operator () (const char *, ...);
4217 : : };
4218 : :
4219 : : /* The dumper. */
4220 : : static dumper dump = {0, dump_flags_t (0)};
4221 : :
4222 : : /* Push to dumping M. Return previous indentation level. */
4223 : :
4224 : : unsigned
4225 : 97506 : dumper::push (module_state *m)
4226 : : {
4227 : 97506 : FILE *stream = NULL;
4228 : 97506 : if (!dumps || !dumps->stack.length ())
4229 : : {
4230 : 96451 : stream = dump_begin (module_dump_id, &flags);
4231 : 96451 : if (!stream)
4232 : : return 0;
4233 : : }
4234 : :
4235 : 5794 : if (!dumps || !dumps->stack.space (1))
4236 : : {
4237 : : /* Create or extend the dump implementor. */
4238 : 1029 : unsigned current = dumps ? dumps->stack.length () : 0;
4239 : 540 : unsigned count = current ? current * 2 : EXPERIMENT (1, 20);
4240 : 1029 : size_t alloc = (offsetof (impl, stack)
4241 : 1029 : + impl::stack_t::embedded_size (count));
4242 : 1029 : dumps = XRESIZEVAR (impl, dumps, alloc);
4243 : 1029 : dumps->stack.embedded_init (count, current);
4244 : : }
4245 : 5794 : if (stream)
4246 : 4739 : dumps->stream = stream;
4247 : :
4248 : 5794 : unsigned n = dumps->indent;
4249 : 5794 : dumps->indent = 0;
4250 : 5794 : dumps->bol = true;
4251 : 5794 : dumps->stack.quick_push (m);
4252 : 5794 : if (m)
4253 : : {
4254 : 1677 : module_state *from = NULL;
4255 : :
4256 : 1677 : if (dumps->stack.length () > 1)
4257 : 530 : from = dumps->stack[dumps->stack.length () - 2];
4258 : : else
4259 : 1147 : dump ("");
4260 : 3054 : dump (from ? "Starting module %M (from %M)"
4261 : : : "Starting module %M", m, from);
4262 : : }
4263 : :
4264 : : return n;
4265 : : }
4266 : :
4267 : : /* Pop from dumping. Restore indentation to N. */
4268 : :
4269 : 97472 : void dumper::pop (unsigned n)
4270 : : {
4271 : 97472 : if (!dumps)
4272 : : return;
4273 : :
4274 : 11588 : gcc_checking_assert (dump () && !dumps->indent);
4275 : 5794 : if (module_state *m = dumps->stack[dumps->stack.length () - 1])
4276 : : {
4277 : 1677 : module_state *from = (dumps->stack.length () > 1
4278 : 1677 : ? dumps->stack[dumps->stack.length () - 2] : NULL);
4279 : 1907 : dump (from ? "Finishing module %M (returning to %M)"
4280 : : : "Finishing module %M", m, from);
4281 : : }
4282 : 5794 : dumps->stack.pop ();
4283 : 5794 : dumps->indent = n;
4284 : 5794 : if (!dumps->stack.length ())
4285 : : {
4286 : 4739 : dump_end (module_dump_id, dumps->stream);
4287 : 4739 : dumps->stream = NULL;
4288 : : }
4289 : : }
4290 : :
4291 : : /* Dump a nested name for arbitrary tree T. Sometimes it won't have a
4292 : : name. */
4293 : :
4294 : : bool
4295 : 1902076 : dumper::impl::nested_name (tree t)
4296 : : {
4297 : 1902076 : tree ti = NULL_TREE;
4298 : 1902076 : int origin = -1;
4299 : 1902076 : tree name = NULL_TREE;
4300 : :
4301 : 1902076 : if (t && TREE_CODE (t) == TREE_BINFO)
4302 : 378 : t = BINFO_TYPE (t);
4303 : :
4304 : 1902052 : if (t && TYPE_P (t))
4305 : 906802 : t = TYPE_NAME (t);
4306 : :
4307 : 1902064 : if (t && DECL_P (t))
4308 : : {
4309 : 1751499 : if (t == global_namespace || DECL_TEMPLATE_PARM_P (t))
4310 : : ;
4311 : 1590522 : else if (tree ctx = DECL_CONTEXT (t))
4312 : 1262584 : if (TREE_CODE (ctx) == TRANSLATION_UNIT_DECL
4313 : 1262584 : || nested_name (ctx))
4314 : 1262584 : fputs ("::", stream);
4315 : :
4316 : 1751499 : int use_tpl;
4317 : 1751499 : ti = node_template_info (t, use_tpl);
4318 : 476105 : if (ti && TREE_CODE (TI_TEMPLATE (ti)) == TEMPLATE_DECL
4319 : 2227550 : && (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == t))
4320 : : t = TI_TEMPLATE (ti);
4321 : 1751499 : tree not_tmpl = t;
4322 : 1751499 : if (TREE_CODE (t) == TEMPLATE_DECL)
4323 : : {
4324 : 173731 : fputs ("template ", stream);
4325 : 173731 : not_tmpl = DECL_TEMPLATE_RESULT (t);
4326 : : }
4327 : :
4328 : 173731 : if (not_tmpl
4329 : 1751459 : && DECL_P (not_tmpl)
4330 : 1751459 : && DECL_LANG_SPECIFIC (not_tmpl)
4331 : 1029314 : && DECL_MODULE_IMPORT_P (not_tmpl))
4332 : : {
4333 : : /* We need to be careful here, so as to not explode on
4334 : : inconsistent data -- we're probably debugging, because
4335 : : Something Is Wrong. */
4336 : 16272 : unsigned index = import_entity_index (t, true);
4337 : 16272 : if (!(index & ~(~0u >> 1)))
4338 : 15759 : origin = import_entity_module (index)->mod;
4339 : 513 : else if (index > ~(~0u >> 1))
4340 : : /* An imported partition member that we're emitting. */
4341 : : origin = 0;
4342 : : else
4343 : 15 : origin = -2;
4344 : : }
4345 : :
4346 : 1751499 : name = DECL_NAME (t) ? DECL_NAME (t)
4347 : 7125 : : HAS_DECL_ASSEMBLER_NAME_P (t) ? DECL_ASSEMBLER_NAME_RAW (t)
4348 : : : NULL_TREE;
4349 : 1751499 : }
4350 : : else
4351 : : name = t;
4352 : :
4353 : 1902076 : if (name)
4354 : 1834771 : switch (TREE_CODE (name))
4355 : : {
4356 : 29234 : default:
4357 : 29234 : fputs ("#unnamed#", stream);
4358 : 29234 : break;
4359 : :
4360 : 1768113 : case IDENTIFIER_NODE:
4361 : 1768113 : fwrite (IDENTIFIER_POINTER (name), 1, IDENTIFIER_LENGTH (name), stream);
4362 : 1768113 : break;
4363 : :
4364 : 37361 : case INTEGER_CST:
4365 : 37361 : print_hex (wi::to_wide (name), stream);
4366 : 37361 : break;
4367 : :
4368 : 63 : case STRING_CST:
4369 : : /* If TREE_TYPE is NULL, this is a raw string. */
4370 : 126 : fwrite (TREE_STRING_POINTER (name), 1,
4371 : 63 : TREE_STRING_LENGTH (name) - (TREE_TYPE (name) != NULL_TREE),
4372 : : stream);
4373 : 63 : break;
4374 : : }
4375 : : else
4376 : 67305 : fputs ("#null#", stream);
4377 : :
4378 : 1902076 : if (origin >= 0)
4379 : : {
4380 : 16257 : const module_state *module = (*modules)[origin];
4381 : 32514 : fprintf (stream, "@%s:%d", !module ? "" : !module->name ? "(unnamed)"
4382 : 16257 : : module->get_flatname (), origin);
4383 : : }
4384 : 1885819 : else if (origin == -2)
4385 : 15 : fprintf (stream, "@???");
4386 : :
4387 : 1902076 : if (ti)
4388 : : {
4389 : 476105 : tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (ti));
4390 : 476105 : fputs ("<", stream);
4391 : 476105 : if (args)
4392 : 1238813 : for (int ix = 0; ix != TREE_VEC_LENGTH (args); ix++)
4393 : : {
4394 : 762708 : if (ix)
4395 : 286615 : fputs (",", stream);
4396 : 762708 : nested_name (TREE_VEC_ELT (args, ix));
4397 : : }
4398 : 476105 : fputs (">", stream);
4399 : : }
4400 : :
4401 : 1902076 : return true;
4402 : : }
4403 : :
4404 : : /* Formatted dumping. FORMAT begins with '+' do not emit a trailing
4405 : : new line. (Normally it is appended.)
4406 : : Escapes:
4407 : : %C - tree_code
4408 : : %I - identifier
4409 : : %M - module_state
4410 : : %N - name -- DECL_NAME
4411 : : %P - context:name pair
4412 : : %R - unsigned:unsigned ratio
4413 : : %S - symbol -- DECL_ASSEMBLER_NAME
4414 : : %U - long unsigned
4415 : : %V - version
4416 : : --- the following are printf-like, but without its flexibility
4417 : : %d - decimal int
4418 : : %p - pointer
4419 : : %s - string
4420 : : %u - unsigned int
4421 : : %x - hex int
4422 : :
4423 : : We do not implement the printf modifiers. */
4424 : :
4425 : : bool
4426 : 636923 : dumper::operator () (const char *format, ...)
4427 : : {
4428 : 636923 : if (!(*this) ())
4429 : : return false;
4430 : :
4431 : 591466 : bool no_nl = format[0] == '+';
4432 : 591466 : format += no_nl;
4433 : :
4434 : 591466 : if (dumps->bol)
4435 : : {
4436 : : /* Module import indent. */
4437 : 437431 : if (unsigned depth = dumps->stack.length () - 1)
4438 : : {
4439 : 18537 : const char *prefix = ">>>>";
4440 : 37074 : fprintf (dumps->stream, (depth <= strlen (prefix)
4441 : 18537 : ? &prefix[strlen (prefix) - depth]
4442 : : : ">.%d.>"), depth);
4443 : : }
4444 : :
4445 : : /* Local indent. */
4446 : 437431 : if (unsigned indent = dumps->indent)
4447 : : {
4448 : 325122 : const char *prefix = " ";
4449 : 613647 : fprintf (dumps->stream, (indent <= strlen (prefix)
4450 : 288525 : ? &prefix[strlen (prefix) - indent]
4451 : : : " .%d. "), indent);
4452 : : }
4453 : 437431 : dumps->bol = false;
4454 : : }
4455 : :
4456 : 591466 : va_list args;
4457 : 591466 : va_start (args, format);
4458 : 2195447 : while (const char *esc = strchr (format, '%'))
4459 : : {
4460 : 1603981 : fwrite (format, 1, (size_t)(esc - format), dumps->stream);
4461 : 1603981 : format = ++esc;
4462 : 1603981 : switch (*format++)
4463 : : {
4464 : 0 : default:
4465 : 0 : gcc_unreachable ();
4466 : :
4467 : 489 : case '%':
4468 : 489 : fputc ('%', dumps->stream);
4469 : 489 : break;
4470 : :
4471 : 337948 : case 'C': /* Code */
4472 : 337948 : {
4473 : 337948 : tree_code code = (tree_code)va_arg (args, unsigned);
4474 : 337948 : fputs (get_tree_code_name (code), dumps->stream);
4475 : : }
4476 : 337948 : break;
4477 : :
4478 : 81 : case 'I': /* Identifier. */
4479 : 81 : {
4480 : 81 : tree t = va_arg (args, tree);
4481 : 81 : dumps->nested_name (t);
4482 : : }
4483 : 81 : break;
4484 : :
4485 : 6283 : case 'M': /* Module. */
4486 : 6283 : {
4487 : 6283 : const char *str = "(none)";
4488 : 6283 : if (module_state *m = va_arg (args, module_state *))
4489 : : {
4490 : 6283 : if (!m->has_location ())
4491 : : str = "(detached)";
4492 : : else
4493 : 6283 : str = m->get_flatname ();
4494 : : }
4495 : 6283 : fputs (str, dumps->stream);
4496 : : }
4497 : 6283 : break;
4498 : :
4499 : 376264 : case 'N': /* Name. */
4500 : 376264 : {
4501 : 376264 : tree t = va_arg (args, tree);
4502 : 752984 : while (t && TREE_CODE (t) == OVERLOAD)
4503 : 456 : t = OVL_FUNCTION (t);
4504 : 376264 : fputc ('\'', dumps->stream);
4505 : 376264 : dumps->nested_name (t);
4506 : 376264 : fputc ('\'', dumps->stream);
4507 : : }
4508 : 376264 : break;
4509 : :
4510 : 16962 : case 'P': /* Pair. */
4511 : 16962 : {
4512 : 16962 : tree ctx = va_arg (args, tree);
4513 : 16962 : tree name = va_arg (args, tree);
4514 : 16962 : fputc ('\'', dumps->stream);
4515 : 16962 : dumps->nested_name (ctx);
4516 : 16962 : if (ctx && ctx != global_namespace)
4517 : 11934 : fputs ("::", dumps->stream);
4518 : 16962 : dumps->nested_name (name);
4519 : 16962 : fputc ('\'', dumps->stream);
4520 : : }
4521 : 16962 : break;
4522 : :
4523 : 696 : case 'R': /* Ratio */
4524 : 696 : {
4525 : 696 : unsigned a = va_arg (args, unsigned);
4526 : 696 : unsigned b = va_arg (args, unsigned);
4527 : 696 : fprintf (dumps->stream, "%.1f", (float) a / (b + !b));
4528 : : }
4529 : 696 : break;
4530 : :
4531 : 32745 : case 'S': /* Symbol name */
4532 : 32745 : {
4533 : 32745 : tree t = va_arg (args, tree);
4534 : 32745 : if (t && TYPE_P (t))
4535 : 11772 : t = TYPE_NAME (t);
4536 : 31311 : if (t && HAS_DECL_ASSEMBLER_NAME_P (t)
4537 : 29907 : && DECL_ASSEMBLER_NAME_SET_P (t))
4538 : : {
4539 : 171 : fputc ('(', dumps->stream);
4540 : 171 : fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)),
4541 : 171 : dumps->stream);
4542 : 171 : fputc (')', dumps->stream);
4543 : : }
4544 : : }
4545 : : break;
4546 : :
4547 : 0 : case 'U': /* long unsigned. */
4548 : 0 : {
4549 : 0 : unsigned long u = va_arg (args, unsigned long);
4550 : 0 : fprintf (dumps->stream, "%lu", u);
4551 : : }
4552 : 0 : break;
4553 : :
4554 : 681 : case 'V': /* Verson. */
4555 : 681 : {
4556 : 681 : unsigned v = va_arg (args, unsigned);
4557 : 681 : verstr_t string;
4558 : :
4559 : 681 : version2string (v, string);
4560 : 681 : fputs (string, dumps->stream);
4561 : : }
4562 : 681 : break;
4563 : :
4564 : 0 : case 'c': /* Character. */
4565 : 0 : {
4566 : 0 : int c = va_arg (args, int);
4567 : 0 : fputc (c, dumps->stream);
4568 : : }
4569 : 0 : break;
4570 : :
4571 : 56574 : case 'd': /* Decimal Int. */
4572 : 56574 : {
4573 : 56574 : int d = va_arg (args, int);
4574 : 56574 : fprintf (dumps->stream, "%d", d);
4575 : : }
4576 : 56574 : break;
4577 : :
4578 : 0 : case 'p': /* Pointer. */
4579 : 0 : {
4580 : 0 : void *p = va_arg (args, void *);
4581 : 0 : fprintf (dumps->stream, "%p", p);
4582 : : }
4583 : 0 : break;
4584 : :
4585 : 451475 : case 's': /* String. */
4586 : 451475 : {
4587 : 451475 : const char *s = va_arg (args, char *);
4588 : 451475 : gcc_checking_assert (s);
4589 : 451475 : fputs (s, dumps->stream);
4590 : : }
4591 : 451475 : break;
4592 : :
4593 : 321604 : case 'u': /* Unsigned. */
4594 : 321604 : {
4595 : 321604 : unsigned u = va_arg (args, unsigned);
4596 : 321604 : fprintf (dumps->stream, "%u", u);
4597 : : }
4598 : 321604 : break;
4599 : :
4600 : 2179 : case 'x': /* Hex. */
4601 : 2179 : {
4602 : 2179 : unsigned x = va_arg (args, unsigned);
4603 : 2179 : fprintf (dumps->stream, "%x", x);
4604 : : }
4605 : 2179 : break;
4606 : : }
4607 : : }
4608 : 591466 : fputs (format, dumps->stream);
4609 : 591466 : va_end (args);
4610 : 591466 : if (!no_nl)
4611 : : {
4612 : 437431 : dumps->bol = true;
4613 : 437431 : fputc ('\n', dumps->stream);
4614 : : }
4615 : : return true;
4616 : : }
4617 : :
4618 : : struct note_def_cache_hasher : ggc_cache_ptr_hash<tree_node>
4619 : : {
4620 : 244496 : static int keep_cache_entry (tree t)
4621 : : {
4622 : 244496 : if (!CHECKING_P)
4623 : : /* GTY is unfortunately not clever enough to conditionalize
4624 : : this. */
4625 : : gcc_unreachable ();
4626 : :
4627 : 244496 : if (ggc_marked_p (t))
4628 : : return -1;
4629 : :
4630 : 0 : unsigned n = dump.push (NULL);
4631 : : /* This might or might not be an error. We should note its
4632 : : dropping whichever. */
4633 : 0 : dump () && dump ("Dropping %N from note_defs table", t);
4634 : 0 : dump.pop (n);
4635 : :
4636 : 0 : return 0;
4637 : : }
4638 : : };
4639 : :
4640 : : /* We should stream each definition at most once.
4641 : : This needs to be a cache because there are cases where a definition
4642 : : ends up being not retained, and we need to drop those so we don't
4643 : : get confused if memory is reallocated. */
4644 : : typedef hash_table<note_def_cache_hasher> note_defs_table_t;
4645 : : static GTY((cache)) note_defs_table_t *note_defs;
4646 : :
4647 : : void
4648 : 488721 : trees_in::assert_definition (tree decl ATTRIBUTE_UNUSED,
4649 : : bool installing ATTRIBUTE_UNUSED)
4650 : : {
4651 : : #if CHECKING_P
4652 : 488721 : tree *slot = note_defs->find_slot (decl, installing ? INSERT : NO_INSERT);
4653 : 488721 : tree not_tmpl = STRIP_TEMPLATE (decl);
4654 : 488721 : if (installing)
4655 : : {
4656 : : /* We must be inserting for the first time. */
4657 : 215943 : gcc_assert (!*slot);
4658 : 215943 : *slot = decl;
4659 : : }
4660 : : else
4661 : : /* If this is not the mergeable entity, it should not be in the
4662 : : table. If it is a non-global-module mergeable entity, it
4663 : : should be in the table. Global module entities could have been
4664 : : defined textually in the current TU and so might or might not
4665 : : be present. */
4666 : 272778 : gcc_assert (!is_duplicate (decl)
4667 : : ? !slot
4668 : : : (slot
4669 : : || !DECL_LANG_SPECIFIC (not_tmpl)
4670 : : || !DECL_MODULE_PURVIEW_P (not_tmpl)
4671 : : || (!DECL_MODULE_IMPORT_P (not_tmpl)
4672 : : && header_module_p ())));
4673 : :
4674 : 488721 : if (not_tmpl != decl)
4675 : 289895 : gcc_assert (!note_defs->find_slot (not_tmpl, NO_INSERT));
4676 : : #endif
4677 : 488721 : }
4678 : :
4679 : : void
4680 : 444932 : trees_out::assert_definition (tree decl ATTRIBUTE_UNUSED)
4681 : : {
4682 : : #if CHECKING_P
4683 : 444932 : tree *slot = note_defs->find_slot (decl, INSERT);
4684 : 444932 : gcc_assert (!*slot);
4685 : 444932 : *slot = decl;
4686 : 444932 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4687 : 263006 : gcc_assert (!note_defs->find_slot (DECL_TEMPLATE_RESULT (decl), NO_INSERT));
4688 : : #endif
4689 : 444932 : }
4690 : :
4691 : : /********************************************************************/
4692 : : static bool
4693 : 9515 : noisy_p ()
4694 : : {
4695 : 0 : if (quiet_flag)
4696 : : return false;
4697 : :
4698 : 0 : pp_needs_newline (global_dc->printer) = true;
4699 : 0 : diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
4700 : :
4701 : 0 : return true;
4702 : : }
4703 : :
4704 : : /* Set the cmi repo. Strip trailing '/', '.' becomes NULL. */
4705 : :
4706 : : static void
4707 : 94308 : set_cmi_repo (const char *r)
4708 : : {
4709 : 94308 : XDELETEVEC (cmi_repo);
4710 : 94308 : XDELETEVEC (cmi_path);
4711 : 94308 : cmi_path_alloc = 0;
4712 : :
4713 : 94308 : cmi_repo = NULL;
4714 : 94308 : cmi_repo_length = 0;
4715 : :
4716 : 94308 : if (!r || !r[0])
4717 : : return;
4718 : :
4719 : 3601 : size_t len = strlen (r);
4720 : 3601 : cmi_repo = XNEWVEC (char, len + 1);
4721 : 3601 : memcpy (cmi_repo, r, len + 1);
4722 : :
4723 : 3601 : if (len > 1 && IS_DIR_SEPARATOR (cmi_repo[len-1]))
4724 : 3601 : len--;
4725 : 3601 : if (len == 1 && cmi_repo[0] == '.')
4726 : 21 : len--;
4727 : 3601 : cmi_repo[len] = 0;
4728 : 3601 : cmi_repo_length = len;
4729 : : }
4730 : :
4731 : : /* TO is a repo-relative name. Provide one that we may use from where
4732 : : we are. */
4733 : :
4734 : : static const char *
4735 : 4481 : maybe_add_cmi_prefix (const char *to, size_t *len_p = NULL)
4736 : : {
4737 : 4481 : size_t len = len_p || cmi_repo_length ? strlen (to) : 0;
4738 : :
4739 : 4481 : if (cmi_repo_length && !IS_ABSOLUTE_PATH (to))
4740 : : {
4741 : 4460 : if (cmi_path_alloc < cmi_repo_length + len + 2)
4742 : : {
4743 : 3571 : XDELETEVEC (cmi_path);
4744 : 3571 : cmi_path_alloc = cmi_repo_length + len * 2 + 2;
4745 : 3571 : cmi_path = XNEWVEC (char, cmi_path_alloc);
4746 : :
4747 : 3571 : memcpy (cmi_path, cmi_repo, cmi_repo_length);
4748 : 3571 : cmi_path[cmi_repo_length] = DIR_SEPARATOR;
4749 : : }
4750 : :
4751 : 4460 : memcpy (&cmi_path[cmi_repo_length + 1], to, len + 1);
4752 : 4460 : len += cmi_repo_length + 1;
4753 : 4460 : to = cmi_path;
4754 : : }
4755 : :
4756 : 4481 : if (len_p)
4757 : 2126 : *len_p = len;
4758 : :
4759 : 4481 : return to;
4760 : : }
4761 : :
4762 : : /* Try and create the directories of PATH. */
4763 : :
4764 : : static void
4765 : 36 : create_dirs (char *path)
4766 : : {
4767 : : /* Try and create the missing directories. */
4768 : 2347 : for (char *base = path; *base; base++)
4769 : 2311 : if (IS_DIR_SEPARATOR (*base))
4770 : : {
4771 : 234 : char sep = *base;
4772 : 234 : *base = 0;
4773 : 234 : int failed = mkdir (path, S_IRWXU | S_IRWXG | S_IRWXO);
4774 : 250 : dump () && dump ("Mkdir ('%s') errno:=%u", path, failed ? errno : 0);
4775 : 234 : *base = sep;
4776 : 234 : if (failed
4777 : : /* Maybe racing with another creator (of a *different*
4778 : : module). */
4779 : 44 : && errno != EEXIST)
4780 : : break;
4781 : : }
4782 : 36 : }
4783 : :
4784 : : /* Given a CLASSTYPE_DECL_LIST VALUE get the template friend decl,
4785 : : if that's what this is. */
4786 : :
4787 : : static tree
4788 : 65821 : friend_from_decl_list (tree frnd)
4789 : : {
4790 : 65821 : tree res = frnd;
4791 : :
4792 : 65821 : if (TREE_CODE (frnd) != TEMPLATE_DECL)
4793 : : {
4794 : 33050 : tree tmpl = NULL_TREE;
4795 : 33050 : if (TYPE_P (frnd))
4796 : : {
4797 : 6024 : res = TYPE_NAME (frnd);
4798 : 5988 : if (CLASS_TYPE_P (frnd)
4799 : 12012 : && CLASSTYPE_TEMPLATE_INFO (frnd))
4800 : 5979 : tmpl = CLASSTYPE_TI_TEMPLATE (frnd);
4801 : : }
4802 : 27026 : else if (DECL_TEMPLATE_INFO (frnd))
4803 : : {
4804 : 27026 : tmpl = DECL_TI_TEMPLATE (frnd);
4805 : 27026 : if (TREE_CODE (tmpl) != TEMPLATE_DECL)
4806 : : tmpl = NULL_TREE;
4807 : : }
4808 : :
4809 : 38282 : if (tmpl && DECL_TEMPLATE_RESULT (tmpl) == res)
4810 : : res = tmpl;
4811 : : }
4812 : :
4813 : 65821 : return res;
4814 : : }
4815 : :
4816 : : static tree
4817 : 32901 : find_enum_member (tree ctx, tree name)
4818 : : {
4819 : 32901 : for (tree values = TYPE_VALUES (ctx);
4820 : 486189 : values; values = TREE_CHAIN (values))
4821 : 478004 : if (DECL_NAME (TREE_VALUE (values)) == name)
4822 : : return TREE_VALUE (values);
4823 : :
4824 : : return NULL_TREE;
4825 : : }
4826 : :
4827 : : /********************************************************************/
4828 : : /* Instrumentation gathered writing bytes. */
4829 : :
4830 : : void
4831 : 232 : bytes_out::instrument ()
4832 : : {
4833 : 232 : dump ("Wrote %u bytes in %u blocks", lengths[3], spans[3]);
4834 : 232 : dump ("Wrote %u bits in %u bytes", lengths[0] + lengths[1], lengths[2]);
4835 : 696 : for (unsigned ix = 0; ix < 2; ix++)
4836 : 696 : dump (" %u %s spans of %R bits", spans[ix],
4837 : : ix ? "one" : "zero", lengths[ix], spans[ix]);
4838 : 232 : dump (" %u blocks with %R bits padding", spans[2],
4839 : 232 : lengths[2] * 8 - (lengths[0] + lengths[1]), spans[2]);
4840 : 232 : }
4841 : :
4842 : : /* Instrumentation gathered writing trees. */
4843 : : void
4844 : 2038 : trees_out::instrument ()
4845 : : {
4846 : 2038 : if (dump (""))
4847 : : {
4848 : 232 : bytes_out::instrument ();
4849 : 232 : dump ("Wrote:");
4850 : 232 : dump (" %u decl trees", decl_val_count);
4851 : 232 : dump (" %u other trees", tree_val_count);
4852 : 232 : dump (" %u back references", back_ref_count);
4853 : 232 : dump (" %u null trees", null_count);
4854 : : }
4855 : 2038 : }
4856 : :
4857 : : /* Setup and teardown for a tree walk. */
4858 : :
4859 : : void
4860 : 2805575 : trees_out::begin ()
4861 : : {
4862 : 2805575 : gcc_assert (!streaming_p () || !tree_map.elements ());
4863 : :
4864 : 2805575 : mark_trees ();
4865 : 2805575 : if (streaming_p ())
4866 : 347120 : parent::begin ();
4867 : 2805575 : }
4868 : :
4869 : : unsigned
4870 : 347120 : trees_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
4871 : : {
4872 : 347120 : gcc_checking_assert (streaming_p ());
4873 : :
4874 : 347120 : unmark_trees ();
4875 : 347120 : return parent::end (sink, name, crc_ptr);
4876 : : }
4877 : :
4878 : : void
4879 : 2458455 : trees_out::end ()
4880 : : {
4881 : 2458455 : gcc_assert (!streaming_p ());
4882 : :
4883 : 2458455 : unmark_trees ();
4884 : : /* Do not parent::end -- we weren't streaming. */
4885 : 2458455 : }
4886 : :
4887 : : void
4888 : 2805575 : trees_out::mark_trees ()
4889 : : {
4890 : 2805575 : if (size_t size = tree_map.elements ())
4891 : : {
4892 : : /* This isn't our first rodeo, destroy and recreate the
4893 : : tree_map. I'm a bad bad man. Use the previous size as a
4894 : : guess for the next one (so not all bad). */
4895 : 2124651 : tree_map.~ptr_int_hash_map ();
4896 : 2124651 : new (&tree_map) ptr_int_hash_map (size);
4897 : : }
4898 : :
4899 : : /* Install the fixed trees, with +ve references. */
4900 : 2805575 : unsigned limit = fixed_trees->length ();
4901 : 537950683 : for (unsigned ix = 0; ix != limit; ix++)
4902 : : {
4903 : 535145108 : tree val = (*fixed_trees)[ix];
4904 : 535145108 : bool existed = tree_map.put (val, ix + tag_fixed);
4905 : 535145108 : gcc_checking_assert (!TREE_VISITED (val) && !existed);
4906 : 535145108 : TREE_VISITED (val) = true;
4907 : : }
4908 : :
4909 : 2805575 : ref_num = 0;
4910 : 2805575 : }
4911 : :
4912 : : /* Unmark the trees we encountered */
4913 : :
4914 : : void
4915 : 2805575 : trees_out::unmark_trees ()
4916 : : {
4917 : 2805575 : ptr_int_hash_map::iterator end (tree_map.end ());
4918 : 631462544 : for (ptr_int_hash_map::iterator iter (tree_map.begin ()); iter != end; ++iter)
4919 : : {
4920 : 628656969 : tree node = reinterpret_cast<tree> ((*iter).first);
4921 : 628656969 : int ref = (*iter).second;
4922 : : /* We should have visited the node, and converted its mergeable
4923 : : reference to a regular reference. */
4924 : 628656969 : gcc_checking_assert (TREE_VISITED (node)
4925 : : && (ref <= tag_backref || ref >= tag_fixed));
4926 : 628656969 : TREE_VISITED (node) = false;
4927 : : }
4928 : 2805575 : }
4929 : :
4930 : : /* Mark DECL for by-value walking. We do this by inserting it into
4931 : : the tree map with a reference of zero. May be called multiple
4932 : : times on the same node. */
4933 : :
4934 : : void
4935 : 4310978 : trees_out::mark_by_value (tree decl)
4936 : : {
4937 : 4310978 : gcc_checking_assert (DECL_P (decl)
4938 : : /* Enum consts are INTEGER_CSTS. */
4939 : : || TREE_CODE (decl) == INTEGER_CST
4940 : : || TREE_CODE (decl) == TREE_BINFO);
4941 : :
4942 : 4310978 : if (TREE_VISITED (decl))
4943 : : /* Must already be forced or fixed. */
4944 : 3254 : gcc_checking_assert (*tree_map.get (decl) >= tag_value);
4945 : : else
4946 : : {
4947 : 4307724 : bool existed = tree_map.put (decl, tag_value);
4948 : 4307724 : gcc_checking_assert (!existed);
4949 : 4307724 : TREE_VISITED (decl) = true;
4950 : : }
4951 : 4310978 : }
4952 : :
4953 : : int
4954 : 112940556 : trees_out::get_tag (tree t)
4955 : : {
4956 : 112940556 : gcc_checking_assert (TREE_VISITED (t));
4957 : 112940556 : return *tree_map.get (t);
4958 : : }
4959 : :
4960 : : /* Insert T into the map, return its tag number. */
4961 : :
4962 : : int
4963 : 93511861 : trees_out::insert (tree t, walk_kind walk)
4964 : : {
4965 : 93511861 : gcc_checking_assert (walk != WK_normal || !TREE_VISITED (t));
4966 : 93511861 : int tag = --ref_num;
4967 : 93511861 : bool existed;
4968 : 93511861 : int &slot = tree_map.get_or_insert (t, &existed);
4969 : 93511861 : gcc_checking_assert (TREE_VISITED (t) == existed
4970 : : && (!existed
4971 : : || (walk == WK_value && slot == tag_value)));
4972 : 93511861 : TREE_VISITED (t) = true;
4973 : 93511861 : slot = tag;
4974 : :
4975 : 93511861 : return tag;
4976 : : }
4977 : :
4978 : : /* Insert T into the backreference array. Return its back reference
4979 : : number. */
4980 : :
4981 : : int
4982 : 29321246 : trees_in::insert (tree t)
4983 : : {
4984 : 29321246 : gcc_checking_assert (t || get_overrun ());
4985 : 29321246 : back_refs.safe_push (t);
4986 : 29321246 : return -(int)back_refs.length ();
4987 : : }
4988 : :
4989 : : /* A chained set of decls. */
4990 : :
4991 : : void
4992 : 103632 : trees_out::chained_decls (tree decls)
4993 : : {
4994 : 254616 : for (; decls; decls = DECL_CHAIN (decls))
4995 : 150984 : tree_node (decls);
4996 : 103632 : tree_node (NULL_TREE);
4997 : 103632 : }
4998 : :
4999 : : tree
5000 : 57523 : trees_in::chained_decls ()
5001 : : {
5002 : 57523 : tree decls = NULL_TREE;
5003 : 57523 : for (tree *chain = &decls;;)
5004 : 139557 : if (tree decl = tree_node ())
5005 : : {
5006 : 82034 : if (!DECL_P (decl) || DECL_CHAIN (decl))
5007 : : {
5008 : 0 : set_overrun ();
5009 : 0 : break;
5010 : : }
5011 : 82034 : *chain = decl;
5012 : 82034 : chain = &DECL_CHAIN (decl);
5013 : : }
5014 : : else
5015 : 82034 : break;
5016 : :
5017 : 57523 : return decls;
5018 : : }
5019 : :
5020 : : /* A vector of decls following DECL_CHAIN. */
5021 : :
5022 : : void
5023 : 427202 : trees_out::vec_chained_decls (tree decls)
5024 : : {
5025 : 427202 : if (streaming_p ())
5026 : : {
5027 : : unsigned len = 0;
5028 : :
5029 : 1239677 : for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
5030 : 1026082 : len++;
5031 : 213595 : u (len);
5032 : : }
5033 : :
5034 : 2479384 : for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
5035 : : {
5036 : 466782 : if (DECL_IMPLICIT_TYPEDEF_P (decl)
5037 : 2067418 : && TYPE_NAME (TREE_TYPE (decl)) != decl)
5038 : : /* An anonynmous struct with a typedef name. An odd thing to
5039 : : write. */
5040 : 12 : tree_node (NULL_TREE);
5041 : : else
5042 : 2052170 : tree_node (decl);
5043 : : }
5044 : 427202 : }
5045 : :
5046 : : vec<tree, va_heap> *
5047 : 215722 : trees_in::vec_chained_decls ()
5048 : : {
5049 : 215722 : vec<tree, va_heap> *v = NULL;
5050 : :
5051 : 215722 : if (unsigned len = u ())
5052 : : {
5053 : 113416 : vec_alloc (v, len);
5054 : :
5055 : 1249271 : for (unsigned ix = 0; ix < len; ix++)
5056 : : {
5057 : 1135855 : tree decl = tree_node ();
5058 : 1135855 : if (decl && !DECL_P (decl))
5059 : : {
5060 : 0 : set_overrun ();
5061 : 0 : break;
5062 : : }
5063 : 1135855 : v->quick_push (decl);
5064 : : }
5065 : :
5066 : 113416 : if (get_overrun ())
5067 : : {
5068 : 0 : vec_free (v);
5069 : 0 : v = NULL;
5070 : : }
5071 : : }
5072 : :
5073 : 215722 : return v;
5074 : : }
5075 : :
5076 : : /* A vector of trees. */
5077 : :
5078 : : void
5079 : 313712 : trees_out::tree_vec (vec<tree, va_gc> *v)
5080 : : {
5081 : 313712 : unsigned len = vec_safe_length (v);
5082 : 313712 : if (streaming_p ())
5083 : 156853 : u (len);
5084 : 411386 : for (unsigned ix = 0; ix != len; ix++)
5085 : 97674 : tree_node ((*v)[ix]);
5086 : 313712 : }
5087 : :
5088 : : vec<tree, va_gc> *
5089 : 159313 : trees_in::tree_vec ()
5090 : : {
5091 : 159313 : vec<tree, va_gc> *v = NULL;
5092 : 159313 : if (unsigned len = u ())
5093 : : {
5094 : 45532 : vec_alloc (v, len);
5095 : 95744 : for (unsigned ix = 0; ix != len; ix++)
5096 : 50212 : v->quick_push (tree_node ());
5097 : : }
5098 : 159313 : return v;
5099 : : }
5100 : :
5101 : : /* A vector of tree pairs. */
5102 : :
5103 : : void
5104 : 8178 : trees_out::tree_pair_vec (vec<tree_pair_s, va_gc> *v)
5105 : : {
5106 : 8178 : unsigned len = vec_safe_length (v);
5107 : 8178 : if (streaming_p ())
5108 : 4089 : u (len);
5109 : 8178 : if (len)
5110 : 44918 : for (unsigned ix = 0; ix != len; ix++)
5111 : : {
5112 : 36890 : tree_pair_s const &s = (*v)[ix];
5113 : 36890 : tree_node (s.purpose);
5114 : 36890 : tree_node (s.value);
5115 : : }
5116 : 8178 : }
5117 : :
5118 : : vec<tree_pair_s, va_gc> *
5119 : 4572 : trees_in::tree_pair_vec ()
5120 : : {
5121 : 4572 : vec<tree_pair_s, va_gc> *v = NULL;
5122 : 4572 : if (unsigned len = u ())
5123 : : {
5124 : 4495 : vec_alloc (v, len);
5125 : 25381 : for (unsigned ix = 0; ix != len; ix++)
5126 : : {
5127 : 20886 : tree_pair_s s;
5128 : 20886 : s.purpose = tree_node ();
5129 : 20886 : s.value = tree_node ();
5130 : 20886 : v->quick_push (s);
5131 : : }
5132 : : }
5133 : 4572 : return v;
5134 : : }
5135 : :
5136 : : void
5137 : 445510 : trees_out::tree_list (tree list, bool has_purpose)
5138 : : {
5139 : 1882332 : for (; list; list = TREE_CHAIN (list))
5140 : : {
5141 : 1436822 : gcc_checking_assert (TREE_VALUE (list));
5142 : 1436822 : tree_node (TREE_VALUE (list));
5143 : 1436822 : if (has_purpose)
5144 : 1398710 : tree_node (TREE_PURPOSE (list));
5145 : : }
5146 : 445510 : tree_node (NULL_TREE);
5147 : 445510 : }
5148 : :
5149 : : tree
5150 : 226093 : trees_in::tree_list (bool has_purpose)
5151 : : {
5152 : 226093 : tree res = NULL_TREE;
5153 : :
5154 : 1025919 : for (tree *chain = &res; tree value = tree_node ();
5155 : 1599652 : chain = &TREE_CHAIN (*chain))
5156 : : {
5157 : 799826 : tree purpose = has_purpose ? tree_node () : NULL_TREE;
5158 : 799826 : *chain = build_tree_list (purpose, value);
5159 : 799826 : }
5160 : :
5161 : 226093 : return res;
5162 : : }
5163 : : /* Start tree write. Write information to allocate the receiving
5164 : : node. */
5165 : :
5166 : : void
5167 : 18364654 : trees_out::start (tree t, bool code_streamed)
5168 : : {
5169 : 18364654 : if (TYPE_P (t))
5170 : : {
5171 : 772006 : enum tree_code code = TREE_CODE (t);
5172 : 772006 : gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
5173 : : /* All these types are TYPE_NON_COMMON. */
5174 : 772006 : gcc_checking_assert (code == RECORD_TYPE
5175 : : || code == UNION_TYPE
5176 : : || code == ENUMERAL_TYPE
5177 : : || code == TEMPLATE_TYPE_PARM
5178 : : || code == TEMPLATE_TEMPLATE_PARM
5179 : : || code == BOUND_TEMPLATE_TEMPLATE_PARM);
5180 : : }
5181 : :
5182 : 18364654 : if (!code_streamed)
5183 : 17669609 : u (TREE_CODE (t));
5184 : :
5185 : 18364654 : switch (TREE_CODE (t))
5186 : : {
5187 : 16422194 : default:
5188 : 16422194 : if (VL_EXP_CLASS_P (t))
5189 : 682915 : u (VL_EXP_OPERAND_LENGTH (t));
5190 : : break;
5191 : :
5192 : 735483 : case INTEGER_CST:
5193 : 735483 : u (TREE_INT_CST_NUNITS (t));
5194 : 735483 : u (TREE_INT_CST_EXT_NUNITS (t));
5195 : 735483 : break;
5196 : :
5197 : 3 : case OMP_CLAUSE:
5198 : 3 : state->extensions |= SE_OPENMP;
5199 : 3 : u (OMP_CLAUSE_CODE (t));
5200 : 3 : break;
5201 : :
5202 : 27486 : case STRING_CST:
5203 : 27486 : str (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
5204 : 27486 : break;
5205 : :
5206 : 18 : case VECTOR_CST:
5207 : 18 : u (VECTOR_CST_LOG2_NPATTERNS (t));
5208 : 18 : u (VECTOR_CST_NELTS_PER_PATTERN (t));
5209 : 18 : break;
5210 : :
5211 : 152764 : case TREE_BINFO:
5212 : 152764 : u (BINFO_N_BASE_BINFOS (t));
5213 : 152764 : break;
5214 : :
5215 : 1026706 : case TREE_VEC:
5216 : 1026706 : u (TREE_VEC_LENGTH (t));
5217 : 1026706 : break;
5218 : :
5219 : 0 : case FIXED_CST:
5220 : 0 : gcc_unreachable (); /* Not supported in C++. */
5221 : 0 : break;
5222 : :
5223 : 0 : case IDENTIFIER_NODE:
5224 : 0 : case SSA_NAME:
5225 : 0 : case TARGET_MEM_REF:
5226 : 0 : case TRANSLATION_UNIT_DECL:
5227 : : /* We shouldn't meet these. */
5228 : 0 : gcc_unreachable ();
5229 : 18364654 : break;
5230 : : }
5231 : 18364654 : }
5232 : :
5233 : : /* Start tree read. Allocate the receiving node. */
5234 : :
5235 : : tree
5236 : 20530703 : trees_in::start (unsigned code)
5237 : : {
5238 : 20530703 : tree t = NULL_TREE;
5239 : :
5240 : 20530703 : if (!code)
5241 : 18378686 : code = u ();
5242 : :
5243 : 20530703 : switch (code)
5244 : : {
5245 : 18451011 : default:
5246 : 18451011 : if (code >= MAX_TREE_CODES)
5247 : : {
5248 : 0 : fail:
5249 : 0 : set_overrun ();
5250 : 0 : return NULL_TREE;
5251 : : }
5252 : 18451011 : else if (TREE_CODE_CLASS (code) == tcc_vl_exp)
5253 : : {
5254 : 777158 : unsigned ops = u ();
5255 : 777158 : t = build_vl_exp (tree_code (code), ops);
5256 : : }
5257 : : else
5258 : 17673853 : t = make_node (tree_code (code));
5259 : : break;
5260 : :
5261 : 785689 : case INTEGER_CST:
5262 : 785689 : {
5263 : 785689 : unsigned n = u ();
5264 : 785689 : unsigned e = u ();
5265 : 785689 : t = make_int_cst (n, e);
5266 : : }
5267 : 785689 : break;
5268 : :
5269 : 3 : case OMP_CLAUSE:
5270 : 3 : {
5271 : 3 : if (!(state->extensions & SE_OPENMP))
5272 : 0 : goto fail;
5273 : :
5274 : 3 : unsigned omp_code = u ();
5275 : 3 : t = build_omp_clause (UNKNOWN_LOCATION, omp_clause_code (omp_code));
5276 : : }
5277 : 3 : break;
5278 : :
5279 : 31503 : case STRING_CST:
5280 : 31503 : {
5281 : 31503 : size_t l;
5282 : 31503 : const char *chars = str (&l);
5283 : 31503 : t = build_string (l, chars);
5284 : : }
5285 : 31503 : break;
5286 : :
5287 : 24 : case VECTOR_CST:
5288 : 24 : {
5289 : 24 : unsigned log2_npats = u ();
5290 : 24 : unsigned elts_per = u ();
5291 : 24 : t = make_vector (log2_npats, elts_per);
5292 : : }
5293 : 24 : break;
5294 : :
5295 : 154741 : case TREE_BINFO:
5296 : 154741 : t = make_tree_binfo (u ());
5297 : 154741 : break;
5298 : :
5299 : 1107732 : case TREE_VEC:
5300 : 1107732 : t = make_tree_vec (u ());
5301 : 1107732 : break;
5302 : :
5303 : 0 : case FIXED_CST:
5304 : 0 : case IDENTIFIER_NODE:
5305 : 0 : case SSA_NAME:
5306 : 0 : case TARGET_MEM_REF:
5307 : 0 : case TRANSLATION_UNIT_DECL:
5308 : 0 : goto fail;
5309 : : }
5310 : :
5311 : : return t;
5312 : : }
5313 : :
5314 : : /* The structure streamers access the raw fields, because the
5315 : : alternative, of using the accessor macros can require using
5316 : : different accessors for the same underlying field, depending on the
5317 : : tree code. That's both confusing and annoying. */
5318 : :
5319 : : /* Read & write the core boolean flags. */
5320 : :
5321 : : void
5322 : 18391433 : trees_out::core_bools (tree t, bits_out& bits)
5323 : : {
5324 : : #define WB(X) (bits.b (X))
5325 : : /* Stream X if COND holds, and if !COND stream a dummy value so that the
5326 : : overall number of bits streamed is independent of the runtime value
5327 : : of COND, which allows the compiler to better optimize this function. */
5328 : : #define WB_IF(COND, X) WB ((COND) ? (X) : false)
5329 : 18391433 : tree_code code = TREE_CODE (t);
5330 : :
5331 : 18391433 : WB (t->base.side_effects_flag);
5332 : 18391433 : WB (t->base.constant_flag);
5333 : 18391433 : WB (t->base.addressable_flag);
5334 : 18391433 : WB (t->base.volatile_flag);
5335 : 18391433 : WB (t->base.readonly_flag);
5336 : : /* base.asm_written_flag is a property of the current TU's use of
5337 : : this decl. */
5338 : 18391433 : WB (t->base.nowarning_flag);
5339 : : /* base.visited read as zero (it's set for writer, because that's
5340 : : how we mark nodes). */
5341 : : /* base.used_flag is not streamed. Readers may set TREE_USED of
5342 : : decls they use. */
5343 : 18391433 : WB (t->base.nothrow_flag);
5344 : 18391433 : WB (t->base.static_flag);
5345 : : /* This is TYPE_CACHED_VALUES_P for types. */
5346 : 18391433 : WB_IF (TREE_CODE_CLASS (code) != tcc_type, t->base.public_flag);
5347 : 18391433 : WB (t->base.private_flag);
5348 : 18391433 : WB (t->base.protected_flag);
5349 : 18391433 : WB (t->base.deprecated_flag);
5350 : 18391433 : WB (t->base.default_def_flag);
5351 : :
5352 : 18391433 : switch (code)
5353 : : {
5354 : : case CALL_EXPR:
5355 : : case INTEGER_CST:
5356 : : case SSA_NAME:
5357 : : case TARGET_MEM_REF:
5358 : : case TREE_VEC:
5359 : : /* These use different base.u fields. */
5360 : : return;
5361 : :
5362 : 15960266 : default:
5363 : 15960266 : WB (t->base.u.bits.lang_flag_0);
5364 : 15960266 : bool flag_1 = t->base.u.bits.lang_flag_1;
5365 : 15960266 : if (!flag_1)
5366 : : ;
5367 : 490078 : else if (code == TEMPLATE_INFO)
5368 : : /* This is TI_PENDING_TEMPLATE_FLAG, not relevant to reader. */
5369 : : flag_1 = false;
5370 : 485985 : else if (code == VAR_DECL)
5371 : : {
5372 : : /* This is DECL_INITIALIZED_P. */
5373 : 80406 : if (TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
5374 : : /* We'll set this when reading the definition. */
5375 : 15960266 : flag_1 = false;
5376 : : }
5377 : 15960266 : WB (flag_1);
5378 : 15960266 : WB (t->base.u.bits.lang_flag_2);
5379 : 15960266 : WB (t->base.u.bits.lang_flag_3);
5380 : 15960266 : WB (t->base.u.bits.lang_flag_4);
5381 : 15960266 : WB (t->base.u.bits.lang_flag_5);
5382 : 15960266 : WB (t->base.u.bits.lang_flag_6);
5383 : 15960266 : WB (t->base.u.bits.saturating_flag);
5384 : 15960266 : WB (t->base.u.bits.unsigned_flag);
5385 : 15960266 : WB (t->base.u.bits.packed_flag);
5386 : 15960266 : WB (t->base.u.bits.user_align);
5387 : 15960266 : WB (t->base.u.bits.nameless_flag);
5388 : 15960266 : WB (t->base.u.bits.atomic_flag);
5389 : 15960266 : WB (t->base.u.bits.unavailable_flag);
5390 : 15960266 : break;
5391 : : }
5392 : :
5393 : 15960266 : if (TREE_CODE_CLASS (code) == tcc_type)
5394 : : {
5395 : 798785 : WB (t->type_common.no_force_blk_flag);
5396 : 798785 : WB (t->type_common.needs_constructing_flag);
5397 : 798785 : WB (t->type_common.transparent_aggr_flag);
5398 : 798785 : WB (t->type_common.restrict_flag);
5399 : 798785 : WB (t->type_common.string_flag);
5400 : 798785 : WB (t->type_common.lang_flag_0);
5401 : 798785 : WB (t->type_common.lang_flag_1);
5402 : 798785 : WB (t->type_common.lang_flag_2);
5403 : 798785 : WB (t->type_common.lang_flag_3);
5404 : 798785 : WB (t->type_common.lang_flag_4);
5405 : 798785 : WB (t->type_common.lang_flag_5);
5406 : 798785 : WB (t->type_common.lang_flag_6);
5407 : 798785 : WB (t->type_common.typeless_storage);
5408 : : }
5409 : :
5410 : 15960266 : if (TREE_CODE_CLASS (code) != tcc_declaration)
5411 : : return;
5412 : :
5413 : 4278540 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
5414 : : {
5415 : 4278540 : WB (t->decl_common.nonlocal_flag);
5416 : 4278540 : WB (t->decl_common.virtual_flag);
5417 : 4278540 : WB (t->decl_common.ignored_flag);
5418 : 4278540 : WB (t->decl_common.abstract_flag);
5419 : 4278540 : WB (t->decl_common.artificial_flag);
5420 : 4278540 : WB (t->decl_common.preserve_flag);
5421 : 4278540 : WB (t->decl_common.debug_expr_is_from);
5422 : 4278540 : WB (t->decl_common.lang_flag_0);
5423 : 4278540 : WB (t->decl_common.lang_flag_1);
5424 : 4278540 : WB (t->decl_common.lang_flag_2);
5425 : 4278540 : WB (t->decl_common.lang_flag_3);
5426 : 4278540 : WB (t->decl_common.lang_flag_4);
5427 : :
5428 : 4278540 : {
5429 : : /* This is DECL_INTERFACE_KNOWN: We should redetermine whether
5430 : : we need to import or export any vtables or typeinfo objects
5431 : : on stream-in. */
5432 : 4278540 : bool interface_known = t->decl_common.lang_flag_5;
5433 : 4278540 : if (VAR_P (t) && (DECL_VTABLE_OR_VTT_P (t) || DECL_TINFO_P (t)))
5434 : : interface_known = false;
5435 : 4278540 : WB (interface_known);
5436 : : }
5437 : :
5438 : 4278540 : WB (t->decl_common.lang_flag_6);
5439 : 4278540 : WB (t->decl_common.lang_flag_7);
5440 : 4278540 : WB (t->decl_common.lang_flag_8);
5441 : 4278540 : WB (t->decl_common.decl_flag_0);
5442 : :
5443 : 4278540 : {
5444 : : /* DECL_EXTERNAL -> decl_flag_1
5445 : : == it is defined elsewhere
5446 : : DECL_NOT_REALLY_EXTERN -> base.not_really_extern
5447 : : == that was a lie, it is here */
5448 : :
5449 : 4278540 : bool is_external = t->decl_common.decl_flag_1;
5450 : 4278540 : if (!is_external)
5451 : : /* decl_flag_1 is DECL_EXTERNAL. Things we emit here, might
5452 : : well be external from the POV of an importer. */
5453 : : // FIXME: Do we need to know if this is a TEMPLATE_RESULT --
5454 : : // a flag from the caller?
5455 : 3561349 : switch (code)
5456 : : {
5457 : : default:
5458 : : break;
5459 : :
5460 : 239799 : case VAR_DECL:
5461 : 239799 : if (TREE_PUBLIC (t)
5462 : 43169 : && !(TREE_STATIC (t)
5463 : 43169 : && DECL_FUNCTION_SCOPE_P (t)
5464 : 135 : && DECL_DECLARED_INLINE_P (DECL_CONTEXT (t)))
5465 : 282923 : && !DECL_VAR_DECLARED_INLINE_P (t))
5466 : : is_external = true;
5467 : : break;
5468 : :
5469 : 37168 : case FUNCTION_DECL:
5470 : 37168 : if (TREE_PUBLIC (t)
5471 : 72878 : && !DECL_DECLARED_INLINE_P (t))
5472 : : is_external = true;
5473 : : break;
5474 : : }
5475 : 4278540 : WB (is_external);
5476 : : }
5477 : :
5478 : 4278540 : WB (t->decl_common.decl_flag_2);
5479 : 4278540 : WB (t->decl_common.decl_flag_3);
5480 : 4278540 : WB (t->decl_common.not_gimple_reg_flag);
5481 : 4278540 : WB (t->decl_common.decl_by_reference_flag);
5482 : 4278540 : WB (t->decl_common.decl_read_flag);
5483 : 4278540 : WB (t->decl_common.decl_nonshareable_flag);
5484 : 4278540 : WB (t->decl_common.decl_not_flexarray);
5485 : : }
5486 : : else
5487 : : return;
5488 : :
5489 : 4278540 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
5490 : : {
5491 : 2008007 : WB (t->decl_with_vis.defer_output);
5492 : 2008007 : WB (t->decl_with_vis.hard_register);
5493 : 2008007 : WB (t->decl_with_vis.common_flag);
5494 : 2008007 : WB (t->decl_with_vis.in_text_section);
5495 : 2008007 : WB (t->decl_with_vis.in_constant_pool);
5496 : 2008007 : WB (t->decl_with_vis.dllimport_flag);
5497 : 2008007 : WB (t->decl_with_vis.weak_flag);
5498 : 2008007 : WB (t->decl_with_vis.seen_in_bind_expr);
5499 : 2008007 : WB (t->decl_with_vis.comdat_flag);
5500 : 2008007 : WB (t->decl_with_vis.visibility_specified);
5501 : 2008007 : WB (t->decl_with_vis.init_priority_p);
5502 : 2008007 : WB (t->decl_with_vis.shadowed_for_var_p);
5503 : 2008007 : WB (t->decl_with_vis.cxx_constructor);
5504 : 2008007 : WB (t->decl_with_vis.cxx_destructor);
5505 : 2008007 : WB (t->decl_with_vis.final);
5506 : 2008007 : WB (t->decl_with_vis.regdecl_flag);
5507 : : }
5508 : : else
5509 : : return;
5510 : :
5511 : 2008007 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
5512 : : {
5513 : 604753 : WB (t->function_decl.static_ctor_flag);
5514 : 604753 : WB (t->function_decl.static_dtor_flag);
5515 : 604753 : WB (t->function_decl.uninlinable);
5516 : 604753 : WB (t->function_decl.possibly_inlined);
5517 : 604753 : WB (t->function_decl.novops_flag);
5518 : 604753 : WB (t->function_decl.returns_twice_flag);
5519 : 604753 : WB (t->function_decl.malloc_flag);
5520 : 604753 : WB (t->function_decl.declared_inline_flag);
5521 : 604753 : WB (t->function_decl.no_inline_warning_flag);
5522 : 604753 : WB (t->function_decl.no_instrument_function_entry_exit);
5523 : 604753 : WB (t->function_decl.no_limit_stack);
5524 : 604753 : WB (t->function_decl.disregard_inline_limits);
5525 : 604753 : WB (t->function_decl.pure_flag);
5526 : 604753 : WB (t->function_decl.looping_const_or_pure_flag);
5527 : :
5528 : 604753 : WB (t->function_decl.has_debug_args_flag);
5529 : 604753 : WB (t->function_decl.versioned_function);
5530 : :
5531 : : /* decl_type is a (misnamed) 2 bit discriminator. */
5532 : 604753 : unsigned kind = t->function_decl.decl_type;
5533 : 604753 : WB ((kind >> 0) & 1);
5534 : 604753 : WB ((kind >> 1) & 1);
5535 : : }
5536 : : #undef WB_IF
5537 : : #undef WB
5538 : : }
5539 : :
5540 : : bool
5541 : 20558580 : trees_in::core_bools (tree t, bits_in& bits)
5542 : : {
5543 : : #define RB(X) ((X) = bits.b ())
5544 : : /* See the comment for WB_IF in trees_out::core_bools. */
5545 : : #define RB_IF(COND, X) ((COND) ? RB (X) : bits.b ())
5546 : :
5547 : 20558580 : tree_code code = TREE_CODE (t);
5548 : :
5549 : 20558580 : RB (t->base.side_effects_flag);
5550 : 20558580 : RB (t->base.constant_flag);
5551 : 20558580 : RB (t->base.addressable_flag);
5552 : 20558580 : RB (t->base.volatile_flag);
5553 : 20558580 : RB (t->base.readonly_flag);
5554 : : /* base.asm_written_flag is not streamed. */
5555 : 20558580 : RB (t->base.nowarning_flag);
5556 : : /* base.visited is not streamed. */
5557 : : /* base.used_flag is not streamed. */
5558 : 20558580 : RB (t->base.nothrow_flag);
5559 : 20558580 : RB (t->base.static_flag);
5560 : 20558580 : RB_IF (TREE_CODE_CLASS (code) != tcc_type, t->base.public_flag);
5561 : 20558580 : RB (t->base.private_flag);
5562 : 20558580 : RB (t->base.protected_flag);
5563 : 20558580 : RB (t->base.deprecated_flag);
5564 : 20558580 : RB (t->base.default_def_flag);
5565 : :
5566 : 20558580 : switch (code)
5567 : : {
5568 : 2655122 : case CALL_EXPR:
5569 : 2655122 : case INTEGER_CST:
5570 : 2655122 : case SSA_NAME:
5571 : 2655122 : case TARGET_MEM_REF:
5572 : 2655122 : case TREE_VEC:
5573 : : /* These use different base.u fields. */
5574 : 2655122 : goto done;
5575 : :
5576 : 17903458 : default:
5577 : 17903458 : RB (t->base.u.bits.lang_flag_0);
5578 : 17903458 : RB (t->base.u.bits.lang_flag_1);
5579 : 17903458 : RB (t->base.u.bits.lang_flag_2);
5580 : 17903458 : RB (t->base.u.bits.lang_flag_3);
5581 : 17903458 : RB (t->base.u.bits.lang_flag_4);
5582 : 17903458 : RB (t->base.u.bits.lang_flag_5);
5583 : 17903458 : RB (t->base.u.bits.lang_flag_6);
5584 : 17903458 : RB (t->base.u.bits.saturating_flag);
5585 : 17903458 : RB (t->base.u.bits.unsigned_flag);
5586 : 17903458 : RB (t->base.u.bits.packed_flag);
5587 : 17903458 : RB (t->base.u.bits.user_align);
5588 : 17903458 : RB (t->base.u.bits.nameless_flag);
5589 : 17903458 : RB (t->base.u.bits.atomic_flag);
5590 : 17903458 : RB (t->base.u.bits.unavailable_flag);
5591 : 17903458 : break;
5592 : : }
5593 : :
5594 : 17903458 : if (TREE_CODE_CLASS (code) == tcc_type)
5595 : : {
5596 : 848423 : RB (t->type_common.no_force_blk_flag);
5597 : 848423 : RB (t->type_common.needs_constructing_flag);
5598 : 848423 : RB (t->type_common.transparent_aggr_flag);
5599 : 848423 : RB (t->type_common.restrict_flag);
5600 : 848423 : RB (t->type_common.string_flag);
5601 : 848423 : RB (t->type_common.lang_flag_0);
5602 : 848423 : RB (t->type_common.lang_flag_1);
5603 : 848423 : RB (t->type_common.lang_flag_2);
5604 : 848423 : RB (t->type_common.lang_flag_3);
5605 : 848423 : RB (t->type_common.lang_flag_4);
5606 : 848423 : RB (t->type_common.lang_flag_5);
5607 : 848423 : RB (t->type_common.lang_flag_6);
5608 : 848423 : RB (t->type_common.typeless_storage);
5609 : : }
5610 : :
5611 : 17903458 : if (TREE_CODE_CLASS (code) != tcc_declaration)
5612 : 13157401 : goto done;
5613 : :
5614 : 4746057 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
5615 : : {
5616 : 4746057 : RB (t->decl_common.nonlocal_flag);
5617 : 4746057 : RB (t->decl_common.virtual_flag);
5618 : 4746057 : RB (t->decl_common.ignored_flag);
5619 : 4746057 : RB (t->decl_common.abstract_flag);
5620 : 4746057 : RB (t->decl_common.artificial_flag);
5621 : 4746057 : RB (t->decl_common.preserve_flag);
5622 : 4746057 : RB (t->decl_common.debug_expr_is_from);
5623 : 4746057 : RB (t->decl_common.lang_flag_0);
5624 : 4746057 : RB (t->decl_common.lang_flag_1);
5625 : 4746057 : RB (t->decl_common.lang_flag_2);
5626 : 4746057 : RB (t->decl_common.lang_flag_3);
5627 : 4746057 : RB (t->decl_common.lang_flag_4);
5628 : 4746057 : RB (t->decl_common.lang_flag_5);
5629 : 4746057 : RB (t->decl_common.lang_flag_6);
5630 : 4746057 : RB (t->decl_common.lang_flag_7);
5631 : 4746057 : RB (t->decl_common.lang_flag_8);
5632 : 4746057 : RB (t->decl_common.decl_flag_0);
5633 : 4746057 : RB (t->decl_common.decl_flag_1);
5634 : 4746057 : RB (t->decl_common.decl_flag_2);
5635 : 4746057 : RB (t->decl_common.decl_flag_3);
5636 : 4746057 : RB (t->decl_common.not_gimple_reg_flag);
5637 : 4746057 : RB (t->decl_common.decl_by_reference_flag);
5638 : 4746057 : RB (t->decl_common.decl_read_flag);
5639 : 4746057 : RB (t->decl_common.decl_nonshareable_flag);
5640 : 4746057 : RB (t->decl_common.decl_not_flexarray);
5641 : : }
5642 : : else
5643 : 0 : goto done;
5644 : :
5645 : 4746057 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
5646 : : {
5647 : 2201391 : RB (t->decl_with_vis.defer_output);
5648 : 2201391 : RB (t->decl_with_vis.hard_register);
5649 : 2201391 : RB (t->decl_with_vis.common_flag);
5650 : 2201391 : RB (t->decl_with_vis.in_text_section);
5651 : 2201391 : RB (t->decl_with_vis.in_constant_pool);
5652 : 2201391 : RB (t->decl_with_vis.dllimport_flag);
5653 : 2201391 : RB (t->decl_with_vis.weak_flag);
5654 : 2201391 : RB (t->decl_with_vis.seen_in_bind_expr);
5655 : 2201391 : RB (t->decl_with_vis.comdat_flag);
5656 : 2201391 : RB (t->decl_with_vis.visibility_specified);
5657 : 2201391 : RB (t->decl_with_vis.init_priority_p);
5658 : 2201391 : RB (t->decl_with_vis.shadowed_for_var_p);
5659 : 2201391 : RB (t->decl_with_vis.cxx_constructor);
5660 : 2201391 : RB (t->decl_with_vis.cxx_destructor);
5661 : 2201391 : RB (t->decl_with_vis.final);
5662 : 2201391 : RB (t->decl_with_vis.regdecl_flag);
5663 : : }
5664 : : else
5665 : 2544666 : goto done;
5666 : :
5667 : 2201391 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
5668 : : {
5669 : 690427 : RB (t->function_decl.static_ctor_flag);
5670 : 690427 : RB (t->function_decl.static_dtor_flag);
5671 : 690427 : RB (t->function_decl.uninlinable);
5672 : 690427 : RB (t->function_decl.possibly_inlined);
5673 : 690427 : RB (t->function_decl.novops_flag);
5674 : 690427 : RB (t->function_decl.returns_twice_flag);
5675 : 690427 : RB (t->function_decl.malloc_flag);
5676 : 690427 : RB (t->function_decl.declared_inline_flag);
5677 : 690427 : RB (t->function_decl.no_inline_warning_flag);
5678 : 690427 : RB (t->function_decl.no_instrument_function_entry_exit);
5679 : 690427 : RB (t->function_decl.no_limit_stack);
5680 : 690427 : RB (t->function_decl.disregard_inline_limits);
5681 : 690427 : RB (t->function_decl.pure_flag);
5682 : 690427 : RB (t->function_decl.looping_const_or_pure_flag);
5683 : :
5684 : 690427 : RB (t->function_decl.has_debug_args_flag);
5685 : 690427 : RB (t->function_decl.versioned_function);
5686 : :
5687 : : /* decl_type is a (misnamed) 2 bit discriminator. */
5688 : 690427 : unsigned kind = 0;
5689 : 690427 : kind |= unsigned (bits.b ()) << 0;
5690 : 690427 : kind |= unsigned (bits.b ()) << 1;
5691 : 690427 : t->function_decl.decl_type = function_decl_type (kind);
5692 : : }
5693 : : #undef RB_IF
5694 : : #undef RB
5695 : 1510964 : done:
5696 : 20558580 : return !get_overrun ();
5697 : : }
5698 : :
5699 : : void
5700 : 2777415 : trees_out::lang_decl_bools (tree t, bits_out& bits)
5701 : : {
5702 : : #define WB(X) (bits.b (X))
5703 : 2777415 : const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
5704 : :
5705 : 2777415 : bits.bflush ();
5706 : 2777415 : WB (lang->u.base.language == lang_cplusplus);
5707 : 2777415 : WB ((lang->u.base.use_template >> 0) & 1);
5708 : 2777415 : WB ((lang->u.base.use_template >> 1) & 1);
5709 : : /* Do not write lang->u.base.not_really_extern, importer will set
5710 : : when reading the definition (if any). */
5711 : 2777415 : WB (lang->u.base.initialized_in_class);
5712 : 2777415 : WB (lang->u.base.threadprivate_or_deleted_p);
5713 : : /* Do not write lang->u.base.anticipated_p, it is a property of the
5714 : : current TU. */
5715 : 2777415 : WB (lang->u.base.friend_or_tls);
5716 : 2777415 : WB (lang->u.base.unknown_bound_p);
5717 : : /* Do not write lang->u.base.odr_used, importer will recalculate if
5718 : : they do ODR use this decl. */
5719 : 2777415 : WB (lang->u.base.concept_p);
5720 : 2777415 : WB (lang->u.base.var_declared_inline_p);
5721 : 2777415 : WB (lang->u.base.dependent_init_p);
5722 : : /* When building a header unit, everthing is marked as purview, (so
5723 : : we know which decls to write). But when we import them we do not
5724 : : want to mark them as in module purview. */
5725 : 5544579 : WB (lang->u.base.module_purview_p && !header_module_p ());
5726 : 2777415 : WB (lang->u.base.module_attach_p);
5727 : 2777415 : WB (lang->u.base.module_keyed_decls_p);
5728 : 2777415 : switch (lang->u.base.selector)
5729 : : {
5730 : 0 : default:
5731 : 0 : gcc_unreachable ();
5732 : :
5733 : 604753 : case lds_fn: /* lang_decl_fn. */
5734 : 604753 : WB (lang->u.fn.global_ctor_p);
5735 : 604753 : WB (lang->u.fn.global_dtor_p);
5736 : 604753 : WB (lang->u.fn.static_function);
5737 : 604753 : WB (lang->u.fn.pure_virtual);
5738 : 604753 : WB (lang->u.fn.defaulted_p);
5739 : 604753 : WB (lang->u.fn.has_in_charge_parm_p);
5740 : 604753 : WB (lang->u.fn.has_vtt_parm_p);
5741 : : /* There shouldn't be a pending inline at this point. */
5742 : 604753 : gcc_assert (!lang->u.fn.pending_inline_p);
5743 : 604753 : WB (lang->u.fn.nonconverting);
5744 : 604753 : WB (lang->u.fn.thunk_p);
5745 : 604753 : WB (lang->u.fn.this_thunk_p);
5746 : : /* Do not stream lang->u.hidden_friend_p, it is a property of
5747 : : the TU. */
5748 : 604753 : WB (lang->u.fn.omp_declare_reduction_p);
5749 : 604753 : WB (lang->u.fn.has_dependent_explicit_spec_p);
5750 : 604753 : WB (lang->u.fn.immediate_fn_p);
5751 : 604753 : WB (lang->u.fn.maybe_deleted);
5752 : : /* We do not stream lang->u.fn.implicit_constexpr. */
5753 : 604753 : WB (lang->u.fn.escalated_p);
5754 : 604753 : WB (lang->u.fn.xobj_func);
5755 : 604753 : goto lds_min;
5756 : :
5757 : 1213 : case lds_decomp: /* lang_decl_decomp. */
5758 : : /* No bools. */
5759 : 1213 : goto lds_min;
5760 : :
5761 : : case lds_min: /* lang_decl_min. */
5762 : 2777415 : lds_min:
5763 : : /* No bools. */
5764 : : break;
5765 : :
5766 : : case lds_ns: /* lang_decl_ns. */
5767 : : /* No bools. */
5768 : : break;
5769 : :
5770 : : case lds_parm: /* lang_decl_parm. */
5771 : : /* No bools. */
5772 : : break;
5773 : : }
5774 : : #undef WB
5775 : 2777415 : }
5776 : :
5777 : : bool
5778 : 3092289 : trees_in::lang_decl_bools (tree t, bits_in& bits)
5779 : : {
5780 : : #define RB(X) ((X) = bits.b ())
5781 : 3092289 : struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
5782 : :
5783 : 3092289 : bits.bflush ();
5784 : 3092289 : lang->u.base.language = bits.b () ? lang_cplusplus : lang_c;
5785 : 3092289 : unsigned v;
5786 : 3092289 : v = bits.b () << 0;
5787 : 3092289 : v |= bits.b () << 1;
5788 : 3092289 : lang->u.base.use_template = v;
5789 : : /* lang->u.base.not_really_extern is not streamed. */
5790 : 3092289 : RB (lang->u.base.initialized_in_class);
5791 : 3092289 : RB (lang->u.base.threadprivate_or_deleted_p);
5792 : : /* lang->u.base.anticipated_p is not streamed. */
5793 : 3092289 : RB (lang->u.base.friend_or_tls);
5794 : 3092289 : RB (lang->u.base.unknown_bound_p);
5795 : : /* lang->u.base.odr_used is not streamed. */
5796 : 3092289 : RB (lang->u.base.concept_p);
5797 : 3092289 : RB (lang->u.base.var_declared_inline_p);
5798 : 3092289 : RB (lang->u.base.dependent_init_p);
5799 : 3092289 : RB (lang->u.base.module_purview_p);
5800 : 3092289 : RB (lang->u.base.module_attach_p);
5801 : 3092289 : RB (lang->u.base.module_keyed_decls_p);
5802 : 3092289 : switch (lang->u.base.selector)
5803 : : {
5804 : 0 : default:
5805 : 0 : gcc_unreachable ();
5806 : :
5807 : 690427 : case lds_fn: /* lang_decl_fn. */
5808 : 690427 : RB (lang->u.fn.global_ctor_p);
5809 : 690427 : RB (lang->u.fn.global_dtor_p);
5810 : 690427 : RB (lang->u.fn.static_function);
5811 : 690427 : RB (lang->u.fn.pure_virtual);
5812 : 690427 : RB (lang->u.fn.defaulted_p);
5813 : 690427 : RB (lang->u.fn.has_in_charge_parm_p);
5814 : 690427 : RB (lang->u.fn.has_vtt_parm_p);
5815 : 690427 : RB (lang->u.fn.nonconverting);
5816 : 690427 : RB (lang->u.fn.thunk_p);
5817 : 690427 : RB (lang->u.fn.this_thunk_p);
5818 : : /* lang->u.fn.hidden_friend_p is not streamed. */
5819 : 690427 : RB (lang->u.fn.omp_declare_reduction_p);
5820 : 690427 : RB (lang->u.fn.has_dependent_explicit_spec_p);
5821 : 690427 : RB (lang->u.fn.immediate_fn_p);
5822 : 690427 : RB (lang->u.fn.maybe_deleted);
5823 : : /* We do not stream lang->u.fn.implicit_constexpr. */
5824 : 690427 : RB (lang->u.fn.escalated_p);
5825 : 690427 : RB (lang->u.fn.xobj_func);
5826 : 690427 : goto lds_min;
5827 : :
5828 : 1411 : case lds_decomp: /* lang_decl_decomp. */
5829 : : /* No bools. */
5830 : 1411 : goto lds_min;
5831 : :
5832 : : case lds_min: /* lang_decl_min. */
5833 : 3092289 : lds_min:
5834 : : /* No bools. */
5835 : : break;
5836 : :
5837 : : case lds_ns: /* lang_decl_ns. */
5838 : : /* No bools. */
5839 : : break;
5840 : :
5841 : : case lds_parm: /* lang_decl_parm. */
5842 : : /* No bools. */
5843 : : break;
5844 : : }
5845 : : #undef RB
5846 : 3092289 : return !get_overrun ();
5847 : : }
5848 : :
5849 : : void
5850 : 222440 : trees_out::lang_type_bools (tree t, bits_out& bits)
5851 : : {
5852 : : #define WB(X) (bits.b (X))
5853 : 222440 : const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
5854 : :
5855 : 222440 : bits.bflush ();
5856 : 222440 : WB (lang->has_type_conversion);
5857 : 222440 : WB (lang->has_copy_ctor);
5858 : 222440 : WB (lang->has_default_ctor);
5859 : 222440 : WB (lang->const_needs_init);
5860 : 222440 : WB (lang->ref_needs_init);
5861 : 222440 : WB (lang->has_const_copy_assign);
5862 : 222440 : WB ((lang->use_template >> 0) & 1);
5863 : 222440 : WB ((lang->use_template >> 1) & 1);
5864 : :
5865 : 222440 : WB (lang->has_mutable);
5866 : 222440 : WB (lang->com_interface);
5867 : 222440 : WB (lang->non_pod_class);
5868 : 222440 : WB (lang->nearly_empty_p);
5869 : 222440 : WB (lang->user_align);
5870 : 222440 : WB (lang->has_copy_assign);
5871 : 222440 : WB (lang->has_new);
5872 : 222440 : WB (lang->has_array_new);
5873 : :
5874 : 222440 : WB ((lang->gets_delete >> 0) & 1);
5875 : 222440 : WB ((lang->gets_delete >> 1) & 1);
5876 : 222440 : WB (lang->interface_only);
5877 : 222440 : WB (lang->interface_unknown);
5878 : 222440 : WB (lang->contains_empty_class_p);
5879 : 222440 : WB (lang->anon_aggr);
5880 : 222440 : WB (lang->non_zero_init);
5881 : 222440 : WB (lang->empty_p);
5882 : :
5883 : 222440 : WB (lang->vec_new_uses_cookie);
5884 : 222440 : WB (lang->declared_class);
5885 : 222440 : WB (lang->diamond_shaped);
5886 : 222440 : WB (lang->repeated_base);
5887 : 222440 : gcc_assert (!lang->being_defined);
5888 : : // lang->debug_requested
5889 : 222440 : WB (lang->fields_readonly);
5890 : 222440 : WB (lang->ptrmemfunc_flag);
5891 : :
5892 : 222440 : WB (lang->lazy_default_ctor);
5893 : 222440 : WB (lang->lazy_copy_ctor);
5894 : 222440 : WB (lang->lazy_copy_assign);
5895 : 222440 : WB (lang->lazy_destructor);
5896 : 222440 : WB (lang->has_const_copy_ctor);
5897 : 222440 : WB (lang->has_complex_copy_ctor);
5898 : 222440 : WB (lang->has_complex_copy_assign);
5899 : 222440 : WB (lang->non_aggregate);
5900 : :
5901 : 222440 : WB (lang->has_complex_dflt);
5902 : 222440 : WB (lang->has_list_ctor);
5903 : 222440 : WB (lang->non_std_layout);
5904 : 222440 : WB (lang->is_literal);
5905 : 222440 : WB (lang->lazy_move_ctor);
5906 : 222440 : WB (lang->lazy_move_assign);
5907 : 222440 : WB (lang->has_complex_move_ctor);
5908 : 222440 : WB (lang->has_complex_move_assign);
5909 : :
5910 : 222440 : WB (lang->has_constexpr_ctor);
5911 : 222440 : WB (lang->unique_obj_representations);
5912 : 222440 : WB (lang->unique_obj_representations_set);
5913 : : #undef WB
5914 : 222440 : }
5915 : :
5916 : : bool
5917 : 235716 : trees_in::lang_type_bools (tree t, bits_in& bits)
5918 : : {
5919 : : #define RB(X) ((X) = bits.b ())
5920 : 235716 : struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
5921 : :
5922 : 235716 : bits.bflush ();
5923 : 235716 : RB (lang->has_type_conversion);
5924 : 235716 : RB (lang->has_copy_ctor);
5925 : 235716 : RB (lang->has_default_ctor);
5926 : 235716 : RB (lang->const_needs_init);
5927 : 235716 : RB (lang->ref_needs_init);
5928 : 235716 : RB (lang->has_const_copy_assign);
5929 : 235716 : unsigned v;
5930 : 235716 : v = bits.b () << 0;
5931 : 235716 : v |= bits.b () << 1;
5932 : 235716 : lang->use_template = v;
5933 : :
5934 : 235716 : RB (lang->has_mutable);
5935 : 235716 : RB (lang->com_interface);
5936 : 235716 : RB (lang->non_pod_class);
5937 : 235716 : RB (lang->nearly_empty_p);
5938 : 235716 : RB (lang->user_align);
5939 : 235716 : RB (lang->has_copy_assign);
5940 : 235716 : RB (lang->has_new);
5941 : 235716 : RB (lang->has_array_new);
5942 : :
5943 : 235716 : v = bits.b () << 0;
5944 : 235716 : v |= bits.b () << 1;
5945 : 235716 : lang->gets_delete = v;
5946 : 235716 : RB (lang->interface_only);
5947 : 235716 : RB (lang->interface_unknown);
5948 : 235716 : RB (lang->contains_empty_class_p);
5949 : 235716 : RB (lang->anon_aggr);
5950 : 235716 : RB (lang->non_zero_init);
5951 : 235716 : RB (lang->empty_p);
5952 : :
5953 : 235716 : RB (lang->vec_new_uses_cookie);
5954 : 235716 : RB (lang->declared_class);
5955 : 235716 : RB (lang->diamond_shaped);
5956 : 235716 : RB (lang->repeated_base);
5957 : 235716 : gcc_assert (!lang->being_defined);
5958 : 235716 : gcc_assert (!lang->debug_requested);
5959 : 235716 : RB (lang->fields_readonly);
5960 : 235716 : RB (lang->ptrmemfunc_flag);
5961 : :
5962 : 235716 : RB (lang->lazy_default_ctor);
5963 : 235716 : RB (lang->lazy_copy_ctor);
5964 : 235716 : RB (lang->lazy_copy_assign);
5965 : 235716 : RB (lang->lazy_destructor);
5966 : 235716 : RB (lang->has_const_copy_ctor);
5967 : 235716 : RB (lang->has_complex_copy_ctor);
5968 : 235716 : RB (lang->has_complex_copy_assign);
5969 : 235716 : RB (lang->non_aggregate);
5970 : :
5971 : 235716 : RB (lang->has_complex_dflt);
5972 : 235716 : RB (lang->has_list_ctor);
5973 : 235716 : RB (lang->non_std_layout);
5974 : 235716 : RB (lang->is_literal);
5975 : 235716 : RB (lang->lazy_move_ctor);
5976 : 235716 : RB (lang->lazy_move_assign);
5977 : 235716 : RB (lang->has_complex_move_ctor);
5978 : 235716 : RB (lang->has_complex_move_assign);
5979 : :
5980 : 235716 : RB (lang->has_constexpr_ctor);
5981 : 235716 : RB (lang->unique_obj_representations);
5982 : 235716 : RB (lang->unique_obj_representations_set);
5983 : : #undef RB
5984 : 235716 : return !get_overrun ();
5985 : : }
5986 : :
5987 : : /* Read & write the core values and pointers. */
5988 : :
5989 : : void
5990 : 48048630 : trees_out::core_vals (tree t)
5991 : : {
5992 : : #define WU(X) (u (X))
5993 : : #define WT(X) (tree_node (X))
5994 : 48048630 : tree_code code = TREE_CODE (t);
5995 : :
5996 : : /* First by shape of the tree. */
5997 : :
5998 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
5999 : : {
6000 : : /* Write this early, for better log information. */
6001 : 11153996 : WT (t->decl_minimal.name);
6002 : 11153996 : if (!DECL_TEMPLATE_PARM_P (t))
6003 : 8585631 : WT (t->decl_minimal.context);
6004 : :
6005 : 11153996 : if (state)
6006 : 9125299 : state->write_location (*this, t->decl_minimal.locus);
6007 : :
6008 : 11153996 : if (streaming_p ())
6009 : 4278540 : if (has_warning_spec (t))
6010 : 4270013 : u (get_warning_spec (t));
6011 : : }
6012 : :
6013 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
6014 : : {
6015 : : /* The only types we write also have TYPE_NON_COMMON. */
6016 : 2818429 : gcc_checking_assert (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON));
6017 : :
6018 : : /* We only stream the main variant. */
6019 : 2818429 : gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
6020 : :
6021 : : /* Stream the name & context first, for better log information */
6022 : 2818429 : WT (t->type_common.name);
6023 : 2818429 : WT (t->type_common.context);
6024 : :
6025 : : /* By construction we want to make sure we have the canonical
6026 : : and main variants already in the type table, so emit them
6027 : : now. */
6028 : 2818429 : WT (t->type_common.main_variant);
6029 : :
6030 : 2818429 : tree canonical = t->type_common.canonical;
6031 : 2818429 : if (canonical && DECL_TEMPLATE_PARM_P (TYPE_NAME (t)))
6032 : : /* We do not want to wander into different templates.
6033 : : Reconstructed on stream in. */
6034 : : canonical = t;
6035 : 2818429 : WT (canonical);
6036 : :
6037 : : /* type_common.next_variant is internally manipulated. */
6038 : : /* type_common.pointer_to, type_common.reference_to. */
6039 : :
6040 : 2818429 : if (streaming_p ())
6041 : : {
6042 : 772006 : WU (t->type_common.precision);
6043 : 772006 : WU (t->type_common.contains_placeholder_bits);
6044 : 772006 : WU (t->type_common.mode);
6045 : 772006 : WU (t->type_common.align);
6046 : : }
6047 : :
6048 : 2818429 : if (!RECORD_OR_UNION_CODE_P (code))
6049 : : {
6050 : 2313211 : WT (t->type_common.size);
6051 : 2313211 : WT (t->type_common.size_unit);
6052 : : }
6053 : 2818429 : WT (t->type_common.attributes);
6054 : :
6055 : 2818429 : WT (t->type_common.common.chain); /* TYPE_STUB_DECL. */
6056 : : }
6057 : :
6058 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
6059 : : {
6060 : 11153996 : if (streaming_p ())
6061 : : {
6062 : 4278540 : WU (t->decl_common.mode);
6063 : 4278540 : WU (t->decl_common.off_align);
6064 : 4278540 : WU (t->decl_common.align);
6065 : : }
6066 : :
6067 : : /* For templates these hold instantiation (partial and/or
6068 : : specialization) information. */
6069 : 11153996 : if (code != TEMPLATE_DECL)
6070 : : {
6071 : 10275682 : WT (t->decl_common.size);
6072 : 10275682 : WT (t->decl_common.size_unit);
6073 : : }
6074 : :
6075 : 11153996 : WT (t->decl_common.attributes);
6076 : : // FIXME: Does this introduce cross-decl links? For instance
6077 : : // from instantiation to the template. If so, we'll need more
6078 : : // deduplication logic. I think we'll need to walk the blocks
6079 : : // of the owning function_decl's abstract origin in tandem, to
6080 : : // generate the locating data needed?
6081 : 11153996 : WT (t->decl_common.abstract_origin);
6082 : : }
6083 : :
6084 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
6085 : : {
6086 : 5303624 : WT (t->decl_with_vis.assembler_name);
6087 : 5303624 : if (streaming_p ())
6088 : 2008007 : WU (t->decl_with_vis.visibility);
6089 : : }
6090 : :
6091 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
6092 : : {
6093 : 2818429 : if (code == ENUMERAL_TYPE)
6094 : : {
6095 : : /* These fields get set even for opaque enums that lack a
6096 : : definition, so we stream them directly for each ENUMERAL_TYPE.
6097 : : We stream TYPE_VALUES as part of the definition. */
6098 : 10610 : WT (t->type_non_common.maxval);
6099 : 10610 : WT (t->type_non_common.minval);
6100 : : }
6101 : : /* Records and unions hold FIELDS, VFIELD & BINFO on these
6102 : : things. */
6103 : 2807819 : else if (!RECORD_OR_UNION_CODE_P (code))
6104 : : {
6105 : : // FIXME: These are from tpl_parm_value's 'type' writing.
6106 : : // Perhaps it should just be doing them directly?
6107 : 2302601 : gcc_checking_assert (code == TEMPLATE_TYPE_PARM
6108 : : || code == TEMPLATE_TEMPLATE_PARM
6109 : : || code == BOUND_TEMPLATE_TEMPLATE_PARM);
6110 : 2302601 : gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
6111 : 2302601 : WT (t->type_non_common.values);
6112 : 2302601 : WT (t->type_non_common.maxval);
6113 : 2302601 : WT (t->type_non_common.minval);
6114 : : }
6115 : :
6116 : 2818429 : WT (t->type_non_common.lang_1);
6117 : : }
6118 : :
6119 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
6120 : : {
6121 : 13534364 : if (state)
6122 : 13285784 : state->write_location (*this, t->exp.locus);
6123 : :
6124 : 13534364 : if (streaming_p ())
6125 : 6592263 : if (has_warning_spec (t))
6126 : 4908301 : u (get_warning_spec (t));
6127 : :
6128 : : /* Walk in forward order, as (for instance) REQUIRES_EXPR has a
6129 : : bunch of unscoped parms on its first operand. It's safer to
6130 : : create those in order. */
6131 : 13534364 : bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
6132 : 49594645 : for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
6133 : 12117168 : : TREE_OPERAND_LENGTH (t)),
6134 : 37477477 : ix = unsigned (vl); ix != limit; ix++)
6135 : 23943113 : WT (TREE_OPERAND (t, ix));
6136 : : }
6137 : : else
6138 : : /* The CODE_CONTAINS tables were inaccurate when I started. */
6139 : 34514266 : gcc_checking_assert (TREE_CODE_CLASS (code) != tcc_expression
6140 : : && TREE_CODE_CLASS (code) != tcc_binary
6141 : : && TREE_CODE_CLASS (code) != tcc_unary
6142 : : && TREE_CODE_CLASS (code) != tcc_reference
6143 : : && TREE_CODE_CLASS (code) != tcc_comparison
6144 : : && TREE_CODE_CLASS (code) != tcc_statement
6145 : : && TREE_CODE_CLASS (code) != tcc_vl_exp);
6146 : :
6147 : : /* Then by CODE. Special cases and/or 1:1 tree shape
6148 : : correspondance. */
6149 : 48048630 : switch (code)
6150 : : {
6151 : : default:
6152 : : break;
6153 : :
6154 : 0 : case ARGUMENT_PACK_SELECT: /* Transient during instantiation. */
6155 : 0 : case DEFERRED_PARSE: /* Expanded upon completion of
6156 : : outermost class. */
6157 : 0 : case IDENTIFIER_NODE: /* Streamed specially. */
6158 : 0 : case BINDING_VECTOR: /* Only in namespace-scope symbol
6159 : : table. */
6160 : 0 : case SSA_NAME:
6161 : 0 : case TRANSLATION_UNIT_DECL: /* There is only one, it is a
6162 : : global_tree. */
6163 : 0 : case USERDEF_LITERAL: /* Expanded during parsing. */
6164 : 0 : gcc_unreachable (); /* Should never meet. */
6165 : :
6166 : : /* Constants. */
6167 : 18 : case COMPLEX_CST:
6168 : 18 : WT (TREE_REALPART (t));
6169 : 18 : WT (TREE_IMAGPART (t));
6170 : 18 : break;
6171 : :
6172 : 0 : case FIXED_CST:
6173 : 0 : gcc_unreachable (); /* Not supported in C++. */
6174 : :
6175 : 4555636 : case INTEGER_CST:
6176 : 4555636 : if (streaming_p ())
6177 : : {
6178 : 735483 : unsigned num = TREE_INT_CST_EXT_NUNITS (t);
6179 : 1473266 : for (unsigned ix = 0; ix != num; ix++)
6180 : 737783 : wu (TREE_INT_CST_ELT (t, ix));
6181 : : }
6182 : : break;
6183 : :
6184 : 0 : case POLY_INT_CST:
6185 : 0 : if (streaming_p ())
6186 : 0 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
6187 : 0 : WT (POLY_INT_CST_COEFF (t, ix));
6188 : : break;
6189 : :
6190 : 52351 : case REAL_CST:
6191 : 52351 : if (streaming_p ())
6192 : 26117 : buf (TREE_REAL_CST_PTR (t), sizeof (real_value));
6193 : : break;
6194 : :
6195 : : case STRING_CST:
6196 : : /* Streamed during start. */
6197 : : break;
6198 : :
6199 : 36 : case VECTOR_CST:
6200 : 102 : for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
6201 : 66 : WT (VECTOR_CST_ENCODED_ELT (t, ix));
6202 : : break;
6203 : :
6204 : : /* Decls. */
6205 : 515870 : case VAR_DECL:
6206 : 515870 : if (DECL_CONTEXT (t)
6207 : 515870 : && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
6208 : : break;
6209 : : /* FALLTHROUGH */
6210 : :
6211 : 4956548 : case RESULT_DECL:
6212 : 4956548 : case PARM_DECL:
6213 : 4956548 : if (DECL_HAS_VALUE_EXPR_P (t))
6214 : 24072 : WT (DECL_VALUE_EXPR (t));
6215 : : /* FALLTHROUGH */
6216 : :
6217 : 5168844 : case CONST_DECL:
6218 : 5168844 : case IMPORTED_DECL:
6219 : 5168844 : WT (t->decl_common.initial);
6220 : 5168844 : break;
6221 : :
6222 : 154350 : case FIELD_DECL:
6223 : 154350 : WT (t->field_decl.offset);
6224 : 154350 : WT (t->field_decl.bit_field_type);
6225 : 154350 : WT (t->field_decl.qualifier); /* bitfield unit. */
6226 : 154350 : WT (t->field_decl.bit_offset);
6227 : 154350 : WT (t->field_decl.fcontext);
6228 : 154350 : WT (t->decl_common.initial);
6229 : 154350 : break;
6230 : :
6231 : 38838 : case LABEL_DECL:
6232 : 38838 : if (streaming_p ())
6233 : : {
6234 : 19419 : WU (t->label_decl.label_decl_uid);
6235 : 19419 : WU (t->label_decl.eh_landing_pad_nr);
6236 : : }
6237 : : break;
6238 : :
6239 : 1209527 : case FUNCTION_DECL:
6240 : 1209527 : if (streaming_p ())
6241 : : {
6242 : : /* Builtins can be streamed by value when a header declares
6243 : : them. */
6244 : 604753 : WU (DECL_BUILT_IN_CLASS (t));
6245 : 604753 : if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
6246 : 13407 : WU (DECL_UNCHECKED_FUNCTION_CODE (t));
6247 : : }
6248 : :
6249 : 1209527 : WT (t->function_decl.personality);
6250 : 1209527 : WT (t->function_decl.function_specific_target);
6251 : 1209527 : WT (t->function_decl.function_specific_optimization);
6252 : 1209527 : WT (t->function_decl.vindex);
6253 : :
6254 : 1209527 : if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
6255 : 5044 : WT (lookup_explicit_specifier (t));
6256 : : break;
6257 : :
6258 : 119572 : case USING_DECL:
6259 : : /* USING_DECL_DECLS */
6260 : 119572 : WT (t->decl_common.initial);
6261 : : /* FALLTHROUGH */
6262 : :
6263 : 3577635 : case TYPE_DECL:
6264 : : /* USING_DECL: USING_DECL_SCOPE */
6265 : : /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6266 : 3577635 : WT (t->decl_non_common.result);
6267 : 3577635 : break;
6268 : :
6269 : : /* Miscellaneous common nodes. */
6270 : 725313 : case BLOCK:
6271 : 725313 : if (state)
6272 : : {
6273 : 725313 : state->write_location (*this, t->block.locus);
6274 : 725313 : state->write_location (*this, t->block.end_locus);
6275 : : }
6276 : :
6277 : : /* DECL_LOCAL_DECL_P decls are first encountered here and
6278 : : streamed by value. */
6279 : 1086841 : for (tree decls = t->block.vars; decls; decls = DECL_CHAIN (decls))
6280 : : {
6281 : 361528 : if (VAR_OR_FUNCTION_DECL_P (decls)
6282 : 361528 : && DECL_LOCAL_DECL_P (decls))
6283 : : {
6284 : : /* Make sure this is the first encounter, and mark for
6285 : : walk-by-value. */
6286 : 290 : gcc_checking_assert (!TREE_VISITED (decls)
6287 : : && !DECL_TEMPLATE_INFO (decls));
6288 : 290 : mark_by_value (decls);
6289 : : }
6290 : 361528 : tree_node (decls);
6291 : : }
6292 : 725313 : tree_node (NULL_TREE);
6293 : :
6294 : : /* nonlocalized_vars is a middle-end thing. */
6295 : 725313 : WT (t->block.subblocks);
6296 : 725313 : WT (t->block.supercontext);
6297 : : // FIXME: As for decl's abstract_origin, does this introduce crosslinks?
6298 : 725313 : WT (t->block.abstract_origin);
6299 : : /* fragment_origin, fragment_chain are middle-end things. */
6300 : 725313 : WT (t->block.chain);
6301 : : /* nonlocalized_vars, block_num & die are middle endy/debug
6302 : : things. */
6303 : 725313 : break;
6304 : :
6305 : 1389322 : case CALL_EXPR:
6306 : 1389322 : if (streaming_p ())
6307 : 668978 : WU (t->base.u.ifn);
6308 : : break;
6309 : :
6310 : : case CONSTRUCTOR:
6311 : : // This must be streamed /after/ we've streamed the type,
6312 : : // because it can directly refer to elements of the type. Eg,
6313 : : // FIELD_DECLs of a RECORD_TYPE.
6314 : : break;
6315 : :
6316 : 6 : case OMP_CLAUSE:
6317 : 6 : {
6318 : : /* The ompcode is serialized in start. */
6319 : 6 : if (streaming_p ())
6320 : 3 : WU (t->omp_clause.subcode.map_kind);
6321 : 6 : if (state)
6322 : 6 : state->write_location (*this, t->omp_clause.locus);
6323 : :
6324 : 6 : unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
6325 : 18 : for (unsigned ix = 0; ix != len; ix++)
6326 : 12 : WT (t->omp_clause.ops[ix]);
6327 : : }
6328 : : break;
6329 : :
6330 : 492414 : case STATEMENT_LIST:
6331 : 1950869 : for (tree stmt : tsi_range (t))
6332 : 1458455 : if (stmt)
6333 : 1458455 : WT (stmt);
6334 : 492414 : WT (NULL_TREE);
6335 : 492414 : break;
6336 : :
6337 : 0 : case OPTIMIZATION_NODE:
6338 : 0 : case TARGET_OPTION_NODE:
6339 : : // FIXME: Our representation for these two nodes is a cache of
6340 : : // the resulting set of options. Not a record of the options
6341 : : // that got changed by a particular attribute or pragma. Should
6342 : : // we record that, or should we record the diff from the command
6343 : : // line options? The latter seems the right behaviour, but is
6344 : : // (a) harder, and I guess could introduce strangeness if the
6345 : : // importer has set some incompatible set of optimization flags?
6346 : 0 : gcc_unreachable ();
6347 : 305534 : break;
6348 : :
6349 : 305534 : case TREE_BINFO:
6350 : 305534 : {
6351 : 305534 : WT (t->binfo.common.chain);
6352 : 305534 : WT (t->binfo.offset);
6353 : 305534 : WT (t->binfo.inheritance);
6354 : 305534 : WT (t->binfo.vptr_field);
6355 : :
6356 : 305534 : WT (t->binfo.vtable);
6357 : 305534 : WT (t->binfo.virtuals);
6358 : 305534 : WT (t->binfo.vtt_subvtt);
6359 : 305534 : WT (t->binfo.vtt_vptr);
6360 : :
6361 : 305534 : tree_vec (BINFO_BASE_ACCESSES (t));
6362 : 305534 : unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
6363 : 399536 : for (unsigned ix = 0; ix != num; ix++)
6364 : 94002 : WT (BINFO_BASE_BINFO (t, ix));
6365 : : }
6366 : : break;
6367 : :
6368 : 3825135 : case TREE_LIST:
6369 : 3825135 : WT (t->list.purpose);
6370 : 3825135 : WT (t->list.value);
6371 : 3825135 : WT (t->list.common.chain);
6372 : 3825135 : break;
6373 : :
6374 : 3145843 : case TREE_VEC:
6375 : 8929064 : for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
6376 : 5783221 : WT (TREE_VEC_ELT (t, ix));
6377 : : /* We stash NON_DEFAULT_TEMPLATE_ARGS_COUNT on TREE_CHAIN! */
6378 : 3145843 : gcc_checking_assert (!t->type_common.common.chain
6379 : : || (TREE_CODE (t->type_common.common.chain)
6380 : : == INTEGER_CST));
6381 : 3145843 : WT (t->type_common.common.chain);
6382 : 3145843 : break;
6383 : :
6384 : : /* C++-specific nodes ... */
6385 : 246838 : case BASELINK:
6386 : 246838 : WT (((lang_tree_node *)t)->baselink.binfo);
6387 : 246838 : WT (((lang_tree_node *)t)->baselink.functions);
6388 : 246838 : WT (((lang_tree_node *)t)->baselink.access_binfo);
6389 : 246838 : break;
6390 : :
6391 : 65654 : case CONSTRAINT_INFO:
6392 : 65654 : WT (((lang_tree_node *)t)->constraint_info.template_reqs);
6393 : 65654 : WT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
6394 : 65654 : WT (((lang_tree_node *)t)->constraint_info.associated_constr);
6395 : 65654 : break;
6396 : :
6397 : 15288 : case DEFERRED_NOEXCEPT:
6398 : 15288 : WT (((lang_tree_node *)t)->deferred_noexcept.pattern);
6399 : 15288 : WT (((lang_tree_node *)t)->deferred_noexcept.args);
6400 : 15288 : break;
6401 : :
6402 : 13042 : case LAMBDA_EXPR:
6403 : 13042 : WT (((lang_tree_node *)t)->lambda_expression.capture_list);
6404 : 13042 : WT (((lang_tree_node *)t)->lambda_expression.this_capture);
6405 : 13042 : WT (((lang_tree_node *)t)->lambda_expression.extra_scope);
6406 : 13042 : WT (((lang_tree_node *)t)->lambda_expression.regen_info);
6407 : 13042 : WT (((lang_tree_node *)t)->lambda_expression.extra_args);
6408 : : /* pending_proxies is a parse-time thing. */
6409 : 13042 : gcc_assert (!((lang_tree_node *)t)->lambda_expression.pending_proxies);
6410 : 13042 : if (state)
6411 : 13042 : state->write_location
6412 : 13042 : (*this, ((lang_tree_node *)t)->lambda_expression.locus);
6413 : 13042 : if (streaming_p ())
6414 : : {
6415 : 4391 : WU (((lang_tree_node *)t)->lambda_expression.default_capture_mode);
6416 : 4391 : WU (((lang_tree_node *)t)->lambda_expression.discriminator_scope);
6417 : 4391 : WU (((lang_tree_node *)t)->lambda_expression.discriminator_sig);
6418 : : }
6419 : : break;
6420 : :
6421 : 2428470 : case OVERLOAD:
6422 : 2428470 : WT (((lang_tree_node *)t)->overload.function);
6423 : 2428470 : WT (t->common.chain);
6424 : 2428470 : break;
6425 : :
6426 : 0 : case PTRMEM_CST:
6427 : 0 : WT (((lang_tree_node *)t)->ptrmem.member);
6428 : 0 : break;
6429 : :
6430 : 19223 : case STATIC_ASSERT:
6431 : 19223 : WT (((lang_tree_node *)t)->static_assertion.condition);
6432 : 19223 : WT (((lang_tree_node *)t)->static_assertion.message);
6433 : 19223 : if (state)
6434 : 19223 : state->write_location
6435 : 19223 : (*this, ((lang_tree_node *)t)->static_assertion.location);
6436 : : break;
6437 : :
6438 : 878314 : case TEMPLATE_DECL:
6439 : : /* Streamed with the template_decl node itself. */
6440 : 878314 : gcc_checking_assert
6441 : : (TREE_VISITED (((lang_tree_node *)t)->template_decl.arguments));
6442 : 878314 : gcc_checking_assert
6443 : : (TREE_VISITED (((lang_tree_node *)t)->template_decl.result));
6444 : 878314 : if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
6445 : 11646 : WT (DECL_CHAIN (t));
6446 : : break;
6447 : :
6448 : 1995765 : case TEMPLATE_INFO:
6449 : 1995765 : {
6450 : 1995765 : WT (((lang_tree_node *)t)->template_info.tmpl);
6451 : 1995765 : WT (((lang_tree_node *)t)->template_info.args);
6452 : 1995765 : WT (((lang_tree_node *)t)->template_info.partial);
6453 : :
6454 : 1995765 : const auto *ac = (((lang_tree_node *)t)
6455 : : ->template_info.deferred_access_checks);
6456 : 1995765 : unsigned len = vec_safe_length (ac);
6457 : 1995765 : if (streaming_p ())
6458 : 996097 : u (len);
6459 : 1995765 : if (len)
6460 : : {
6461 : 0 : for (unsigned ix = 0; ix != len; ix++)
6462 : : {
6463 : 0 : const auto &m = (*ac)[ix];
6464 : 0 : WT (m.binfo);
6465 : 0 : WT (m.decl);
6466 : 0 : WT (m.diag_decl);
6467 : 0 : if (state)
6468 : 0 : state->write_location (*this, m.loc);
6469 : : }
6470 : : }
6471 : : }
6472 : : break;
6473 : :
6474 : 2474295 : case TEMPLATE_PARM_INDEX:
6475 : 2474295 : if (streaming_p ())
6476 : : {
6477 : 549745 : WU (((lang_tree_node *)t)->tpi.index);
6478 : 549745 : WU (((lang_tree_node *)t)->tpi.level);
6479 : 549745 : WU (((lang_tree_node *)t)->tpi.orig_level);
6480 : : }
6481 : 2474295 : WT (((lang_tree_node *)t)->tpi.decl);
6482 : : /* TEMPLATE_PARM_DESCENDANTS (AKA TREE_CHAIN) is an internal
6483 : : cache, do not stream. */
6484 : 2474295 : break;
6485 : :
6486 : 33660 : case TRAIT_EXPR:
6487 : 33660 : WT (((lang_tree_node *)t)->trait_expression.type1);
6488 : 33660 : WT (((lang_tree_node *)t)->trait_expression.type2);
6489 : 33660 : if (streaming_p ())
6490 : 12850 : WU (((lang_tree_node *)t)->trait_expression.kind);
6491 : : break;
6492 : : }
6493 : :
6494 : 48048630 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
6495 : : {
6496 : : /* We want to stream the type of a expression-like nodes /after/
6497 : : we've streamed the operands. The type often contains (bits
6498 : : of the) types of the operands, and with things like decltype
6499 : : and noexcept in play, we really want to stream the decls
6500 : : defining the type before we try and stream the type on its
6501 : : own. Otherwise we can find ourselves trying to read in a
6502 : : decl, when we're already partially reading in a component of
6503 : : its type. And that's bad. */
6504 : 45227387 : tree type = t->typed.type;
6505 : 45227387 : unsigned prec = 0;
6506 : :
6507 : 45227387 : switch (code)
6508 : : {
6509 : : default:
6510 : : break;
6511 : :
6512 : : case TEMPLATE_DECL:
6513 : : /* We fill in the template's type separately. */
6514 : 45227387 : type = NULL_TREE;
6515 : : break;
6516 : :
6517 : 3458063 : case TYPE_DECL:
6518 : 3458063 : if (DECL_ORIGINAL_TYPE (t) && t == TYPE_NAME (type))
6519 : : /* This is a typedef. We set its type separately. */
6520 : : type = NULL_TREE;
6521 : : break;
6522 : :
6523 : 10610 : case ENUMERAL_TYPE:
6524 : 10610 : if (type && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
6525 : : {
6526 : : /* Type is a restricted range integer type derived from the
6527 : : integer_types. Find the right one. */
6528 : 7132 : prec = TYPE_PRECISION (type);
6529 : 7132 : tree name = DECL_NAME (TYPE_NAME (type));
6530 : :
6531 : 93134 : for (unsigned itk = itk_none; itk--;)
6532 : 93134 : if (integer_types[itk]
6533 : 93134 : && DECL_NAME (TYPE_NAME (integer_types[itk])) == name)
6534 : : {
6535 : : type = integer_types[itk];
6536 : : break;
6537 : : }
6538 : 7132 : gcc_assert (type != t->typed.type);
6539 : : }
6540 : : break;
6541 : : }
6542 : :
6543 : 45227387 : WT (type);
6544 : 45227387 : if (prec && streaming_p ())
6545 : 3566 : WU (prec);
6546 : : }
6547 : :
6548 : 48048630 : if (TREE_CODE (t) == CONSTRUCTOR)
6549 : : {
6550 : 110398 : unsigned len = vec_safe_length (t->constructor.elts);
6551 : 110398 : if (streaming_p ())
6552 : 54327 : WU (len);
6553 : 110398 : if (len)
6554 : 247036 : for (unsigned ix = 0; ix != len; ix++)
6555 : : {
6556 : 212265 : const constructor_elt &elt = (*t->constructor.elts)[ix];
6557 : :
6558 : 212265 : WT (elt.index);
6559 : 212265 : WT (elt.value);
6560 : : }
6561 : : }
6562 : :
6563 : : #undef WT
6564 : : #undef WU
6565 : 48048630 : }
6566 : :
6567 : : // Streaming in a reference to a decl can cause that decl to be
6568 : : // TREE_USED, which is the mark_used behaviour we need most of the
6569 : : // time. The trees_in::unused can be incremented to inhibit this,
6570 : : // which is at least needed for vtables.
6571 : :
6572 : : bool
6573 : 20530703 : trees_in::core_vals (tree t)
6574 : : {
6575 : : #define RU(X) ((X) = u ())
6576 : : #define RUC(T,X) ((X) = T (u ()))
6577 : : #define RT(X) ((X) = tree_node ())
6578 : : #define RTU(X) ((X) = tree_node (true))
6579 : 20530703 : tree_code code = TREE_CODE (t);
6580 : :
6581 : : /* First by tree shape. */
6582 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
6583 : : {
6584 : 4746057 : RT (t->decl_minimal.name);
6585 : 4746057 : if (!DECL_TEMPLATE_PARM_P (t))
6586 : 4127969 : RT (t->decl_minimal.context);
6587 : :
6588 : : /* Don't zap the locus just yet, we don't record it correctly
6589 : : and thus lose all location information. */
6590 : 4746057 : t->decl_minimal.locus = state->read_location (*this);
6591 : 4746057 : if (has_warning_spec (t))
6592 : 4735572 : put_warning_spec (t, u ());
6593 : : }
6594 : :
6595 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
6596 : : {
6597 : 820546 : RT (t->type_common.name);
6598 : 820546 : RT (t->type_common.context);
6599 : :
6600 : 820546 : RT (t->type_common.main_variant);
6601 : 820546 : RT (t->type_common.canonical);
6602 : :
6603 : : /* type_common.next_variant is internally manipulated. */
6604 : : /* type_common.pointer_to, type_common.reference_to. */
6605 : :
6606 : 820546 : RU (t->type_common.precision);
6607 : 820546 : RU (t->type_common.contains_placeholder_bits);
6608 : 820546 : RUC (machine_mode, t->type_common.mode);
6609 : 820546 : RU (t->type_common.align);
6610 : :
6611 : 820546 : if (!RECORD_OR_UNION_CODE_P (code))
6612 : : {
6613 : 554929 : RT (t->type_common.size);
6614 : 554929 : RT (t->type_common.size_unit);
6615 : : }
6616 : 820546 : RT (t->type_common.attributes);
6617 : :
6618 : 820546 : RT (t->type_common.common.chain); /* TYPE_STUB_DECL. */
6619 : : }
6620 : :
6621 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
6622 : : {
6623 : 4746057 : RUC (machine_mode, t->decl_common.mode);
6624 : 4746057 : RU (t->decl_common.off_align);
6625 : 4746057 : RU (t->decl_common.align);
6626 : :
6627 : 4746057 : if (code != TEMPLATE_DECL)
6628 : : {
6629 : 4270165 : RT (t->decl_common.size);
6630 : 4270165 : RT (t->decl_common.size_unit);
6631 : : }
6632 : :
6633 : 4746057 : RT (t->decl_common.attributes);
6634 : 4746057 : RT (t->decl_common.abstract_origin);
6635 : : }
6636 : :
6637 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
6638 : : {
6639 : 2201391 : RT (t->decl_with_vis.assembler_name);
6640 : 2201391 : RUC (symbol_visibility, t->decl_with_vis.visibility);
6641 : : }
6642 : :
6643 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
6644 : : {
6645 : 820546 : if (code == ENUMERAL_TYPE)
6646 : : {
6647 : : /* These fields get set even for opaque enums that lack a
6648 : : definition, so we stream them directly for each ENUMERAL_TYPE.
6649 : : We stream TYPE_VALUES as part of the definition. */
6650 : 4983 : RT (t->type_non_common.maxval);
6651 : 4983 : RT (t->type_non_common.minval);
6652 : : }
6653 : : /* Records and unions hold FIELDS, VFIELD & BINFO on these
6654 : : things. */
6655 : 815563 : else if (!RECORD_OR_UNION_CODE_P (code))
6656 : : {
6657 : : /* This is not clobbering TYPE_CACHED_VALUES, because this
6658 : : is a type that doesn't have any. */
6659 : 549946 : gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
6660 : 549946 : RT (t->type_non_common.values);
6661 : 549946 : RT (t->type_non_common.maxval);
6662 : 549946 : RT (t->type_non_common.minval);
6663 : : }
6664 : :
6665 : 820546 : RT (t->type_non_common.lang_1);
6666 : : }
6667 : :
6668 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
6669 : : {
6670 : 7554388 : t->exp.locus = state->read_location (*this);
6671 : 7554388 : if (has_warning_spec (t))
6672 : 5628751 : put_warning_spec (t, u ());
6673 : :
6674 : 7554388 : bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
6675 : 14331618 : for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
6676 : 6777230 : : TREE_OPERAND_LENGTH (t)),
6677 : 20907756 : ix = unsigned (vl); ix != limit; ix++)
6678 : 13353368 : RTU (TREE_OPERAND (t, ix));
6679 : : }
6680 : :
6681 : : /* Then by CODE. Special cases and/or 1:1 tree shape
6682 : : correspondance. */
6683 : 20530703 : switch (code)
6684 : : {
6685 : : default:
6686 : : break;
6687 : :
6688 : : case ARGUMENT_PACK_SELECT:
6689 : : case DEFERRED_PARSE:
6690 : : case IDENTIFIER_NODE:
6691 : : case BINDING_VECTOR:
6692 : : case SSA_NAME:
6693 : : case TRANSLATION_UNIT_DECL:
6694 : : case USERDEF_LITERAL:
6695 : : return false; /* Should never meet. */
6696 : :
6697 : : /* Constants. */
6698 : 9 : case COMPLEX_CST:
6699 : 9 : RT (TREE_REALPART (t));
6700 : 9 : RT (TREE_IMAGPART (t));
6701 : 9 : break;
6702 : :
6703 : : case FIXED_CST:
6704 : : /* Not suported in C++. */
6705 : : return false;
6706 : :
6707 : 785689 : case INTEGER_CST:
6708 : 785689 : {
6709 : 785689 : unsigned num = TREE_INT_CST_EXT_NUNITS (t);
6710 : 1573890 : for (unsigned ix = 0; ix != num; ix++)
6711 : 788201 : TREE_INT_CST_ELT (t, ix) = wu ();
6712 : : }
6713 : : break;
6714 : :
6715 : : case POLY_INT_CST:
6716 : 0 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
6717 : 0 : RT (POLY_INT_CST_COEFF (t, ix));
6718 : : break;
6719 : :
6720 : 35439 : case REAL_CST:
6721 : 35439 : if (const void *bytes = buf (sizeof (real_value)))
6722 : 35439 : memcpy (TREE_REAL_CST_PTR (t), bytes, sizeof (real_value));
6723 : : break;
6724 : :
6725 : : case STRING_CST:
6726 : : /* Streamed during start. */
6727 : : break;
6728 : :
6729 : 24 : case VECTOR_CST:
6730 : 63 : for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
6731 : 39 : RT (VECTOR_CST_ENCODED_ELT (t, ix));
6732 : : break;
6733 : :
6734 : : /* Decls. */
6735 : 294154 : case VAR_DECL:
6736 : 294154 : if (DECL_CONTEXT (t)
6737 : 294154 : && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
6738 : : break;
6739 : : /* FALLTHROUGH */
6740 : :
6741 : 2126804 : case RESULT_DECL:
6742 : 2126804 : case PARM_DECL:
6743 : 2126804 : if (DECL_HAS_VALUE_EXPR_P (t))
6744 : : {
6745 : : /* The DECL_VALUE hash table is a cache, thus if we're
6746 : : reading a duplicate (which we end up discarding), the
6747 : : value expr will also be cleaned up at the next gc. */
6748 : 11530 : tree val = tree_node ();
6749 : 11530 : SET_DECL_VALUE_EXPR (t, val);
6750 : : }
6751 : : /* FALLTHROUGH */
6752 : :
6753 : 2187863 : case CONST_DECL:
6754 : 2187863 : case IMPORTED_DECL:
6755 : 2187863 : RT (t->decl_common.initial);
6756 : 2187863 : break;
6757 : :
6758 : 85218 : case FIELD_DECL:
6759 : 85218 : RT (t->field_decl.offset);
6760 : 85218 : RT (t->field_decl.bit_field_type);
6761 : 85218 : RT (t->field_decl.qualifier);
6762 : 85218 : RT (t->field_decl.bit_offset);
6763 : 85218 : RT (t->field_decl.fcontext);
6764 : 85218 : RT (t->decl_common.initial);
6765 : 85218 : break;
6766 : :
6767 : 22355 : case LABEL_DECL:
6768 : 22355 : RU (t->label_decl.label_decl_uid);
6769 : 22355 : RU (t->label_decl.eh_landing_pad_nr);
6770 : 22355 : break;
6771 : :
6772 : 690427 : case FUNCTION_DECL:
6773 : 690427 : {
6774 : 690427 : unsigned bltin = u ();
6775 : 690427 : t->function_decl.built_in_class = built_in_class (bltin);
6776 : 690427 : if (bltin != NOT_BUILT_IN)
6777 : : {
6778 : 16136 : bltin = u ();
6779 : 16136 : DECL_UNCHECKED_FUNCTION_CODE (t) = built_in_function (bltin);
6780 : : }
6781 : :
6782 : 690427 : RT (t->function_decl.personality);
6783 : 690427 : RT (t->function_decl.function_specific_target);
6784 : 690427 : RT (t->function_decl.function_specific_optimization);
6785 : 690427 : RT (t->function_decl.vindex);
6786 : :
6787 : 690427 : if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
6788 : : {
6789 : 2845 : tree spec;
6790 : 2845 : RT (spec);
6791 : 2845 : store_explicit_specifier (t, spec);
6792 : : }
6793 : : }
6794 : : break;
6795 : :
6796 : 60384 : case USING_DECL:
6797 : : /* USING_DECL_DECLS */
6798 : 60384 : RT (t->decl_common.initial);
6799 : : /* FALLTHROUGH */
6800 : :
6801 : 1216442 : case TYPE_DECL:
6802 : : /* USING_DECL: USING_DECL_SCOPE */
6803 : : /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6804 : 1216442 : RT (t->decl_non_common.result);
6805 : 1216442 : break;
6806 : :
6807 : : /* Miscellaneous common nodes. */
6808 : 416112 : case BLOCK:
6809 : 416112 : t->block.locus = state->read_location (*this);
6810 : 416112 : t->block.end_locus = state->read_location (*this);
6811 : :
6812 : 416112 : for (tree *chain = &t->block.vars;;)
6813 : 632632 : if (tree decl = tree_node ())
6814 : : {
6815 : : /* For a deduplicated local type or enumerator, chain the
6816 : : duplicate decl instead of the canonical in-TU decl. Seeing
6817 : : a duplicate here means the containing function whose body
6818 : : we're streaming in is a duplicate too, so we'll end up
6819 : : discarding this BLOCK (and the rest of the duplicate function
6820 : : body) anyway. */
6821 : 216520 : decl = maybe_duplicate (decl);
6822 : :
6823 : 216520 : if (!DECL_P (decl) || DECL_CHAIN (decl))
6824 : : {
6825 : 0 : set_overrun ();
6826 : 0 : break;
6827 : : }
6828 : 216520 : *chain = decl;
6829 : 216520 : chain = &DECL_CHAIN (decl);
6830 : : }
6831 : : else
6832 : 216520 : break;
6833 : :
6834 : : /* nonlocalized_vars is middle-end. */
6835 : 416112 : RT (t->block.subblocks);
6836 : 416112 : RT (t->block.supercontext);
6837 : 416112 : RT (t->block.abstract_origin);
6838 : : /* fragment_origin, fragment_chain are middle-end. */
6839 : 416112 : RT (t->block.chain);
6840 : : /* nonlocalized_vars, block_num, die are middle endy/debug
6841 : : things. */
6842 : 416112 : break;
6843 : :
6844 : 761701 : case CALL_EXPR:
6845 : 761701 : RUC (internal_fn, t->base.u.ifn);
6846 : 761701 : break;
6847 : :
6848 : : case CONSTRUCTOR:
6849 : : // Streamed after the node's type.
6850 : : break;
6851 : :
6852 : 3 : case OMP_CLAUSE:
6853 : 3 : {
6854 : 3 : RU (t->omp_clause.subcode.map_kind);
6855 : 3 : t->omp_clause.locus = state->read_location (*this);
6856 : :
6857 : 3 : unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
6858 : 9 : for (unsigned ix = 0; ix != len; ix++)
6859 : 6 : RT (t->omp_clause.ops[ix]);
6860 : : }
6861 : : break;
6862 : :
6863 : 281032 : case STATEMENT_LIST:
6864 : 281032 : {
6865 : 281032 : tree_stmt_iterator iter = tsi_start (t);
6866 : 1127798 : for (tree stmt; RT (stmt);)
6867 : 846766 : tsi_link_after (&iter, stmt, TSI_CONTINUE_LINKING);
6868 : : }
6869 : 281032 : break;
6870 : :
6871 : 0 : case OPTIMIZATION_NODE:
6872 : 0 : case TARGET_OPTION_NODE:
6873 : : /* Not yet implemented, see trees_out::core_vals. */
6874 : 0 : gcc_unreachable ();
6875 : 154741 : break;
6876 : :
6877 : 154741 : case TREE_BINFO:
6878 : 154741 : RT (t->binfo.common.chain);
6879 : 154741 : RT (t->binfo.offset);
6880 : 154741 : RT (t->binfo.inheritance);
6881 : 154741 : RT (t->binfo.vptr_field);
6882 : :
6883 : : /* Do not mark the vtables as USED in the address expressions
6884 : : here. */
6885 : 154741 : unused++;
6886 : 154741 : RT (t->binfo.vtable);
6887 : 154741 : RT (t->binfo.virtuals);
6888 : 154741 : RT (t->binfo.vtt_subvtt);
6889 : 154741 : RT (t->binfo.vtt_vptr);
6890 : 154741 : unused--;
6891 : :
6892 : 154741 : BINFO_BASE_ACCESSES (t) = tree_vec ();
6893 : 154741 : if (!get_overrun ())
6894 : : {
6895 : 154741 : unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
6896 : 202823 : for (unsigned ix = 0; ix != num; ix++)
6897 : 48082 : BINFO_BASE_APPEND (t, tree_node ());
6898 : : }
6899 : : break;
6900 : :
6901 : 1877367 : case TREE_LIST:
6902 : 1877367 : RT (t->list.purpose);
6903 : 1877367 : RT (t->list.value);
6904 : 1877367 : RT (t->list.common.chain);
6905 : 1877367 : break;
6906 : :
6907 : 1107732 : case TREE_VEC:
6908 : 3075580 : for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
6909 : 1967848 : RT (TREE_VEC_ELT (t, ix));
6910 : 1107732 : RT (t->type_common.common.chain);
6911 : 1107732 : break;
6912 : :
6913 : : /* C++-specific nodes ... */
6914 : 131518 : case BASELINK:
6915 : 131518 : RT (((lang_tree_node *)t)->baselink.binfo);
6916 : 131518 : RTU (((lang_tree_node *)t)->baselink.functions);
6917 : 131518 : RT (((lang_tree_node *)t)->baselink.access_binfo);
6918 : 131518 : break;
6919 : :
6920 : 29127 : case CONSTRAINT_INFO:
6921 : 29127 : RT (((lang_tree_node *)t)->constraint_info.template_reqs);
6922 : 29127 : RT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
6923 : 29127 : RT (((lang_tree_node *)t)->constraint_info.associated_constr);
6924 : 29127 : break;
6925 : :
6926 : 8767 : case DEFERRED_NOEXCEPT:
6927 : 8767 : RT (((lang_tree_node *)t)->deferred_noexcept.pattern);
6928 : 8767 : RT (((lang_tree_node *)t)->deferred_noexcept.args);
6929 : 8767 : break;
6930 : :
6931 : 4921 : case LAMBDA_EXPR:
6932 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.capture_list);
6933 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.this_capture);
6934 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.extra_scope);
6935 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.regen_info);
6936 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.extra_args);
6937 : : /* lambda_expression.pending_proxies is NULL */
6938 : 4921 : ((lang_tree_node *)t)->lambda_expression.locus
6939 : 4921 : = state->read_location (*this);
6940 : 4921 : RUC (cp_lambda_default_capture_mode_type,
6941 : : ((lang_tree_node *)t)->lambda_expression.default_capture_mode);
6942 : 4921 : RU (((lang_tree_node *)t)->lambda_expression.discriminator_scope);
6943 : 4921 : RU (((lang_tree_node *)t)->lambda_expression.discriminator_sig);
6944 : 4921 : break;
6945 : :
6946 : 795662 : case OVERLOAD:
6947 : 795662 : RT (((lang_tree_node *)t)->overload.function);
6948 : 795662 : RT (t->common.chain);
6949 : 795662 : break;
6950 : :
6951 : 0 : case PTRMEM_CST:
6952 : 0 : RT (((lang_tree_node *)t)->ptrmem.member);
6953 : 0 : break;
6954 : :
6955 : 10640 : case STATIC_ASSERT:
6956 : 10640 : RT (((lang_tree_node *)t)->static_assertion.condition);
6957 : 10640 : RT (((lang_tree_node *)t)->static_assertion.message);
6958 : 10640 : ((lang_tree_node *)t)->static_assertion.location
6959 : 10640 : = state->read_location (*this);
6960 : 10640 : break;
6961 : :
6962 : 475892 : case TEMPLATE_DECL:
6963 : : /* Streamed when reading the raw template decl itself. */
6964 : 475892 : gcc_assert (((lang_tree_node *)t)->template_decl.arguments);
6965 : 475892 : gcc_assert (((lang_tree_node *)t)->template_decl.result);
6966 : 475892 : if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
6967 : 6764 : RT (DECL_CHAIN (t));
6968 : : break;
6969 : :
6970 : 1090214 : case TEMPLATE_INFO:
6971 : 1090214 : RT (((lang_tree_node *)t)->template_info.tmpl);
6972 : 1090214 : RT (((lang_tree_node *)t)->template_info.args);
6973 : 1090214 : RT (((lang_tree_node *)t)->template_info.partial);
6974 : 1090214 : if (unsigned len = u ())
6975 : : {
6976 : 0 : auto &ac = (((lang_tree_node *)t)
6977 : : ->template_info.deferred_access_checks);
6978 : 0 : vec_alloc (ac, len);
6979 : 0 : for (unsigned ix = 0; ix != len; ix++)
6980 : : {
6981 : 0 : deferred_access_check m;
6982 : :
6983 : 0 : RT (m.binfo);
6984 : 0 : RT (m.decl);
6985 : 0 : RT (m.diag_decl);
6986 : 0 : m.loc = state->read_location (*this);
6987 : 0 : ac->quick_push (m);
6988 : : }
6989 : : }
6990 : : break;
6991 : :
6992 : 589180 : case TEMPLATE_PARM_INDEX:
6993 : 589180 : RU (((lang_tree_node *)t)->tpi.index);
6994 : 589180 : RU (((lang_tree_node *)t)->tpi.level);
6995 : 589180 : RU (((lang_tree_node *)t)->tpi.orig_level);
6996 : 589180 : RT (((lang_tree_node *)t)->tpi.decl);
6997 : 589180 : break;
6998 : :
6999 : 12821 : case TRAIT_EXPR:
7000 : 12821 : RT (((lang_tree_node *)t)->trait_expression.type1);
7001 : 12821 : RT (((lang_tree_node *)t)->trait_expression.type2);
7002 : 12821 : RUC (cp_trait_kind, ((lang_tree_node *)t)->trait_expression.kind);
7003 : 12821 : break;
7004 : : }
7005 : :
7006 : 20530703 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
7007 : : {
7008 : 18975843 : tree type = tree_node ();
7009 : :
7010 : 18975843 : if (type && code == ENUMERAL_TYPE && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
7011 : : {
7012 : 3207 : unsigned precision = u ();
7013 : :
7014 : 3207 : type = build_distinct_type_copy (type);
7015 : 3207 : TYPE_PRECISION (type) = precision;
7016 : 6414 : set_min_and_max_values_for_integral_type (type, precision,
7017 : 3207 : TYPE_SIGN (type));
7018 : : }
7019 : :
7020 : 18975843 : if (code != TEMPLATE_DECL)
7021 : 18499951 : t->typed.type = type;
7022 : : }
7023 : :
7024 : 20530703 : if (TREE_CODE (t) == CONSTRUCTOR)
7025 : 60032 : if (unsigned len = u ())
7026 : : {
7027 : 19803 : vec_alloc (t->constructor.elts, len);
7028 : 136641 : for (unsigned ix = 0; ix != len; ix++)
7029 : : {
7030 : 116838 : constructor_elt elt;
7031 : :
7032 : 116838 : RT (elt.index);
7033 : 116838 : RTU (elt.value);
7034 : 116838 : t->constructor.elts->quick_push (elt);
7035 : : }
7036 : : }
7037 : :
7038 : : #undef RT
7039 : : #undef RM
7040 : : #undef RU
7041 : 20530703 : return !get_overrun ();
7042 : : }
7043 : :
7044 : : void
7045 : 6363390 : trees_out::lang_decl_vals (tree t)
7046 : : {
7047 : 6363390 : const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
7048 : : #define WU(X) (u (X))
7049 : : #define WT(X) (tree_node (X))
7050 : : /* Module index already written. */
7051 : 6363390 : switch (lang->u.base.selector)
7052 : : {
7053 : 0 : default:
7054 : 0 : gcc_unreachable ();
7055 : :
7056 : 1209527 : case lds_fn: /* lang_decl_fn. */
7057 : 1209527 : if (streaming_p ())
7058 : : {
7059 : 604753 : if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
7060 : 101592 : WU (lang->u.fn.ovl_op_code);
7061 : : }
7062 : :
7063 : 1209527 : if (DECL_CLASS_SCOPE_P (t))
7064 : 872148 : WT (lang->u.fn.context);
7065 : :
7066 : 1209527 : if (lang->u.fn.thunk_p)
7067 : : {
7068 : : /* The thunked-to function. */
7069 : 2152 : WT (lang->u.fn.befriending_classes);
7070 : 2152 : if (streaming_p ())
7071 : 1076 : wi (lang->u.fn.u5.fixed_offset);
7072 : : }
7073 : 1207375 : else if (decl_tls_wrapper_p (t))
7074 : : /* The wrapped variable. */
7075 : 6 : WT (lang->u.fn.befriending_classes);
7076 : : else
7077 : 1207369 : WT (lang->u.fn.u5.cloned_function);
7078 : :
7079 : 1209527 : if (FNDECL_USED_AUTO (t))
7080 : 2169 : WT (lang->u.fn.u.saved_auto_return_type);
7081 : :
7082 : 1209527 : goto lds_min;
7083 : :
7084 : 2450 : case lds_decomp: /* lang_decl_decomp. */
7085 : 2450 : WT (lang->u.decomp.base);
7086 : 2450 : goto lds_min;
7087 : :
7088 : 3748785 : case lds_min: /* lang_decl_min. */
7089 : 3748785 : lds_min:
7090 : 3748785 : WT (lang->u.min.template_info);
7091 : 3748785 : {
7092 : 3748785 : tree access = lang->u.min.access;
7093 : :
7094 : : /* DECL_ACCESS needs to be maintained by the definition of the
7095 : : (derived) class that changes the access. The other users
7096 : : of DECL_ACCESS need to write it here. */
7097 : 1209527 : if (!DECL_THUNK_P (t)
7098 : 4956160 : && (DECL_CONTEXT (t) && TYPE_P (DECL_CONTEXT (t))))
7099 : : access = NULL_TREE;
7100 : :
7101 : 3748785 : WT (access);
7102 : : }
7103 : 3748785 : break;
7104 : :
7105 : : case lds_ns: /* lang_decl_ns. */
7106 : : break;
7107 : :
7108 : 2614095 : case lds_parm: /* lang_decl_parm. */
7109 : 2614095 : if (streaming_p ())
7110 : : {
7111 : 912222 : WU (lang->u.parm.level);
7112 : 912222 : WU (lang->u.parm.index);
7113 : : }
7114 : : break;
7115 : : }
7116 : : #undef WU
7117 : : #undef WT
7118 : 6363390 : }
7119 : :
7120 : : bool
7121 : 3092289 : trees_in::lang_decl_vals (tree t)
7122 : : {
7123 : 3092289 : struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
7124 : : #define RU(X) ((X) = u ())
7125 : : #define RT(X) ((X) = tree_node ())
7126 : :
7127 : : /* Module index already read. */
7128 : 3092289 : switch (lang->u.base.selector)
7129 : : {
7130 : 0 : default:
7131 : 0 : gcc_unreachable ();
7132 : :
7133 : 690427 : case lds_fn: /* lang_decl_fn. */
7134 : 690427 : if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
7135 : : {
7136 : 117159 : unsigned code = u ();
7137 : :
7138 : : /* Check consistency. */
7139 : 117159 : if (code >= OVL_OP_MAX
7140 : 117159 : || (ovl_op_info[IDENTIFIER_ASSIGN_OP_P (DECL_NAME (t))][code]
7141 : 117159 : .ovl_op_code) == OVL_OP_ERROR_MARK)
7142 : 0 : set_overrun ();
7143 : : else
7144 : 117159 : lang->u.fn.ovl_op_code = code;
7145 : : }
7146 : :
7147 : 690427 : if (DECL_CLASS_SCOPE_P (t))
7148 : 498861 : RT (lang->u.fn.context);
7149 : :
7150 : 690427 : if (lang->u.fn.thunk_p)
7151 : : {
7152 : 1196 : RT (lang->u.fn.befriending_classes);
7153 : 1196 : lang->u.fn.u5.fixed_offset = wi ();
7154 : : }
7155 : 689231 : else if (decl_tls_wrapper_p (t))
7156 : 6 : RT (lang->u.fn.befriending_classes);
7157 : : else
7158 : 689225 : RT (lang->u.fn.u5.cloned_function);
7159 : :
7160 : 690427 : if (FNDECL_USED_AUTO (t))
7161 : 1251 : RT (lang->u.fn.u.saved_auto_return_type);
7162 : 690427 : goto lds_min;
7163 : :
7164 : 1411 : case lds_decomp: /* lang_decl_decomp. */
7165 : 1411 : RT (lang->u.decomp.base);
7166 : 1411 : goto lds_min;
7167 : :
7168 : 2069176 : case lds_min: /* lang_decl_min. */
7169 : 2069176 : lds_min:
7170 : 2069176 : RT (lang->u.min.template_info);
7171 : 2069176 : RT (lang->u.min.access);
7172 : 2069176 : break;
7173 : :
7174 : : case lds_ns: /* lang_decl_ns. */
7175 : : break;
7176 : :
7177 : 1022796 : case lds_parm: /* lang_decl_parm. */
7178 : 1022796 : RU (lang->u.parm.level);
7179 : 1022796 : RU (lang->u.parm.index);
7180 : 1022796 : break;
7181 : : }
7182 : : #undef RU
7183 : : #undef RT
7184 : 3092289 : return !get_overrun ();
7185 : : }
7186 : :
7187 : : /* Most of the value contents of lang_type is streamed in
7188 : : define_class. */
7189 : :
7190 : : void
7191 : 444886 : trees_out::lang_type_vals (tree t)
7192 : : {
7193 : 444886 : const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
7194 : : #define WU(X) (u (X))
7195 : : #define WT(X) (tree_node (X))
7196 : 444886 : if (streaming_p ())
7197 : 222440 : WU (lang->align);
7198 : : #undef WU
7199 : : #undef WT
7200 : 444886 : }
7201 : :
7202 : : bool
7203 : 235716 : trees_in::lang_type_vals (tree t)
7204 : : {
7205 : 235716 : struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
7206 : : #define RU(X) ((X) = u ())
7207 : : #define RT(X) ((X) = tree_node ())
7208 : 235716 : RU (lang->align);
7209 : : #undef RU
7210 : : #undef RT
7211 : 235716 : return !get_overrun ();
7212 : : }
7213 : :
7214 : : /* Write out the bools of T, including information about any
7215 : : LANG_SPECIFIC information. Including allocation of any lang
7216 : : specific object. */
7217 : :
7218 : : void
7219 : 18391433 : trees_out::tree_node_bools (tree t)
7220 : : {
7221 : 18391433 : gcc_checking_assert (streaming_p ());
7222 : :
7223 : : /* We should never stream a namespace. */
7224 : 18391433 : gcc_checking_assert (TREE_CODE (t) != NAMESPACE_DECL
7225 : : || DECL_NAMESPACE_ALIAS (t));
7226 : :
7227 : 18391433 : bits_out bits = stream_bits ();
7228 : 18391433 : core_bools (t, bits);
7229 : :
7230 : 18391433 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7231 : : {
7232 : 4278540 : case tcc_declaration:
7233 : 4278540 : {
7234 : 4278540 : bool specific = DECL_LANG_SPECIFIC (t) != NULL;
7235 : 4278540 : bits.b (specific);
7236 : 4278540 : if (specific && VAR_P (t))
7237 : 399797 : bits.b (DECL_DECOMPOSITION_P (t));
7238 : 2777415 : if (specific)
7239 : 2777415 : lang_decl_bools (t, bits);
7240 : : }
7241 : : break;
7242 : :
7243 : 798785 : case tcc_type:
7244 : 798785 : {
7245 : 798785 : bool specific = (TYPE_MAIN_VARIANT (t) == t
7246 : 798785 : && TYPE_LANG_SPECIFIC (t) != NULL);
7247 : 798785 : gcc_assert (TYPE_LANG_SPECIFIC (t)
7248 : : == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t)));
7249 : :
7250 : 798785 : bits.b (specific);
7251 : 798785 : if (specific)
7252 : 222440 : lang_type_bools (t, bits);
7253 : : }
7254 : : break;
7255 : :
7256 : : default:
7257 : : break;
7258 : : }
7259 : :
7260 : 18391433 : bits.bflush ();
7261 : 18391433 : }
7262 : :
7263 : : bool
7264 : 20558580 : trees_in::tree_node_bools (tree t)
7265 : : {
7266 : 20558580 : bits_in bits = stream_bits ();
7267 : 20558580 : bool ok = core_bools (t, bits);
7268 : :
7269 : 20558580 : if (ok)
7270 : 20558580 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7271 : : {
7272 : 4746057 : case tcc_declaration:
7273 : 4746057 : if (bits.b ())
7274 : : {
7275 : 3092289 : bool decomp = VAR_P (t) && bits.b ();
7276 : :
7277 : 3092289 : ok = maybe_add_lang_decl_raw (t, decomp);
7278 : 3092289 : if (ok)
7279 : 3092289 : ok = lang_decl_bools (t, bits);
7280 : : }
7281 : : break;
7282 : :
7283 : 848423 : case tcc_type:
7284 : 848423 : if (bits.b ())
7285 : : {
7286 : 235716 : ok = maybe_add_lang_type_raw (t);
7287 : 235716 : if (ok)
7288 : 235716 : ok = lang_type_bools (t, bits);
7289 : : }
7290 : : break;
7291 : :
7292 : : default:
7293 : : break;
7294 : : }
7295 : :
7296 : 20558580 : bits.bflush ();
7297 : 20558580 : if (!ok || get_overrun ())
7298 : 0 : return false;
7299 : :
7300 : : return true;
7301 : 20558580 : }
7302 : :
7303 : :
7304 : : /* Write out the lang-specifc vals of node T. */
7305 : :
7306 : : void
7307 : 48048630 : trees_out::lang_vals (tree t)
7308 : : {
7309 : 48048630 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7310 : : {
7311 : 11153996 : case tcc_declaration:
7312 : 11153996 : if (DECL_LANG_SPECIFIC (t))
7313 : 6363390 : lang_decl_vals (t);
7314 : : break;
7315 : :
7316 : 2818429 : case tcc_type:
7317 : 2818429 : if (TYPE_MAIN_VARIANT (t) == t && TYPE_LANG_SPECIFIC (t))
7318 : 444886 : lang_type_vals (t);
7319 : : break;
7320 : :
7321 : : default:
7322 : : break;
7323 : : }
7324 : 48048630 : }
7325 : :
7326 : : bool
7327 : 20530703 : trees_in::lang_vals (tree t)
7328 : : {
7329 : 20530703 : bool ok = true;
7330 : :
7331 : 20530703 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7332 : : {
7333 : 4746057 : case tcc_declaration:
7334 : 4746057 : if (DECL_LANG_SPECIFIC (t))
7335 : 3092289 : ok = lang_decl_vals (t);
7336 : : break;
7337 : :
7338 : 820546 : case tcc_type:
7339 : 820546 : if (TYPE_LANG_SPECIFIC (t))
7340 : 235716 : ok = lang_type_vals (t);
7341 : : else
7342 : 584830 : TYPE_LANG_SPECIFIC (t) = TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t));
7343 : : break;
7344 : :
7345 : : default:
7346 : : break;
7347 : : }
7348 : :
7349 : 20530703 : return ok;
7350 : : }
7351 : :
7352 : : /* Write out the value fields of node T. */
7353 : :
7354 : : void
7355 : 48048630 : trees_out::tree_node_vals (tree t)
7356 : : {
7357 : 48048630 : core_vals (t);
7358 : 48048630 : lang_vals (t);
7359 : 48048630 : }
7360 : :
7361 : : bool
7362 : 20530703 : trees_in::tree_node_vals (tree t)
7363 : : {
7364 : 20530703 : bool ok = core_vals (t);
7365 : 20530703 : if (ok)
7366 : 20530703 : ok = lang_vals (t);
7367 : :
7368 : 20530703 : return ok;
7369 : : }
7370 : :
7371 : :
7372 : : /* If T is a back reference, fixed reference or NULL, write out its
7373 : : code and return WK_none. Otherwise return WK_value if we must write
7374 : : by value, or WK_normal otherwise. */
7375 : :
7376 : : walk_kind
7377 : 321635153 : trees_out::ref_node (tree t)
7378 : : {
7379 : 321635153 : if (!t)
7380 : : {
7381 : 129376468 : if (streaming_p ())
7382 : : {
7383 : : /* NULL_TREE -> tt_null. */
7384 : 49546249 : null_count++;
7385 : 49546249 : i (tt_null);
7386 : : }
7387 : 129376468 : return WK_none;
7388 : : }
7389 : :
7390 : 192258685 : if (!TREE_VISITED (t))
7391 : : return WK_normal;
7392 : :
7393 : : /* An already-visited tree. It must be in the map. */
7394 : 112940556 : int val = get_tag (t);
7395 : :
7396 : 112940556 : if (val == tag_value)
7397 : : /* An entry we should walk into. */
7398 : : return WK_value;
7399 : :
7400 : 111060873 : const char *kind;
7401 : :
7402 : 111060873 : if (val <= tag_backref)
7403 : : {
7404 : : /* Back reference -> -ve number */
7405 : 85061164 : if (streaming_p ())
7406 : 40417132 : i (val);
7407 : : kind = "backref";
7408 : : }
7409 : 25999709 : else if (val >= tag_fixed)
7410 : : {
7411 : : /* Fixed reference -> tt_fixed */
7412 : 25999709 : val -= tag_fixed;
7413 : 25999709 : if (streaming_p ())
7414 : 9077451 : i (tt_fixed), u (val);
7415 : : kind = "fixed";
7416 : : }
7417 : :
7418 : 111060873 : if (streaming_p ())
7419 : : {
7420 : 49494583 : back_ref_count++;
7421 : 49494583 : dump (dumper::TREE)
7422 : 13140 : && dump ("Wrote %s:%d %C:%N%S", kind, val, TREE_CODE (t), t, t);
7423 : : }
7424 : : return WK_none;
7425 : : }
7426 : :
7427 : : tree
7428 : 45124582 : trees_in::back_ref (int tag)
7429 : : {
7430 : 45124582 : tree res = NULL_TREE;
7431 : :
7432 : 45124582 : if (tag < 0 && unsigned (~tag) < back_refs.length ())
7433 : 45124582 : res = back_refs[~tag];
7434 : :
7435 : 45124582 : if (!res
7436 : : /* Checking TREE_CODE is a dereference, so we know this is not a
7437 : : wild pointer. Checking the code provides evidence we've not
7438 : : corrupted something. */
7439 : 45124582 : || TREE_CODE (res) >= MAX_TREE_CODES)
7440 : 0 : set_overrun ();
7441 : : else
7442 : 45138469 : dump (dumper::TREE) && dump ("Read backref:%d found %C:%N%S", tag,
7443 : : TREE_CODE (res), res, res);
7444 : 45124582 : return res;
7445 : : }
7446 : :
7447 : : unsigned
7448 : 4356921 : trees_out::add_indirect_tpl_parms (tree parms)
7449 : : {
7450 : 4356921 : unsigned len = 0;
7451 : 8116175 : for (; parms; parms = TREE_CHAIN (parms), len++)
7452 : : {
7453 : 4574336 : if (TREE_VISITED (parms))
7454 : : break;
7455 : :
7456 : 3759254 : int tag = insert (parms);
7457 : 3759254 : if (streaming_p ())
7458 : 3766791 : dump (dumper::TREE)
7459 : 153 : && dump ("Indirect:%d template's parameter %u %C:%N",
7460 : 153 : tag, len, TREE_CODE (parms), parms);
7461 : : }
7462 : :
7463 : 4356921 : if (streaming_p ())
7464 : 711488 : u (len);
7465 : :
7466 : 4356921 : return len;
7467 : : }
7468 : :
7469 : : unsigned
7470 : 762808 : trees_in::add_indirect_tpl_parms (tree parms)
7471 : : {
7472 : 762808 : unsigned len = u ();
7473 : 1361812 : for (unsigned ix = 0; ix != len; parms = TREE_CHAIN (parms), ix++)
7474 : : {
7475 : 599004 : int tag = insert (parms);
7476 : 599416 : dump (dumper::TREE)
7477 : 159 : && dump ("Indirect:%d template's parameter %u %C:%N",
7478 : 159 : tag, ix, TREE_CODE (parms), parms);
7479 : : }
7480 : :
7481 : 762808 : return len;
7482 : : }
7483 : :
7484 : : /* We've just found DECL by name. Insert nodes that come with it, but
7485 : : cannot be found by name, so we'll not accidentally walk into them. */
7486 : :
7487 : : void
7488 : 10144406 : trees_out::add_indirects (tree decl)
7489 : : {
7490 : 10144406 : unsigned count = 0;
7491 : :
7492 : : // FIXME:OPTIMIZATION We'll eventually want default fn parms of
7493 : : // templates and perhaps default template parms too. The former can
7494 : : // be referenced from instantiations (as they are lazily
7495 : : // instantiated). Also (deferred?) exception specifications of
7496 : : // templates. See the note about PARM_DECLs in trees_out::decl_node.
7497 : 10144406 : tree inner = decl;
7498 : 10144406 : if (TREE_CODE (decl) == TEMPLATE_DECL)
7499 : : {
7500 : 4356921 : count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));
7501 : :
7502 : 4356921 : inner = DECL_TEMPLATE_RESULT (decl);
7503 : 4356921 : int tag = insert (inner);
7504 : 4356921 : if (streaming_p ())
7505 : 711488 : dump (dumper::TREE)
7506 : 219 : && dump ("Indirect:%d template's result %C:%N",
7507 : 219 : tag, TREE_CODE (inner), inner);
7508 : 4356921 : count++;
7509 : : }
7510 : :
7511 : 10144406 : if (TREE_CODE (inner) == TYPE_DECL)
7512 : : {
7513 : : /* Make sure the type is in the map too. Otherwise we get
7514 : : different RECORD_TYPEs for the same type, and things go
7515 : : south. */
7516 : 5682030 : tree type = TREE_TYPE (inner);
7517 : 5682030 : gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
7518 : : || TYPE_NAME (type) == inner);
7519 : 5682030 : int tag = insert (type);
7520 : 5682030 : if (streaming_p ())
7521 : 627939 : dump (dumper::TREE) && dump ("Indirect:%d decl's type %C:%N", tag,
7522 : 360 : TREE_CODE (type), type);
7523 : 5682030 : count++;
7524 : : }
7525 : :
7526 : 10144406 : if (streaming_p ())
7527 : : {
7528 : 1516407 : u (count);
7529 : 1516917 : dump (dumper::TREE) && dump ("Inserted %u indirects", count);
7530 : : }
7531 : 10144406 : }
7532 : :
7533 : : bool
7534 : 1609209 : trees_in::add_indirects (tree decl)
7535 : : {
7536 : 1609209 : unsigned count = 0;
7537 : :
7538 : 1609209 : tree inner = decl;
7539 : 1609209 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7540 : : {
7541 : 762808 : count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));
7542 : :
7543 : 762808 : inner = DECL_TEMPLATE_RESULT (decl);
7544 : 762808 : int tag = insert (inner);
7545 : 762808 : dump (dumper::TREE)
7546 : 228 : && dump ("Indirect:%d templates's result %C:%N", tag,
7547 : 228 : TREE_CODE (inner), inner);
7548 : 762808 : count++;
7549 : : }
7550 : :
7551 : 1609209 : if (TREE_CODE (inner) == TYPE_DECL)
7552 : : {
7553 : 646084 : tree type = TREE_TYPE (inner);
7554 : 646084 : gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
7555 : : || TYPE_NAME (type) == inner);
7556 : 646084 : int tag = insert (type);
7557 : 646084 : dump (dumper::TREE)
7558 : 360 : && dump ("Indirect:%d decl's type %C:%N", tag, TREE_CODE (type), type);
7559 : 646084 : count++;
7560 : : }
7561 : :
7562 : 1609782 : dump (dumper::TREE) && dump ("Inserted %u indirects", count);
7563 : 1609209 : return count == u ();
7564 : : }
7565 : :
7566 : : /* Stream a template parameter. There are 4.5 kinds of parameter:
7567 : : a) Template - TEMPLATE_DECL->TYPE_DECL->TEMPLATE_TEMPLATE_PARM
7568 : : TEMPLATE_TYPE_PARM_INDEX TPI
7569 : : b) Type - TYPE_DECL->TEMPLATE_TYPE_PARM TEMPLATE_TYPE_PARM_INDEX TPI
7570 : : c.1) NonTYPE - PARM_DECL DECL_INITIAL TPI We meet this first
7571 : : c.2) NonTYPE - CONST_DECL DECL_INITIAL Same TPI
7572 : : d) BoundTemplate - TYPE_DECL->BOUND_TEMPLATE_TEMPLATE_PARM
7573 : : TEMPLATE_TYPE_PARM_INDEX->TPI
7574 : : TEMPLATE_TEMPLATE_PARM_INFO->TEMPLATE_INFO
7575 : :
7576 : : All of these point to a TEMPLATE_PARM_INDEX, and #B also has a TEMPLATE_INFO
7577 : : */
7578 : :
7579 : : void
7580 : 2568365 : trees_out::tpl_parm_value (tree parm)
7581 : : {
7582 : 2568365 : gcc_checking_assert (DECL_P (parm) && DECL_TEMPLATE_PARM_P (parm));
7583 : :
7584 : 2568365 : int parm_tag = insert (parm);
7585 : 2568365 : if (streaming_p ())
7586 : : {
7587 : 576085 : i (tt_tpl_parm);
7588 : 576085 : dump (dumper::TREE) && dump ("Writing template parm:%d %C:%N",
7589 : 114 : parm_tag, TREE_CODE (parm), parm);
7590 : 576085 : start (parm);
7591 : 576085 : tree_node_bools (parm);
7592 : : }
7593 : :
7594 : 2568365 : tree inner = parm;
7595 : 2568365 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7596 : : {
7597 : 6040 : inner = DECL_TEMPLATE_RESULT (inner);
7598 : 6040 : int inner_tag = insert (inner);
7599 : 6040 : if (streaming_p ())
7600 : : {
7601 : 1574 : dump (dumper::TREE) && dump ("Writing inner template parm:%d %C:%N",
7602 : 0 : inner_tag, TREE_CODE (inner), inner);
7603 : 1574 : start (inner);
7604 : 1574 : tree_node_bools (inner);
7605 : : }
7606 : : }
7607 : :
7608 : 2568365 : tree type = NULL_TREE;
7609 : 2568365 : if (TREE_CODE (inner) == TYPE_DECL)
7610 : : {
7611 : 2302601 : type = TREE_TYPE (inner);
7612 : 2302601 : int type_tag = insert (type);
7613 : 2302601 : if (streaming_p ())
7614 : : {
7615 : 514098 : dump (dumper::TREE) && dump ("Writing template parm type:%d %C:%N",
7616 : 108 : type_tag, TREE_CODE (type), type);
7617 : 514098 : start (type);
7618 : 514098 : tree_node_bools (type);
7619 : : }
7620 : : }
7621 : :
7622 : 2568365 : if (inner != parm)
7623 : : {
7624 : : /* This is a template-template parameter. */
7625 : 6040 : unsigned tpl_levels = 0;
7626 : 6040 : tpl_header (parm, &tpl_levels);
7627 : 6040 : tpl_parms_fini (parm, tpl_levels);
7628 : : }
7629 : :
7630 : 2568365 : tree_node_vals (parm);
7631 : 2568365 : if (inner != parm)
7632 : 6040 : tree_node_vals (inner);
7633 : 2568365 : if (type)
7634 : : {
7635 : 2302601 : tree_node_vals (type);
7636 : 2302601 : if (DECL_NAME (inner) == auto_identifier
7637 : 2302601 : || DECL_NAME (inner) == decltype_auto_identifier)
7638 : : {
7639 : : /* Placeholder auto. */
7640 : 68878 : tree_node (DECL_INITIAL (inner));
7641 : 68878 : tree_node (DECL_SIZE_UNIT (inner));
7642 : : }
7643 : : }
7644 : :
7645 : 2568365 : if (streaming_p ())
7646 : 576085 : dump (dumper::TREE) && dump ("Wrote template parm:%d %C:%N",
7647 : 114 : parm_tag, TREE_CODE (parm), parm);
7648 : 2568365 : }
7649 : :
7650 : : tree
7651 : 618088 : trees_in::tpl_parm_value ()
7652 : : {
7653 : 618088 : tree parm = start ();
7654 : 618088 : if (!parm || !tree_node_bools (parm))
7655 : 0 : return NULL_TREE;
7656 : :
7657 : 618088 : int parm_tag = insert (parm);
7658 : 618088 : dump (dumper::TREE) && dump ("Reading template parm:%d %C:%N",
7659 : 198 : parm_tag, TREE_CODE (parm), parm);
7660 : :
7661 : 618088 : tree inner = parm;
7662 : 618088 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7663 : : {
7664 : 1338 : inner = start ();
7665 : 1338 : if (!inner || !tree_node_bools (inner))
7666 : 0 : return NULL_TREE;
7667 : 1338 : int inner_tag = insert (inner);
7668 : 1338 : dump (dumper::TREE) && dump ("Reading inner template parm:%d %C:%N",
7669 : 0 : inner_tag, TREE_CODE (inner), inner);
7670 : 1338 : DECL_TEMPLATE_RESULT (parm) = inner;
7671 : : }
7672 : :
7673 : 618088 : tree type = NULL_TREE;
7674 : 618088 : if (TREE_CODE (inner) == TYPE_DECL)
7675 : : {
7676 : 549946 : type = start ();
7677 : 549946 : if (!type || !tree_node_bools (type))
7678 : 0 : return NULL_TREE;
7679 : 549946 : int type_tag = insert (type);
7680 : 549946 : dump (dumper::TREE) && dump ("Reading template parm type:%d %C:%N",
7681 : 120 : type_tag, TREE_CODE (type), type);
7682 : :
7683 : 549946 : TREE_TYPE (inner) = TREE_TYPE (parm) = type;
7684 : 549946 : TYPE_NAME (type) = parm;
7685 : : }
7686 : :
7687 : 618088 : if (inner != parm)
7688 : : {
7689 : : /* A template template parameter. */
7690 : 1338 : unsigned tpl_levels = 0;
7691 : 1338 : tpl_header (parm, &tpl_levels);
7692 : 1338 : tpl_parms_fini (parm, tpl_levels);
7693 : : }
7694 : :
7695 : 618088 : tree_node_vals (parm);
7696 : 618088 : if (inner != parm)
7697 : 1338 : tree_node_vals (inner);
7698 : 618088 : if (type)
7699 : : {
7700 : 549946 : tree_node_vals (type);
7701 : 549946 : if (DECL_NAME (inner) == auto_identifier
7702 : 549946 : || DECL_NAME (inner) == decltype_auto_identifier)
7703 : : {
7704 : : /* Placeholder auto. */
7705 : 30965 : DECL_INITIAL (inner) = tree_node ();
7706 : 30965 : DECL_SIZE_UNIT (inner) = tree_node ();
7707 : : }
7708 : 549946 : if (TYPE_CANONICAL (type))
7709 : : {
7710 : 549946 : gcc_checking_assert (TYPE_CANONICAL (type) == type);
7711 : 549946 : TYPE_CANONICAL (type) = canonical_type_parameter (type);
7712 : : }
7713 : : }
7714 : :
7715 : 618088 : dump (dumper::TREE) && dump ("Read template parm:%d %C:%N",
7716 : 198 : parm_tag, TREE_CODE (parm), parm);
7717 : :
7718 : : return parm;
7719 : : }
7720 : :
7721 : : void
7722 : 1596874 : trees_out::install_entity (tree decl, depset *dep)
7723 : : {
7724 : 1596874 : gcc_checking_assert (streaming_p ());
7725 : :
7726 : : /* Write the entity index, so we can insert it as soon as we
7727 : : know this is new. */
7728 : 1596874 : u (dep ? dep->cluster + 1 : 0);
7729 : 1596874 : if (CHECKING_P && dep)
7730 : : {
7731 : : /* Add it to the entity map, such that we can tell it is
7732 : : part of us. */
7733 : 1214001 : bool existed;
7734 : 1214001 : unsigned *slot = &entity_map->get_or_insert
7735 : 1214001 : (DECL_UID (decl), &existed);
7736 : 1214001 : if (existed)
7737 : : /* If it existed, it should match. */
7738 : 607 : gcc_checking_assert (decl == (*entity_ary)[*slot]);
7739 : 1214001 : *slot = ~dep->cluster;
7740 : : }
7741 : 1596874 : }
7742 : :
7743 : : bool
7744 : 1763760 : trees_in::install_entity (tree decl)
7745 : : {
7746 : 1763760 : unsigned entity_index = u ();
7747 : 1763760 : if (!entity_index)
7748 : : return false;
7749 : :
7750 : 1328994 : if (entity_index > state->entity_num)
7751 : : {
7752 : 0 : set_overrun ();
7753 : 0 : return false;
7754 : : }
7755 : :
7756 : : /* Insert the real decl into the entity ary. */
7757 : 1328994 : unsigned ident = state->entity_lwm + entity_index - 1;
7758 : 1328994 : (*entity_ary)[ident] = decl;
7759 : :
7760 : : /* And into the entity map, if it's not already there. */
7761 : 1328994 : tree not_tmpl = STRIP_TEMPLATE (decl);
7762 : 1328994 : if (!DECL_LANG_SPECIFIC (not_tmpl)
7763 : 2480365 : || !DECL_MODULE_ENTITY_P (not_tmpl))
7764 : : {
7765 : 1328503 : retrofit_lang_decl (not_tmpl);
7766 : 1328503 : DECL_MODULE_ENTITY_P (not_tmpl) = true;
7767 : :
7768 : : /* Insert into the entity hash (it cannot already be there). */
7769 : 1328503 : bool existed;
7770 : 1328503 : unsigned &slot = entity_map->get_or_insert (DECL_UID (decl), &existed);
7771 : 1328503 : gcc_checking_assert (!existed);
7772 : 1328503 : slot = ident;
7773 : : }
7774 : 491 : else if (state->is_partition ())
7775 : : {
7776 : : /* The decl is already in the entity map, but we see it again now from a
7777 : : partition: we want to overwrite if the original decl wasn't also from
7778 : : a (possibly different) partition. Otherwise, for things like template
7779 : : instantiations, make_dependency might not realise that this is also
7780 : : provided from a partition and should be considered part of this module
7781 : : (and thus always emitted into the primary interface's CMI). */
7782 : 123 : unsigned *slot = entity_map->get (DECL_UID (decl));
7783 : 123 : module_state *imp = import_entity_module (*slot);
7784 : 123 : if (!imp->is_partition ())
7785 : 24 : *slot = ident;
7786 : : }
7787 : :
7788 : : return true;
7789 : : }
7790 : :
7791 : : static bool has_definition (tree decl);
7792 : :
7793 : : /* DECL is a decl node that must be written by value. DEP is the
7794 : : decl's depset. */
7795 : :
7796 : : void
7797 : 4423008 : trees_out::decl_value (tree decl, depset *dep)
7798 : : {
7799 : : /* We should not be writing clones or template parms. */
7800 : 4423008 : gcc_checking_assert (DECL_P (decl)
7801 : : && !DECL_CLONED_FUNCTION_P (decl)
7802 : : && !DECL_TEMPLATE_PARM_P (decl));
7803 : :
7804 : : /* We should never be writing non-typedef ptrmemfuncs by value. */
7805 : 4423008 : gcc_checking_assert (TREE_CODE (decl) != TYPE_DECL
7806 : : || DECL_ORIGINAL_TYPE (decl)
7807 : : || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)));
7808 : :
7809 : 4423008 : merge_kind mk = get_merge_kind (decl, dep);
7810 : 4423008 : bool is_imported_temploid_friend = imported_temploid_friends->get (decl);
7811 : :
7812 : 4423008 : if (CHECKING_P)
7813 : : {
7814 : : /* Never start in the middle of a template. */
7815 : 4423008 : int use_tpl = -1;
7816 : 4423008 : if (tree ti = node_template_info (decl, use_tpl))
7817 : 1584828 : gcc_checking_assert (TREE_CODE (TI_TEMPLATE (ti)) == OVERLOAD
7818 : : || TREE_CODE (TI_TEMPLATE (ti)) == FIELD_DECL
7819 : : || (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti))
7820 : : != decl));
7821 : : }
7822 : :
7823 : 4423008 : if (streaming_p ())
7824 : : {
7825 : : /* A new node -> tt_decl. */
7826 : 1596874 : decl_val_count++;
7827 : 1596874 : i (tt_decl);
7828 : 1596874 : u (mk);
7829 : 1596874 : start (decl);
7830 : :
7831 : 1596874 : |
