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_STRING
212 : : #define INCLUDE_VECTOR
213 : : #include "system.h"
214 : : #include "coretypes.h"
215 : : #include "cp-tree.h"
216 : : #include "timevar.h"
217 : : #include "stringpool.h"
218 : : #include "dumpfile.h"
219 : : #include "bitmap.h"
220 : : #include "cgraph.h"
221 : : #include "varasm.h"
222 : : #include "tree-iterator.h"
223 : : #include "cpplib.h"
224 : : #include "mkdeps.h"
225 : : #include "incpath.h"
226 : : #include "libiberty.h"
227 : : #include "stor-layout.h"
228 : : #include "version.h"
229 : : #include "tree-diagnostic.h"
230 : : #include "toplev.h"
231 : : #include "opts.h"
232 : : #include "attribs.h"
233 : : #include "intl.h"
234 : : #include "langhooks.h"
235 : : /* This TU doesn't need or want to see the networking. */
236 : : #define CODY_NETWORKING 0
237 : : #include "mapper-client.h"
238 : : #include <zlib.h> // for crc32, crc32_combine
239 : :
240 : : #if 0 // 1 for testing no mmap
241 : : #define MAPPED_READING 0
242 : : #define MAPPED_WRITING 0
243 : : #else
244 : : #if HAVE_MMAP_FILE && _POSIX_MAPPED_FILES > 0
245 : : /* mmap, munmap. */
246 : : #define MAPPED_READING 1
247 : : #if HAVE_SYSCONF && defined (_SC_PAGE_SIZE)
248 : : /* msync, sysconf (_SC_PAGE_SIZE), ftruncate */
249 : : /* posix_fallocate used if available. */
250 : : #define MAPPED_WRITING 1
251 : : #else
252 : : #define MAPPED_WRITING 0
253 : : #endif
254 : : #else
255 : : #define MAPPED_READING 0
256 : : #define MAPPED_WRITING 0
257 : : #endif
258 : : #endif
259 : :
260 : : /* Some open(2) flag differences, what a colourful world it is! */
261 : : #if defined (O_CLOEXEC)
262 : : // OK
263 : : #elif defined (_O_NOINHERIT)
264 : : /* Windows' _O_NOINHERIT matches O_CLOEXEC flag */
265 : : #define O_CLOEXEC _O_NOINHERIT
266 : : #else
267 : : #define O_CLOEXEC 0
268 : : #endif
269 : : #if defined (O_BINARY)
270 : : // Ok?
271 : : #elif defined (_O_BINARY)
272 : : /* Windows' open(2) call defaults to text! */
273 : : #define O_BINARY _O_BINARY
274 : : #else
275 : : #define O_BINARY 0
276 : : #endif
277 : :
278 : 507598 : static inline cpp_hashnode *cpp_node (tree id)
279 : : {
280 : 507598 : return CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (id));
281 : : }
282 : :
283 : 226888 : static inline tree identifier (const cpp_hashnode *node)
284 : : {
285 : : /* HT_NODE() expands to node->ident that HT_IDENT_TO_GCC_IDENT()
286 : : then subtracts a nonzero constant, deriving a pointer to
287 : : a different member than ident. That's strictly undefined
288 : : and detected by -Warray-bounds. Suppress it. See PR 101372. */
289 : 226888 : #pragma GCC diagnostic push
290 : 226888 : #pragma GCC diagnostic ignored "-Warray-bounds"
291 : 226888 : return HT_IDENT_TO_GCC_IDENT (HT_NODE (const_cast<cpp_hashnode *> (node)));
292 : 226888 : #pragma GCC diagnostic pop
293 : : }
294 : :
295 : : /* Id for dumping module information. */
296 : : int module_dump_id;
297 : :
298 : : /* We have a special module owner. */
299 : : #define MODULE_UNKNOWN (~0U) /* Not yet known. */
300 : :
301 : : /* Prefix for section names. */
302 : : #define MOD_SNAME_PFX ".gnu.c++"
303 : :
304 : : /* Format a version for user consumption. */
305 : :
306 : : typedef char verstr_t[32];
307 : : static void
308 : 3343 : version2string (unsigned version, verstr_t &out)
309 : : {
310 : 3343 : unsigned major = MODULE_MAJOR (version);
311 : 3343 : unsigned minor = MODULE_MINOR (version);
312 : :
313 : 3343 : if (IS_EXPERIMENTAL (version))
314 : 3343 : sprintf (out, "%04u/%02u/%02u-%02u:%02u%s",
315 : 3343 : 2000 + major / 10000, (major / 100) % 100, (major % 100),
316 : : minor / 100, minor % 100,
317 : : EXPERIMENT ("", " (experimental)"));
318 : : else
319 : 0 : sprintf (out, "%u.%u", major, minor);
320 : 3343 : }
321 : :
322 : : /* Include files to note translation for. */
323 : : static vec<const char *, va_heap, vl_embed> *note_includes;
324 : :
325 : : /* Modules to note CMI pathames. */
326 : : static vec<const char *, va_heap, vl_embed> *note_cmis;
327 : :
328 : : /* Traits to hash an arbitrary pointer. Entries are not deletable,
329 : : and removal is a noop (removal needed upon destruction). */
330 : : template <typename T>
331 : : struct nodel_ptr_hash : pointer_hash<T>, typed_noop_remove <T *> {
332 : : /* Nothing is deletable. Everything is insertable. */
333 : : static bool is_deleted (T *) { return false; }
334 : : static void mark_deleted (T *) { gcc_unreachable (); }
335 : : };
336 : :
337 : : /* Map from pointer to signed integer. */
338 : : typedef simple_hashmap_traits<nodel_ptr_hash<void>, int> ptr_int_traits;
339 : : typedef hash_map<void *,signed,ptr_int_traits> ptr_int_hash_map;
340 : :
341 : : /********************************************************************/
342 : : /* Basic streaming & ELF. Serialization is usually via mmap. For
343 : : writing we slide a buffer over the output file, syncing it
344 : : approproiately. For reading we simply map the whole file (as a
345 : : file-backed read-only map -- it's just address space, leaving the
346 : : OS pager to deal with getting the data to us). Some buffers need
347 : : to be more conventional malloc'd contents. */
348 : :
349 : : /* Variable length buffer. */
350 : :
351 : : namespace {
352 : :
353 : : constexpr line_map_uint_t loc_one = 1;
354 : :
355 : : class data {
356 : : public:
357 : 2279 : class allocator {
358 : : public:
359 : : /* Tools tend to moan if the dtor's not virtual. */
360 : 94386 : virtual ~allocator () {}
361 : :
362 : : public:
363 : : void grow (data &obj, unsigned needed, bool exact);
364 : : void shrink (data &obj);
365 : :
366 : : public:
367 : : virtual char *grow (char *ptr, unsigned needed);
368 : : virtual void shrink (char *ptr);
369 : : };
370 : :
371 : : public:
372 : : char *buffer; /* Buffer being transferred. */
373 : : /* Although size_t would be the usual size, we know we never get
374 : : more than 4GB of buffer -- because that's the limit of the
375 : : encapsulation format. And if you need bigger imports, you're
376 : : doing it wrong. */
377 : : unsigned size; /* Allocated size of buffer. */
378 : : unsigned pos; /* Position in buffer. */
379 : :
380 : : public:
381 : 1163480 : data ()
382 : 1163480 : :buffer (NULL), size (0), pos (0)
383 : : {
384 : : }
385 : 1174819 : ~data ()
386 : : {
387 : : /* Make sure the derived and/or using class know what they're
388 : : doing. */
389 : 1174819 : gcc_checking_assert (!buffer);
390 : 1174819 : }
391 : :
392 : : protected:
393 : 816610903 : char *use (unsigned count)
394 : : {
395 : 816610903 : if (size < pos + count)
396 : : return NULL;
397 : 816610903 : char *res = &buffer[pos];
398 : 816610903 : pos += count;
399 : 411096991 : return res;
400 : : }
401 : :
402 : : unsigned calc_crc (unsigned) const;
403 : :
404 : : public:
405 : 60314024 : void unuse (unsigned count)
406 : : {
407 : 60314024 : pos -= count;
408 : 21992 : }
409 : :
410 : : public:
411 : : static allocator simple_memory;
412 : : };
413 : : } // anon namespace
414 : :
415 : : /* The simple data allocator. */
416 : : data::allocator data::simple_memory;
417 : :
418 : : /* Grow buffer to at least size NEEDED. */
419 : :
420 : : void
421 : 952715 : data::allocator::grow (data &obj, unsigned needed, bool exact)
422 : : {
423 : 952715 : gcc_checking_assert (needed ? needed > obj.size : !obj.size);
424 : 952715 : if (!needed)
425 : : /* Pick a default size. */
426 : 402294 : needed = EXPERIMENT (100, 1000);
427 : :
428 : 952715 : if (!exact)
429 : 946193 : needed *= 2;
430 : 952715 : obj.buffer = grow (obj.buffer, needed);
431 : 952715 : if (obj.buffer)
432 : 952715 : obj.size = needed;
433 : : else
434 : 0 : obj.pos = obj.size = 0;
435 : 952715 : }
436 : :
437 : : /* Free a buffer. */
438 : :
439 : : void
440 : 413701 : data::allocator::shrink (data &obj)
441 : : {
442 : 0 : shrink (obj.buffer);
443 : 413701 : obj.buffer = NULL;
444 : 413701 : obj.size = 0;
445 : 0 : }
446 : :
447 : : char *
448 : 8885 : data::allocator::grow (char *ptr, unsigned needed)
449 : : {
450 : 8885 : return XRESIZEVAR (char, ptr, needed);
451 : : }
452 : :
453 : : void
454 : 11395 : data::allocator::shrink (char *ptr)
455 : : {
456 : 11395 : XDELETEVEC (ptr);
457 : 11395 : }
458 : :
459 : : /* Calculate the crc32 of the buffer. Note the CRC is stored in the
460 : : first 4 bytes, so don't include them. */
461 : :
462 : : unsigned
463 : 767507 : data::calc_crc (unsigned l) const
464 : : {
465 : 767507 : return crc32 (0, (unsigned char *)buffer + 4, l - 4);
466 : : }
467 : :
468 : : class elf_in;
469 : :
470 : : /* Byte stream reader. */
471 : :
472 : : namespace {
473 : : class bytes_in : public data {
474 : : typedef data parent;
475 : :
476 : : protected:
477 : : bool overrun; /* Sticky read-too-much flag. */
478 : :
479 : : public:
480 : 373056 : bytes_in ()
481 : 373056 : : parent (), overrun (false)
482 : : {
483 : : }
484 : 375293 : ~bytes_in ()
485 : : {
486 : 10113 : }
487 : :
488 : : public:
489 : : /* Begin reading a named section. */
490 : : bool begin (location_t loc, elf_in *src, const char *name);
491 : : /* Begin reading a numbered section with optional name. */
492 : : bool begin (location_t loc, elf_in *src, unsigned, const char * = NULL);
493 : : /* Complete reading a buffer. Propagate errors and return true on
494 : : success. */
495 : : bool end (elf_in *src);
496 : : /* Return true if there is unread data. */
497 : 2743578 : bool more_p () const
498 : : {
499 : 2743578 : return pos != size;
500 : : }
501 : :
502 : : public:
503 : : /* Start reading at OFFSET. */
504 : 310 : void random_access (unsigned offset)
505 : : {
506 : 310 : if (offset > size)
507 : 0 : set_overrun ();
508 : 310 : pos = offset;
509 : : }
510 : :
511 : : public:
512 : 2528237 : void align (unsigned boundary)
513 : : {
514 : 2528237 : if (unsigned pad = pos & (boundary - 1))
515 : 4893825 : read (boundary - pad);
516 : : }
517 : :
518 : : public:
519 : 405513912 : const char *read (unsigned count)
520 : : {
521 : 2365588 : char *ptr = use (count);
522 : 405513912 : if (!ptr)
523 : 0 : set_overrun ();
524 : 330526870 : return ptr;
525 : : }
526 : :
527 : : public:
528 : : bool check_crc () const;
529 : : /* We store the CRC in the first 4 bytes, using host endianness. */
530 : 374061 : unsigned get_crc () const
531 : : {
532 : 374061 : return *(const unsigned *)&buffer[0];
533 : : }
534 : :
535 : : public:
536 : : /* Manipulate the overrun flag. */
537 : 237387410 : bool get_overrun () const
538 : : {
539 : 237387410 : return overrun;
540 : : }
541 : 14 : void set_overrun ()
542 : : {
543 : 14 : overrun = true;
544 : 0 : }
545 : :
546 : : public:
547 : : unsigned u32 (); /* Read uncompressed integer. */
548 : :
549 : : public:
550 : : int c () ATTRIBUTE_UNUSED; /* Read a char. */
551 : : int i (); /* Read a signed int. */
552 : : unsigned u (); /* Read an unsigned int. */
553 : : size_t z (); /* Read a size_t. */
554 : : location_t loc (); /* Read a location_t. */
555 : : HOST_WIDE_INT wi (); /* Read a HOST_WIDE_INT. */
556 : : unsigned HOST_WIDE_INT wu (); /* Read an unsigned HOST_WIDE_INT. */
557 : : const char *str (size_t * = NULL); /* Read a string. */
558 : : const void *buf (size_t); /* Read a fixed-length buffer. */
559 : : cpp_hashnode *cpp_node (); /* Read a cpp node. */
560 : :
561 : : struct bits_in;
562 : : bits_in stream_bits ();
563 : : };
564 : : } // anon namespace
565 : :
566 : : /* Verify the buffer's CRC is correct. */
567 : :
568 : : bool
569 : 371702 : bytes_in::check_crc () const
570 : : {
571 : 371702 : if (size < 4)
572 : : return false;
573 : :
574 : 371702 : unsigned c_crc = calc_crc (size);
575 : 371702 : if (c_crc != get_crc ())
576 : : return false;
577 : :
578 : : return true;
579 : : }
580 : :
581 : : class elf_out;
582 : :
583 : : /* Byte stream writer. */
584 : :
585 : : namespace {
586 : : class bytes_out : public data {
587 : : typedef data parent;
588 : :
589 : : public:
590 : : allocator *memory; /* Obtainer of memory. */
591 : :
592 : : public:
593 : 785768 : bytes_out (allocator *memory)
594 : 785768 : : parent (), memory (memory)
595 : : {
596 : : }
597 : 785768 : ~bytes_out ()
598 : : {
599 : 804607 : }
600 : :
601 : : public:
602 : 978027318 : bool streaming_p () const
603 : : {
604 : 978027318 : return memory != NULL;
605 : : }
606 : :
607 : : public:
608 : : void set_crc (unsigned *crc_ptr);
609 : :
610 : : public:
611 : : /* Begin writing, maybe reserve space for CRC. */
612 : : void begin (bool need_crc = true);
613 : : /* Finish writing. Spill to section by number. */
614 : : unsigned end (elf_out *, unsigned, unsigned *crc_ptr = NULL);
615 : :
616 : : public:
617 : 2658865 : void align (unsigned boundary)
618 : : {
619 : 2658865 : if (unsigned pad = pos & (boundary - 1))
620 : 2486830 : write (boundary - pad);
621 : 2658865 : }
622 : :
623 : : public:
624 : 411096991 : char *write (unsigned count, bool exact = false)
625 : : {
626 : 411096991 : if (size < pos + count)
627 : 539354 : memory->grow (*this, pos + count, exact);
628 : 411096991 : return use (count);
629 : : }
630 : :
631 : : public:
632 : : void u32 (unsigned); /* Write uncompressed integer. */
633 : :
634 : : public:
635 : : void c (unsigned char) ATTRIBUTE_UNUSED; /* Write unsigned char. */
636 : : void i (int); /* Write signed int. */
637 : : void u (unsigned); /* Write unsigned int. */
638 : : void z (size_t s); /* Write size_t. */
639 : : void loc (location_t); /* Write location_t. */
640 : : void wi (HOST_WIDE_INT); /* Write HOST_WIDE_INT. */
641 : : void wu (unsigned HOST_WIDE_INT); /* Write unsigned HOST_WIDE_INT. */
642 : 19926 : void str (const char *ptr)
643 : : {
644 : 19926 : str (ptr, strlen (ptr));
645 : 19926 : }
646 : 488722 : void cpp_node (const cpp_hashnode *node)
647 : : {
648 : 488722 : str ((const char *)NODE_NAME (node), NODE_LEN (node));
649 : 17493 : }
650 : : void str (const char *, size_t); /* Write string of known length. */
651 : : void buf (const void *, size_t); /* Write fixed length buffer. */
652 : : void *buf (size_t); /* Create a writable buffer */
653 : :
654 : : struct bits_out;
655 : : bits_out stream_bits ();
656 : :
657 : : public:
658 : : /* Format a NUL-terminated raw string. */
659 : : void printf (const char *, ...) ATTRIBUTE_PRINTF_2;
660 : : void print_time (const char *, const tm *, const char *);
661 : :
662 : : public:
663 : : /* Dump instrumentation. */
664 : : static void instrument ();
665 : :
666 : : protected:
667 : : /* Instrumentation. */
668 : : static unsigned spans[4];
669 : : static unsigned lengths[4];
670 : : };
671 : : } // anon namespace
672 : :
673 : : /* Finish bit packet. Rewind the bytes not used. */
674 : :
675 : : static unsigned
676 : 60270227 : bit_flush (data& bits, uint32_t& bit_val, unsigned& bit_pos)
677 : : {
678 : 60270227 : gcc_assert (bit_pos);
679 : 60270227 : unsigned bytes = (bit_pos + 7) / 8;
680 : 60270227 : bits.unuse (4 - bytes);
681 : 60270227 : bit_pos = 0;
682 : 60270227 : bit_val = 0;
683 : 60270227 : return bytes;
684 : : }
685 : :
686 : : /* Bit stream reader (RAII-enabled). Bools are packed into bytes. You
687 : : cannot mix bools and non-bools. Use bflush to flush the current stream
688 : : of bools on demand. Upon destruction bflush is called.
689 : :
690 : : When reading, we don't know how many bools we'll read in. So read
691 : : 4 bytes-worth, and then rewind when flushing if we didn't need them
692 : : all. You can't have a block of bools closer than 4 bytes to the
693 : : end of the buffer.
694 : :
695 : : Both bits_in and bits_out maintain the necessary state for bit packing,
696 : : and since these objects are locally constructed the compiler can more
697 : : easily track their state across consecutive reads/writes and optimize
698 : : away redundant buffering checks. */
699 : :
700 : : struct bytes_in::bits_in {
701 : : bytes_in& in;
702 : : uint32_t bit_val = 0;
703 : : unsigned bit_pos = 0;
704 : :
705 : 22195749 : bits_in (bytes_in& in)
706 : 22195749 : : in (in)
707 : : { }
708 : :
709 : 22195749 : ~bits_in ()
710 : : {
711 : 20702129 : bflush ();
712 : 22195749 : }
713 : :
714 : : bits_in(bits_in&&) = default;
715 : : bits_in(const bits_in&) = delete;
716 : : bits_in& operator=(const bits_in&) = delete;
717 : :
718 : : /* Completed a block of bools. */
719 : 46216143 : void bflush ()
720 : : {
721 : 46216143 : if (bit_pos)
722 : 25514014 : bit_flush (in, bit_val, bit_pos);
723 : 46216143 : }
724 : :
725 : : /* Read one bit. */
726 : 768615212 : bool b ()
727 : : {
728 : 768615212 : if (!bit_pos)
729 : 33536377 : bit_val = in.u32 ();
730 : 768615212 : bool x = (bit_val >> bit_pos) & 1;
731 : 768615212 : bit_pos = (bit_pos + 1) % 32;
732 : 768615212 : return x;
733 : : }
734 : : };
735 : :
736 : : /* Factory function for bits_in. */
737 : :
738 : : bytes_in::bits_in
739 : 22195749 : bytes_in::stream_bits ()
740 : : {
741 : 22195749 : return bits_in (*this);
742 : : }
743 : :
744 : : /* Bit stream writer (RAII-enabled), counterpart to bits_in. */
745 : :
746 : : struct bytes_out::bits_out {
747 : : bytes_out& out;
748 : : uint32_t bit_val = 0;
749 : : unsigned bit_pos = 0;
750 : : char is_set = -1;
751 : :
752 : 22998240 : bits_out (bytes_out& out)
753 : 22998240 : : out (out)
754 : : { }
755 : :
756 : 22998240 : ~bits_out ()
757 : : {
758 : 113401 : bflush ();
759 : : }
760 : :
761 : : bits_out(bits_out&&) = default;
762 : : bits_out(const bits_out&) = delete;
763 : : bits_out& operator=(const bits_out&) = delete;
764 : :
765 : : /* Completed a block of bools. */
766 : 47857321 : void bflush ()
767 : : {
768 : 47857321 : if (bit_pos)
769 : : {
770 : 26414576 : out.u32 (bit_val);
771 : 26414576 : out.lengths[2] += bit_flush (out, bit_val, bit_pos);
772 : : }
773 : 47857321 : out.spans[2]++;
774 : 47857321 : is_set = -1;
775 : 47857321 : }
776 : :
777 : : /* Write one bit.
778 : :
779 : : It may be worth optimizing for most bools being zero. Some kind of
780 : : run-length encoding? */
781 : 792847915 : void b (bool x)
782 : : {
783 : 792847915 : if (is_set != x)
784 : : {
785 : 84025789 : is_set = x;
786 : 84025789 : out.spans[x]++;
787 : : }
788 : 792847915 : out.lengths[x]++;
789 : 792847915 : bit_val |= unsigned (x) << bit_pos++;
790 : 792847915 : if (bit_pos == 32)
791 : : {
792 : 8341637 : out.u32 (bit_val);
793 : 8341637 : out.lengths[2] += bit_flush (out, bit_val, bit_pos);
794 : : }
795 : 792847915 : }
796 : : };
797 : :
798 : : /* Factory function for bits_out. */
799 : :
800 : : bytes_out::bits_out
801 : 22998240 : bytes_out::stream_bits ()
802 : : {
803 : 22998240 : return bits_out (*this);
804 : : }
805 : :
806 : : /* Instrumentation. */
807 : : unsigned bytes_out::spans[4];
808 : : unsigned bytes_out::lengths[4];
809 : :
810 : : /* If CRC_PTR non-null, set the CRC of the buffer. Mix the CRC into
811 : : that pointed to by CRC_PTR. */
812 : :
813 : : void
814 : 397954 : bytes_out::set_crc (unsigned *crc_ptr)
815 : : {
816 : 397954 : if (crc_ptr)
817 : : {
818 : 395805 : gcc_checking_assert (pos >= 4);
819 : :
820 : 395805 : unsigned crc = calc_crc (pos);
821 : 395805 : unsigned accum = *crc_ptr;
822 : : /* Only mix the existing *CRC_PTR if it is non-zero. */
823 : 395805 : accum = accum ? crc32_combine (accum, crc, pos - 4) : crc;
824 : 395805 : *crc_ptr = accum;
825 : :
826 : : /* Buffer will be sufficiently aligned. */
827 : 395805 : *(unsigned *)buffer = crc;
828 : : }
829 : 397954 : }
830 : :
831 : : /* Exactly 4 bytes. Used internally for bool packing and a few other
832 : : places. We can't simply use uint32_t because (a) alignment and
833 : : (b) we need little-endian for the bool streaming rewinding to make
834 : : sense. */
835 : :
836 : : void
837 : 34763169 : bytes_out::u32 (unsigned val)
838 : : {
839 : 34763169 : if (char *ptr = write (4))
840 : : {
841 : 34763169 : ptr[0] = val;
842 : 34763169 : ptr[1] = val >> 8;
843 : 34763169 : ptr[2] = val >> 16;
844 : 34763169 : ptr[3] = val >> 24;
845 : : }
846 : 34763169 : }
847 : :
848 : : unsigned
849 : 33543782 : bytes_in::u32 ()
850 : : {
851 : 33543782 : unsigned val = 0;
852 : 33543782 : if (const char *ptr = read (4))
853 : : {
854 : 33543782 : val |= (unsigned char)ptr[0];
855 : 33543782 : val |= (unsigned char)ptr[1] << 8;
856 : 33543782 : val |= (unsigned char)ptr[2] << 16;
857 : 33543782 : val |= (unsigned char)ptr[3] << 24;
858 : : }
859 : :
860 : 33543782 : return val;
861 : : }
862 : :
863 : : /* Chars are unsigned and written as single bytes. */
864 : :
865 : : void
866 : 0 : bytes_out::c (unsigned char v)
867 : : {
868 : 0 : if (char *ptr = write (1))
869 : 0 : *ptr = v;
870 : 0 : }
871 : :
872 : : int
873 : 0 : bytes_in::c ()
874 : : {
875 : 0 : int v = 0;
876 : 0 : if (const char *ptr = read (1))
877 : 0 : v = (unsigned char)ptr[0];
878 : 0 : return v;
879 : : }
880 : :
881 : : /* Ints 7-bit as a byte. Otherwise a 3bit count of following bytes in
882 : : big-endian form. 4 bits are in the first byte. */
883 : :
884 : : void
885 : 142014483 : bytes_out::i (int v)
886 : : {
887 : 142014483 : if (char *ptr = write (1))
888 : : {
889 : 142014483 : if (v <= 0x3f && v >= -0x40)
890 : 110930141 : *ptr = v & 0x7f;
891 : : else
892 : : {
893 : 31084342 : unsigned bytes = 0;
894 : 31084342 : int probe;
895 : 31084342 : if (v >= 0)
896 : 0 : for (probe = v >> 8; probe > 0x7; probe >>= 8)
897 : 0 : bytes++;
898 : : else
899 : 49387299 : for (probe = v >> 8; probe < -0x8; probe >>= 8)
900 : 18302957 : bytes++;
901 : 31084342 : *ptr = 0x80 | bytes << 4 | (probe & 0xf);
902 : 31084342 : if ((ptr = write (++bytes)))
903 : 80471641 : for (; bytes--; v >>= 8)
904 : 49387299 : ptr[bytes] = v & 0xff;
905 : : }
906 : : }
907 : 142014483 : }
908 : :
909 : : int
910 : 140143815 : bytes_in::i ()
911 : : {
912 : 140143815 : int v = 0;
913 : 140143815 : if (const char *ptr = read (1))
914 : : {
915 : 140143815 : v = *ptr & 0xff;
916 : 140143815 : if (v & 0x80)
917 : : {
918 : 30772736 : unsigned bytes = (v >> 4) & 0x7;
919 : 30772736 : v &= 0xf;
920 : 30772736 : if (v & 0x8)
921 : 30772736 : v |= -1 ^ 0x7;
922 : : /* unsigned necessary due to left shifts of -ve values. */
923 : 30772736 : unsigned uv = unsigned (v);
924 : 30772736 : if ((ptr = read (++bytes)))
925 : 80436706 : while (bytes--)
926 : 49663970 : uv = (uv << 8) | (*ptr++ & 0xff);
927 : 30772736 : v = int (uv);
928 : : }
929 : 109371079 : else if (v & 0x40)
930 : 15280306 : v |= -1 ^ 0x3f;
931 : : }
932 : :
933 : 140143815 : return v;
934 : : }
935 : :
936 : : void
937 : 126154263 : bytes_out::u (unsigned v)
938 : : {
939 : 126154263 : if (char *ptr = write (1))
940 : : {
941 : 126154263 : if (v <= 0x7f)
942 : 110401385 : *ptr = v;
943 : : else
944 : : {
945 : 15752878 : unsigned bytes = 0;
946 : 15752878 : unsigned probe;
947 : 18715371 : for (probe = v >> 8; probe > 0xf; probe >>= 8)
948 : 2962493 : bytes++;
949 : 15752878 : *ptr = 0x80 | bytes << 4 | probe;
950 : 15752878 : if ((ptr = write (++bytes)))
951 : 34468249 : for (; bytes--; v >>= 8)
952 : 18715371 : ptr[bytes] = v & 0xff;
953 : : }
954 : : }
955 : 126154263 : }
956 : :
957 : : unsigned
958 : 125206345 : bytes_in::u ()
959 : : {
960 : 125206345 : unsigned v = 0;
961 : :
962 : 125206345 : if (const char *ptr = read (1))
963 : : {
964 : 125206345 : v = *ptr & 0xff;
965 : 125206345 : if (v & 0x80)
966 : : {
967 : 15787363 : unsigned bytes = (v >> 4) & 0x7;
968 : 15787363 : v &= 0xf;
969 : 15787363 : if ((ptr = read (++bytes)))
970 : 34687600 : while (bytes--)
971 : 18900237 : v = (v << 8) | (*ptr++ & 0xff);
972 : : }
973 : : }
974 : :
975 : 125206345 : return v;
976 : : }
977 : :
978 : : void
979 : 30986763 : bytes_out::wi (HOST_WIDE_INT v)
980 : : {
981 : 30986763 : if (char *ptr = write (1))
982 : : {
983 : 30986763 : if (v <= 0x3f && v >= -0x40)
984 : 5835162 : *ptr = v & 0x7f;
985 : : else
986 : : {
987 : 25151601 : unsigned bytes = 0;
988 : 25151601 : HOST_WIDE_INT probe;
989 : 25151601 : if (v >= 0)
990 : 90472510 : for (probe = v >> 8; probe > 0x7; probe >>= 8)
991 : 65324225 : bytes++;
992 : : else
993 : 10637 : for (probe = v >> 8; probe < -0x8; probe >>= 8)
994 : 7321 : bytes++;
995 : 25151601 : *ptr = 0x80 | bytes << 4 | (probe & 0xf);
996 : 25151601 : if ((ptr = write (++bytes)))
997 : 115634748 : for (; bytes--; v >>= 8)
998 : 90483147 : ptr[bytes] = v & 0xff;
999 : : }
1000 : : }
1001 : 30986763 : }
1002 : :
1003 : : HOST_WIDE_INT
1004 : 29104691 : bytes_in::wi ()
1005 : : {
1006 : 29104691 : HOST_WIDE_INT v = 0;
1007 : 29104691 : if (const char *ptr = read (1))
1008 : : {
1009 : 29104691 : v = *ptr & 0xff;
1010 : 29104691 : if (v & 0x80)
1011 : : {
1012 : 26061355 : unsigned bytes = (v >> 4) & 0x7;
1013 : 26061355 : v &= 0xf;
1014 : 26061355 : if (v & 0x8)
1015 : 3335 : v |= -1 ^ 0x7;
1016 : : /* unsigned necessary due to left shifts of -ve values. */
1017 : 26061355 : unsigned HOST_WIDE_INT uv = (unsigned HOST_WIDE_INT) v;
1018 : 26061355 : if ((ptr = read (++bytes)))
1019 : 119299556 : while (bytes--)
1020 : 93238201 : uv = (uv << 8) | (*ptr++ & 0xff);
1021 : 26061355 : v = (HOST_WIDE_INT) uv;
1022 : : }
1023 : 3043336 : else if (v & 0x40)
1024 : 14589 : v |= -1 ^ 0x3f;
1025 : : }
1026 : :
1027 : 29104691 : return v;
1028 : : }
1029 : :
1030 : : /* unsigned wide ints are just written as signed wide ints. */
1031 : :
1032 : : inline void
1033 : 30985543 : bytes_out::wu (unsigned HOST_WIDE_INT v)
1034 : : {
1035 : 30985543 : wi ((HOST_WIDE_INT) v);
1036 : : }
1037 : :
1038 : : inline unsigned HOST_WIDE_INT
1039 : 29103495 : bytes_in::wu ()
1040 : : {
1041 : 57394188 : return (unsigned HOST_WIDE_INT) wi ();
1042 : : }
1043 : :
1044 : : /* size_t written as unsigned or unsigned wide int. */
1045 : :
1046 : : inline void
1047 : 2612284 : bytes_out::z (size_t s)
1048 : : {
1049 : 2612284 : if (sizeof (s) == sizeof (unsigned))
1050 : : u (s);
1051 : : else
1052 : 5170582 : wu (s);
1053 : : }
1054 : :
1055 : : inline size_t
1056 : 2492791 : bytes_in::z ()
1057 : : {
1058 : 2492791 : if (sizeof (size_t) == sizeof (unsigned))
1059 : : return u ();
1060 : : else
1061 : 4985582 : return wu ();
1062 : : }
1063 : :
1064 : : /* location_t written as 32- or 64-bit as needed. */
1065 : :
1066 : 27517122 : inline void bytes_out::loc (location_t l)
1067 : : {
1068 : 27517122 : if (sizeof (location_t) > sizeof (unsigned))
1069 : 52379717 : wu (l);
1070 : : else
1071 : : u (l);
1072 : 2652378 : }
1073 : :
1074 : 25800224 : inline location_t bytes_in::loc ()
1075 : : {
1076 : 25800224 : if (sizeof (location_t) > sizeof (unsigned))
1077 : 51598096 : return wu ();
1078 : : else
1079 : : return u ();
1080 : : }
1081 : :
1082 : : /* Buffer simply memcpied. */
1083 : : void *
1084 : 2658865 : bytes_out::buf (size_t len)
1085 : : {
1086 : 2658865 : align (sizeof (void *) * 2);
1087 : 2658865 : return write (len);
1088 : : }
1089 : :
1090 : : void
1091 : 2588441 : bytes_out::buf (const void *src, size_t len)
1092 : : {
1093 : 2588441 : if (void *ptr = buf (len))
1094 : 2588441 : memcpy (ptr, src, len);
1095 : 2588441 : }
1096 : :
1097 : : const void *
1098 : 2528237 : bytes_in::buf (size_t len)
1099 : : {
1100 : 2528237 : align (sizeof (void *) * 2);
1101 : 2528237 : const char *ptr = read (len);
1102 : :
1103 : 2528237 : return ptr;
1104 : : }
1105 : :
1106 : : /* strings as an size_t length, followed by the buffer. Make sure
1107 : : there's a NUL terminator on read. */
1108 : :
1109 : : void
1110 : 2612284 : bytes_out::str (const char *string, size_t len)
1111 : : {
1112 : 2558298 : z (len);
1113 : 2558298 : if (len)
1114 : : {
1115 : 2558298 : gcc_checking_assert (!string[len]);
1116 : 2558298 : buf (string, len + 1);
1117 : : }
1118 : 53986 : }
1119 : :
1120 : : const char *
1121 : 2492791 : bytes_in::str (size_t *len_p)
1122 : : {
1123 : 2492791 : size_t len = z ();
1124 : :
1125 : : /* We're about to trust some user data. */
1126 : 2492791 : if (overrun)
1127 : 0 : len = 0;
1128 : 2492791 : if (len_p)
1129 : 2489765 : *len_p = len;
1130 : 2492791 : const char *str = NULL;
1131 : 2492791 : if (len)
1132 : : {
1133 : 2492634 : str = reinterpret_cast<const char *> (buf (len + 1));
1134 : 2492634 : if (!str || str[len])
1135 : : {
1136 : 0 : set_overrun ();
1137 : 0 : str = NULL;
1138 : : }
1139 : : }
1140 : 0 : return str ? str : "";
1141 : : }
1142 : :
1143 : : cpp_hashnode *
1144 : 507755 : bytes_in::cpp_node ()
1145 : : {
1146 : 507755 : size_t len;
1147 : 507755 : const char *s = str (&len);
1148 : 507755 : if (!len)
1149 : : return NULL;
1150 : 507598 : return ::cpp_node (get_identifier_with_length (s, len));
1151 : : }
1152 : :
1153 : : /* Format a string directly to the buffer, including a terminating
1154 : : NUL. Intended for human consumption. */
1155 : :
1156 : : void
1157 : 21992 : bytes_out::printf (const char *format, ...)
1158 : : {
1159 : 21992 : va_list args;
1160 : : /* Exercise buffer expansion. */
1161 : 21992 : size_t len = EXPERIMENT (10, 500);
1162 : :
1163 : 43797 : while (char *ptr = write (len))
1164 : : {
1165 : 43797 : va_start (args, format);
1166 : 43797 : size_t actual = vsnprintf (ptr, len, format, args) + 1;
1167 : 43797 : va_end (args);
1168 : 43797 : if (actual <= len)
1169 : : {
1170 : 21992 : unuse (len - actual);
1171 : 21992 : break;
1172 : : }
1173 : 21805 : unuse (len);
1174 : 21805 : len = actual;
1175 : 21805 : }
1176 : 21992 : }
1177 : :
1178 : : void
1179 : 4298 : bytes_out::print_time (const char *kind, const tm *time, const char *tz)
1180 : : {
1181 : 4298 : printf ("%stime: %4u/%02u/%02u %02u:%02u:%02u %s",
1182 : 4298 : kind, time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
1183 : 4298 : time->tm_hour, time->tm_min, time->tm_sec, tz);
1184 : 4298 : }
1185 : :
1186 : : /* Encapsulated Lazy Records Of Named Declarations.
1187 : : Header: Stunningly Elf32_Ehdr-like
1188 : : Sections: Sectional data
1189 : : [1-N) : User data sections
1190 : : N .strtab : strings, stunningly ELF STRTAB-like
1191 : : Index: Section table, stunningly ELF32_Shdr-like. */
1192 : :
1193 : : class elf {
1194 : : protected:
1195 : : /* Constants used within the format. */
1196 : : enum private_constants {
1197 : : /* File kind. */
1198 : : ET_NONE = 0,
1199 : : EM_NONE = 0,
1200 : : OSABI_NONE = 0,
1201 : :
1202 : : /* File format. */
1203 : : EV_CURRENT = 1,
1204 : : CLASS32 = 1,
1205 : : DATA2LSB = 1,
1206 : : DATA2MSB = 2,
1207 : :
1208 : : /* Section numbering. */
1209 : : SHN_UNDEF = 0,
1210 : : SHN_LORESERVE = 0xff00,
1211 : : SHN_XINDEX = 0xffff,
1212 : :
1213 : : /* Section types. */
1214 : : SHT_NONE = 0, /* No contents. */
1215 : : SHT_PROGBITS = 1, /* Random bytes. */
1216 : : SHT_STRTAB = 3, /* A string table. */
1217 : :
1218 : : /* Section flags. */
1219 : : SHF_NONE = 0x00, /* Nothing. */
1220 : : SHF_STRINGS = 0x20, /* NUL-Terminated strings. */
1221 : :
1222 : : /* I really hope we do not get CMI files larger than 4GB. */
1223 : : MY_CLASS = CLASS32,
1224 : : /* It is host endianness that is relevant. */
1225 : : MY_ENDIAN = DATA2LSB
1226 : : #ifdef WORDS_BIGENDIAN
1227 : : ^ DATA2LSB ^ DATA2MSB
1228 : : #endif
1229 : : };
1230 : :
1231 : : public:
1232 : : /* Constants visible to users. */
1233 : : enum public_constants {
1234 : : /* Special error codes. Breaking layering a bit. */
1235 : : E_BAD_DATA = -1, /* Random unexpected data errors. */
1236 : : E_BAD_LAZY = -2, /* Badly ordered laziness. */
1237 : : E_BAD_IMPORT = -3 /* A nested import failed. */
1238 : : };
1239 : :
1240 : : protected:
1241 : : /* File identification. On-disk representation. */
1242 : : struct ident {
1243 : : uint8_t magic[4]; /* 0x7f, 'E', 'L', 'F' */
1244 : : uint8_t klass; /* 4:CLASS32 */
1245 : : uint8_t data; /* 5:DATA2[LM]SB */
1246 : : uint8_t version; /* 6:EV_CURRENT */
1247 : : uint8_t osabi; /* 7:OSABI_NONE */
1248 : : uint8_t abiver; /* 8: 0 */
1249 : : uint8_t pad[7]; /* 9-15 */
1250 : : };
1251 : : /* File header. On-disk representation. */
1252 : : struct header {
1253 : : struct ident ident;
1254 : : uint16_t type; /* ET_NONE */
1255 : : uint16_t machine; /* EM_NONE */
1256 : : uint32_t version; /* EV_CURRENT */
1257 : : uint32_t entry; /* 0 */
1258 : : uint32_t phoff; /* 0 */
1259 : : uint32_t shoff; /* Section Header Offset in file */
1260 : : uint32_t flags;
1261 : : uint16_t ehsize; /* ELROND Header SIZE -- sizeof (header) */
1262 : : uint16_t phentsize; /* 0 */
1263 : : uint16_t phnum; /* 0 */
1264 : : uint16_t shentsize; /* Section Header SIZE -- sizeof (section) */
1265 : : uint16_t shnum; /* Section Header NUM */
1266 : : uint16_t shstrndx; /* Section Header STRing iNDeX */
1267 : : };
1268 : : /* File section. On-disk representation. */
1269 : : struct section {
1270 : : uint32_t name; /* String table offset. */
1271 : : uint32_t type; /* SHT_* */
1272 : : uint32_t flags; /* SHF_* */
1273 : : uint32_t addr; /* 0 */
1274 : : uint32_t offset; /* OFFSET in file */
1275 : : uint32_t size; /* SIZE of section */
1276 : : uint32_t link; /* 0 */
1277 : : uint32_t info; /* 0 */
1278 : : uint32_t addralign; /* 0 */
1279 : : uint32_t entsize; /* ENTry SIZE, usually 0 */
1280 : : };
1281 : :
1282 : : protected:
1283 : : data hdr; /* The header. */
1284 : : data sectab; /* The section table. */
1285 : : data strtab; /* String table. */
1286 : : int fd; /* File descriptor we're reading or writing. */
1287 : : int err; /* Sticky error code. */
1288 : :
1289 : : public:
1290 : : /* Construct from STREAM. E is errno if STREAM NULL. */
1291 : 4656 : elf (int fd, int e)
1292 : 9312 : :hdr (), sectab (), strtab (), fd (fd), err (fd >= 0 ? 0 : e)
1293 : : {}
1294 : 4586 : ~elf ()
1295 : : {
1296 : 4586 : gcc_checking_assert (fd < 0 && !hdr.buffer
1297 : : && !sectab.buffer && !strtab.buffer);
1298 : 4586 : }
1299 : :
1300 : : public:
1301 : : /* Return the error, if we have an error. */
1302 : 740095 : int get_error () const
1303 : : {
1304 : 740095 : return err;
1305 : : }
1306 : : /* Set the error, unless it's already been set. */
1307 : 20 : void set_error (int e = E_BAD_DATA)
1308 : : {
1309 : 20 : if (!err)
1310 : 13 : err = e;
1311 : 0 : }
1312 : : /* Get an error string. */
1313 : : const char *get_error (const char *) const;
1314 : :
1315 : : public:
1316 : : /* Begin reading/writing file. Return false on error. */
1317 : 4529 : bool begin () const
1318 : : {
1319 : 4529 : return !get_error ();
1320 : : }
1321 : : /* Finish reading/writing file. Return false on error. */
1322 : : bool end ();
1323 : : };
1324 : :
1325 : : /* Return error string. */
1326 : :
1327 : : const char *
1328 : 31 : elf::get_error (const char *name) const
1329 : : {
1330 : 31 : if (!name)
1331 : : return "Unknown CMI mapping";
1332 : :
1333 : 31 : switch (err)
1334 : : {
1335 : 0 : case 0:
1336 : 0 : gcc_unreachable ();
1337 : : case E_BAD_DATA:
1338 : : return "Bad file data";
1339 : 6 : case E_BAD_IMPORT:
1340 : 6 : return "Bad import dependency";
1341 : 0 : case E_BAD_LAZY:
1342 : 0 : return "Bad lazy ordering";
1343 : 18 : default:
1344 : 18 : return xstrerror (err);
1345 : : }
1346 : : }
1347 : :
1348 : : /* Finish file, return true if there's an error. */
1349 : :
1350 : : bool
1351 : 6524 : elf::end ()
1352 : : {
1353 : : /* Close the stream and free the section table. */
1354 : 6524 : if (fd >= 0 && close (fd))
1355 : 0 : set_error (errno);
1356 : 6524 : fd = -1;
1357 : :
1358 : 6524 : return !get_error ();
1359 : : }
1360 : :
1361 : : /* ELROND reader. */
1362 : :
1363 : : class elf_in : public elf {
1364 : : typedef elf parent;
1365 : :
1366 : : private:
1367 : : /* For freezing & defrosting. */
1368 : : #if !defined (HOST_LACKS_INODE_NUMBERS)
1369 : : dev_t device;
1370 : : ino_t inode;
1371 : : #endif
1372 : :
1373 : : public:
1374 : 2377 : elf_in (int fd, int e)
1375 : 4754 : :parent (fd, e)
1376 : : {
1377 : : }
1378 : 2307 : ~elf_in ()
1379 : : {
1380 : 2307 : }
1381 : :
1382 : : public:
1383 : 359614 : bool is_frozen () const
1384 : : {
1385 : 18 : return fd < 0 && hdr.pos;
1386 : : }
1387 : 18 : bool is_freezable () const
1388 : : {
1389 : 9 : return fd >= 0 && hdr.pos;
1390 : : }
1391 : : void freeze ();
1392 : : bool defrost (const char *);
1393 : :
1394 : : /* If BYTES is in the mmapped area, allocate a new buffer for it. */
1395 : 0 : void preserve (bytes_in &bytes ATTRIBUTE_UNUSED)
1396 : : {
1397 : : #if MAPPED_READING
1398 : 0 : if (hdr.buffer && bytes.buffer >= hdr.buffer
1399 : 0 : && bytes.buffer < hdr.buffer + hdr.pos)
1400 : : {
1401 : 0 : char *buf = bytes.buffer;
1402 : 0 : bytes.buffer = data::simple_memory.grow (NULL, bytes.size);
1403 : 0 : memcpy (bytes.buffer, buf, bytes.size);
1404 : : }
1405 : : #endif
1406 : 0 : }
1407 : : /* If BYTES is not in SELF's mmapped area, free it. SELF might be
1408 : : NULL. */
1409 : 984 : static void release (elf_in *self ATTRIBUTE_UNUSED, bytes_in &bytes)
1410 : : {
1411 : : #if MAPPED_READING
1412 : 984 : if (!(self && self->hdr.buffer && bytes.buffer >= self->hdr.buffer
1413 : 984 : && bytes.buffer < self->hdr.buffer + self->hdr.pos))
1414 : : #endif
1415 : 0 : data::simple_memory.shrink (bytes.buffer);
1416 : 984 : bytes.buffer = NULL;
1417 : 984 : bytes.size = 0;
1418 : 984 : }
1419 : :
1420 : : public:
1421 : 376420 : static void grow (data &data, unsigned needed)
1422 : : {
1423 : 376420 : gcc_checking_assert (!data.buffer);
1424 : : #if !MAPPED_READING
1425 : : data.buffer = XNEWVEC (char, needed);
1426 : : #endif
1427 : 376420 : data.size = needed;
1428 : 376420 : }
1429 : 381509 : static void shrink (data &data)
1430 : : {
1431 : : #if !MAPPED_READING
1432 : : XDELETEVEC (data.buffer);
1433 : : #endif
1434 : 381509 : data.buffer = NULL;
1435 : 381509 : data.size = 0;
1436 : 0 : }
1437 : :
1438 : : public:
1439 : 374061 : const section *get_section (unsigned s) const
1440 : : {
1441 : 374061 : if (s * sizeof (section) < sectab.size)
1442 : 374061 : return reinterpret_cast<const section *>
1443 : 374061 : (§ab.buffer[s * sizeof (section)]);
1444 : : else
1445 : : return NULL;
1446 : : }
1447 : : unsigned get_section_limit () const
1448 : : {
1449 : : return sectab.size / sizeof (section);
1450 : : }
1451 : :
1452 : : protected:
1453 : : const char *read (data *, unsigned, unsigned);
1454 : :
1455 : : public:
1456 : : /* Read section by number. */
1457 : 374061 : bool read (data *d, const section *s)
1458 : : {
1459 : 374061 : return s && read (d, s->offset, s->size);
1460 : : }
1461 : :
1462 : : /* Find section by name. */
1463 : : unsigned find (const char *name);
1464 : : /* Find section by index. */
1465 : : const section *find (unsigned snum, unsigned type = SHT_PROGBITS);
1466 : :
1467 : : public:
1468 : : /* Release the string table, when we're done with it. */
1469 : 6585 : void release ()
1470 : : {
1471 : 6585 : shrink (strtab);
1472 : 39 : }
1473 : :
1474 : : public:
1475 : : bool begin (location_t);
1476 : 4245 : bool end ()
1477 : : {
1478 : 4245 : release ();
1479 : : #if MAPPED_READING
1480 : 4245 : if (hdr.buffer)
1481 : 2307 : munmap (hdr.buffer, hdr.pos);
1482 : 4245 : hdr.buffer = NULL;
1483 : : #endif
1484 : 4245 : shrink (sectab);
1485 : :
1486 : 4245 : return parent::end ();
1487 : : }
1488 : :
1489 : : public:
1490 : : /* Return string name at OFFSET. Checks OFFSET range. Always
1491 : : returns non-NULL. We know offset 0 is an empty string. */
1492 : 364493 : const char *name (unsigned offset)
1493 : : {
1494 : 728986 : return &strtab.buffer[offset < strtab.size ? offset : 0];
1495 : : }
1496 : : };
1497 : :
1498 : : /* ELROND writer. */
1499 : :
1500 : : class elf_out : public elf, public data::allocator {
1501 : : typedef elf parent;
1502 : : /* Desired section alignment on disk. */
1503 : : static const int SECTION_ALIGN = 16;
1504 : :
1505 : : private:
1506 : : ptr_int_hash_map identtab; /* Map of IDENTIFIERS to strtab offsets. */
1507 : : unsigned pos; /* Write position in file. */
1508 : : #if MAPPED_WRITING
1509 : : unsigned offset; /* Offset of the mapping. */
1510 : : unsigned extent; /* Length of mapping. */
1511 : : unsigned page_size; /* System page size. */
1512 : : #endif
1513 : :
1514 : : public:
1515 : 2279 : elf_out (int fd, int e)
1516 : 4455 : :parent (fd, e), identtab (500), pos (0)
1517 : : {
1518 : : #if MAPPED_WRITING
1519 : 2279 : offset = extent = 0;
1520 : 2279 : page_size = sysconf (_SC_PAGE_SIZE);
1521 : 2279 : if (page_size < SECTION_ALIGN)
1522 : : /* Something really strange. */
1523 : 0 : set_error (EINVAL);
1524 : : #endif
1525 : 2279 : }
1526 : 2279 : ~elf_out ()
1527 : 2279 : {
1528 : 2279 : data::simple_memory.shrink (hdr);
1529 : 2279 : data::simple_memory.shrink (sectab);
1530 : 2279 : data::simple_memory.shrink (strtab);
1531 : 2279 : }
1532 : :
1533 : : #if MAPPED_WRITING
1534 : : private:
1535 : : void create_mapping (unsigned ext, bool extending = true);
1536 : : void remove_mapping ();
1537 : : #endif
1538 : :
1539 : : protected:
1540 : : using allocator::grow;
1541 : : char *grow (char *, unsigned needed) final override;
1542 : : #if MAPPED_WRITING
1543 : : using allocator::shrink;
1544 : : void shrink (char *) final override;
1545 : : #endif
1546 : :
1547 : : public:
1548 : 4539 : unsigned get_section_limit () const
1549 : : {
1550 : 4539 : return sectab.pos / sizeof (section);
1551 : : }
1552 : :
1553 : : protected:
1554 : : unsigned add (unsigned type, unsigned name = 0,
1555 : : unsigned off = 0, unsigned size = 0, unsigned flags = SHF_NONE);
1556 : : unsigned write (const data &);
1557 : : #if MAPPED_WRITING
1558 : : unsigned write (const bytes_out &);
1559 : : #endif
1560 : :
1561 : : public:
1562 : : /* IDENTIFIER to strtab offset. */
1563 : : unsigned name (tree ident);
1564 : : /* String literal to strtab offset. */
1565 : : unsigned name (const char *n);
1566 : : /* Qualified name of DECL to strtab offset. */
1567 : : unsigned qualified_name (tree decl, bool is_defn);
1568 : :
1569 : : private:
1570 : : unsigned strtab_write (const char *s, unsigned l);
1571 : : void strtab_write (tree decl, int);
1572 : :
1573 : : public:
1574 : : /* Add a section with contents or strings. */
1575 : : unsigned add (const bytes_out &, bool string_p, unsigned name);
1576 : :
1577 : : public:
1578 : : /* Begin and end writing. */
1579 : : bool begin ();
1580 : : bool end ();
1581 : : };
1582 : :
1583 : : /* Begin reading section NAME (of type PROGBITS) from SOURCE.
1584 : : Data always checked for CRC. */
1585 : :
1586 : : bool
1587 : 14439 : bytes_in::begin (location_t loc, elf_in *source, const char *name)
1588 : : {
1589 : 14439 : unsigned snum = source->find (name);
1590 : :
1591 : 14439 : return begin (loc, source, snum, name);
1592 : : }
1593 : :
1594 : : /* Begin reading section numbered SNUM with NAME (may be NULL). */
1595 : :
1596 : : bool
1597 : 371702 : bytes_in::begin (location_t loc, elf_in *source, unsigned snum, const char *name)
1598 : : {
1599 : 371702 : if (!source->read (this, source->find (snum))
1600 : 371702 : || !size || !check_crc ())
1601 : : {
1602 : 0 : source->set_error (elf::E_BAD_DATA);
1603 : 0 : source->shrink (*this);
1604 : 0 : if (name)
1605 : 0 : error_at (loc, "section %qs is missing or corrupted", name);
1606 : : else
1607 : 0 : error_at (loc, "section #%u is missing or corrupted", snum);
1608 : 0 : return false;
1609 : : }
1610 : 371702 : pos = 4;
1611 : 371702 : return true;
1612 : : }
1613 : :
1614 : : /* Finish reading a section. */
1615 : :
1616 : : bool
1617 : 370679 : bytes_in::end (elf_in *src)
1618 : : {
1619 : 370679 : if (more_p ())
1620 : 7 : set_overrun ();
1621 : 370679 : if (overrun)
1622 : 7 : src->set_error ();
1623 : :
1624 : 370679 : src->shrink (*this);
1625 : :
1626 : 370679 : return !overrun;
1627 : : }
1628 : :
1629 : : /* Begin writing buffer. */
1630 : :
1631 : : void
1632 : 397954 : bytes_out::begin (bool need_crc)
1633 : : {
1634 : 0 : if (need_crc)
1635 : 0 : pos = 4;
1636 : 0 : memory->grow (*this, 0, false);
1637 : 383467 : }
1638 : :
1639 : : /* Finish writing buffer. Stream out to SINK as named section NAME.
1640 : : Return section number or 0 on failure. If CRC_PTR is true, crc
1641 : : the data. Otherwise it is a string section. */
1642 : :
1643 : : unsigned
1644 : 397954 : bytes_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
1645 : : {
1646 : 397954 : lengths[3] += pos;
1647 : 397954 : spans[3]++;
1648 : :
1649 : 397954 : set_crc (crc_ptr);
1650 : 397954 : unsigned sec_num = sink->add (*this, !crc_ptr, name);
1651 : 397954 : memory->shrink (*this);
1652 : :
1653 : 397954 : return sec_num;
1654 : : }
1655 : :
1656 : : /* Close and open the file, without destroying it. */
1657 : :
1658 : : void
1659 : 9 : elf_in::freeze ()
1660 : : {
1661 : 9 : gcc_checking_assert (!is_frozen ());
1662 : : #if MAPPED_READING
1663 : 9 : if (munmap (hdr.buffer, hdr.pos) < 0)
1664 : 0 : set_error (errno);
1665 : : #endif
1666 : 9 : if (close (fd) < 0)
1667 : 0 : set_error (errno);
1668 : 9 : fd = -1;
1669 : 9 : }
1670 : :
1671 : : bool
1672 : 9 : elf_in::defrost (const char *name)
1673 : : {
1674 : 9 : gcc_checking_assert (is_frozen ());
1675 : 9 : struct stat stat;
1676 : :
1677 : 9 : fd = open (name, O_RDONLY | O_CLOEXEC | O_BINARY);
1678 : 9 : if (fd < 0 || fstat (fd, &stat) < 0)
1679 : 0 : set_error (errno);
1680 : : else
1681 : : {
1682 : 9 : bool ok = hdr.pos == unsigned (stat.st_size);
1683 : : #ifndef HOST_LACKS_INODE_NUMBERS
1684 : 9 : if (device != stat.st_dev
1685 : 9 : || inode != stat.st_ino)
1686 : : ok = false;
1687 : : #endif
1688 : 9 : if (!ok)
1689 : 0 : set_error (EMFILE);
1690 : : #if MAPPED_READING
1691 : 0 : if (ok)
1692 : : {
1693 : 9 : char *mapping = reinterpret_cast<char *>
1694 : 9 : (mmap (NULL, hdr.pos, PROT_READ, MAP_SHARED, fd, 0));
1695 : 9 : if (mapping == MAP_FAILED)
1696 : 0 : fail:
1697 : 0 : set_error (errno);
1698 : : else
1699 : : {
1700 : 9 : if (madvise (mapping, hdr.pos, MADV_RANDOM))
1701 : 0 : goto fail;
1702 : :
1703 : : /* These buffers are never NULL in this case. */
1704 : 9 : strtab.buffer = mapping + strtab.pos;
1705 : 9 : sectab.buffer = mapping + sectab.pos;
1706 : 9 : hdr.buffer = mapping;
1707 : : }
1708 : : }
1709 : : #endif
1710 : : }
1711 : :
1712 : 9 : return !get_error ();
1713 : : }
1714 : :
1715 : : /* Read at current position into BUFFER. Return true on success. */
1716 : :
1717 : : const char *
1718 : 376420 : elf_in::read (data *data, unsigned pos, unsigned length)
1719 : : {
1720 : : #if MAPPED_READING
1721 : 376420 : if (pos + length > hdr.pos)
1722 : : {
1723 : 0 : set_error (EINVAL);
1724 : 0 : return NULL;
1725 : : }
1726 : : #else
1727 : : if (pos != ~0u && lseek (fd, pos, SEEK_SET) < 0)
1728 : : {
1729 : : set_error (errno);
1730 : : return NULL;
1731 : : }
1732 : : #endif
1733 : 376420 : grow (*data, length);
1734 : : #if MAPPED_READING
1735 : 376420 : data->buffer = hdr.buffer + pos;
1736 : : #else
1737 : : if (::read (fd, data->buffer, data->size) != ssize_t (length))
1738 : : {
1739 : : set_error (errno);
1740 : : shrink (*data);
1741 : : return NULL;
1742 : : }
1743 : : #endif
1744 : :
1745 : 376420 : return data->buffer;
1746 : : }
1747 : :
1748 : : /* Read section SNUM of TYPE. Return section pointer or NULL on error. */
1749 : :
1750 : : const elf::section *
1751 : 374061 : elf_in::find (unsigned snum, unsigned type)
1752 : : {
1753 : 374061 : const section *sec = get_section (snum);
1754 : 374061 : if (!snum || !sec || sec->type != type)
1755 : 0 : return NULL;
1756 : : return sec;
1757 : : }
1758 : :
1759 : : /* Find a section NAME and TYPE. Return section number, or zero on
1760 : : failure. */
1761 : :
1762 : : unsigned
1763 : 14465 : elf_in::find (const char *sname)
1764 : : {
1765 : 85002 : for (unsigned pos = sectab.size; pos -= sizeof (section); )
1766 : : {
1767 : 85002 : const section *sec
1768 : 85002 : = reinterpret_cast<const section *> (§ab.buffer[pos]);
1769 : :
1770 : 170004 : if (0 == strcmp (sname, name (sec->name)))
1771 : 14465 : return pos / sizeof (section);
1772 : : }
1773 : :
1774 : : return 0;
1775 : : }
1776 : :
1777 : : /* Begin reading file. Verify header. Pull in section and string
1778 : : tables. Return true on success. */
1779 : :
1780 : : bool
1781 : 2359 : elf_in::begin (location_t loc)
1782 : : {
1783 : 2359 : if (!parent::begin ())
1784 : : return false;
1785 : :
1786 : 2359 : struct stat stat;
1787 : 2359 : unsigned size = 0;
1788 : 2359 : if (!fstat (fd, &stat))
1789 : : {
1790 : : #if !defined (HOST_LACKS_INODE_NUMBERS)
1791 : 2359 : device = stat.st_dev;
1792 : 2359 : inode = stat.st_ino;
1793 : : #endif
1794 : : /* Never generate files > 4GB, check we've not been given one. */
1795 : 2359 : if (stat.st_size == unsigned (stat.st_size))
1796 : 2359 : size = unsigned (stat.st_size);
1797 : : }
1798 : :
1799 : : #if MAPPED_READING
1800 : : /* MAP_SHARED so that the file is backing store. If someone else
1801 : : concurrently writes it, they're wrong. */
1802 : 2359 : void *mapping = mmap (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
1803 : 2359 : if (mapping == MAP_FAILED)
1804 : : {
1805 : 0 : fail:
1806 : 0 : set_error (errno);
1807 : 0 : return false;
1808 : : }
1809 : : /* We'll be hopping over this randomly. Some systems declare the
1810 : : first parm as char *, and other declare it as void *. */
1811 : 2359 : if (madvise (reinterpret_cast <char *> (mapping), size, MADV_RANDOM))
1812 : 0 : goto fail;
1813 : :
1814 : 2359 : hdr.buffer = (char *)mapping;
1815 : : #else
1816 : : read (&hdr, 0, sizeof (header));
1817 : : #endif
1818 : 2359 : hdr.pos = size; /* Record size of the file. */
1819 : :
1820 : 2359 : const header *h = reinterpret_cast<const header *> (hdr.buffer);
1821 : 2359 : if (!h)
1822 : : return false;
1823 : :
1824 : 2359 : if (h->ident.magic[0] != 0x7f
1825 : : || h->ident.magic[1] != 'E'
1826 : : || h->ident.magic[2] != 'L'
1827 : 2359 : || h->ident.magic[3] != 'F')
1828 : : {
1829 : 0 : error_at (loc, "not Encapsulated Lazy Records of Named Declarations");
1830 : 0 : failed:
1831 : 0 : shrink (hdr);
1832 : 0 : return false;
1833 : : }
1834 : :
1835 : : /* We expect a particular format -- the ELF is not intended to be
1836 : : distributable. */
1837 : 2359 : if (h->ident.klass != MY_CLASS
1838 : : || h->ident.data != MY_ENDIAN
1839 : 2359 : || h->ident.version != EV_CURRENT
1840 : : || h->type != ET_NONE
1841 : 2359 : || h->machine != EM_NONE
1842 : 2359 : || h->ident.osabi != OSABI_NONE)
1843 : : {
1844 : 0 : error_at (loc, "unexpected encapsulation format or type");
1845 : 0 : goto failed;
1846 : : }
1847 : :
1848 : 2359 : int e = -1;
1849 : 2359 : if (!h->shoff || h->shentsize != sizeof (section))
1850 : : {
1851 : 0 : malformed:
1852 : 0 : set_error (e);
1853 : 0 : error_at (loc, "encapsulation is malformed");
1854 : 0 : goto failed;
1855 : : }
1856 : :
1857 : 2359 : unsigned strndx = h->shstrndx;
1858 : 2359 : unsigned shnum = h->shnum;
1859 : 2359 : if (shnum == SHN_XINDEX)
1860 : : {
1861 : 0 : if (!read (§ab, h->shoff, sizeof (section)))
1862 : : {
1863 : 0 : section_table_fail:
1864 : 0 : e = errno;
1865 : 0 : goto malformed;
1866 : : }
1867 : 0 : shnum = get_section (0)->size;
1868 : : /* Freeing does mean we'll re-read it in the case we're not
1869 : : mapping, but this is going to be rare. */
1870 : 0 : shrink (sectab);
1871 : : }
1872 : :
1873 : 2359 : if (!shnum)
1874 : 0 : goto malformed;
1875 : :
1876 : 2359 : if (!read (§ab, h->shoff, shnum * sizeof (section)))
1877 : 0 : goto section_table_fail;
1878 : :
1879 : 2359 : if (strndx == SHN_XINDEX)
1880 : 0 : strndx = get_section (0)->link;
1881 : :
1882 : 2359 : if (!read (&strtab, find (strndx, SHT_STRTAB)))
1883 : 0 : goto malformed;
1884 : :
1885 : : /* The string table should be at least one byte, with NUL chars
1886 : : at either end. */
1887 : 2359 : if (!(strtab.size && !strtab.buffer[0]
1888 : 2359 : && !strtab.buffer[strtab.size - 1]))
1889 : 0 : goto malformed;
1890 : :
1891 : : #if MAPPED_READING
1892 : : /* Record the offsets of the section and string tables. */
1893 : 2359 : sectab.pos = h->shoff;
1894 : 2359 : strtab.pos = shnum * sizeof (section);
1895 : : #else
1896 : : shrink (hdr);
1897 : : #endif
1898 : :
1899 : 2359 : return true;
1900 : : }
1901 : :
1902 : : /* Create a new mapping. */
1903 : :
1904 : : #if MAPPED_WRITING
1905 : : void
1906 : 3090 : elf_out::create_mapping (unsigned ext, bool extending)
1907 : : {
1908 : : #ifndef HAVE_POSIX_FALLOCATE
1909 : : #define posix_fallocate(fd,off,len) ftruncate (fd, off + len)
1910 : : #endif
1911 : 3090 : void *mapping = MAP_FAILED;
1912 : 3090 : if (extending && ext < 1024 * 1024)
1913 : : {
1914 : 2756 : if (!posix_fallocate (fd, offset, ext * 2))
1915 : 2756 : mapping = mmap (NULL, ext * 2, PROT_READ | PROT_WRITE,
1916 : 2756 : MAP_SHARED, fd, offset);
1917 : 2756 : if (mapping != MAP_FAILED)
1918 : : ext *= 2;
1919 : : }
1920 : : if (mapping == MAP_FAILED)
1921 : : {
1922 : 334 : if (!extending || !posix_fallocate (fd, offset, ext))
1923 : 334 : mapping = mmap (NULL, ext, PROT_READ | PROT_WRITE,
1924 : 334 : MAP_SHARED, fd, offset);
1925 : 334 : if (mapping == MAP_FAILED)
1926 : : {
1927 : 0 : set_error (errno);
1928 : : mapping = NULL;
1929 : : ext = 0;
1930 : : }
1931 : : }
1932 : : #undef posix_fallocate
1933 : 3090 : hdr.buffer = (char *)mapping;
1934 : 3090 : extent = ext;
1935 : 3090 : }
1936 : : #endif
1937 : :
1938 : : /* Flush out the current mapping. */
1939 : :
1940 : : #if MAPPED_WRITING
1941 : : void
1942 : 3096 : elf_out::remove_mapping ()
1943 : : {
1944 : 3096 : if (hdr.buffer)
1945 : : {
1946 : : /* MS_ASYNC dtrt with the removed mapping, including a
1947 : : subsequent overlapping remap. */
1948 : 3090 : if (msync (hdr.buffer, extent, MS_ASYNC)
1949 : 3090 : || munmap (hdr.buffer, extent))
1950 : : /* We're somewhat screwed at this point. */
1951 : 0 : set_error (errno);
1952 : : }
1953 : :
1954 : 3096 : hdr.buffer = NULL;
1955 : 3096 : }
1956 : : #endif
1957 : :
1958 : : /* Grow a mapping of PTR to be NEEDED bytes long. This gets
1959 : : interesting if the new size grows the EXTENT. */
1960 : :
1961 : : char *
1962 : 943830 : elf_out::grow (char *data, unsigned needed)
1963 : : {
1964 : 943830 : if (!data)
1965 : : {
1966 : : /* First allocation, check we're aligned. */
1967 : 402306 : gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)));
1968 : : #if MAPPED_WRITING
1969 : 402306 : data = hdr.buffer + (pos - offset);
1970 : : #endif
1971 : : }
1972 : :
1973 : : #if MAPPED_WRITING
1974 : 943830 : unsigned off = data - hdr.buffer;
1975 : 943830 : if (off + needed > extent)
1976 : : {
1977 : : /* We need to grow the mapping. */
1978 : 796 : unsigned lwm = off & ~(page_size - 1);
1979 : 796 : unsigned hwm = (off + needed + page_size - 1) & ~(page_size - 1);
1980 : :
1981 : 796 : gcc_checking_assert (hwm > extent);
1982 : :
1983 : 796 : remove_mapping ();
1984 : :
1985 : 796 : offset += lwm;
1986 : 796 : create_mapping (extent < hwm - lwm ? hwm - lwm : extent);
1987 : :
1988 : 796 : data = hdr.buffer + (off - lwm);
1989 : : }
1990 : : #else
1991 : : data = allocator::grow (data, needed);
1992 : : #endif
1993 : :
1994 : 943830 : return data;
1995 : : }
1996 : :
1997 : : #if MAPPED_WRITING
1998 : : /* Shrinking is a NOP. */
1999 : : void
2000 : 402306 : elf_out::shrink (char *)
2001 : : {
2002 : 402306 : }
2003 : : #endif
2004 : :
2005 : : /* Write S of length L to the strtab buffer. L must include the ending
2006 : : NUL, if that's what you want. */
2007 : :
2008 : : unsigned
2009 : 1794970 : elf_out::strtab_write (const char *s, unsigned l)
2010 : : {
2011 : 1794970 : if (strtab.pos + l > strtab.size)
2012 : 1076 : data::simple_memory.grow (strtab, strtab.pos + l, false);
2013 : 1794970 : memcpy (strtab.buffer + strtab.pos, s, l);
2014 : 1794970 : unsigned res = strtab.pos;
2015 : 1794970 : strtab.pos += l;
2016 : 1794970 : return res;
2017 : : }
2018 : :
2019 : : /* Write qualified name of decl. INNER >0 if this is a definition, <0
2020 : : if this is a qualifier of an outer name. */
2021 : :
2022 : : void
2023 : 715250 : elf_out::strtab_write (tree decl, int inner)
2024 : : {
2025 : 715250 : tree ctx = CP_DECL_CONTEXT (decl);
2026 : 715250 : if (TYPE_P (ctx))
2027 : 7400 : ctx = TYPE_NAME (ctx);
2028 : 715250 : if (ctx != global_namespace)
2029 : 348354 : strtab_write (ctx, -1);
2030 : :
2031 : 715250 : tree name = DECL_NAME (decl);
2032 : 715250 : if (!name)
2033 : 32 : name = DECL_ASSEMBLER_NAME_RAW (decl);
2034 : 715250 : strtab_write (IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
2035 : :
2036 : 715250 : if (inner)
2037 : 493722 : strtab_write (&"::{}"[inner+1], 2);
2038 : 715250 : }
2039 : :
2040 : : /* Map IDENTIFIER IDENT to strtab offset. Inserts into strtab if not
2041 : : already there. */
2042 : :
2043 : : unsigned
2044 : 216095 : elf_out::name (tree ident)
2045 : : {
2046 : 216095 : unsigned res = 0;
2047 : 216095 : if (ident)
2048 : : {
2049 : 216089 : bool existed;
2050 : 216089 : int *slot = &identtab.get_or_insert (ident, &existed);
2051 : 216089 : if (!existed)
2052 : 387592 : *slot = strtab_write (IDENTIFIER_POINTER (ident),
2053 : 193796 : IDENTIFIER_LENGTH (ident) + 1);
2054 : 216089 : res = *slot;
2055 : : }
2056 : 216095 : return res;
2057 : : }
2058 : :
2059 : : /* Map LITERAL to strtab offset. Does not detect duplicates and
2060 : : expects LITERAL to remain live until strtab is written out. */
2061 : :
2062 : : unsigned
2063 : 25306 : elf_out::name (const char *literal)
2064 : : {
2065 : 25306 : return strtab_write (literal, strlen (literal) + 1);
2066 : : }
2067 : :
2068 : : /* Map a DECL's qualified name to strtab offset. Does not detect
2069 : : duplicates. */
2070 : :
2071 : : unsigned
2072 : 366896 : elf_out::qualified_name (tree decl, bool is_defn)
2073 : : {
2074 : 366896 : gcc_checking_assert (DECL_P (decl) && decl != global_namespace);
2075 : 366896 : unsigned result = strtab.pos;
2076 : :
2077 : 366896 : strtab_write (decl, is_defn);
2078 : 366896 : strtab_write ("", 1);
2079 : :
2080 : 366896 : return result;
2081 : : }
2082 : :
2083 : : /* Add section to file. Return section number. TYPE & NAME identify
2084 : : the section. OFF and SIZE identify the file location of its
2085 : : data. FLAGS contains additional info. */
2086 : :
2087 : : unsigned
2088 : 402300 : elf_out::add (unsigned type, unsigned name, unsigned off, unsigned size,
2089 : : unsigned flags)
2090 : : {
2091 : 402300 : gcc_checking_assert (!(off & (SECTION_ALIGN - 1)));
2092 : 402300 : if (sectab.pos + sizeof (section) > sectab.size)
2093 : 3469 : data::simple_memory.grow (sectab, sectab.pos + sizeof (section), false);
2094 : 402300 : section *sec = reinterpret_cast<section *> (sectab.buffer + sectab.pos);
2095 : 402300 : memset (sec, 0, sizeof (section));
2096 : 402300 : sec->type = type;
2097 : 402300 : sec->flags = flags;
2098 : 402300 : sec->name = name;
2099 : 402300 : sec->offset = off;
2100 : 402300 : sec->size = size;
2101 : 402300 : if (flags & SHF_STRINGS)
2102 : 4325 : sec->entsize = 1;
2103 : :
2104 : 402300 : unsigned res = sectab.pos;
2105 : 402300 : sectab.pos += sizeof (section);
2106 : 402300 : return res / sizeof (section);
2107 : : }
2108 : :
2109 : : /* Pad to the next alignment boundary, then write BUFFER to disk.
2110 : : Return the position of the start of the write, or zero on failure. */
2111 : :
2112 : : unsigned
2113 : 8698 : elf_out::write (const data &buffer)
2114 : : {
2115 : : #if MAPPED_WRITING
2116 : : /* HDR is always mapped. */
2117 : 8698 : if (&buffer != &hdr)
2118 : : {
2119 : 4352 : bytes_out out (this);
2120 : 4352 : grow (out, buffer.pos, true);
2121 : 4352 : if (out.buffer)
2122 : 4352 : memcpy (out.buffer, buffer.buffer, buffer.pos);
2123 : 4352 : shrink (out);
2124 : 4352 : }
2125 : : else
2126 : : /* We should have been aligned during the first allocation. */
2127 : 4346 : gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)));
2128 : : #else
2129 : : if (::write (fd, buffer.buffer, buffer.pos) != ssize_t (buffer.pos))
2130 : : {
2131 : : set_error (errno);
2132 : : return 0;
2133 : : }
2134 : : #endif
2135 : 8698 : unsigned res = pos;
2136 : 8698 : pos += buffer.pos;
2137 : :
2138 : 8698 : if (unsigned padding = -pos & (SECTION_ALIGN - 1))
2139 : : {
2140 : : #if !MAPPED_WRITING
2141 : : /* Align the section on disk, should help the necessary copies.
2142 : : fseeking to extend is non-portable. */
2143 : : static char zero[SECTION_ALIGN];
2144 : : if (::write (fd, &zero, padding) != ssize_t (padding))
2145 : : set_error (errno);
2146 : : #endif
2147 : 7570 : pos += padding;
2148 : : }
2149 : 8698 : return res;
2150 : : }
2151 : :
2152 : : /* Write a streaming buffer. It must be using us as an allocator. */
2153 : :
2154 : : #if MAPPED_WRITING
2155 : : unsigned
2156 : 397954 : elf_out::write (const bytes_out &buf)
2157 : : {
2158 : 397954 : gcc_checking_assert (buf.memory == this);
2159 : : /* A directly mapped buffer. */
2160 : 397954 : gcc_checking_assert (buf.buffer - hdr.buffer >= 0
2161 : : && buf.buffer - hdr.buffer + buf.size <= extent);
2162 : 397954 : unsigned res = pos;
2163 : 397954 : pos += buf.pos;
2164 : :
2165 : : /* Align up. We're not going to advance into the next page. */
2166 : 397954 : pos += -pos & (SECTION_ALIGN - 1);
2167 : :
2168 : 397954 : return res;
2169 : : }
2170 : : #endif
2171 : :
2172 : : /* Write data and add section. STRING_P is true for a string
2173 : : section, false for PROGBITS. NAME identifies the section (0 is the
2174 : : empty name). DATA is the contents. Return section number or 0 on
2175 : : failure (0 is the undef section). */
2176 : :
2177 : : unsigned
2178 : 397954 : elf_out::add (const bytes_out &data, bool string_p, unsigned name)
2179 : : {
2180 : 397954 : unsigned off = write (data);
2181 : :
2182 : 795908 : return add (string_p ? SHT_STRTAB : SHT_PROGBITS, name,
2183 : 397954 : off, data.pos, string_p ? SHF_STRINGS : SHF_NONE);
2184 : : }
2185 : :
2186 : : /* Begin writing the file. Initialize the section table and write an
2187 : : empty header. Return false on failure. */
2188 : :
2189 : : bool
2190 : 2170 : elf_out::begin ()
2191 : : {
2192 : 2170 : if (!parent::begin ())
2193 : : return false;
2194 : :
2195 : : /* Let the allocators pick a default. */
2196 : 2170 : data::simple_memory.grow (strtab, 0, false);
2197 : 2170 : data::simple_memory.grow (sectab, 0, false);
2198 : :
2199 : : /* The string table starts with an empty string. */
2200 : 2170 : name ("");
2201 : :
2202 : : /* Create the UNDEF section. */
2203 : 2170 : add (SHT_NONE);
2204 : :
2205 : : #if MAPPED_WRITING
2206 : : /* Start a mapping. */
2207 : 2170 : create_mapping (EXPERIMENT (page_size,
2208 : : (32767 + page_size) & ~(page_size - 1)));
2209 : 2170 : if (!hdr.buffer)
2210 : : return false;
2211 : : #endif
2212 : :
2213 : : /* Write an empty header. */
2214 : 2170 : grow (hdr, sizeof (header), true);
2215 : 2170 : header *h = reinterpret_cast<header *> (hdr.buffer);
2216 : 2170 : memset (h, 0, sizeof (header));
2217 : 2170 : hdr.pos = hdr.size;
2218 : 2170 : write (hdr);
2219 : 2170 : return !get_error ();
2220 : : }
2221 : :
2222 : : /* Finish writing the file. Write out the string & section tables.
2223 : : Fill in the header. Return true on error. */
2224 : :
2225 : : bool
2226 : 2279 : elf_out::end ()
2227 : : {
2228 : 2279 : if (fd >= 0)
2229 : : {
2230 : : /* Write the string table. */
2231 : 2176 : unsigned strnam = name (".strtab");
2232 : 2176 : unsigned stroff = write (strtab);
2233 : 2176 : unsigned strndx = add (SHT_STRTAB, strnam, stroff, strtab.pos,
2234 : : SHF_STRINGS);
2235 : :
2236 : : /* Store escape values in section[0]. */
2237 : 2176 : if (strndx >= SHN_LORESERVE)
2238 : : {
2239 : 0 : reinterpret_cast<section *> (sectab.buffer)->link = strndx;
2240 : 0 : strndx = SHN_XINDEX;
2241 : : }
2242 : 2176 : unsigned shnum = sectab.pos / sizeof (section);
2243 : 2176 : if (shnum >= SHN_LORESERVE)
2244 : : {
2245 : 0 : reinterpret_cast<section *> (sectab.buffer)->size = shnum;
2246 : 0 : shnum = SHN_XINDEX;
2247 : : }
2248 : :
2249 : 2176 : unsigned shoff = write (sectab);
2250 : :
2251 : : #if MAPPED_WRITING
2252 : 2176 : if (offset)
2253 : : {
2254 : 124 : remove_mapping ();
2255 : 124 : offset = 0;
2256 : 124 : create_mapping ((sizeof (header) + page_size - 1) & ~(page_size - 1),
2257 : : false);
2258 : : }
2259 : 2176 : unsigned length = pos;
2260 : : #else
2261 : : if (lseek (fd, 0, SEEK_SET) < 0)
2262 : : set_error (errno);
2263 : : #endif
2264 : : /* Write header. */
2265 : 2176 : if (!get_error ())
2266 : : {
2267 : : /* Write the correct header now. */
2268 : 2176 : header *h = reinterpret_cast<header *> (hdr.buffer);
2269 : 2176 : h->ident.magic[0] = 0x7f;
2270 : 2176 : h->ident.magic[1] = 'E'; /* Elrond */
2271 : 2176 : h->ident.magic[2] = 'L'; /* is an */
2272 : 2176 : h->ident.magic[3] = 'F'; /* elf. */
2273 : 2176 : h->ident.klass = MY_CLASS;
2274 : 2176 : h->ident.data = MY_ENDIAN;
2275 : 2176 : h->ident.version = EV_CURRENT;
2276 : 2176 : h->ident.osabi = OSABI_NONE;
2277 : 2176 : h->type = ET_NONE;
2278 : 2176 : h->machine = EM_NONE;
2279 : 2176 : h->version = EV_CURRENT;
2280 : 2176 : h->shoff = shoff;
2281 : 2176 : h->ehsize = sizeof (header);
2282 : 2176 : h->shentsize = sizeof (section);
2283 : 2176 : h->shnum = shnum;
2284 : 2176 : h->shstrndx = strndx;
2285 : :
2286 : 2176 : pos = 0;
2287 : 2176 : write (hdr);
2288 : : }
2289 : :
2290 : : #if MAPPED_WRITING
2291 : 2176 : remove_mapping ();
2292 : 2176 : if (ftruncate (fd, length))
2293 : 0 : set_error (errno);
2294 : : #endif
2295 : : }
2296 : :
2297 : 2279 : data::simple_memory.shrink (sectab);
2298 : 2279 : data::simple_memory.shrink (strtab);
2299 : :
2300 : 2279 : return parent::end ();
2301 : : }
2302 : :
2303 : : /********************************************************************/
2304 : :
2305 : : /* A dependency set. This is used during stream out to determine the
2306 : : connectivity of the graph. Every namespace-scope declaration that
2307 : : needs writing has a depset. The depset is filled with the (depsets
2308 : : of) declarations within this module that it references. For a
2309 : : declaration that'll generally be named types. For definitions
2310 : : it'll also be declarations in the body.
2311 : :
2312 : : From that we can convert the graph to a DAG, via determining the
2313 : : Strongly Connected Clusters. Each cluster is streamed
2314 : : independently, and thus we achieve lazy loading.
2315 : :
2316 : : Other decls that get a depset are namespaces themselves and
2317 : : unnameable declarations. */
2318 : :
2319 : : class depset {
2320 : : private:
2321 : : tree entity; /* Entity, or containing namespace. */
2322 : : uintptr_t discriminator; /* Flags or identifier. */
2323 : :
2324 : : public:
2325 : : /* The kinds of entity the depset could describe. The ordering is
2326 : : significant, see entity_kind_name. */
2327 : : enum entity_kind
2328 : : {
2329 : : EK_DECL, /* A decl. */
2330 : : EK_SPECIALIZATION, /* A specialization. */
2331 : : EK_PARTIAL, /* A partial specialization. */
2332 : : EK_USING, /* A using declaration (at namespace scope). */
2333 : : EK_NAMESPACE, /* A namespace. */
2334 : : EK_REDIRECT, /* Redirect to a template_decl. */
2335 : : EK_EXPLICIT_HWM,
2336 : : EK_BINDING = EK_EXPLICIT_HWM, /* Implicitly encoded. */
2337 : : EK_FOR_BINDING, /* A decl being inserted for a binding. */
2338 : : EK_INNER_DECL, /* A decl defined outside of its imported
2339 : : context. */
2340 : : EK_DIRECT_HWM = EK_PARTIAL + 1,
2341 : :
2342 : : EK_BITS = 3 /* Only need to encode below EK_EXPLICIT_HWM. */
2343 : : };
2344 : :
2345 : : private:
2346 : : /* Placement of bit fields in discriminator. */
2347 : : enum disc_bits
2348 : : {
2349 : : DB_ZERO_BIT, /* Set to disambiguate identifier from flags */
2350 : : DB_SPECIAL_BIT, /* First dep slot is special. */
2351 : : DB_KIND_BIT, /* Kind of the entity. */
2352 : : DB_KIND_BITS = EK_BITS,
2353 : : DB_DEFN_BIT = DB_KIND_BIT + DB_KIND_BITS,
2354 : : DB_IS_PENDING_BIT, /* Is a maybe-pending entity. */
2355 : : DB_TU_LOCAL_BIT, /* It is a TU-local entity. */
2356 : : DB_REFS_TU_LOCAL_BIT, /* Refers to a TU-local entity (but is not
2357 : : necessarily an exposure.) */
2358 : : DB_EXPOSURE_BIT, /* Exposes a TU-local entity. */
2359 : : DB_IMPORTED_BIT, /* An imported entity. */
2360 : : DB_UNREACHED_BIT, /* A yet-to-be reached entity. */
2361 : : DB_MAYBE_RECURSIVE_BIT, /* An entity maybe in a recursive cluster. */
2362 : : DB_ENTRY_BIT, /* The first reached recursive dep. */
2363 : : DB_HIDDEN_BIT, /* A hidden binding. */
2364 : : /* The following bits are not independent, but enumerating them is
2365 : : awkward. */
2366 : : DB_TYPE_SPEC_BIT, /* Specialization in the type table. */
2367 : : DB_FRIEND_SPEC_BIT, /* An instantiated template friend. */
2368 : : };
2369 : :
2370 : : public:
2371 : : /* The first slot is special for EK_SPECIALIZATIONS it is a
2372 : : spec_entry pointer. It is not relevant for the SCC
2373 : : determination. */
2374 : : vec<depset *> deps; /* Depsets we reference. */
2375 : :
2376 : : public:
2377 : : unsigned cluster; /* Strongly connected cluster, later entity number */
2378 : : unsigned section; /* Section written to. */
2379 : : /* During SCC construction, section is lowlink, until the depset is
2380 : : removed from the stack. See Tarjan algorithm for details. */
2381 : :
2382 : : private:
2383 : : /* Construction via factories. Destruction via hash traits. */
2384 : : depset (tree entity);
2385 : : ~depset ();
2386 : :
2387 : : public:
2388 : : static depset *make_binding (tree, tree);
2389 : : static depset *make_entity (tree, entity_kind, bool = false);
2390 : : /* Late setting a binding name -- /then/ insert into hash! */
2391 : : inline void set_binding_name (tree name)
2392 : : {
2393 : : gcc_checking_assert (!get_name ());
2394 : : discriminator = reinterpret_cast<uintptr_t> (name);
2395 : : }
2396 : :
2397 : : private:
2398 : 5606317 : template<unsigned I> void set_flag_bit ()
2399 : : {
2400 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2401 : 5606317 : discriminator |= 1u << I;
2402 : 3434753 : }
2403 : 522054 : template<unsigned I> void clear_flag_bit ()
2404 : : {
2405 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2406 : 522054 : discriminator &= ~(1u << I);
2407 : 522054 : }
2408 : 633142642 : template<unsigned I> bool get_flag_bit () const
2409 : : {
2410 : 0 : gcc_checking_assert (I < 2 || !is_binding ());
2411 : 761370707 : return bool ((discriminator >> I) & 1);
2412 : : }
2413 : :
2414 : : public:
2415 : 620161304 : bool is_binding () const
2416 : : {
2417 : 132184872 : return !get_flag_bit<DB_ZERO_BIT> ();
2418 : : }
2419 : 348778202 : entity_kind get_entity_kind () const
2420 : : {
2421 : 29176 : if (is_binding ())
2422 : : return EK_BINDING;
2423 : 265054458 : return entity_kind ((discriminator >> DB_KIND_BIT) & ((1u << EK_BITS) - 1));
2424 : : }
2425 : : const char *entity_kind_name () const;
2426 : :
2427 : : public:
2428 : 11260392 : bool has_defn () const
2429 : : {
2430 : : /* Never consider TU-local entities as having definitions, since
2431 : : we will never be accessing them from importers anyway. */
2432 : 14799332 : return get_flag_bit<DB_DEFN_BIT> () && !is_tu_local ();
2433 : : }
2434 : :
2435 : : public:
2436 : : /* This entity might be found other than by namespace-scope lookup;
2437 : : see module_state::write_pendings for more details. */
2438 : 2780684 : bool is_pending_entity () const
2439 : : {
2440 : 4419173 : return (get_entity_kind () == EK_SPECIALIZATION
2441 : 1638489 : || get_entity_kind () == EK_PARTIAL
2442 : 4368641 : || (get_entity_kind () == EK_DECL
2443 : 1554237 : && get_flag_bit<DB_IS_PENDING_BIT> ()));
2444 : : }
2445 : : public:
2446 : 52126347 : bool is_tu_local () const
2447 : : {
2448 : 28947402 : return get_flag_bit<DB_TU_LOCAL_BIT> ();
2449 : : }
2450 : 1196363 : bool refs_tu_local () const
2451 : : {
2452 : 193983 : return get_flag_bit<DB_REFS_TU_LOCAL_BIT> ();
2453 : : }
2454 : 1666076 : bool is_exposure () const
2455 : : {
2456 : 1666076 : return get_flag_bit<DB_EXPOSURE_BIT> ();
2457 : : }
2458 : 33842423 : bool is_import () const
2459 : : {
2460 : 10879392 : return get_flag_bit<DB_IMPORTED_BIT> ();
2461 : : }
2462 : 20154937 : bool is_unreached () const
2463 : : {
2464 : 1402412 : return get_flag_bit<DB_UNREACHED_BIT> ();
2465 : : }
2466 : 1784358 : bool is_hidden () const
2467 : : {
2468 : 1784358 : return get_flag_bit<DB_HIDDEN_BIT> ();
2469 : : }
2470 : 1215637 : bool is_maybe_recursive () const
2471 : : {
2472 : 1215637 : return get_flag_bit<DB_MAYBE_RECURSIVE_BIT> ();
2473 : : }
2474 : 845 : bool is_entry () const
2475 : : {
2476 : 845 : return get_flag_bit<DB_ENTRY_BIT> ();
2477 : : }
2478 : 1713225 : bool is_type_spec () const
2479 : : {
2480 : 1713225 : return get_flag_bit<DB_TYPE_SPEC_BIT> ();
2481 : : }
2482 : 1713225 : bool is_friend_spec () const
2483 : : {
2484 : 1713225 : return get_flag_bit<DB_FRIEND_SPEC_BIT> ();
2485 : : }
2486 : :
2487 : : public:
2488 : : /* We set these bit outside of depset. */
2489 : 6131 : void set_hidden_binding ()
2490 : : {
2491 : 6131 : set_flag_bit<DB_HIDDEN_BIT> ();
2492 : 6131 : }
2493 : 30 : void clear_hidden_binding ()
2494 : : {
2495 : 30 : clear_flag_bit<DB_HIDDEN_BIT> ();
2496 : 30 : }
2497 : :
2498 : : public:
2499 : 12981338 : bool is_special () const
2500 : : {
2501 : 12981338 : return get_flag_bit<DB_SPECIAL_BIT> ();
2502 : : }
2503 : 2171564 : void set_special ()
2504 : : {
2505 : 2171564 : set_flag_bit<DB_SPECIAL_BIT> ();
2506 : 0 : }
2507 : :
2508 : : public:
2509 : 159456254 : tree get_entity () const
2510 : : {
2511 : 159456254 : return entity;
2512 : : }
2513 : 27944111 : tree get_name () const
2514 : : {
2515 : 27944111 : gcc_checking_assert (is_binding ());
2516 : 27944111 : return reinterpret_cast <tree> (discriminator);
2517 : : }
2518 : :
2519 : : public:
2520 : : /* Traits for a hash table of pointers to bindings. */
2521 : : struct traits {
2522 : : /* Each entry is a pointer to a depset. */
2523 : : typedef depset *value_type;
2524 : : /* We lookup by container:maybe-identifier pair. */
2525 : : typedef std::pair<tree,tree> compare_type;
2526 : :
2527 : : static const bool empty_zero_p = true;
2528 : :
2529 : : /* hash and equality for compare_type. */
2530 : 21285650 : inline static hashval_t hash (const compare_type &p)
2531 : : {
2532 : 21285650 : hashval_t h = pointer_hash<tree_node>::hash (p.first);
2533 : 21285650 : if (p.second)
2534 : : {
2535 : 265923 : hashval_t nh = IDENTIFIER_HASH_VALUE (p.second);
2536 : 265923 : h = iterative_hash_hashval_t (h, nh);
2537 : : }
2538 : 21285650 : return h;
2539 : : }
2540 : 91615768 : inline static bool equal (const value_type b, const compare_type &p)
2541 : : {
2542 : 91615768 : if (b->entity != p.first)
2543 : : return false;
2544 : :
2545 : 15475085 : if (p.second)
2546 : 23058 : return b->discriminator == reinterpret_cast<uintptr_t> (p.second);
2547 : : else
2548 : 15452027 : return !b->is_binding ();
2549 : : }
2550 : :
2551 : : /* (re)hasher for a binding itself. */
2552 : 68102317 : inline static hashval_t hash (const value_type b)
2553 : : {
2554 : 68102317 : hashval_t h = pointer_hash<tree_node>::hash (b->entity);
2555 : 68102317 : if (b->is_binding ())
2556 : : {
2557 : 5592099 : hashval_t nh = IDENTIFIER_HASH_VALUE (b->get_name ());
2558 : 5592099 : h = iterative_hash_hashval_t (h, nh);
2559 : : }
2560 : 68102317 : return h;
2561 : : }
2562 : :
2563 : : /* Empty via NULL. */
2564 : 0 : static inline void mark_empty (value_type &p) {p = NULL;}
2565 : : static inline bool is_empty (value_type p) {return !p;}
2566 : :
2567 : : /* Nothing is deletable. Everything is insertable. */
2568 : : static bool is_deleted (value_type) { return false; }
2569 : : static void mark_deleted (value_type) { gcc_unreachable (); }
2570 : :
2571 : : /* We own the entities in the hash table. */
2572 : 3252931 : static void remove (value_type p)
2573 : : {
2574 : 3252931 : delete (p);
2575 : 3252931 : }
2576 : : };
2577 : :
2578 : : public:
2579 : : class hash : public hash_table<traits> {
2580 : : typedef traits::compare_type key_t;
2581 : : typedef hash_table<traits> parent;
2582 : :
2583 : : public:
2584 : : vec<depset *> worklist; /* Worklist of decls to walk. */
2585 : : hash *chain; /* Original table. */
2586 : : depset *current; /* Current depset being depended. */
2587 : : unsigned section; /* When writing out, the section. */
2588 : : bool reached_unreached; /* We reached an unreached entity. */
2589 : : bool writing_merge_key; /* We're writing merge key information. */
2590 : : bool ignore_tu_local; /* In a context where referencing a TU-local
2591 : : entity is not an exposure. */
2592 : :
2593 : : public:
2594 : 383462 : hash (size_t size, hash *c = NULL)
2595 : 766924 : : parent (size), chain (c), current (NULL), section (0),
2596 : 383462 : reached_unreached (false), writing_merge_key (false),
2597 : 383462 : ignore_tu_local (false)
2598 : : {
2599 : 383462 : worklist.create (size);
2600 : 383462 : }
2601 : 383462 : ~hash ()
2602 : : {
2603 : 2170 : worklist.release ();
2604 : 383462 : }
2605 : :
2606 : : public:
2607 : 117805497 : bool is_key_order () const
2608 : : {
2609 : 117805497 : return chain != NULL;
2610 : : }
2611 : :
2612 : : private:
2613 : : depset **entity_slot (tree entity, bool = true);
2614 : : depset **binding_slot (tree ctx, tree name, bool = true);
2615 : : depset *maybe_add_declaration (tree decl);
2616 : :
2617 : : public:
2618 : : depset *find_dependency (tree entity);
2619 : : depset *find_binding (tree ctx, tree name);
2620 : : depset *make_dependency (tree decl, entity_kind);
2621 : : void add_dependency (depset *);
2622 : :
2623 : : public:
2624 : : void add_mergeable (depset *);
2625 : : depset *add_dependency (tree decl, entity_kind);
2626 : : void add_namespace_context (depset *, tree ns);
2627 : :
2628 : : private:
2629 : : bool has_tu_local_tmpl_arg (tree decl, tree args, bool explain);
2630 : : bool is_tu_local_entity (tree decl, bool explain = false);
2631 : : bool is_tu_local_value (tree decl, tree expr, bool explain = false);
2632 : :
2633 : : private:
2634 : : static bool add_binding_entity (tree, WMB_Flags, void *);
2635 : :
2636 : : public:
2637 : : bool add_namespace_entities (tree ns, bitmap partitions);
2638 : : void add_specializations (bool decl_p);
2639 : : void add_partial_entities (vec<tree, va_gc> *);
2640 : : void add_class_entities (vec<tree, va_gc> *);
2641 : :
2642 : : private:
2643 : : void add_deduction_guides (tree decl);
2644 : :
2645 : : public:
2646 : : void find_dependencies (module_state *);
2647 : : bool finalize_dependencies ();
2648 : : vec<depset *> connect ();
2649 : : };
2650 : :
2651 : : public:
2652 : : struct tarjan {
2653 : : vec<depset *> result;
2654 : : vec<depset *> stack;
2655 : : unsigned index;
2656 : :
2657 : 383441 : tarjan (unsigned size)
2658 : 383441 : : index (0)
2659 : : {
2660 : 383441 : result.create (size);
2661 : 383441 : stack.create (50);
2662 : 383441 : }
2663 : 383441 : ~tarjan ()
2664 : : {
2665 : 383441 : gcc_assert (!stack.length ());
2666 : 383441 : stack.release ();
2667 : 383441 : }
2668 : :
2669 : : public:
2670 : : void connect (depset *);
2671 : : };
2672 : : };
2673 : :
2674 : : inline
2675 : 3252931 : depset::depset (tree entity)
2676 : 3252931 : :entity (entity), discriminator (0), cluster (0), section (0)
2677 : : {
2678 : 3252931 : deps.create (0);
2679 : : }
2680 : :
2681 : : inline
2682 : 3252931 : depset::~depset ()
2683 : : {
2684 : 3252931 : deps.release ();
2685 : 3252931 : }
2686 : :
2687 : : const char *
2688 : 245994 : depset::entity_kind_name () const
2689 : : {
2690 : : /* Same order as entity_kind. */
2691 : 245994 : static const char *const names[] =
2692 : : {"decl", "specialization", "partial", "using",
2693 : : "namespace", "redirect", "binding"};
2694 : 245994 : entity_kind kind = get_entity_kind ();
2695 : 245799 : gcc_checking_assert (kind < ARRAY_SIZE (names));
2696 : 245994 : return names[kind];
2697 : : }
2698 : :
2699 : : /* Create a depset for a namespace binding NS::NAME. */
2700 : :
2701 : 213619 : depset *depset::make_binding (tree ns, tree name)
2702 : : {
2703 : 213619 : depset *binding = new depset (ns);
2704 : :
2705 : 213619 : binding->discriminator = reinterpret_cast <uintptr_t> (name);
2706 : :
2707 : 213619 : return binding;
2708 : : }
2709 : :
2710 : 3039312 : depset *depset::make_entity (tree entity, entity_kind ek, bool is_defn)
2711 : : {
2712 : 3039312 : depset *r = new depset (entity);
2713 : :
2714 : 3039312 : r->discriminator = ((1 << DB_ZERO_BIT)
2715 : 3039312 : | (ek << DB_KIND_BIT)
2716 : 3039312 : | is_defn << DB_DEFN_BIT);
2717 : :
2718 : 3039312 : return r;
2719 : : }
2720 : :
2721 : : class pending_key
2722 : : {
2723 : : public:
2724 : : tree ns;
2725 : : tree id;
2726 : : };
2727 : :
2728 : : template<>
2729 : : struct default_hash_traits<pending_key>
2730 : : {
2731 : : using value_type = pending_key;
2732 : :
2733 : : static const bool empty_zero_p = false;
2734 : 47219059 : static hashval_t hash (const value_type &k)
2735 : : {
2736 : 47219059 : hashval_t h = IDENTIFIER_HASH_VALUE (k.id);
2737 : 47219059 : h = iterative_hash_hashval_t (DECL_UID (k.ns), h);
2738 : :
2739 : 47219059 : return h;
2740 : : }
2741 : 11159144 : static bool equal (const value_type &k, const value_type &l)
2742 : : {
2743 : 11159144 : return k.ns == l.ns && k.id == l.id;
2744 : : }
2745 : 280612 : static void mark_empty (value_type &k)
2746 : : {
2747 : 280612 : k.ns = k.id = NULL_TREE;
2748 : : }
2749 : 6053 : static void mark_deleted (value_type &k)
2750 : : {
2751 : 6053 : k.ns = NULL_TREE;
2752 : 6053 : gcc_checking_assert (k.id);
2753 : 6053 : }
2754 : 369613306 : static bool is_empty (const value_type &k)
2755 : : {
2756 : 369544994 : return k.ns == NULL_TREE && k.id == NULL_TREE;
2757 : : }
2758 : 15054569 : static bool is_deleted (const value_type &k)
2759 : : {
2760 : 15054569 : return k.ns == NULL_TREE && k.id != NULL_TREE;
2761 : : }
2762 : : static void remove (value_type &)
2763 : : {
2764 : : }
2765 : : };
2766 : :
2767 : : typedef hash_map<pending_key, auto_vec<unsigned>> pending_map_t;
2768 : :
2769 : : /* Not-loaded entities that are keyed to a namespace-scope
2770 : : identifier. See module_state::write_pendings for details. */
2771 : : pending_map_t *pending_table;
2772 : :
2773 : : /* Decls that need some post processing once a batch of lazy loads has
2774 : : completed. */
2775 : : vec<tree, va_heap, vl_embed> *post_load_decls;
2776 : :
2777 : : /* Some entities are keyed to another entitity for ODR purposes.
2778 : : For example, at namespace scope, 'inline auto var = []{};', that
2779 : : lambda is keyed to 'var', and follows its ODRness. */
2780 : : typedef hash_map<tree, auto_vec<tree>> keyed_map_t;
2781 : : static keyed_map_t *keyed_table;
2782 : :
2783 : : /* Instantiations of temploid friends imported from another module
2784 : : need to be attached to the same module as the temploid. This maps
2785 : : these decls to the temploid they are instantiated them, as there is
2786 : : no other easy way to get this information. */
2787 : : static GTY((cache)) decl_tree_cache_map *imported_temploid_friends;
2788 : :
2789 : : /********************************************************************/
2790 : : /* Tree streaming. The tree streaming is very specific to the tree
2791 : : structures themselves. A tag indicates the kind of tree being
2792 : : streamed. -ve tags indicate backreferences to already-streamed
2793 : : trees. Backreferences are auto-numbered. */
2794 : :
2795 : : /* Tree tags. */
2796 : : enum tree_tag {
2797 : : tt_null, /* NULL_TREE. */
2798 : : tt_tu_local, /* A TU-local entity. */
2799 : : tt_fixed, /* Fixed vector index. */
2800 : :
2801 : : tt_node, /* By-value node. */
2802 : : tt_decl, /* By-value mergeable decl. */
2803 : : tt_tpl_parm, /* Template parm. */
2804 : :
2805 : : /* The ordering of the following 4 is relied upon in
2806 : : trees_out::tree_node. */
2807 : : tt_id, /* Identifier node. */
2808 : : tt_conv_id, /* Conversion operator name. */
2809 : : tt_anon_id, /* Anonymous name. */
2810 : : tt_lambda_id, /* Lambda name. */
2811 : :
2812 : : tt_typedef_type, /* A (possibly implicit) typedefed type. */
2813 : : tt_derived_type, /* A type derived from another type. */
2814 : : tt_variant_type, /* A variant of another type. */
2815 : :
2816 : : tt_tinfo_var, /* Typeinfo object. */
2817 : : tt_tinfo_typedef, /* Typeinfo typedef. */
2818 : : tt_ptrmem_type, /* Pointer to member type. */
2819 : : tt_nttp_var, /* NTTP_OBJECT VAR_DECL. */
2820 : :
2821 : : tt_parm, /* Function parameter or result. */
2822 : : tt_enum_value, /* An enum value. */
2823 : : tt_enum_decl, /* An enum decl. */
2824 : : tt_data_member, /* Data member/using-decl. */
2825 : :
2826 : : tt_binfo, /* A BINFO. */
2827 : : tt_vtable, /* A vtable. */
2828 : : tt_thunk, /* A thunk. */
2829 : : tt_clone_ref,
2830 : :
2831 : : tt_entity, /* A extra-cluster entity. */
2832 : :
2833 : : tt_template, /* The TEMPLATE_RESULT of a template. */
2834 : : };
2835 : :
2836 : : enum walk_kind {
2837 : : WK_none, /* No walk to do (a back- or fixed-ref happened). */
2838 : : WK_normal, /* Normal walk (by-name if possible). */
2839 : :
2840 : : WK_value, /* By-value walk. */
2841 : : };
2842 : :
2843 : : enum merge_kind
2844 : : {
2845 : : MK_unique, /* Known unique. */
2846 : : MK_named, /* Found by CTX, NAME + maybe_arg types etc. */
2847 : : MK_field, /* Found by CTX and index on TYPE_FIELDS */
2848 : : MK_vtable, /* Found by CTX and index on TYPE_VTABLES */
2849 : : MK_as_base, /* Found by CTX. */
2850 : :
2851 : : MK_partial,
2852 : :
2853 : : MK_enum, /* Found by CTX, & 1stMemberNAME. */
2854 : : MK_keyed, /* Found by key & index. */
2855 : : MK_local_type, /* Found by CTX, index. */
2856 : :
2857 : : MK_friend_spec, /* Like named, but has a tmpl & args too. */
2858 : : MK_local_friend, /* Found by CTX, index. */
2859 : :
2860 : : MK_indirect_lwm = MK_enum,
2861 : :
2862 : : /* Template specialization kinds below. These are all found via
2863 : : primary template and specialization args. */
2864 : : MK_template_mask = 0x10, /* A template specialization. */
2865 : :
2866 : : MK_tmpl_decl_mask = 0x4, /* In decl table. */
2867 : :
2868 : : MK_tmpl_tmpl_mask = 0x1, /* We want TEMPLATE_DECL. */
2869 : :
2870 : : MK_type_spec = MK_template_mask,
2871 : : MK_decl_spec = MK_template_mask | MK_tmpl_decl_mask,
2872 : :
2873 : : MK_hwm = 0x20
2874 : : };
2875 : : /* This is more than a debugging array. NULLs are used to determine
2876 : : an invalid merge_kind number. */
2877 : : static char const *const merge_kind_name[MK_hwm] =
2878 : : {
2879 : : "unique", "named", "field", "vtable", /* 0...3 */
2880 : : "asbase", "partial", "enum", "attached", /* 4...7 */
2881 : :
2882 : : "local type", "friend spec", "local friend", NULL, /* 8...11 */
2883 : : NULL, NULL, NULL, NULL,
2884 : :
2885 : : "type spec", "type tmpl spec", /* 16,17 type (template). */
2886 : : NULL, NULL,
2887 : :
2888 : : "decl spec", "decl tmpl spec", /* 20,21 decl (template). */
2889 : : NULL, NULL,
2890 : : NULL, NULL, NULL, NULL,
2891 : : NULL, NULL, NULL, NULL,
2892 : : };
2893 : :
2894 : : /* Mergeable entity location data. */
2895 : : struct merge_key {
2896 : : cp_ref_qualifier ref_q : 2;
2897 : : unsigned index;
2898 : :
2899 : : tree ret; /* Return type, if appropriate. */
2900 : : tree args; /* Arg types, if appropriate. */
2901 : :
2902 : : tree constraints; /* Constraints. */
2903 : :
2904 : 3708019 : merge_key ()
2905 : 3708019 : :ref_q (REF_QUAL_NONE), index (0),
2906 : 3708019 : ret (NULL_TREE), args (NULL_TREE),
2907 : 3708019 : constraints (NULL_TREE)
2908 : : {
2909 : : }
2910 : : };
2911 : :
2912 : : /* Hashmap of merged duplicates. Usually decls, but can contain
2913 : : BINFOs. */
2914 : : typedef hash_map<tree,uintptr_t,
2915 : : simple_hashmap_traits<nodel_ptr_hash<tree_node>,uintptr_t> >
2916 : : duplicate_hash_map;
2917 : :
2918 : : /* Data needed for post-processing. */
2919 : : struct post_process_data {
2920 : : tree decl;
2921 : : location_t start_locus;
2922 : : location_t end_locus;
2923 : : };
2924 : :
2925 : : /* Tree stream reader. Note that reading a stream doesn't mark the
2926 : : read trees with TREE_VISITED. Thus it's quite safe to have
2927 : : multiple concurrent readers. Which is good, because lazy
2928 : : loading.
2929 : :
2930 : : It's important that trees_in/out have internal linkage so that the
2931 : : compiler knows core_bools, lang_type_bools and lang_decl_bools have
2932 : : only a single caller (tree_node_bools) and inlines them appropriately. */
2933 : : namespace {
2934 : : class trees_in : public bytes_in {
2935 : : typedef bytes_in parent;
2936 : :
2937 : : private:
2938 : : module_state *state; /* Module being imported. */
2939 : : vec<tree> back_refs; /* Back references. */
2940 : : duplicate_hash_map *duplicates; /* Map from existings to duplicate. */
2941 : : vec<post_process_data> post_decls; /* Decls to post process. */
2942 : : unsigned unused; /* Inhibit any interior TREE_USED
2943 : : marking. */
2944 : :
2945 : : public:
2946 : : trees_in (module_state *);
2947 : : ~trees_in ();
2948 : :
2949 : : public:
2950 : : int insert (tree);
2951 : : tree back_ref (int);
2952 : :
2953 : : private:
2954 : : tree start (unsigned = 0);
2955 : :
2956 : : public:
2957 : : /* Needed for binfo writing */
2958 : : bool core_bools (tree, bits_in&);
2959 : :
2960 : : private:
2961 : : /* Stream tree_core, lang_decl_specific and lang_type_specific
2962 : : bits. */
2963 : : bool core_vals (tree);
2964 : : bool lang_type_bools (tree, bits_in&);
2965 : : bool lang_type_vals (tree);
2966 : : bool lang_decl_bools (tree, bits_in&);
2967 : : bool lang_decl_vals (tree);
2968 : : bool lang_vals (tree);
2969 : : bool tree_node_bools (tree);
2970 : : bool tree_node_vals (tree);
2971 : : tree tree_value ();
2972 : : tree decl_value ();
2973 : : tree tpl_parm_value ();
2974 : :
2975 : : private:
2976 : : tree chained_decls (); /* Follow DECL_CHAIN. */
2977 : : vec<tree, va_heap> *vec_chained_decls ();
2978 : : vec<tree, va_gc> *tree_vec (); /* vec of tree. */
2979 : : vec<tree_pair_s, va_gc> *tree_pair_vec (); /* vec of tree_pair. */
2980 : : tree tree_list (bool has_purpose);
2981 : :
2982 : : public:
2983 : : /* Read a tree node. */
2984 : : tree tree_node (bool is_use = false);
2985 : :
2986 : : private:
2987 : : bool install_entity (tree decl);
2988 : : tree tpl_parms (unsigned &tpl_levels);
2989 : : bool tpl_parms_fini (tree decl, unsigned tpl_levels);
2990 : : bool tpl_header (tree decl, unsigned *tpl_levels);
2991 : : int fn_parms_init (tree);
2992 : : void fn_parms_fini (int tag, tree fn, tree existing, bool has_defn);
2993 : : unsigned add_indirect_tpl_parms (tree);
2994 : : public:
2995 : : bool add_indirects (tree);
2996 : :
2997 : : public:
2998 : : /* Serialize various definitions. */
2999 : : bool read_definition (tree decl);
3000 : :
3001 : : private:
3002 : : bool is_matching_decl (tree existing, tree decl, bool is_typedef);
3003 : : static bool install_implicit_member (tree decl);
3004 : : bool read_function_def (tree decl, tree maybe_template);
3005 : : bool read_var_def (tree decl, tree maybe_template);
3006 : : bool read_class_def (tree decl, tree maybe_template);
3007 : : bool read_enum_def (tree decl, tree maybe_template);
3008 : :
3009 : : public:
3010 : : tree decl_container ();
3011 : : tree key_mergeable (int tag, merge_kind, tree decl, tree inner, tree type,
3012 : : tree container, bool is_attached,
3013 : : bool is_imported_temploid_friend);
3014 : : unsigned binfo_mergeable (tree *);
3015 : :
3016 : : private:
3017 : : tree key_local_type (const merge_key&, tree, tree);
3018 : : uintptr_t *find_duplicate (tree existing);
3019 : : void register_duplicate (tree decl, tree existing);
3020 : : /* Mark as an already diagnosed bad duplicate. */
3021 : 42 : void unmatched_duplicate (tree existing)
3022 : : {
3023 : 84 : *find_duplicate (existing) |= 1;
3024 : 42 : }
3025 : :
3026 : : public:
3027 : 270117 : bool is_duplicate (tree decl)
3028 : : {
3029 : 540234 : return find_duplicate (decl) != NULL;
3030 : : }
3031 : 241975 : tree maybe_duplicate (tree decl)
3032 : : {
3033 : 241975 : if (uintptr_t *dup = find_duplicate (decl))
3034 : 17280 : return reinterpret_cast<tree> (*dup & ~uintptr_t (1));
3035 : : return decl;
3036 : : }
3037 : : tree odr_duplicate (tree decl, bool has_defn);
3038 : :
3039 : : public:
3040 : : /* Return the decls to postprocess. */
3041 : : const vec<post_process_data>& post_process ()
3042 : : {
3043 : : return post_decls;
3044 : : }
3045 : : private:
3046 : : /* Register DATA for postprocessing. */
3047 : 137893 : void post_process (post_process_data data)
3048 : : {
3049 : 137893 : post_decls.safe_push (data);
3050 : : }
3051 : :
3052 : : private:
3053 : : void assert_definition (tree, bool installing);
3054 : : };
3055 : : } // anon namespace
3056 : :
3057 : 360566 : trees_in::trees_in (module_state *state)
3058 : 360566 : :parent (), state (state), unused (0)
3059 : : {
3060 : 360566 : duplicates = NULL;
3061 : 360566 : back_refs.create (500);
3062 : 360566 : post_decls.create (0);
3063 : 360566 : }
3064 : :
3065 : 360566 : trees_in::~trees_in ()
3066 : : {
3067 : 572570 : delete (duplicates);
3068 : 360566 : back_refs.release ();
3069 : 360566 : post_decls.release ();
3070 : 360566 : }
3071 : :
3072 : : /* Tree stream writer. */
3073 : : namespace {
3074 : : class trees_out : public bytes_out {
3075 : : typedef bytes_out parent;
3076 : :
3077 : : private:
3078 : : module_state *state; /* The module we are writing. */
3079 : : ptr_int_hash_map tree_map; /* Trees to references */
3080 : : depset::hash *dep_hash; /* Dependency table. */
3081 : : int ref_num; /* Back reference number. */
3082 : : unsigned section;
3083 : : bool writing_local_entities; /* Whether we might walk into a TU-local
3084 : : entity we need to emit placeholders for. */
3085 : : #if CHECKING_P
3086 : : int importedness; /* Checker that imports not occurring
3087 : : inappropriately. +ve imports ok,
3088 : : -ve imports not ok. */
3089 : : #endif
3090 : :
3091 : : public:
3092 : : trees_out (allocator *, module_state *, depset::hash &deps, unsigned sec = 0);
3093 : : ~trees_out ();
3094 : :
3095 : : private:
3096 : : void mark_trees ();
3097 : : void unmark_trees ();
3098 : :
3099 : : public:
3100 : : /* Hey, let's ignore the well known STL iterator idiom. */
3101 : : void begin ();
3102 : : unsigned end (elf_out *sink, unsigned name, unsigned *crc_ptr);
3103 : : void end ();
3104 : :
3105 : : public:
3106 : : enum tags
3107 : : {
3108 : : tag_backref = -1, /* Upper bound on the backrefs. */
3109 : : tag_value = 0, /* Write by value. */
3110 : : tag_fixed /* Lower bound on the fixed trees. */
3111 : : };
3112 : :
3113 : : public:
3114 : : /* The walk is used for three similar purposes:
3115 : :
3116 : : 1. The initial scan for dependencies.
3117 : : 2. Once dependencies have been found, ordering them.
3118 : : 3. Writing dependencies to file (streaming_p).
3119 : :
3120 : : For cases where it matters, these accessers can be used to determine
3121 : : which state we're in. */
3122 : 84589073 : bool is_initial_scan () const
3123 : : {
3124 : 143563884 : return !streaming_p () && !is_key_order ();
3125 : : }
3126 : 79689642 : bool is_key_order () const
3127 : : {
3128 : 58974811 : return dep_hash->is_key_order ();
3129 : : }
3130 : :
3131 : : public:
3132 : : int insert (tree, walk_kind = WK_normal);
3133 : :
3134 : : private:
3135 : : void start (tree, bool = false);
3136 : :
3137 : : private:
3138 : : walk_kind ref_node (tree);
3139 : : public:
3140 : : int get_tag (tree);
3141 : 762584 : void set_importing (int i ATTRIBUTE_UNUSED)
3142 : : {
3143 : : #if CHECKING_P
3144 : 762584 : importedness = i;
3145 : : #endif
3146 : : }
3147 : :
3148 : : private:
3149 : : void core_bools (tree, bits_out&);
3150 : : void core_vals (tree);
3151 : : void lang_type_bools (tree, bits_out&);
3152 : : void lang_type_vals (tree);
3153 : : void lang_decl_bools (tree, bits_out&);
3154 : : void lang_decl_vals (tree);
3155 : : void lang_vals (tree);
3156 : : void tree_node_bools (tree);
3157 : : void tree_node_vals (tree);
3158 : :
3159 : : private:
3160 : : void chained_decls (tree);
3161 : : void vec_chained_decls (tree);
3162 : : void tree_vec (vec<tree, va_gc> *);
3163 : : void tree_pair_vec (vec<tree_pair_s, va_gc> *);
3164 : : void tree_list (tree, bool has_purpose);
3165 : :
3166 : : private:
3167 : : bool has_tu_local_dep (tree) const;
3168 : : tree find_tu_local_decl (tree);
3169 : :
3170 : : public:
3171 : : /* Mark a node for by-value walking. */
3172 : : void mark_by_value (tree);
3173 : :
3174 : : public:
3175 : : void tree_node (tree);
3176 : :
3177 : : private:
3178 : : void install_entity (tree decl, depset *);
3179 : : void tpl_parms (tree parms, unsigned &tpl_levels);
3180 : : void tpl_parms_fini (tree decl, unsigned tpl_levels);
3181 : : void fn_parms_fini (tree) {}
3182 : : unsigned add_indirect_tpl_parms (tree);
3183 : : public:
3184 : : void add_indirects (tree);
3185 : : void fn_parms_init (tree);
3186 : : void tpl_header (tree decl, unsigned *tpl_levels);
3187 : :
3188 : : public:
3189 : : merge_kind get_merge_kind (tree decl, depset *maybe_dep);
3190 : : tree decl_container (tree decl);
3191 : : void key_mergeable (int tag, merge_kind, tree decl, tree inner,
3192 : : tree container, depset *maybe_dep);
3193 : : void binfo_mergeable (tree binfo);
3194 : :
3195 : : private:
3196 : : void key_local_type (merge_key&, tree, tree);
3197 : : bool decl_node (tree, walk_kind ref);
3198 : : void type_node (tree);
3199 : : void tree_value (tree);
3200 : : void tpl_parm_value (tree);
3201 : :
3202 : : public:
3203 : : void decl_value (tree, depset *);
3204 : :
3205 : : public:
3206 : : /* Serialize various definitions. */
3207 : : void write_definition (tree decl, bool refs_tu_local = false);
3208 : : void mark_declaration (tree decl, bool do_defn);
3209 : :
3210 : : private:
3211 : : void mark_function_def (tree decl);
3212 : : void mark_var_def (tree decl);
3213 : : void mark_class_def (tree decl);
3214 : : void mark_enum_def (tree decl);
3215 : : void mark_class_member (tree decl, bool do_defn = true);
3216 : : void mark_binfos (tree type);
3217 : :
3218 : : private:
3219 : : void write_var_def (tree decl);
3220 : : void write_function_def (tree decl);
3221 : : void write_class_def (tree decl);
3222 : : void write_enum_def (tree decl);
3223 : :
3224 : : private:
3225 : : static void assert_definition (tree);
3226 : :
3227 : : public:
3228 : : static void instrument ();
3229 : :
3230 : : private:
3231 : : /* Tree instrumentation. */
3232 : : static unsigned tree_val_count;
3233 : : static unsigned decl_val_count;
3234 : : static unsigned back_ref_count;
3235 : : static unsigned tu_local_count;
3236 : : static unsigned null_count;
3237 : : };
3238 : : } // anon namespace
3239 : :
3240 : : /* Instrumentation counters. */
3241 : : unsigned trees_out::tree_val_count;
3242 : : unsigned trees_out::decl_val_count;
3243 : : unsigned trees_out::back_ref_count;
3244 : : unsigned trees_out::tu_local_count;
3245 : : unsigned trees_out::null_count;
3246 : :
3247 : 766929 : trees_out::trees_out (allocator *mem, module_state *state, depset::hash &deps,
3248 : 766929 : unsigned section)
3249 : 1533858 : :parent (mem), state (state), tree_map (500),
3250 : 766929 : dep_hash (&deps), ref_num (0), section (section),
3251 : 766929 : writing_local_entities (false)
3252 : : {
3253 : : #if CHECKING_P
3254 : 766929 : importedness = 0;
3255 : : #endif
3256 : 766929 : }
3257 : :
3258 : 766929 : trees_out::~trees_out ()
3259 : : {
3260 : 766929 : }
3261 : :
3262 : : /********************************************************************/
3263 : : /* Location. We're aware of the line-map concept and reproduce it
3264 : : here. Each imported module allocates a contiguous span of ordinary
3265 : : maps, and of macro maps. adhoc maps are serialized by contents,
3266 : : not pre-allocated. The scattered linemaps of a module are
3267 : : coalesced when writing. */
3268 : :
3269 : :
3270 : : /* I use half-open [first,second) ranges. */
3271 : : typedef std::pair<line_map_uint_t,line_map_uint_t> range_t;
3272 : :
3273 : : /* A range of locations. */
3274 : : typedef std::pair<location_t,location_t> loc_range_t;
3275 : :
3276 : : /* Spans of the line maps that are occupied by this TU. I.e. not
3277 : : within imports. Only extended when in an interface unit.
3278 : : Interval zero corresponds to the forced header linemap(s). This
3279 : : is a singleton object. */
3280 : :
3281 : : class loc_spans {
3282 : : public:
3283 : : /* An interval of line maps. The line maps here represent a contiguous
3284 : : non-imported range. */
3285 : 4817 : struct span {
3286 : : loc_range_t ordinary; /* Ordinary map location range. */
3287 : : loc_range_t macro; /* Macro map location range. */
3288 : : /* Add to locs to get serialized loc. */
3289 : : location_diff_t ordinary_delta;
3290 : : location_diff_t macro_delta;
3291 : : };
3292 : :
3293 : : private:
3294 : : vec<span> *spans;
3295 : : bool locs_exhausted_p;
3296 : :
3297 : : public:
3298 : : loc_spans ()
3299 : : /* Do not preallocate spans, as that causes
3300 : : --enable-detailed-mem-stats problems. */
3301 : : : spans (nullptr), locs_exhausted_p (false)
3302 : : {
3303 : : }
3304 : 92107 : ~loc_spans ()
3305 : : {
3306 : 92107 : delete spans;
3307 : 92107 : }
3308 : :
3309 : : public:
3310 : 241 : span &operator[] (unsigned ix)
3311 : : {
3312 : 482 : return (*spans)[ix];
3313 : : }
3314 : : unsigned length () const
3315 : : {
3316 : : return spans->length ();
3317 : : }
3318 : :
3319 : : public:
3320 : 12467 : bool init_p () const
3321 : : {
3322 : 12467 : return spans != nullptr;
3323 : : }
3324 : : /* Initializer. */
3325 : : void init (const line_maps *lmaps, const line_map_ordinary *map);
3326 : :
3327 : : /* Slightly skewed preprocessed files can cause us to miss an
3328 : : initialization in some places. Fallback initializer. */
3329 : 4684 : void maybe_init ()
3330 : : {
3331 : 4684 : if (!init_p ())
3332 : 6 : init (line_table, nullptr);
3333 : 4684 : }
3334 : :
3335 : : public:
3336 : : enum {
3337 : : SPAN_RESERVED = 0, /* Reserved (fixed) locations. */
3338 : : SPAN_FIRST = 1, /* LWM of locations to stream */
3339 : : SPAN_MAIN = 2 /* Main file and onwards. */
3340 : : };
3341 : :
3342 : : public:
3343 : 449494 : location_t main_start () const
3344 : : {
3345 : 449494 : return (*spans)[SPAN_MAIN].ordinary.first;
3346 : : }
3347 : :
3348 : : public:
3349 : : void open (location_t);
3350 : : void close ();
3351 : :
3352 : : public:
3353 : : /* Propagate imported linemaps to us, if needed. */
3354 : : bool maybe_propagate (module_state *import, location_t loc);
3355 : :
3356 : : public:
3357 : : /* Whether we can no longer represent new imported locations. */
3358 : 0 : bool locations_exhausted_p () const
3359 : : {
3360 : 0 : return locs_exhausted_p;
3361 : : }
3362 : 0 : void report_location_exhaustion (location_t loc)
3363 : : {
3364 : 0 : if (!locs_exhausted_p)
3365 : : {
3366 : : /* Just give the notice once. */
3367 : 0 : locs_exhausted_p = true;
3368 : 0 : inform (loc, "unable to represent further imported source locations");
3369 : : }
3370 : : }
3371 : :
3372 : : public:
3373 : : const span *ordinary (location_t);
3374 : : const span *macro (location_t);
3375 : : };
3376 : :
3377 : : static loc_spans spans;
3378 : :
3379 : : /* Information about ordinary locations we stream out. */
3380 : : struct ord_loc_info
3381 : : {
3382 : : const line_map_ordinary *src; // line map we're based on
3383 : : line_map_uint_t offset; // offset to this line
3384 : : line_map_uint_t span; // number of locs we span
3385 : : line_map_uint_t remap; // serialization
3386 : :
3387 : 347894363 : static int compare (const void *a_, const void *b_)
3388 : : {
3389 : 347894363 : auto *a = static_cast<const ord_loc_info *> (a_);
3390 : 347894363 : auto *b = static_cast<const ord_loc_info *> (b_);
3391 : :
3392 : 347894363 : if (a->src != b->src)
3393 : 79117564 : return a->src < b->src ? -1 : +1;
3394 : :
3395 : : // Ensure no overlap
3396 : 294427021 : gcc_checking_assert (a->offset + a->span <= b->offset
3397 : : || b->offset + b->span <= a->offset);
3398 : :
3399 : 294427021 : gcc_checking_assert (a->offset != b->offset);
3400 : 294427021 : return a->offset < b->offset ? -1 : +1;
3401 : : }
3402 : : };
3403 : : struct ord_loc_traits
3404 : : {
3405 : : typedef ord_loc_info value_type;
3406 : : typedef value_type compare_type;
3407 : :
3408 : : static const bool empty_zero_p = false;
3409 : :
3410 : 142759032 : static hashval_t hash (const value_type &v)
3411 : : {
3412 : 120518005 : auto h = pointer_hash<const line_map_ordinary>::hash (v.src);
3413 : 142759032 : return iterative_hash_hashval_t (v.offset, h);
3414 : : }
3415 : 157533122 : static bool equal (const value_type &v, const compare_type p)
3416 : : {
3417 : 157533122 : return v.src == p.src && v.offset == p.offset;
3418 : : }
3419 : :
3420 : 10060004 : static void mark_empty (value_type &v)
3421 : : {
3422 : 10060004 : v.src = nullptr;
3423 : : }
3424 : 465785671 : static bool is_empty (value_type &v)
3425 : : {
3426 : 465785671 : return !v.src;
3427 : : }
3428 : :
3429 : : static bool is_deleted (value_type &) { return false; }
3430 : : static void mark_deleted (value_type &) { gcc_unreachable (); }
3431 : :
3432 : 2602551 : static void remove (value_type &) {}
3433 : : };
3434 : : /* Table keyed by ord_loc_info, used for noting. */
3435 : : static hash_table<ord_loc_traits> *ord_loc_table;
3436 : : /* Sorted vector, used for writing. */
3437 : : static vec<ord_loc_info> *ord_loc_remap;
3438 : :
3439 : : /* Information about macro locations we stream out. */
3440 : : struct macro_loc_info
3441 : : {
3442 : : const line_map_macro *src; // original expansion
3443 : : line_map_uint_t remap; // serialization
3444 : :
3445 : 16843876 : static int compare (const void *a_, const void *b_)
3446 : : {
3447 : 16843876 : auto *a = static_cast<const macro_loc_info *> (a_);
3448 : 16843876 : auto *b = static_cast<const macro_loc_info *> (b_);
3449 : :
3450 : 16843876 : gcc_checking_assert (MAP_START_LOCATION (a->src)
3451 : : != MAP_START_LOCATION (b->src));
3452 : 16843876 : if (MAP_START_LOCATION (a->src) < MAP_START_LOCATION (b->src))
3453 : : return -1;
3454 : : else
3455 : 8121314 : return +1;
3456 : : }
3457 : : };
3458 : : struct macro_loc_traits
3459 : : {
3460 : : typedef macro_loc_info value_type;
3461 : : typedef const line_map_macro *compare_type;
3462 : :
3463 : : static const bool empty_zero_p = false;
3464 : :
3465 : 16307291 : static hashval_t hash (compare_type p)
3466 : : {
3467 : 16307291 : return pointer_hash<const line_map_macro>::hash (p);
3468 : : }
3469 : 13883227 : static hashval_t hash (const value_type &v)
3470 : : {
3471 : 13883227 : return hash (v.src);
3472 : : }
3473 : : static bool equal (const value_type &v, const compare_type p)
3474 : : {
3475 : : return v.src == p;
3476 : : }
3477 : :
3478 : 1192907 : static void mark_empty (value_type &v)
3479 : : {
3480 : 1192907 : v.src = nullptr;
3481 : : }
3482 : 51086141 : static bool is_empty (value_type &v)
3483 : : {
3484 : 51086141 : return !v.src;
3485 : : }
3486 : :
3487 : : static bool is_deleted (value_type &) { return false; }
3488 : : static void mark_deleted (value_type &) { gcc_unreachable (); }
3489 : :
3490 : 284066 : static void remove (value_type &) {}
3491 : : };
3492 : : /* Table keyed by line_map_macro, used for noting. */
3493 : : static hash_table<macro_loc_traits> *macro_loc_table;
3494 : : /* Sorted vector, used for writing. */
3495 : : static vec<macro_loc_info> *macro_loc_remap;
3496 : :
3497 : : /* Indirection to allow bsearching imports by ordinary location. */
3498 : : static vec<module_state *> *ool;
3499 : :
3500 : : /********************************************************************/
3501 : : /* Data needed by a module during the process of loading. */
3502 : : struct GTY(()) slurping {
3503 : :
3504 : : /* Remap import's module numbering to our numbering. Values are
3505 : : shifted by 1. Bit0 encodes if the import is direct. */
3506 : : vec<unsigned, va_heap, vl_embed> *
3507 : : GTY((skip)) remap; /* Module owner remapping. */
3508 : :
3509 : : elf_in *GTY((skip)) from; /* The elf loader. */
3510 : :
3511 : : /* This map is only for header imports themselves -- the global
3512 : : headers bitmap hold it for the current TU. */
3513 : : bitmap headers; /* Transitive set of direct imports, including
3514 : : self. Used for macro visibility and
3515 : : priority. */
3516 : :
3517 : : /* These objects point into the mmapped area, unless we're not doing
3518 : : that, or we got frozen or closed. In those cases they point to
3519 : : buffers we own. */
3520 : : bytes_in macro_defs; /* Macro definitions. */
3521 : : bytes_in macro_tbl; /* Macro table. */
3522 : :
3523 : : /* Location remapping. first->ordinary, second->macro. */
3524 : : range_t GTY((skip)) loc_deltas;
3525 : :
3526 : : unsigned current; /* Section currently being loaded. */
3527 : : unsigned remaining; /* Number of lazy sections yet to read. */
3528 : : unsigned lru; /* An LRU counter. */
3529 : :
3530 : : public:
3531 : : slurping (elf_in *);
3532 : : ~slurping ();
3533 : :
3534 : : public:
3535 : : /* Close the ELF file, if it's open. */
3536 : 4245 : void close ()
3537 : : {
3538 : 4245 : if (from)
3539 : : {
3540 : 2307 : from->end ();
3541 : 4614 : delete from;
3542 : 2307 : from = NULL;
3543 : : }
3544 : 4245 : }
3545 : :
3546 : : public:
3547 : : void release_macros ();
3548 : :
3549 : : public:
3550 : 2359 : void alloc_remap (unsigned size)
3551 : : {
3552 : 2359 : gcc_assert (!remap);
3553 : 2359 : vec_safe_reserve (remap, size);
3554 : 5019 : for (unsigned ix = size; ix--;)
3555 : 2660 : remap->quick_push (0);
3556 : 2359 : }
3557 : 1756702 : unsigned remap_module (unsigned owner)
3558 : : {
3559 : 1756702 : if (owner < remap->length ())
3560 : 1756702 : return (*remap)[owner] >> 1;
3561 : : return 0;
3562 : : }
3563 : :
3564 : : public:
3565 : : /* GC allocation. But we must explicitly delete it. */
3566 : 2377 : static void *operator new (size_t x)
3567 : : {
3568 : 4754 : return ggc_alloc_atomic (x);
3569 : : }
3570 : 2307 : static void operator delete (void *p)
3571 : : {
3572 : 2307 : ggc_free (p);
3573 : 2307 : }
3574 : : };
3575 : :
3576 : 2377 : slurping::slurping (elf_in *from)
3577 : 2377 : : remap (NULL), from (from),
3578 : 2377 : headers (BITMAP_GGC_ALLOC ()), macro_defs (), macro_tbl (),
3579 : 2377 : loc_deltas (0, 0),
3580 : 2377 : current (~0u), remaining (0), lru (0)
3581 : : {
3582 : 2377 : }
3583 : :
3584 : 2307 : slurping::~slurping ()
3585 : : {
3586 : 2307 : vec_free (remap);
3587 : 2307 : remap = NULL;
3588 : 2307 : release_macros ();
3589 : 2307 : close ();
3590 : 2307 : }
3591 : :
3592 : 4245 : void slurping::release_macros ()
3593 : : {
3594 : 4245 : if (macro_defs.size)
3595 : 796 : elf_in::release (from, macro_defs);
3596 : 4245 : if (macro_tbl.size)
3597 : 0 : elf_in::release (from, macro_tbl);
3598 : 4245 : }
3599 : :
3600 : : /* Flags for extensions that end up being streamed. */
3601 : :
3602 : : enum streamed_extensions {
3603 : : SE_OPENMP = 1 << 0,
3604 : : SE_BITS = 1
3605 : : };
3606 : :
3607 : : /* Counter indices. */
3608 : : enum module_state_counts
3609 : : {
3610 : : MSC_sec_lwm,
3611 : : MSC_sec_hwm,
3612 : : MSC_pendings,
3613 : : MSC_entities,
3614 : : MSC_namespaces,
3615 : : MSC_bindings,
3616 : : MSC_macros,
3617 : : MSC_inits,
3618 : : MSC_HWM
3619 : : };
3620 : :
3621 : : /********************************************************************/
3622 : : struct module_state_config;
3623 : :
3624 : : /* Increasing levels of loadedness. */
3625 : : enum module_loadedness {
3626 : : ML_NONE, /* Not loaded. */
3627 : : ML_CONFIG, /* Config loaed. */
3628 : : ML_PREPROCESSOR, /* Preprocessor loaded. */
3629 : : ML_LANGUAGE, /* Language loaded. */
3630 : : };
3631 : :
3632 : : /* Increasing levels of directness (toplevel) of import. */
3633 : : enum module_directness {
3634 : : MD_NONE, /* Not direct. */
3635 : : MD_PARTITION_DIRECT, /* Direct import of a partition. */
3636 : : MD_DIRECT, /* Direct import. */
3637 : : MD_PURVIEW_DIRECT, /* direct import in purview. */
3638 : : };
3639 : :
3640 : : /* State of a particular module. */
3641 : :
3642 : : class GTY((chain_next ("%h.parent"), for_user)) module_state {
3643 : : public:
3644 : : /* We always import & export ourselves. */
3645 : : bitmap imports; /* Transitive modules we're importing. */
3646 : : bitmap exports; /* Subset of that, that we're exporting. */
3647 : :
3648 : : module_state *parent;
3649 : : tree name; /* Name of the module. */
3650 : :
3651 : : slurping *slurp; /* Data for loading. */
3652 : :
3653 : : const char *flatname; /* Flatname of module. */
3654 : : char *filename; /* CMI Filename */
3655 : :
3656 : : /* Indices into the entity_ary. */
3657 : : unsigned entity_lwm;
3658 : : unsigned entity_num;
3659 : :
3660 : : /* Location ranges for this module. adhoc-locs are decomposed, so
3661 : : don't have a range. */
3662 : : loc_range_t GTY((skip)) ordinary_locs;
3663 : : loc_range_t GTY((skip)) macro_locs; // [lwm,num)
3664 : :
3665 : : /* LOC is first set too the importing location. When initially
3666 : : loaded it refers to a module loc whose parent is the importing
3667 : : location. */
3668 : : location_t loc; /* Location referring to module itself. */
3669 : : unsigned crc; /* CRC we saw reading it in. */
3670 : :
3671 : : unsigned mod; /* Module owner number. */
3672 : : unsigned remap; /* Remapping during writing. */
3673 : :
3674 : : unsigned short subst; /* Mangle subst if !0. */
3675 : :
3676 : : /* How loaded this module is. */
3677 : : enum module_loadedness loadedness : 2;
3678 : :
3679 : : bool module_p : 1; /* /The/ module of this TU. */
3680 : : bool header_p : 1; /* Is a header unit. */
3681 : : bool interface_p : 1; /* An interface. */
3682 : : bool partition_p : 1; /* A partition. */
3683 : :
3684 : : /* How directly this module is imported. */
3685 : : enum module_directness directness : 2;
3686 : :
3687 : : bool exported_p : 1; /* directness != MD_NONE && exported. */
3688 : : bool cmi_noted_p : 1; /* We've told the user about the CMI, don't
3689 : : do it again */
3690 : : bool active_init_p : 1; /* This module's global initializer needs
3691 : : calling. */
3692 : : bool inform_cmi_p : 1; /* Inform of a read/write. */
3693 : : bool visited_p : 1; /* A walk-once flag. */
3694 : : /* Record extensions emitted or permitted. */
3695 : : unsigned extensions : SE_BITS;
3696 : : /* 14 bits used, 2 bits remain */
3697 : :
3698 : : public:
3699 : : module_state (tree name, module_state *, bool);
3700 : : ~module_state ();
3701 : :
3702 : : public:
3703 : 2371 : void release ()
3704 : : {
3705 : 2371 : imports = exports = NULL;
3706 : 2371 : slurped ();
3707 : 2307 : }
3708 : 4309 : void slurped ()
3709 : : {
3710 : 4309 : delete slurp;
3711 : 4309 : slurp = NULL;
3712 : 4309 : }
3713 : 2108263 : elf_in *from () const
3714 : : {
3715 : 2108263 : return slurp->from;
3716 : : }
3717 : :
3718 : : public:
3719 : : /* Kind of this module. */
3720 : 217896 : bool is_module () const
3721 : : {
3722 : 217896 : return module_p;
3723 : : }
3724 : 3030211 : bool is_header () const
3725 : : {
3726 : 3030211 : return header_p;
3727 : : }
3728 : 474 : bool is_interface () const
3729 : : {
3730 : 474 : return interface_p;
3731 : : }
3732 : 263852 : bool is_partition () const
3733 : : {
3734 : 263852 : return partition_p;
3735 : : }
3736 : :
3737 : : /* How this module is used in the current TU. */
3738 : 33 : bool is_exported () const
3739 : : {
3740 : 33 : return exported_p;
3741 : : }
3742 : 16450 : bool is_direct () const
3743 : : {
3744 : 16450 : return directness >= MD_DIRECT;
3745 : : }
3746 : 217 : bool is_purview_direct () const
3747 : : {
3748 : 217 : return directness == MD_PURVIEW_DIRECT;
3749 : : }
3750 : 328 : bool is_partition_direct () const
3751 : : {
3752 : 328 : return directness == MD_PARTITION_DIRECT;
3753 : : }
3754 : :
3755 : : public:
3756 : : /* Is this a real module? */
3757 : 13313 : bool has_location () const
3758 : : {
3759 : 13313 : return loc != UNKNOWN_LOCATION;
3760 : : }
3761 : :
3762 : : public:
3763 : : bool check_not_purview (location_t loc);
3764 : :
3765 : : public:
3766 : : void mangle (bool include_partition);
3767 : :
3768 : : public:
3769 : : void set_import (module_state const *, bool is_export);
3770 : : void announce (const char *) const;
3771 : :
3772 : : public:
3773 : : /* Read and write module. */
3774 : : bool write_begin (elf_out *to, cpp_reader *,
3775 : : module_state_config &, unsigned &crc);
3776 : : void write_end (elf_out *to, cpp_reader *,
3777 : : module_state_config &, unsigned &crc);
3778 : : bool read_initial (cpp_reader *);
3779 : : bool read_preprocessor (bool);
3780 : : bool read_language (bool);
3781 : :
3782 : : public:
3783 : : /* Read a section. */
3784 : : bool load_section (unsigned snum, binding_slot *mslot);
3785 : : /* Lazily read a section. */
3786 : : bool lazy_load (unsigned index, binding_slot *mslot);
3787 : :
3788 : : public:
3789 : : /* Juggle a limited number of file numbers. */
3790 : : static void freeze_an_elf ();
3791 : : bool maybe_defrost ();
3792 : :
3793 : : public:
3794 : : void maybe_completed_reading ();
3795 : : bool check_read (bool outermost, bool ok);
3796 : :
3797 : : private:
3798 : : /* The README, for human consumption. */
3799 : : void write_readme (elf_out *to, cpp_reader *, const char *dialect);
3800 : : void write_env (elf_out *to);
3801 : :
3802 : : private:
3803 : : /* Import tables. */
3804 : : void write_imports (bytes_out &cfg, bool direct);
3805 : : unsigned read_imports (bytes_in &cfg, cpp_reader *, line_maps *maps);
3806 : :
3807 : : private:
3808 : : void write_imports (elf_out *to, unsigned *crc_ptr);
3809 : : bool read_imports (cpp_reader *, line_maps *);
3810 : :
3811 : : private:
3812 : : void write_partitions (elf_out *to, unsigned, unsigned *crc_ptr);
3813 : : bool read_partitions (unsigned);
3814 : :
3815 : : private:
3816 : : void write_config (elf_out *to, struct module_state_config &, unsigned crc);
3817 : : bool read_config (struct module_state_config &);
3818 : : static void write_counts (elf_out *to, unsigned [MSC_HWM], unsigned *crc_ptr);
3819 : : bool read_counts (unsigned *);
3820 : :
3821 : : public:
3822 : : void note_cmi_name ();
3823 : :
3824 : : private:
3825 : : static unsigned write_bindings (elf_out *to, vec<depset *> depsets,
3826 : : unsigned *crc_ptr);
3827 : : bool read_bindings (unsigned count, unsigned lwm, unsigned hwm);
3828 : :
3829 : : static void write_namespace (bytes_out &sec, depset *ns_dep);
3830 : : tree read_namespace (bytes_in &sec);
3831 : :
3832 : : void write_namespaces (elf_out *to, vec<depset *> spaces,
3833 : : unsigned, unsigned *crc_ptr);
3834 : : bool read_namespaces (unsigned);
3835 : :
3836 : : void intercluster_seed (trees_out &sec, unsigned index, depset *dep);
3837 : : unsigned write_cluster (elf_out *to, depset *depsets[], unsigned size,
3838 : : depset::hash &, unsigned *counts, unsigned *crc_ptr);
3839 : : bool read_cluster (unsigned snum);
3840 : :
3841 : : private:
3842 : : unsigned write_inits (elf_out *to, depset::hash &, unsigned *crc_ptr);
3843 : : bool read_inits (unsigned count);
3844 : :
3845 : : private:
3846 : : unsigned write_pendings (elf_out *to, vec<depset *> depsets,
3847 : : depset::hash &, unsigned *crc_ptr);
3848 : : bool read_pendings (unsigned count);
3849 : :
3850 : : private:
3851 : : void write_entities (elf_out *to, vec<depset *> depsets,
3852 : : unsigned count, unsigned *crc_ptr);
3853 : : bool read_entities (unsigned count, unsigned lwm, unsigned hwm);
3854 : :
3855 : : private:
3856 : : void write_init_maps ();
3857 : : range_t write_prepare_maps (module_state_config *, bool);
3858 : : bool read_prepare_maps (const module_state_config *);
3859 : :
3860 : : void write_ordinary_maps (elf_out *to, range_t &,
3861 : : bool, unsigned *crc_ptr);
3862 : : bool read_ordinary_maps (line_map_uint_t, unsigned);
3863 : : void write_macro_maps (elf_out *to, range_t &, unsigned *crc_ptr);
3864 : : bool read_macro_maps (line_map_uint_t);
3865 : :
3866 : : private:
3867 : : void write_define (bytes_out &, const cpp_macro *);
3868 : : cpp_macro *read_define (bytes_in &, cpp_reader *) const;
3869 : : vec<cpp_hashnode *> *prepare_macros (cpp_reader *);
3870 : : unsigned write_macros (elf_out *to, vec<cpp_hashnode *> *, unsigned *crc_ptr);
3871 : : bool read_macros ();
3872 : : void install_macros ();
3873 : :
3874 : : public:
3875 : : void import_macros ();
3876 : :
3877 : : public:
3878 : : static void undef_macro (cpp_reader *, location_t, cpp_hashnode *);
3879 : : static cpp_macro *deferred_macro (cpp_reader *, location_t, cpp_hashnode *);
3880 : :
3881 : : public:
3882 : : static bool note_location (location_t);
3883 : : static void write_location (bytes_out &, location_t);
3884 : : location_t read_location (bytes_in &) const;
3885 : :
3886 : : public:
3887 : : void set_flatname ();
3888 : 39122 : const char *get_flatname () const
3889 : : {
3890 : 39122 : return flatname;
3891 : : }
3892 : : location_t imported_from () const;
3893 : :
3894 : : public:
3895 : : void set_filename (const Cody::Packet &);
3896 : : bool do_import (cpp_reader *, bool outermost);
3897 : : };
3898 : :
3899 : : /* Hash module state by name. This cannot be a member of
3900 : : module_state, because of GTY restrictions. We never delete from
3901 : : the hash table, but ggc_ptr_hash doesn't support that
3902 : : simplification. */
3903 : :
3904 : : struct module_state_hash : ggc_ptr_hash<module_state> {
3905 : : typedef std::pair<tree,uintptr_t> compare_type; /* {name,parent} */
3906 : :
3907 : : static inline hashval_t hash (const value_type m);
3908 : : static inline hashval_t hash (const compare_type &n);
3909 : : static inline bool equal (const value_type existing,
3910 : : const compare_type &candidate);
3911 : : };
3912 : :
3913 : 9208 : module_state::module_state (tree name, module_state *parent, bool partition)
3914 : 9208 : : imports (BITMAP_GGC_ALLOC ()), exports (BITMAP_GGC_ALLOC ()),
3915 : 9208 : parent (parent), name (name), slurp (NULL),
3916 : 9208 : flatname (NULL), filename (NULL),
3917 : 9208 : entity_lwm (~0u >> 1), entity_num (0),
3918 : 9208 : ordinary_locs (0, 0), macro_locs (0, 0),
3919 : 9208 : loc (UNKNOWN_LOCATION),
3920 : 9208 : crc (0), mod (MODULE_UNKNOWN), remap (0), subst (0)
3921 : : {
3922 : 9208 : loadedness = ML_NONE;
3923 : :
3924 : 9208 : module_p = header_p = interface_p = partition_p = false;
3925 : :
3926 : 9208 : directness = MD_NONE;
3927 : 9208 : exported_p = false;
3928 : :
3929 : 9208 : cmi_noted_p = false;
3930 : 9208 : active_init_p = false;
3931 : :
3932 : 9208 : partition_p = partition;
3933 : :
3934 : 9208 : inform_cmi_p = false;
3935 : 9208 : visited_p = false;
3936 : :
3937 : 9208 : extensions = 0;
3938 : 9208 : if (name && TREE_CODE (name) == STRING_CST)
3939 : : {
3940 : 1703 : header_p = true;
3941 : :
3942 : 1703 : const char *string = TREE_STRING_POINTER (name);
3943 : 1703 : gcc_checking_assert (string[0] == '.'
3944 : : ? IS_DIR_SEPARATOR (string[1])
3945 : : : IS_ABSOLUTE_PATH (string));
3946 : : }
3947 : :
3948 : 9208 : gcc_checking_assert (!(parent && header_p));
3949 : 9208 : }
3950 : :
3951 : 64 : module_state::~module_state ()
3952 : : {
3953 : 64 : release ();
3954 : 64 : }
3955 : :
3956 : : /* Hash module state. */
3957 : : static hashval_t
3958 : 13127 : module_name_hash (const_tree name)
3959 : : {
3960 : 13127 : if (TREE_CODE (name) == STRING_CST)
3961 : 3152 : return htab_hash_string (TREE_STRING_POINTER (name));
3962 : : else
3963 : 9975 : return IDENTIFIER_HASH_VALUE (name);
3964 : : }
3965 : :
3966 : : hashval_t
3967 : 3405 : module_state_hash::hash (const value_type m)
3968 : : {
3969 : 3405 : hashval_t ph = pointer_hash<void>::hash
3970 : 3405 : (reinterpret_cast<void *> (reinterpret_cast<uintptr_t> (m->parent)
3971 : 3405 : | m->is_partition ()));
3972 : 3405 : hashval_t nh = module_name_hash (m->name);
3973 : 3405 : return iterative_hash_hashval_t (ph, nh);
3974 : : }
3975 : :
3976 : : /* Hash a name. */
3977 : : hashval_t
3978 : 9722 : module_state_hash::hash (const compare_type &c)
3979 : : {
3980 : 9722 : hashval_t ph = pointer_hash<void>::hash (reinterpret_cast<void *> (c.second));
3981 : 9722 : hashval_t nh = module_name_hash (c.first);
3982 : :
3983 : 9722 : return iterative_hash_hashval_t (ph, nh);
3984 : : }
3985 : :
3986 : : bool
3987 : 6549 : module_state_hash::equal (const value_type existing,
3988 : : const compare_type &candidate)
3989 : : {
3990 : 6549 : uintptr_t ep = (reinterpret_cast<uintptr_t> (existing->parent)
3991 : 6549 : | existing->is_partition ());
3992 : 6549 : if (ep != candidate.second)
3993 : : return false;
3994 : :
3995 : : /* Identifier comparison is by pointer. If the string_csts happen
3996 : : to be the same object, then they're equal too. */
3997 : 5342 : if (existing->name == candidate.first)
3998 : : return true;
3999 : :
4000 : : /* If neither are string csts, they can't be equal. */
4001 : 1072 : if (TREE_CODE (candidate.first) != STRING_CST
4002 : 457 : || TREE_CODE (existing->name) != STRING_CST)
4003 : : return false;
4004 : :
4005 : : /* String equality. */
4006 : 396 : if (TREE_STRING_LENGTH (existing->name)
4007 : 396 : == TREE_STRING_LENGTH (candidate.first)
4008 : 396 : && !memcmp (TREE_STRING_POINTER (existing->name),
4009 : 393 : TREE_STRING_POINTER (candidate.first),
4010 : 393 : TREE_STRING_LENGTH (existing->name)))
4011 : 125 : return true;
4012 : :
4013 : : return false;
4014 : : }
4015 : :
4016 : : /********************************************************************/
4017 : : /* Global state */
4018 : :
4019 : : /* Mapper name. */
4020 : : static const char *module_mapper_name;
4021 : :
4022 : : /* Deferred import queue (FIFO). */
4023 : : static vec<module_state *, va_heap, vl_embed> *pending_imports;
4024 : :
4025 : : /* CMI repository path and workspace. */
4026 : : static char *cmi_repo;
4027 : : static size_t cmi_repo_length;
4028 : : static char *cmi_path;
4029 : : static size_t cmi_path_alloc;
4030 : :
4031 : : /* Count of available and loaded clusters. */
4032 : : static unsigned available_clusters;
4033 : : static unsigned loaded_clusters;
4034 : :
4035 : : /* What the current TU is. */
4036 : : unsigned module_kind;
4037 : :
4038 : : /* Global trees. */
4039 : : static const std::pair<tree *, unsigned> global_tree_arys[] =
4040 : : {
4041 : : std::pair<tree *, unsigned> (sizetype_tab, stk_type_kind_last),
4042 : : std::pair<tree *, unsigned> (integer_types, itk_none),
4043 : : std::pair<tree *, unsigned> (global_trees, TI_MODULE_HWM),
4044 : : std::pair<tree *, unsigned> (c_global_trees, CTI_MODULE_HWM),
4045 : : std::pair<tree *, unsigned> (cp_global_trees, CPTI_MODULE_HWM),
4046 : : std::pair<tree *, unsigned> (NULL, 0)
4047 : : };
4048 : : static GTY(()) vec<tree, va_gc> *fixed_trees;
4049 : : static unsigned global_crc;
4050 : :
4051 : : /* Lazy loading can open many files concurrently, there are
4052 : : per-process limits on that. We pay attention to the process limit,
4053 : : and attempt to increase it when we run out. Otherwise we use an
4054 : : LRU scheme to figure out who to flush. Note that if the import
4055 : : graph /depth/ exceeds lazy_limit, we'll exceed the limit. */
4056 : : static unsigned lazy_lru; /* LRU counter. */
4057 : : static unsigned lazy_open; /* Number of open modules */
4058 : : static unsigned lazy_limit; /* Current limit of open modules. */
4059 : : static unsigned lazy_hard_limit; /* Hard limit on open modules. */
4060 : : /* Account for source, assembler and dump files & directory searches.
4061 : : We don't keep the source file's open, so we don't have to account
4062 : : for #include depth. I think dump files are opened and closed per
4063 : : pass, but ICBW. */
4064 : : #define LAZY_HEADROOM 15 /* File descriptor headroom. */
4065 : :
4066 : : /* Vector of module state. Indexed by OWNER. Has at least 2 slots. */
4067 : : static GTY(()) vec<module_state *, va_gc> *modules;
4068 : :
4069 : : /* Hash of module state, findable by {name, parent}. */
4070 : : static GTY(()) hash_table<module_state_hash> *modules_hash;
4071 : :
4072 : : /* Map of imported entities. We map DECL_UID to index of entity
4073 : : vector. */
4074 : : typedef hash_map<unsigned/*UID*/, unsigned/*index*/,
4075 : : simple_hashmap_traits<int_hash<unsigned,0>, unsigned>
4076 : : > entity_map_t;
4077 : : static entity_map_t *entity_map;
4078 : : /* Doesn't need GTYing, because any tree referenced here is also
4079 : : findable by, symbol table, specialization table, return type of
4080 : : reachable function. */
4081 : : static vec<binding_slot, va_heap, vl_embed> *entity_ary;
4082 : :
4083 : : /* Members entities of imported classes that are defined in this TU.
4084 : : These are where the entity's context is not from the current TU.
4085 : : We need to emit the definition (but not the enclosing class).
4086 : :
4087 : : We could find these by walking ALL the imported classes that we
4088 : : could provide a member definition. But that's expensive,
4089 : : especially when you consider lazy implicit member declarations,
4090 : : which could be ANY imported class. */
4091 : : static GTY(()) vec<tree, va_gc> *class_members;
4092 : :
4093 : : /* The same problem exists for class template partial
4094 : : specializations. Now that we have constraints, the invariant of
4095 : : expecting them in the instantiation table no longer holds. One of
4096 : : the constrained partial specializations will be there, but the
4097 : : others not so much. It's not even an unconstrained partial
4098 : : spacialization in the table :( so any partial template declaration
4099 : : is added to this list too. */
4100 : : static GTY(()) vec<tree, va_gc> *partial_specializations;
4101 : :
4102 : : /********************************************************************/
4103 : :
4104 : : /* Our module mapper (created lazily). */
4105 : : module_client *mapper;
4106 : :
4107 : : static module_client *make_mapper (location_t loc, class mkdeps *deps);
4108 : 38250 : inline module_client *get_mapper (location_t loc, class mkdeps *deps)
4109 : : {
4110 : 38250 : auto *res = mapper;
4111 : 272 : if (!res)
4112 : 3881 : res = make_mapper (loc, deps);
4113 : 38250 : return res;
4114 : : }
4115 : :
4116 : : /********************************************************************/
4117 : : static tree
4118 : 464020 : get_clone_target (tree decl)
4119 : : {
4120 : 464020 : tree target;
4121 : :
4122 : 464020 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4123 : : {
4124 : 53044 : tree res_orig = DECL_CLONED_FUNCTION (DECL_TEMPLATE_RESULT (decl));
4125 : :
4126 : 53044 : target = DECL_TI_TEMPLATE (res_orig);
4127 : : }
4128 : : else
4129 : 410976 : target = DECL_CLONED_FUNCTION (decl);
4130 : :
4131 : 464020 : gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (target));
4132 : :
4133 : 464020 : return target;
4134 : : }
4135 : :
4136 : : /* Like FOR_EACH_CLONE, but will walk cloned templates. */
4137 : : #define FOR_EVERY_CLONE(CLONE, FN) \
4138 : : if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)); \
4139 : : else \
4140 : : for (CLONE = DECL_CHAIN (FN); \
4141 : : CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
4142 : : CLONE = DECL_CHAIN (CLONE))
4143 : :
4144 : : /* It'd be nice if USE_TEMPLATE was a field of template_info
4145 : : (a) it'd solve the enum case dealt with below,
4146 : : (b) both class templates and decl templates would store this in the
4147 : : same place
4148 : : (c) this function wouldn't need the by-ref arg, which is annoying. */
4149 : :
4150 : : static tree
4151 : 181849665 : node_template_info (tree decl, int &use)
4152 : : {
4153 : 181849665 : tree ti = NULL_TREE;
4154 : 181849665 : int use_tpl = -1;
4155 : 181849665 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
4156 : : {
4157 : 21292953 : tree type = TREE_TYPE (decl);
4158 : :
4159 : 21292953 : ti = TYPE_TEMPLATE_INFO (type);
4160 : 21292953 : if (ti)
4161 : : {
4162 : 5823633 : if (TYPE_LANG_SPECIFIC (type))
4163 : 5815141 : use_tpl = CLASSTYPE_USE_TEMPLATE (type);
4164 : : else
4165 : : {
4166 : : /* An enum, where we don't explicitly encode use_tpl.
4167 : : If the containing context (a type or a function), is
4168 : : an ({im,ex}plicit) instantiation, then this is too.
4169 : : If it's a partial or explicit specialization, then
4170 : : this is not!. */
4171 : 8492 : tree ctx = CP_DECL_CONTEXT (decl);
4172 : 8492 : if (TYPE_P (ctx))
4173 : 8308 : ctx = TYPE_NAME (ctx);
4174 : 8492 : node_template_info (ctx, use);
4175 : 8492 : use_tpl = use != 2 ? use : 0;
4176 : : }
4177 : : }
4178 : : }
4179 : 160556712 : else if (DECL_LANG_SPECIFIC (decl)
4180 : 160556712 : && (VAR_P (decl)
4181 : : || TREE_CODE (decl) == TYPE_DECL
4182 : : || TREE_CODE (decl) == FUNCTION_DECL
4183 : : || TREE_CODE (decl) == FIELD_DECL
4184 : : || TREE_CODE (decl) == CONCEPT_DECL
4185 : : || TREE_CODE (decl) == TEMPLATE_DECL))
4186 : : {
4187 : 88361808 : use_tpl = DECL_USE_TEMPLATE (decl);
4188 : 88361808 : ti = DECL_TEMPLATE_INFO (decl);
4189 : : }
4190 : :
4191 : 181849665 : use = use_tpl;
4192 : 181849665 : return ti;
4193 : : }
4194 : :
4195 : : /* Find the index in entity_ary for an imported DECL. It should
4196 : : always be there, but bugs can cause it to be missing, and that can
4197 : : crash the crash reporting -- let's not do that! When streaming
4198 : : out we place entities from this module there too -- with negated
4199 : : indices. */
4200 : :
4201 : : static unsigned
4202 : 1733895 : import_entity_index (tree decl, bool null_ok = false)
4203 : : {
4204 : 1733895 : if (unsigned *slot = entity_map->get (DECL_UID (decl)))
4205 : 1733850 : return *slot;
4206 : :
4207 : 45 : gcc_checking_assert (null_ok);
4208 : : return ~(~0u >> 1);
4209 : : }
4210 : :
4211 : : /* Find the module for an imported entity at INDEX in the entity ary.
4212 : : There must be one. */
4213 : :
4214 : : static module_state *
4215 : 34250 : import_entity_module (unsigned index)
4216 : : {
4217 : 34250 : if (index > ~(~0u >> 1))
4218 : : /* This is an index for an exported entity. */
4219 : 18 : return (*modules)[0];
4220 : :
4221 : : /* Do not include the current TU (not an off-by-one error). */
4222 : 34232 : unsigned pos = 1;
4223 : 34232 : unsigned len = modules->length () - pos;
4224 : 75335 : while (len)
4225 : : {
4226 : 41103 : unsigned half = len / 2;
4227 : 41103 : module_state *probe = (*modules)[pos + half];
4228 : 41103 : if (index < probe->entity_lwm)
4229 : : len = half;
4230 : 34350 : else if (index < probe->entity_lwm + probe->entity_num)
4231 : : return probe;
4232 : : else
4233 : : {
4234 : 118 : pos += half + 1;
4235 : 118 : len = len - (half + 1);
4236 : : }
4237 : : }
4238 : 0 : gcc_unreachable ();
4239 : : }
4240 : :
4241 : :
4242 : : /********************************************************************/
4243 : : /* A dumping machinery. */
4244 : :
4245 : : class dumper {
4246 : : public:
4247 : : enum {
4248 : : LOCATION = TDF_LINENO, /* -lineno:Source location streaming. */
4249 : : DEPEND = TDF_GRAPH, /* -graph:Dependency graph construction. */
4250 : : CLUSTER = TDF_BLOCKS, /* -blocks:Clusters. */
4251 : : TREE = TDF_UID, /* -uid:Tree streaming. */
4252 : : MERGE = TDF_ALIAS, /* -alias:Mergeable Entities. */
4253 : : ELF = TDF_ASMNAME, /* -asmname:Elf data. */
4254 : : MACRO = TDF_VOPS /* -vops:Macros. */
4255 : : };
4256 : :
4257 : : private:
4258 : : struct impl {
4259 : : typedef vec<module_state *, va_heap, vl_embed> stack_t;
4260 : :
4261 : : FILE *stream; /* Dump stream. */
4262 : : unsigned indent; /* Local indentation. */
4263 : : bool bol; /* Beginning of line. */
4264 : : stack_t stack; /* Trailing array of module_state. */
4265 : :
4266 : : bool nested_name (tree); /* Dump a name following DECL_CONTEXT. */
4267 : : };
4268 : :
4269 : : public:
4270 : : /* The dumper. */
4271 : : impl *dumps;
4272 : : dump_flags_t flags;
4273 : :
4274 : : public:
4275 : : /* Push/pop module state dumping. */
4276 : : unsigned push (module_state *);
4277 : : void pop (unsigned);
4278 : :
4279 : : public:
4280 : : /* Change local indentation. */
4281 : 498190288 : void indent ()
4282 : : {
4283 : 282 : if (dumps)
4284 : 7784170 : dumps->indent++;
4285 : : }
4286 : 498190288 : void outdent ()
4287 : : {
4288 : 498190288 : if (dumps)
4289 : : {
4290 : 7784170 : gcc_checking_assert (dumps->indent);
4291 : 7784170 : dumps->indent--;
4292 : : }
4293 : 498190288 : }
4294 : :
4295 : : public:
4296 : : /* Is dump enabled?. */
4297 : 318594635 : bool operator () (int mask = 0)
4298 : : {
4299 : 8905756 : if (!dumps || !dumps->stream)
4300 : : return false;
4301 : 3584543 : if (mask && !(mask & flags))
4302 : 31216 : return false;
4303 : : return true;
4304 : : }
4305 : : /* Dump some information. */
4306 : : bool operator () (const char *, ...);
4307 : : };
4308 : :
4309 : : /* The dumper. */
4310 : : static dumper dump = {0, dump_flags_t (0)};
4311 : :
4312 : : /* Push to dumping M. Return previous indentation level. */
4313 : :
4314 : : unsigned
4315 : 102182 : dumper::push (module_state *m)
4316 : : {
4317 : 102182 : FILE *stream = NULL;
4318 : 102182 : if (!dumps || !dumps->stack.length ())
4319 : : {
4320 : 101100 : stream = dump_begin (module_dump_id, &flags);
4321 : 101100 : if (!stream)
4322 : : return 0;
4323 : : }
4324 : :
4325 : 6029 : if (!dumps || !dumps->stack.space (1))
4326 : : {
4327 : : /* Create or extend the dump implementor. */
4328 : 1050 : unsigned current = dumps ? dumps->stack.length () : 0;
4329 : 552 : unsigned count = current ? current * 2 : EXPERIMENT (1, 20);
4330 : 1050 : size_t alloc = (offsetof (impl, stack)
4331 : 1050 : + impl::stack_t::embedded_size (count));
4332 : 1050 : dumps = XRESIZEVAR (impl, dumps, alloc);
4333 : 1050 : dumps->stack.embedded_init (count, current);
4334 : : }
4335 : 6029 : if (stream)
4336 : 4947 : dumps->stream = stream;
4337 : :
4338 : 6029 : unsigned n = dumps->indent;
4339 : 6029 : dumps->indent = 0;
4340 : 6029 : dumps->bol = true;
4341 : 6029 : dumps->stack.quick_push (m);
4342 : 6029 : if (m)
4343 : : {
4344 : 1731 : module_state *from = NULL;
4345 : :
4346 : 1731 : if (dumps->stack.length () > 1)
4347 : 548 : from = dumps->stack[dumps->stack.length () - 2];
4348 : : else
4349 : 1183 : dump ("");
4350 : 3150 : dump (from ? "Starting module %M (from %M)"
4351 : : : "Starting module %M", m, from);
4352 : : }
4353 : :
4354 : : return n;
4355 : : }
4356 : :
4357 : : /* Pop from dumping. Restore indentation to N. */
4358 : :
4359 : 102148 : void dumper::pop (unsigned n)
4360 : : {
4361 : 102148 : if (!dumps)
4362 : : return;
4363 : :
4364 : 12058 : gcc_checking_assert (dump () && !dumps->indent);
4365 : 6029 : if (module_state *m = dumps->stack[dumps->stack.length () - 1])
4366 : : {
4367 : 1731 : module_state *from = (dumps->stack.length () > 1
4368 : 1731 : ? dumps->stack[dumps->stack.length () - 2] : NULL);
4369 : 1967 : dump (from ? "Finishing module %M (returning to %M)"
4370 : : : "Finishing module %M", m, from);
4371 : : }
4372 : 6029 : dumps->stack.pop ();
4373 : 6029 : dumps->indent = n;
4374 : 6029 : if (!dumps->stack.length ())
4375 : : {
4376 : 4947 : dump_end (module_dump_id, dumps->stream);
4377 : 4947 : dumps->stream = NULL;
4378 : : }
4379 : : }
4380 : :
4381 : : /* Dump a nested name for arbitrary tree T. Sometimes it won't have a
4382 : : name. */
4383 : :
4384 : : bool
4385 : 2041573 : dumper::impl::nested_name (tree t)
4386 : : {
4387 : 2041573 : tree ti = NULL_TREE;
4388 : 2041573 : int origin = -1;
4389 : 2041573 : tree name = NULL_TREE;
4390 : :
4391 : 2041573 : if (t && TREE_CODE (t) == TU_LOCAL_ENTITY)
4392 : 0 : t = TU_LOCAL_ENTITY_NAME (t);
4393 : :
4394 : 2041549 : if (t && TREE_CODE (t) == TREE_BINFO)
4395 : 378 : t = BINFO_TYPE (t);
4396 : :
4397 : 2041573 : if (t && TYPE_P (t))
4398 : 965256 : t = TYPE_NAME (t);
4399 : :
4400 : 2041537 : if (t && DECL_P (t))
4401 : : {
4402 : 1874986 : if (t == global_namespace || DECL_TEMPLATE_PARM_P (t))
4403 : : ;
4404 : 1705357 : else if (tree ctx = DECL_CONTEXT (t))
4405 : 1357313 : if (TREE_CODE (ctx) == TRANSLATION_UNIT_DECL
4406 : 1357313 : || nested_name (ctx))
4407 : 1357313 : fputs ("::", stream);
4408 : :
4409 : 1874986 : int use_tpl;
4410 : 1874986 : ti = node_template_info (t, use_tpl);
4411 : 509782 : if (ti && TREE_CODE (TI_TEMPLATE (ti)) == TEMPLATE_DECL
4412 : 2384714 : && (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == t))
4413 : : t = TI_TEMPLATE (ti);
4414 : 1874986 : tree not_tmpl = t;
4415 : 1874986 : if (TREE_CODE (t) == TEMPLATE_DECL)
4416 : : {
4417 : 186300 : fputs ("template ", stream);
4418 : 186300 : not_tmpl = DECL_TEMPLATE_RESULT (t);
4419 : : }
4420 : :
4421 : 186300 : if (not_tmpl
4422 : 1874946 : && DECL_P (not_tmpl)
4423 : 1874946 : && DECL_LANG_SPECIFIC (not_tmpl)
4424 : 1112436 : && DECL_MODULE_IMPORT_P (not_tmpl))
4425 : : {
4426 : : /* We need to be careful here, so as to not explode on
4427 : : inconsistent data -- we're probably debugging, because
4428 : : Something Is Wrong. */
4429 : 16350 : unsigned index = import_entity_index (t, true);
4430 : 16350 : if (!(index & ~(~0u >> 1)))
4431 : 15792 : origin = import_entity_module (index)->mod;
4432 : 558 : else if (index > ~(~0u >> 1))
4433 : : /* An imported partition member that we're emitting. */
4434 : : origin = 0;
4435 : : else
4436 : 45 : origin = -2;
4437 : : }
4438 : :
4439 : 1874986 : name = DECL_NAME (t) ? DECL_NAME (t)
4440 : 7148 : : HAS_DECL_ASSEMBLER_NAME_P (t) ? DECL_ASSEMBLER_NAME_RAW (t)
4441 : : : NULL_TREE;
4442 : : }
4443 : : else
4444 : : name = t;
4445 : :
4446 : 1874986 : if (name)
4447 : 1967446 : switch (TREE_CODE (name))
4448 : : {
4449 : 29274 : default:
4450 : 29274 : fputs ("#unnamed#", stream);
4451 : 29274 : break;
4452 : :
4453 : 1894490 : case IDENTIFIER_NODE:
4454 : 1894490 : fwrite (IDENTIFIER_POINTER (name), 1, IDENTIFIER_LENGTH (name), stream);
4455 : 1894490 : break;
4456 : :
4457 : 43607 : case INTEGER_CST:
4458 : 43607 : print_hex (wi::to_wide (name), stream);
4459 : 43607 : break;
4460 : :
4461 : 75 : case STRING_CST:
4462 : : /* If TREE_TYPE is NULL, this is a raw string. */
4463 : 150 : fwrite (TREE_STRING_POINTER (name), 1,
4464 : 75 : TREE_STRING_LENGTH (name) - (TREE_TYPE (name) != NULL_TREE),
4465 : : stream);
4466 : 75 : break;
4467 : : }
4468 : : else
4469 : 74127 : fputs ("#null#", stream);
4470 : :
4471 : 2041573 : if (origin >= 0)
4472 : : {
4473 : 16305 : const module_state *module = (*modules)[origin];
4474 : 32610 : fprintf (stream, "@%s:%d", !module ? "" : !module->name ? "(unnamed)"
4475 : 16305 : : module->get_flatname (), origin);
4476 : : }
4477 : 2025268 : else if (origin == -2)
4478 : 45 : fprintf (stream, "@???");
4479 : :
4480 : 2041573 : if (ti)
4481 : : {
4482 : 509782 : tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (ti));
4483 : 509782 : fputs ("<", stream);
4484 : 509782 : if (args)
4485 : 1323622 : for (int ix = 0; ix != TREE_VEC_LENGTH (args); ix++)
4486 : : {
4487 : 813840 : if (ix)
4488 : 304070 : fputs (",", stream);
4489 : 813840 : nested_name (TREE_VEC_ELT (args, ix));
4490 : : }
4491 : 509782 : fputs (">", stream);
4492 : : }
4493 : :
4494 : 2041573 : return true;
4495 : : }
4496 : :
4497 : : /* Formatted dumping. FORMAT begins with '+' do not emit a trailing
4498 : : new line. (Normally it is appended.)
4499 : : Escapes:
4500 : : %C - tree_code
4501 : : %I - identifier
4502 : : %K - location_t or line_map_uint_t
4503 : : %M - module_state
4504 : : %N - name -- DECL_NAME
4505 : : %P - context:name pair
4506 : : %R - unsigned:unsigned ratio
4507 : : %S - symbol -- DECL_ASSEMBLER_NAME
4508 : : %U - long unsigned
4509 : : %V - version
4510 : : --- the following are printf-like, but without its flexibility
4511 : : %d - decimal int
4512 : : %p - pointer
4513 : : %s - string
4514 : : %u - unsigned int
4515 : : %x - hex int
4516 : :
4517 : : We do not implement the printf modifiers. */
4518 : :
4519 : : bool
4520 : 672859 : dumper::operator () (const char *format, ...)
4521 : : {
4522 : 672859 : if (!(*this) ())
4523 : : return false;
4524 : :
4525 : 623548 : bool no_nl = format[0] == '+';
4526 : 623548 : format += no_nl;
4527 : :
4528 : 623548 : if (dumps->bol)
4529 : : {
4530 : : /* Module import indent. */
4531 : 465682 : if (unsigned depth = dumps->stack.length () - 1)
4532 : : {
4533 : 18783 : const char *prefix = ">>>>";
4534 : 37566 : fprintf (dumps->stream, (depth <= strlen (prefix)
4535 : 18783 : ? &prefix[strlen (prefix) - depth]
4536 : : : ">.%d.>"), depth);
4537 : : }
4538 : :
4539 : : /* Local indent. */
4540 : 465682 : if (unsigned indent = dumps->indent)
4541 : : {
4542 : 349366 : const char *prefix = " ";
4543 : 657944 : fprintf (dumps->stream, (indent <= strlen (prefix)
4544 : 308578 : ? &prefix[strlen (prefix) - indent]
4545 : : : " .%d. "), indent);
4546 : : }
4547 : 465682 : dumps->bol = false;
4548 : : }
4549 : :
4550 : 623548 : va_list args;
4551 : 623548 : va_start (args, format);
4552 : 2329892 : while (const char *esc = strchr (format, '%'))
4553 : : {
4554 : 1706344 : fwrite (format, 1, (size_t)(esc - format), dumps->stream);
4555 : 1706344 : format = ++esc;
4556 : 1706344 : switch (*format++)
4557 : : {
4558 : 0 : default:
4559 : 0 : gcc_unreachable ();
4560 : :
4561 : 498 : case '%':
4562 : 498 : fputc ('%', dumps->stream);
4563 : 498 : break;
4564 : :
4565 : 359075 : case 'C': /* Code */
4566 : 359075 : {
4567 : 359075 : tree_code code = (tree_code)va_arg (args, unsigned);
4568 : 359075 : fputs (get_tree_code_name (code), dumps->stream);
4569 : : }
4570 : 359075 : break;
4571 : :
4572 : 81 : case 'I': /* Identifier. */
4573 : 81 : {
4574 : 81 : tree t = va_arg (args, tree);
4575 : 81 : dumps->nested_name (t);
4576 : : }
4577 : 81 : break;
4578 : :
4579 : 3938 : case 'K': /* location_t, either 32- or 64-bit. */
4580 : 3938 : {
4581 : 3938 : unsigned long long u = va_arg (args, location_t);
4582 : 3938 : fprintf (dumps->stream, "%llu", u);
4583 : : }
4584 : 3938 : break;
4585 : :
4586 : 6671 : case 'M': /* Module. */
4587 : 6671 : {
4588 : 6671 : const char *str = "(none)";
4589 : 6671 : if (module_state *m = va_arg (args, module_state *))
4590 : : {
4591 : 6671 : if (!m->has_location ())
4592 : : str = "(detached)";
4593 : : else
4594 : 6671 : str = m->get_flatname ();
4595 : : }
4596 : 6671 : fputs (str, dumps->stream);
4597 : : }
4598 : 6671 : break;
4599 : :
4600 : 401542 : case 'N': /* Name. */
4601 : 401542 : {
4602 : 401542 : tree t = va_arg (args, tree);
4603 : 803540 : while (t && TREE_CODE (t) == OVERLOAD)
4604 : 456 : t = OVL_FUNCTION (t);
4605 : 401542 : fputc ('\'', dumps->stream);
4606 : 401542 : dumps->nested_name (t);
4607 : 401542 : fputc ('\'', dumps->stream);
4608 : : }
4609 : 401542 : break;
4610 : :
4611 : 19767 : case 'P': /* Pair. */
4612 : 19767 : {
4613 : 19767 : tree ctx = va_arg (args, tree);
4614 : 19767 : tree name = va_arg (args, tree);
4615 : 19767 : fputc ('\'', dumps->stream);
4616 : 19767 : dumps->nested_name (ctx);
4617 : 19767 : if (ctx && ctx != global_namespace)
4618 : 14114 : fputs ("::", dumps->stream);
4619 : 19767 : dumps->nested_name (name);
4620 : 19767 : fputc ('\'', dumps->stream);
4621 : : }
4622 : 19767 : break;
4623 : :
4624 : 723 : case 'R': /* Ratio */
4625 : 723 : {
4626 : 723 : unsigned a = va_arg (args, unsigned);
4627 : 723 : unsigned b = va_arg (args, unsigned);
4628 : 723 : fprintf (dumps->stream, "%.1f", (float) a / (b + !b));
4629 : : }
4630 : 723 : break;
4631 : :
4632 : 32850 : case 'S': /* Symbol name */
4633 : 32850 : {
4634 : 32850 : tree t = va_arg (args, tree);
4635 : 32850 : if (t && TYPE_P (t))
4636 : 11772 : t = TYPE_NAME (t);
4637 : 31416 : if (t && HAS_DECL_ASSEMBLER_NAME_P (t)
4638 : 29985 : && DECL_ASSEMBLER_NAME_SET_P (t))
4639 : : {
4640 : 180 : fputc ('(', dumps->stream);
4641 : 180 : fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)),
4642 : 180 : dumps->stream);
4643 : 180 : fputc (')', dumps->stream);
4644 : : }
4645 : : }
4646 : : break;
4647 : :
4648 : 0 : case 'U': /* long unsigned. */
4649 : 0 : {
4650 : 0 : unsigned long u = va_arg (args, unsigned long);
4651 : 0 : fprintf (dumps->stream, "%lu", u);
4652 : : }
4653 : 0 : break;
4654 : :
4655 : 696 : case 'V': /* Version. */
4656 : 696 : {
4657 : 696 : unsigned v = va_arg (args, unsigned);
4658 : 696 : verstr_t string;
4659 : :
4660 : 696 : version2string (v, string);
4661 : 696 : fputs (string, dumps->stream);
4662 : : }
4663 : 696 : break;
4664 : :
4665 : 0 : case 'c': /* Character. */
4666 : 0 : {
4667 : 0 : int c = va_arg (args, int);
4668 : 0 : fputc (c, dumps->stream);
4669 : : }
4670 : 0 : break;
4671 : :
4672 : 56964 : case 'd': /* Decimal Int. */
4673 : 56964 : {
4674 : 56964 : int d = va_arg (args, int);
4675 : 56964 : fprintf (dumps->stream, "%d", d);
4676 : : }
4677 : 56964 : break;
4678 : :
4679 : 0 : case 'p': /* Pointer. */
4680 : 0 : {
4681 : 0 : void *p = va_arg (args, void *);
4682 : 0 : fprintf (dumps->stream, "%p", p);
4683 : : }
4684 : 0 : break;
4685 : :
4686 : 484863 : case 's': /* String. */
4687 : 484863 : {
4688 : 484863 : const char *s = va_arg (args, char *);
4689 : 484863 : gcc_checking_assert (s);
4690 : 484863 : fputs (s, dumps->stream);
4691 : : }
4692 : 484863 : break;
4693 : :
4694 : 336443 : case 'u': /* Unsigned. */
4695 : 336443 : {
4696 : 336443 : unsigned u = va_arg (args, unsigned);
4697 : 336443 : fprintf (dumps->stream, "%u", u);
4698 : : }
4699 : 336443 : break;
4700 : :
4701 : 2233 : case 'x': /* Hex. */
4702 : 2233 : {
4703 : 2233 : unsigned x = va_arg (args, unsigned);
4704 : 2233 : fprintf (dumps->stream, "%x", x);
4705 : : }
4706 : 2233 : break;
4707 : : }
4708 : : }
4709 : 623548 : fputs (format, dumps->stream);
4710 : 623548 : va_end (args);
4711 : 623548 : if (!no_nl)
4712 : : {
4713 : 465682 : dumps->bol = true;
4714 : 465682 : fputc ('\n', dumps->stream);
4715 : : }
4716 : : return true;
4717 : : }
4718 : :
4719 : : struct note_def_cache_hasher : ggc_cache_ptr_hash<tree_node>
4720 : : {
4721 : 244039 : static int keep_cache_entry (tree t)
4722 : : {
4723 : 244039 : if (!CHECKING_P)
4724 : : /* GTY is unfortunately not clever enough to conditionalize
4725 : : this. */
4726 : : gcc_unreachable ();
4727 : :
4728 : 244039 : if (ggc_marked_p (t))
4729 : : return -1;
4730 : :
4731 : 0 : unsigned n = dump.push (NULL);
4732 : : /* This might or might not be an error. We should note its
4733 : : dropping whichever. */
4734 : 0 : dump () && dump ("Dropping %N from note_defs table", t);
4735 : 0 : dump.pop (n);
4736 : :
4737 : 0 : return 0;
4738 : : }
4739 : : };
4740 : :
4741 : : /* We should stream each definition at most once.
4742 : : This needs to be a cache because there are cases where a definition
4743 : : ends up being not retained, and we need to drop those so we don't
4744 : : get confused if memory is reallocated. */
4745 : : typedef hash_table<note_def_cache_hasher> note_defs_table_t;
4746 : : static GTY((cache)) note_defs_table_t *note_defs;
4747 : :
4748 : : void
4749 : 489206 : trees_in::assert_definition (tree decl ATTRIBUTE_UNUSED,
4750 : : bool installing ATTRIBUTE_UNUSED)
4751 : : {
4752 : : #if CHECKING_P
4753 : 489206 : tree *slot = note_defs->find_slot (decl, installing ? INSERT : NO_INSERT);
4754 : 489206 : tree not_tmpl = STRIP_TEMPLATE (decl);
4755 : 489206 : if (installing)
4756 : : {
4757 : : /* We must be inserting for the first time. */
4758 : 219089 : gcc_assert (!*slot);
4759 : 219089 : *slot = decl;
4760 : : }
4761 : : else
4762 : : /* If this is not the mergeable entity, it should not be in the
4763 : : table. If it is a non-global-module mergeable entity, it
4764 : : should be in the table. Global module entities could have been
4765 : : defined textually in the current TU and so might or might not
4766 : : be present. */
4767 : 270117 : gcc_assert (!is_duplicate (decl)
4768 : : ? !slot
4769 : : : (slot
4770 : : || !DECL_LANG_SPECIFIC (not_tmpl)
4771 : : || !DECL_MODULE_PURVIEW_P (not_tmpl)
4772 : : || (!DECL_MODULE_IMPORT_P (not_tmpl)
4773 : : && header_module_p ())));
4774 : :
4775 : 489206 : if (not_tmpl != decl)
4776 : 290337 : gcc_assert (!note_defs->find_slot (not_tmpl, NO_INSERT));
4777 : : #endif
4778 : 489206 : }
4779 : :
4780 : : void
4781 : 506665 : trees_out::assert_definition (tree decl ATTRIBUTE_UNUSED)
4782 : : {
4783 : : #if CHECKING_P
4784 : 506665 : tree *slot = note_defs->find_slot (decl, INSERT);
4785 : 506665 : gcc_assert (!*slot);
4786 : 506665 : *slot = decl;
4787 : 506665 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4788 : 300225 : gcc_assert (!note_defs->find_slot (DECL_TEMPLATE_RESULT (decl), NO_INSERT));
4789 : : #endif
4790 : 506665 : }
4791 : :
4792 : : /********************************************************************/
4793 : : static bool
4794 : 10053 : noisy_p ()
4795 : : {
4796 : 0 : if (quiet_flag)
4797 : : return false;
4798 : :
4799 : 0 : pp_needs_newline (global_dc->get_reference_printer ()) = true;
4800 : 0 : diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
4801 : :
4802 : 0 : return true;
4803 : : }
4804 : :
4805 : : /* Set the cmi repo. Strip trailing '/', '.' becomes NULL. */
4806 : :
4807 : : static void
4808 : 94430 : set_cmi_repo (const char *r)
4809 : : {
4810 : 94430 : XDELETEVEC (cmi_repo);
4811 : 94430 : XDELETEVEC (cmi_path);
4812 : 94430 : cmi_path_alloc = 0;
4813 : :
4814 : 94430 : cmi_repo = NULL;
4815 : 94430 : cmi_repo_length = 0;
4816 : :
4817 : 94430 : if (!r || !r[0])
4818 : : return;
4819 : :
4820 : 3878 : size_t len = strlen (r);
4821 : 3878 : cmi_repo = XNEWVEC (char, len + 1);
4822 : 3878 : memcpy (cmi_repo, r, len + 1);
4823 : :
4824 : 3878 : if (len > 1 && IS_DIR_SEPARATOR (cmi_repo[len-1]))
4825 : 3878 : len--;
4826 : 3878 : if (len == 1 && cmi_repo[0] == '.')
4827 : 21 : len--;
4828 : 3878 : cmi_repo[len] = 0;
4829 : 3878 : cmi_repo_length = len;
4830 : : }
4831 : :
4832 : : /* TO is a repo-relative name. Provide one that we may use from where
4833 : : we are. */
4834 : :
4835 : : static const char *
4836 : 4729 : maybe_add_cmi_prefix (const char *to, size_t *len_p = NULL)
4837 : : {
4838 : 4729 : size_t len = len_p || cmi_repo_length ? strlen (to) : 0;
4839 : :
4840 : 4729 : if (cmi_repo_length && !IS_ABSOLUTE_PATH (to))
4841 : : {
4842 : 4708 : if (cmi_path_alloc < cmi_repo_length + len + 2)
4843 : : {
4844 : 3797 : XDELETEVEC (cmi_path);
4845 : 3797 : cmi_path_alloc = cmi_repo_length + len * 2 + 2;
4846 : 3797 : cmi_path = XNEWVEC (char, cmi_path_alloc);
4847 : :
4848 : 3797 : memcpy (cmi_path, cmi_repo, cmi_repo_length);
4849 : 3797 : cmi_path[cmi_repo_length] = DIR_SEPARATOR;
4850 : : }
4851 : :
4852 : 4708 : memcpy (&cmi_path[cmi_repo_length + 1], to, len + 1);
4853 : 4708 : len += cmi_repo_length + 1;
4854 : 4708 : to = cmi_path;
4855 : : }
4856 : :
4857 : 4729 : if (len_p)
4858 : 2279 : *len_p = len;
4859 : :
4860 : 4729 : return to;
4861 : : }
4862 : :
4863 : : /* Try and create the directories of PATH. */
4864 : :
4865 : : static void
4866 : 40 : create_dirs (char *path)
4867 : : {
4868 : : /* Try and create the missing directories. */
4869 : 2549 : for (char *base = path; *base; base++)
4870 : 2509 : if (IS_DIR_SEPARATOR (*base))
4871 : : {
4872 : 248 : char sep = *base;
4873 : 248 : *base = 0;
4874 : 248 : int failed = mkdir (path, S_IRWXU | S_IRWXG | S_IRWXO);
4875 : 253 : dump () && dump ("Mkdir ('%s') errno:=%u", path, failed ? errno : 0);
4876 : 248 : *base = sep;
4877 : 248 : if (failed
4878 : : /* Maybe racing with another creator (of a *different*
4879 : : module). */
4880 : 48 : && errno != EEXIST)
4881 : : break;
4882 : : }
4883 : 40 : }
4884 : :
4885 : : /* Given a CLASSTYPE_DECL_LIST VALUE get the template friend decl,
4886 : : if that's what this is. */
4887 : :
4888 : : static tree
4889 : 76905 : friend_from_decl_list (tree frnd)
4890 : : {
4891 : 76905 : tree res = frnd;
4892 : :
4893 : 76905 : if (TREE_CODE (frnd) != TEMPLATE_DECL)
4894 : : {
4895 : 39979 : tree tmpl = NULL_TREE;
4896 : 39979 : if (TYPE_P (frnd))
4897 : : {
4898 : 7062 : res = TYPE_NAME (frnd);
4899 : 6993 : if (CLASS_TYPE_P (frnd)
4900 : 14055 : && CLASSTYPE_TEMPLATE_INFO (frnd))
4901 : 6984 : tmpl = CLASSTYPE_TI_TEMPLATE (frnd);
4902 : : }
4903 : 32917 : else if (DECL_TEMPLATE_INFO (frnd))
4904 : : {
4905 : 32917 : tmpl = DECL_TI_TEMPLATE (frnd);
4906 : 32917 : if (TREE_CODE (tmpl) != TEMPLATE_DECL)
4907 : : tmpl = NULL_TREE;
4908 : : }
4909 : :
4910 : 46129 : if (tmpl && DECL_TEMPLATE_RESULT (tmpl) == res)
4911 : : res = tmpl;
4912 : : }
4913 : :
4914 : 76905 : return res;
4915 : : }
4916 : :
4917 : : static tree
4918 : 33239 : find_enum_member (tree ctx, tree name)
4919 : : {
4920 : 33239 : for (tree values = TYPE_VALUES (ctx);
4921 : 486545 : values; values = TREE_CHAIN (values))
4922 : 478243 : if (DECL_NAME (TREE_VALUE (values)) == name)
4923 : : return TREE_VALUE (values);
4924 : :
4925 : : return NULL_TREE;
4926 : : }
4927 : :
4928 : : /********************************************************************/
4929 : : /* Instrumentation gathered writing bytes. */
4930 : :
4931 : : void
4932 : 241 : bytes_out::instrument ()
4933 : : {
4934 : 241 : dump ("Wrote %u bytes in %u blocks", lengths[3], spans[3]);
4935 : 241 : dump ("Wrote %u bits in %u bytes", lengths[0] + lengths[1], lengths[2]);
4936 : 723 : for (unsigned ix = 0; ix < 2; ix++)
4937 : 723 : dump (" %u %s spans of %R bits", spans[ix],
4938 : : ix ? "one" : "zero", lengths[ix], spans[ix]);
4939 : 241 : dump (" %u blocks with %R bits padding", spans[2],
4940 : 241 : lengths[2] * 8 - (lengths[0] + lengths[1]), spans[2]);
4941 : 241 : }
4942 : :
4943 : : /* Instrumentation gathered writing trees. */
4944 : : void
4945 : 2149 : trees_out::instrument ()
4946 : : {
4947 : 2149 : if (dump (""))
4948 : : {
4949 : 241 : bytes_out::instrument ();
4950 : 241 : dump ("Wrote:");
4951 : 241 : dump (" %u decl trees", decl_val_count);
4952 : 241 : dump (" %u other trees", tree_val_count);
4953 : 241 : dump (" %u back references", back_ref_count);
4954 : 241 : dump (" %u TU-local entities", tu_local_count);
4955 : 241 : dump (" %u null trees", null_count);
4956 : : }
4957 : 2149 : }
4958 : :
4959 : : /* Setup and teardown for a tree walk. */
4960 : :
4961 : : void
4962 : 3164211 : trees_out::begin ()
4963 : : {
4964 : 3164211 : gcc_assert (!streaming_p () || !tree_map.elements ());
4965 : :
4966 : 3164211 : mark_trees ();
4967 : 3164211 : if (streaming_p ())
4968 : 383467 : parent::begin ();
4969 : 3164211 : }
4970 : :
4971 : : unsigned
4972 : 383467 : trees_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
4973 : : {
4974 : 383467 : gcc_checking_assert (streaming_p ());
4975 : :
4976 : 383467 : unmark_trees ();
4977 : 383467 : return parent::end (sink, name, crc_ptr);
4978 : : }
4979 : :
4980 : : void
4981 : 2780744 : trees_out::end ()
4982 : : {
4983 : 2780744 : gcc_assert (!streaming_p ());
4984 : :
4985 : 2780744 : unmark_trees ();
4986 : : /* Do not parent::end -- we weren't streaming. */
4987 : 2780744 : }
4988 : :
4989 : : void
4990 : 3164211 : trees_out::mark_trees ()
4991 : : {
4992 : 3164211 : if (size_t size = tree_map.elements ())
4993 : : {
4994 : : /* This isn't our first rodeo, destroy and recreate the
4995 : : tree_map. I'm a bad bad man. Use the previous size as a
4996 : : guess for the next one (so not all bad). */
4997 : 2411904 : tree_map.~ptr_int_hash_map ();
4998 : 2411904 : new (&tree_map) ptr_int_hash_map (size);
4999 : : }
5000 : :
5001 : : /* Install the fixed trees, with +ve references. */
5002 : 3164211 : unsigned limit = fixed_trees->length ();
5003 : 609878261 : for (unsigned ix = 0; ix != limit; ix++)
5004 : : {
5005 : 606714050 : tree val = (*fixed_trees)[ix];
5006 : 606714050 : bool existed = tree_map.put (val, ix + tag_fixed);
5007 : 606714050 : gcc_checking_assert (!TREE_VISITED (val) && !existed);
5008 : 606714050 : TREE_VISITED (val) = true;
5009 : : }
5010 : :
5011 : 3164211 : ref_num = 0;
5012 : 3164211 : }
5013 : :
5014 : : /* Unmark the trees we encountered */
5015 : :
5016 : : void
5017 : 3164211 : trees_out::unmark_trees ()
5018 : : {
5019 : 3164211 : ptr_int_hash_map::iterator end (tree_map.end ());
5020 : 717917802 : for (ptr_int_hash_map::iterator iter (tree_map.begin ()); iter != end; ++iter)
5021 : : {
5022 : 714753591 : tree node = reinterpret_cast<tree> ((*iter).first);
5023 : 714753591 : int ref = (*iter).second;
5024 : : /* We should have visited the node, and converted its mergeable
5025 : : reference to a regular reference. */
5026 : 714753591 : gcc_checking_assert (TREE_VISITED (node)
5027 : : && (ref <= tag_backref || ref >= tag_fixed));
5028 : 714753591 : TREE_VISITED (node) = false;
5029 : : }
5030 : 3164211 : }
5031 : :
5032 : : /* Mark DECL for by-value walking. We do this by inserting it into
5033 : : the tree map with a reference of zero. May be called multiple
5034 : : times on the same node. */
5035 : :
5036 : : void
5037 : 4872497 : trees_out::mark_by_value (tree decl)
5038 : : {
5039 : 4872497 : gcc_checking_assert (DECL_P (decl)
5040 : : /* Enum consts are INTEGER_CSTS. */
5041 : : || TREE_CODE (decl) == INTEGER_CST
5042 : : || TREE_CODE (decl) == TREE_BINFO);
5043 : :
5044 : 4872497 : if (TREE_VISITED (decl))
5045 : : /* Must already be forced or fixed. */
5046 : 3756 : gcc_checking_assert (*tree_map.get (decl) >= tag_value);
5047 : : else
5048 : : {
5049 : 4868741 : bool existed = tree_map.put (decl, tag_value);
5050 : 4868741 : gcc_checking_assert (!existed);
5051 : 4868741 : TREE_VISITED (decl) = true;
5052 : : }
5053 : 4872497 : }
5054 : :
5055 : : int
5056 : 130157886 : trees_out::get_tag (tree t)
5057 : : {
5058 : 130157886 : gcc_checking_assert (TREE_VISITED (t));
5059 : 130157886 : return *tree_map.get (t);
5060 : : }
5061 : :
5062 : : /* Insert T into the map, return its tag number. */
5063 : :
5064 : : int
5065 : 108039541 : trees_out::insert (tree t, walk_kind walk)
5066 : : {
5067 : 108039541 : gcc_checking_assert (walk != WK_normal || !TREE_VISITED (t));
5068 : 108039541 : int tag = --ref_num;
5069 : 108039541 : bool existed;
5070 : 108039541 : int &slot = tree_map.get_or_insert (t, &existed);
5071 : 108039541 : gcc_checking_assert (TREE_VISITED (t) == existed
5072 : : && (!existed
5073 : : || (walk == WK_value && slot == tag_value)));
5074 : 108039541 : TREE_VISITED (t) = true;
5075 : 108039541 : slot = tag;
5076 : :
5077 : 108039541 : return tag;
5078 : : }
5079 : :
5080 : : /* Insert T into the backreference array. Return its back reference
5081 : : number. */
5082 : :
5083 : : int
5084 : 29451585 : trees_in::insert (tree t)
5085 : : {
5086 : 29451585 : gcc_checking_assert (t || get_overrun ());
5087 : 29451585 : back_refs.safe_push (t);
5088 : 29451585 : return -(int)back_refs.length ();
5089 : : }
5090 : :
5091 : : /* A chained set of decls. */
5092 : :
5093 : : void
5094 : 117271 : trees_out::chained_decls (tree decls)
5095 : : {
5096 : 289361 : for (; decls; decls = DECL_CHAIN (decls))
5097 : 172090 : tree_node (decls);
5098 : 117271 : tree_node (NULL_TREE);
5099 : 117271 : }
5100 : :
5101 : : tree
5102 : 57105 : trees_in::chained_decls ()
5103 : : {
5104 : 57105 : tree decls = NULL_TREE;
5105 : 57105 : for (tree *chain = &decls;;)
5106 : 138740 : if (tree decl = tree_node ())
5107 : : {
5108 : 81635 : if (!DECL_P (decl) || DECL_CHAIN (decl))
5109 : : {
5110 : 0 : set_overrun ();
5111 : 0 : break;
5112 : : }
5113 : 81635 : *chain = decl;
5114 : 81635 : chain = &DECL_CHAIN (decl);
5115 : : }
5116 : : else
5117 : 81635 : break;
5118 : :
5119 : 57105 : return decls;
5120 : : }
5121 : :
5122 : : /* A vector of decls following DECL_CHAIN. */
5123 : :
5124 : : void
5125 : 474984 : trees_out::vec_chained_decls (tree decls)
5126 : : {
5127 : 474984 : if (streaming_p ())
5128 : : {
5129 : : unsigned len = 0;
5130 : :
5131 : 1408313 : for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
5132 : 1170858 : len++;
5133 : 237455 : u (len);
5134 : : }
5135 : :
5136 : 2817025 : for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
5137 : : {
5138 : 518491 : if (DECL_IMPLICIT_TYPEDEF_P (decl)
5139 : 2359921 : && TYPE_NAME (TREE_TYPE (decl)) != decl)
5140 : : /* An anonynmous struct with a typedef name. An odd thing to
5141 : : write. */
5142 : 12 : tree_node (NULL_TREE);
5143 : : else
5144 : 2342029 : tree_node (decl);
5145 : : }
5146 : 474984 : }
5147 : :
5148 : : vec<tree, va_heap> *
5149 : 214770 : trees_in::vec_chained_decls ()
5150 : : {
5151 : 214770 : vec<tree, va_heap> *v = NULL;
5152 : :
5153 : 214770 : if (unsigned len = u ())
5154 : : {
5155 : 112952 : vec_alloc (v, len);
5156 : :
5157 : 1242625 : for (unsigned ix = 0; ix < len; ix++)
5158 : : {
5159 : 1129673 : tree decl = tree_node ();
5160 : 1129673 : if (decl && !DECL_P (decl))
5161 : : {
5162 : 0 : set_overrun ();
5163 : 0 : break;
5164 : : }
5165 : 1129673 : v->quick_push (decl);
5166 : : }
5167 : :
5168 : 112952 : if (get_overrun ())
5169 : : {
5170 : 0 : vec_free (v);
5171 : 0 : v = NULL;
5172 : : }
5173 : : }
5174 : :
5175 : 214770 : return v;
5176 : : }
5177 : :
5178 : : /* A vector of trees. */
5179 : :
5180 : : void
5181 : 346393 : trees_out::tree_vec (vec<tree, va_gc> *v)
5182 : : {
5183 : 346393 : unsigned len = vec_safe_length (v);
5184 : 346393 : if (streaming_p ())
5185 : 173178 : u (len);
5186 : 452539 : for (unsigned ix = 0; ix != len; ix++)
5187 : 106146 : tree_node ((*v)[ix]);
5188 : 346393 : }
5189 : :
5190 : : vec<tree, va_gc> *
5191 : 157535 : trees_in::tree_vec ()
5192 : : {
5193 : 157535 : vec<tree, va_gc> *v = NULL;
5194 : 157535 : if (unsigned len = u ())
5195 : : {
5196 : 44496 : vec_alloc (v, len);
5197 : 93397 : for (unsigned ix = 0; ix != len; ix++)
5198 : 48901 : v->quick_push (tree_node ());
5199 : : }
5200 : 157535 : return v;
5201 : : }
5202 : :
5203 : : /* A vector of tree pairs. */
5204 : :
5205 : : void
5206 : 9226 : trees_out::tree_pair_vec (vec<tree_pair_s, va_gc> *v)
5207 : : {
5208 : 9226 : unsigned len = vec_safe_length (v);
5209 : 9226 : if (streaming_p ())
5210 : 4613 : u (len);
5211 : 9226 : if (len)
5212 : 50728 : for (unsigned ix = 0; ix != len; ix++)
5213 : : {
5214 : 41682 : tree_pair_s const &s = (*v)[ix];
5215 : 41682 : tree_node (s.purpose);
5216 : 41682 : tree_node (s.value);
5217 : : }
5218 : 9226 : }
5219 : :
5220 : : vec<tree_pair_s, va_gc> *
5221 : 4584 : trees_in::tree_pair_vec ()
5222 : : {
5223 : 4584 : vec<tree_pair_s, va_gc> *v = NULL;
5224 : 4584 : if (unsigned len = u ())
5225 : : {
5226 : 4498 : vec_alloc (v, len);
5227 : 25390 : for (unsigned ix = 0; ix != len; ix++)
5228 : : {
5229 : 20892 : tree_pair_s s;
5230 : 20892 : s.purpose = tree_node ();
5231 : 20892 : s.value = tree_node ();
5232 : 20892 : v->quick_push (s);
5233 : : }
5234 : : }
5235 : 4584 : return v;
5236 : : }
5237 : :
5238 : : void
5239 : 496346 : trees_out::tree_list (tree list, bool has_purpose)
5240 : : {
5241 : 2133593 : for (; list; list = TREE_CHAIN (list))
5242 : : {
5243 : 1637247 : gcc_checking_assert (TREE_VALUE (list));
5244 : 1637247 : tree_node (TREE_VALUE (list));
5245 : 1637247 : if (has_purpose)
5246 : 1592697 : tree_node (TREE_PURPOSE (list));
5247 : : }
5248 : 496346 : tree_node (NULL_TREE);
5249 : 496346 : }
5250 : :
5251 : : tree
5252 : 225274 : trees_in::tree_list (bool has_purpose)
5253 : : {
5254 : 225274 : tree res = NULL_TREE;
5255 : :
5256 : 1020581 : for (tree *chain = &res; tree value = tree_node ();
5257 : 1590614 : chain = &TREE_CHAIN (*chain))
5258 : : {
5259 : 795307 : tree purpose = has_purpose ? tree_node () : NULL_TREE;
5260 : 795307 : *chain = build_tree_list (purpose, value);
5261 : 795307 : }
5262 : :
5263 : 225274 : return res;
5264 : : }
5265 : : /* Start tree write. Write information to allocate the receiving
5266 : : node. */
5267 : :
5268 : : void
5269 : 21296100 : trees_out::start (tree t, bool code_streamed)
5270 : : {
5271 : 21296100 : if (TYPE_P (t))
5272 : : {
5273 : 870041 : enum tree_code code = TREE_CODE (t);
5274 : 870041 : gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
5275 : : /* All these types are TYPE_NON_COMMON. */
5276 : 870041 : gcc_checking_assert (code == RECORD_TYPE
5277 : : || code == UNION_TYPE
5278 : : || code == ENUMERAL_TYPE
5279 : : || code == TEMPLATE_TYPE_PARM
5280 : : || code == TEMPLATE_TEMPLATE_PARM
5281 : : || code == BOUND_TEMPLATE_TEMPLATE_PARM);
5282 : : }
5283 : :
5284 : 21296100 : if (!code_streamed)
5285 : 20510607 : u (TREE_CODE (t));
5286 : :
5287 : 21296100 : switch (TREE_CODE (t))
5288 : : {
5289 : 19055149 : default:
5290 : 19055149 : if (VL_EXP_CLASS_P (t))
5291 : 789923 : u (VL_EXP_OPERAND_LENGTH (t));
5292 : : break;
5293 : :
5294 : 853563 : case INTEGER_CST:
5295 : 853563 : u (TREE_INT_CST_NUNITS (t));
5296 : 853563 : u (TREE_INT_CST_EXT_NUNITS (t));
5297 : 853563 : break;
5298 : :
5299 : 3 : case OMP_CLAUSE:
5300 : 3 : state->extensions |= SE_OPENMP;
5301 : 3 : u (OMP_CLAUSE_CODE (t));
5302 : 3 : break;
5303 : :
5304 : 49205 : case STRING_CST:
5305 : 49205 : str (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
5306 : 49205 : break;
5307 : :
5308 : 18 : case VECTOR_CST:
5309 : 18 : u (VECTOR_CST_LOG2_NPATTERNS (t));
5310 : 18 : u (VECTOR_CST_NELTS_PER_PATTERN (t));
5311 : 18 : break;
5312 : :
5313 : 168565 : case TREE_BINFO:
5314 : 168565 : u (BINFO_N_BASE_BINFOS (t));
5315 : 168565 : break;
5316 : :
5317 : 1169597 : case TREE_VEC:
5318 : 1169597 : u (TREE_VEC_LENGTH (t));
5319 : 1169597 : break;
5320 : :
5321 : 0 : case FIXED_CST:
5322 : 0 : gcc_unreachable (); /* Not supported in C++. */
5323 : 0 : break;
5324 : :
5325 : 0 : case IDENTIFIER_NODE:
5326 : 0 : case SSA_NAME:
5327 : 0 : case TARGET_MEM_REF:
5328 : 0 : case TRANSLATION_UNIT_DECL:
5329 : : /* We shouldn't meet these. */
5330 : 0 : gcc_unreachable ();
5331 : 21296100 : break;
5332 : : }
5333 : 21296100 : }
5334 : :
5335 : : /* Start tree read. Allocate the receiving node. */
5336 : :
5337 : : tree
5338 : 20673224 : trees_in::start (unsigned code)
5339 : : {
5340 : 20673224 : tree t = NULL_TREE;
5341 : :
5342 : 20673224 : if (!code)
5343 : 18529777 : code = u ();
5344 : :
5345 : 20673224 : switch (code)
5346 : : {
5347 : 18555719 : default:
5348 : 18555719 : if (code >= MAX_TREE_CODES)
5349 : : {
5350 : 0 : fail:
5351 : 0 : set_overrun ();
5352 : 0 : return NULL_TREE;
5353 : : }
5354 : 18555719 : else if (TREE_CODE_CLASS (code) == tcc_vl_exp)
5355 : : {
5356 : 773859 : unsigned ops = u ();
5357 : 773859 : t = build_vl_exp (tree_code (code), ops);
5358 : : }
5359 : : else
5360 : 17781860 : t = make_node (tree_code (code));
5361 : : break;
5362 : :
5363 : 807984 : case INTEGER_CST:
5364 : 807984 : {
5365 : 807984 : unsigned n = u ();
5366 : 807984 : unsigned e = u ();
5367 : 807984 : t = make_int_cst (n, e);
5368 : : }
5369 : 807984 : break;
5370 : :
5371 : 3 : case OMP_CLAUSE:
5372 : 3 : {
5373 : 3 : if (!(state->extensions & SE_OPENMP))
5374 : 0 : goto fail;
5375 : :
5376 : 3 : unsigned omp_code = u ();
5377 : 3 : t = build_omp_clause (UNKNOWN_LOCATION, omp_clause_code (omp_code));
5378 : : }
5379 : 3 : break;
5380 : :
5381 : 49041 : case STRING_CST:
5382 : 49041 : {
5383 : 49041 : size_t l;
5384 : 49041 : const char *chars = str (&l);
5385 : 49041 : t = build_string (l, chars);
5386 : : }
5387 : 49041 : break;
5388 : :
5389 : 24 : case VECTOR_CST:
5390 : 24 : {
5391 : 24 : unsigned log2_npats = u ();
5392 : 24 : unsigned elts_per = u ();
5393 : 24 : t = make_vector (log2_npats, elts_per);
5394 : : }
5395 : 24 : break;
5396 : :
5397 : 152951 : case TREE_BINFO:
5398 : 152951 : t = make_tree_binfo (u ());
5399 : 152951 : break;
5400 : :
5401 : 1107502 : case TREE_VEC:
5402 : 1107502 : t = make_tree_vec (u ());
5403 : 1107502 : break;
5404 : :
5405 : 0 : case FIXED_CST:
5406 : 0 : case IDENTIFIER_NODE:
5407 : 0 : case SSA_NAME:
5408 : 0 : case TARGET_MEM_REF:
5409 : 0 : case TRANSLATION_UNIT_DECL:
5410 : 0 : goto fail;
5411 : : }
5412 : :
5413 : : return t;
5414 : : }
5415 : :
5416 : : /* The structure streamers access the raw fields, because the
5417 : : alternative, of using the accessor macros can require using
5418 : : different accessors for the same underlying field, depending on the
5419 : : tree code. That's both confusing and annoying. */
5420 : :
5421 : : /* Read & write the core boolean flags. */
5422 : :
5423 : : void
5424 : 21329344 : trees_out::core_bools (tree t, bits_out& bits)
5425 : : {
5426 : : #define WB(X) (bits.b (X))
5427 : : /* Stream X if COND holds, and if !COND stream a dummy value so that the
5428 : : overall number of bits streamed is independent of the runtime value
5429 : : of COND, which allows the compiler to better optimize this function. */
5430 : : #define WB_IF(COND, X) WB ((COND) ? (X) : false)
5431 : 21329344 : tree_code code = TREE_CODE (t);
5432 : :
5433 : 21329344 : WB (t->base.side_effects_flag);
5434 : 21329344 : WB (t->base.constant_flag);
5435 : 21329344 : WB (t->base.addressable_flag);
5436 : 21329344 : WB (t->base.volatile_flag);
5437 : 21329344 : WB (t->base.readonly_flag);
5438 : : /* base.asm_written_flag is a property of the current TU's use of
5439 : : this decl. */
5440 : 21329344 : WB (t->base.nowarning_flag);
5441 : : /* base.visited read as zero (it's set for writer, because that's
5442 : : how we mark nodes). */
5443 : : /* base.used_flag is not streamed. Readers may set TREE_USED of
5444 : : decls they use. */
5445 : 21329344 : WB (t->base.nothrow_flag);
5446 : 21329344 : WB (t->base.static_flag);
5447 : : /* This is TYPE_CACHED_VALUES_P for types. */
5448 : 21329344 : WB_IF (TREE_CODE_CLASS (code) != tcc_type, t->base.public_flag);
5449 : 21329344 : WB (t->base.private_flag);
5450 : 21329344 : WB (t->base.protected_flag);
5451 : 21329344 : WB (t->base.deprecated_flag);
5452 : 21329344 : WB (t->base.default_def_flag);
5453 : :
5454 : 21329344 : switch (code)
5455 : : {
5456 : : case CALL_EXPR:
5457 : : case INTEGER_CST:
5458 : : case SSA_NAME:
5459 : : case TARGET_MEM_REF:
5460 : : case TREE_VEC:
5461 : : /* These use different base.u fields. */
5462 : : return;
5463 : :
5464 : 18532602 : default:
5465 : 18532602 : WB (t->base.u.bits.lang_flag_0);
5466 : 18532602 : bool flag_1 = t->base.u.bits.lang_flag_1;
5467 : 18532602 : if (!flag_1)
5468 : : ;
5469 : 575984 : else if (code == TEMPLATE_INFO)
5470 : : /* This is TI_PENDING_TEMPLATE_FLAG, not relevant to reader. */
5471 : : flag_1 = false;
5472 : 571175 : else if (code == VAR_DECL)
5473 : : {
5474 : : /* This is DECL_INITIALIZED_P. */
5475 : 95575 : if (TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
5476 : : /* We'll set this when reading the definition. */
5477 : 18532602 : flag_1 = false;
5478 : : }
5479 : 18532602 : WB (flag_1);
5480 : 18532602 : WB (t->base.u.bits.lang_flag_2);
5481 : 18532602 : WB (t->base.u.bits.lang_flag_3);
5482 : 18532602 : WB (t->base.u.bits.lang_flag_4);
5483 : 18532602 : WB (t->base.u.bits.lang_flag_5);
5484 : 18532602 : WB (t->base.u.bits.lang_flag_6);
5485 : 18532602 : WB (t->base.u.bits.saturating_flag);
5486 : 18532602 : WB (t->base.u.bits.unsigned_flag);
5487 : 18532602 : WB (t->base.u.bits.packed_flag);
5488 : 18532602 : WB (t->base.u.bits.user_align);
5489 : 18532602 : WB (t->base.u.bits.nameless_flag);
5490 : 18532602 : WB (t->base.u.bits.atomic_flag);
5491 : 18532602 : WB (t->base.u.bits.unavailable_flag);
5492 : 18532602 : break;
5493 : : }
5494 : :
5495 : 18532602 : if (TREE_CODE_CLASS (code) == tcc_type)
5496 : : {
5497 : 903285 : WB (t->type_common.no_force_blk_flag);
5498 : 903285 : WB (t->type_common.needs_constructing_flag);
5499 : 903285 : WB (t->type_common.transparent_aggr_flag);
5500 : 903285 : WB (t->type_common.restrict_flag);
5501 : 903285 : WB (t->type_common.string_flag);
5502 : 903285 : WB (t->type_common.lang_flag_0);
5503 : 903285 : WB (t->type_common.lang_flag_1);
5504 : 903285 : WB (t->type_common.lang_flag_2);
5505 : 903285 : WB (t->type_common.lang_flag_3);
5506 : 903285 : WB (t->type_common.lang_flag_4);
5507 : 903285 : WB (t->type_common.lang_flag_5);
5508 : 903285 : WB (t->type_common.lang_flag_6);
5509 : 903285 : WB (t->type_common.typeless_storage);
5510 : : }
5511 : :
5512 : 18532602 : if (TREE_CODE_CLASS (code) != tcc_declaration)
5513 : : return;
5514 : :
5515 : 4893542 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
5516 : : {
5517 : 4893542 : WB (t->decl_common.nonlocal_flag);
5518 : 4893542 : WB (t->decl_common.virtual_flag);
5519 : 4893542 : WB (t->decl_common.ignored_flag);
5520 : 4893542 : WB (t->decl_common.abstract_flag);
5521 : 4893542 : WB (t->decl_common.artificial_flag);
5522 : 4893542 : WB (t->decl_common.preserve_flag);
5523 : 4893542 : WB (t->decl_common.debug_expr_is_from);
5524 : 4893542 : WB (t->decl_common.lang_flag_0);
5525 : 4893542 : WB (t->decl_common.lang_flag_1);
5526 : 4893542 : WB (t->decl_common.lang_flag_2);
5527 : 4893542 : WB (t->decl_common.lang_flag_3);
5528 : 4893542 : WB (t->decl_common.lang_flag_4);
5529 : :
5530 : 4893542 : {
5531 : : /* This is DECL_INTERFACE_KNOWN: We should redetermine whether
5532 : : we need to import or export any vtables or typeinfo objects
5533 : : on stream-in. */
5534 : 4893542 : bool interface_known = t->decl_common.lang_flag_5;
5535 : 4893542 : if (VAR_P (t) && (DECL_VTABLE_OR_VTT_P (t) || DECL_TINFO_P (t)))
5536 : : interface_known = false;
5537 : 4893542 : WB (interface_known);
5538 : : }
5539 : :
5540 : 4893542 : WB (t->decl_common.lang_flag_6);
5541 : 4893542 : WB (t->decl_common.lang_flag_7);
5542 : 4893542 : WB (t->decl_common.lang_flag_8);
5543 : 4893542 : WB (t->decl_common.decl_flag_0);
5544 : :
5545 : 4893542 : {
5546 : : /* DECL_EXTERNAL -> decl_flag_1
5547 : : == it is defined elsewhere
5548 : : DECL_NOT_REALLY_EXTERN -> base.not_really_extern
5549 : : == that was a lie, it is here */
5550 : :
5551 : 4893542 : bool is_external = t->decl_common.decl_flag_1;
5552 : 4893542 : if (!is_external)
5553 : : /* decl_flag_1 is DECL_EXTERNAL. Things we emit here, might
5554 : : well be external from the POV of an importer. */
5555 : : // FIXME: Do we need to know if this is a TEMPLATE_RESULT --
5556 : : // a flag from the caller?
5557 : 4078221 : switch (code)
5558 : : {
5559 : : default:
5560 : : break;
5561 : :
5562 : 293960 : case VAR_DECL:
5563 : 293960 : if (TREE_PUBLIC (t)
5564 : 342422 : && DECL_VTABLE_OR_VTT_P (t))
5565 : : /* We handle vtable linkage specially. */
5566 : : is_external = true;
5567 : 339344 : gcc_fallthrough ();
5568 : 339344 : case FUNCTION_DECL:
5569 : 339344 : if (TREE_PUBLIC (t)
5570 : 339344 : && !vague_linkage_p (t))
5571 : : is_external = true;
5572 : : break;
5573 : : }
5574 : 4893542 : WB (is_external);
5575 : : }
5576 : :
5577 : 4893542 : WB (t->decl_common.decl_flag_2);
5578 : 4893542 : WB (t->decl_common.decl_flag_3);
5579 : 4893542 : WB (t->decl_common.not_gimple_reg_flag);
5580 : 4893542 : WB (t->decl_common.decl_by_reference_flag);
5581 : 4893542 : WB (t->decl_common.decl_read_flag);
5582 : 4893542 : WB (t->decl_common.decl_nonshareable_flag);
5583 : 4893542 : WB (t->decl_common.decl_not_flexarray);
5584 : : }
5585 : : else
5586 : : return;
5587 : :
5588 : 4893542 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
5589 : : {
5590 : 2295115 : WB (t->decl_with_vis.defer_output);
5591 : 2295115 : WB (t->decl_with_vis.hard_register);
5592 : 2295115 : WB (t->decl_with_vis.common_flag);
5593 : 2295115 : WB (t->decl_with_vis.in_text_section);
5594 : 2295115 : WB (t->decl_with_vis.in_constant_pool);
5595 : 2295115 : WB (t->decl_with_vis.dllimport_flag);
5596 : 2295115 : WB (t->decl_with_vis.weak_flag);
5597 : 2295115 : WB (t->decl_with_vis.seen_in_bind_expr);
5598 : 2295115 : WB (t->decl_with_vis.comdat_flag);
5599 : 2295115 : WB (t->decl_with_vis.visibility_specified);
5600 : 2295115 : WB (t->decl_with_vis.init_priority_p);
5601 : 2295115 : WB (t->decl_with_vis.shadowed_for_var_p);
5602 : 2295115 : WB (t->decl_with_vis.cxx_constructor);
5603 : 2295115 : WB (t->decl_with_vis.cxx_destructor);
5604 : 2295115 : WB (t->decl_with_vis.final);
5605 : 2295115 : WB (t->decl_with_vis.regdecl_flag);
5606 : : }
5607 : : else
5608 : : return;
5609 : :
5610 : 2295115 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
5611 : : {
5612 : 693925 : WB (t->function_decl.static_ctor_flag);
5613 : 693925 : WB (t->function_decl.static_dtor_flag);
5614 : 693925 : WB (t->function_decl.uninlinable);
5615 : 693925 : WB (t->function_decl.possibly_inlined);
5616 : 693925 : WB (t->function_decl.novops_flag);
5617 : 693925 : WB (t->function_decl.returns_twice_flag);
5618 : 693925 : WB (t->function_decl.malloc_flag);
5619 : 693925 : WB (t->function_decl.declared_inline_flag);
5620 : 693925 : WB (t->function_decl.no_inline_warning_flag);
5621 : 693925 : WB (t->function_decl.no_instrument_function_entry_exit);
5622 : 693925 : WB (t->function_decl.no_limit_stack);
5623 : 693925 : WB (t->function_decl.disregard_inline_limits);
5624 : 693925 : WB (t->function_decl.pure_flag);
5625 : 693925 : WB (t->function_decl.looping_const_or_pure_flag);
5626 : :
5627 : 693925 : WB (t->function_decl.has_debug_args_flag);
5628 : 693925 : WB (t->function_decl.versioned_function);
5629 : :
5630 : : /* decl_type is a (misnamed) 2 bit discriminator. */
5631 : 693925 : unsigned kind = t->function_decl.decl_type;
5632 : 693925 : WB ((kind >> 0) & 1);
5633 : 693925 : WB ((kind >> 1) & 1);
5634 : : }
5635 : : #undef WB_IF
5636 : : #undef WB
5637 : : }
5638 : :
5639 : : bool
5640 : 20701825 : trees_in::core_bools (tree t, bits_in& bits)
5641 : : {
5642 : : #define RB(X) ((X) = bits.b ())
5643 : : /* See the comment for WB_IF in trees_out::core_bools. */
5644 : : #define RB_IF(COND, X) ((COND) ? RB (X) : bits.b ())
5645 : :
5646 : 20701825 : tree_code code = TREE_CODE (t);
5647 : :
5648 : 20701825 : RB (t->base.side_effects_flag);
5649 : 20701825 : RB (t->base.constant_flag);
5650 : 20701825 : RB (t->base.addressable_flag);
5651 : 20701825 : RB (t->base.volatile_flag);
5652 : 20701825 : RB (t->base.readonly_flag);
5653 : : /* base.asm_written_flag is not streamed. */
5654 : 20701825 : RB (t->base.nowarning_flag);
5655 : : /* base.visited is not streamed. */
5656 : : /* base.used_flag is not streamed. */
5657 : 20701825 : RB (t->base.nothrow_flag);
5658 : 20701825 : RB (t->base.static_flag);
5659 : 20701825 : RB_IF (TREE_CODE_CLASS (code) != tcc_type, t->base.public_flag);
5660 : 20701825 : RB (t->base.private_flag);
5661 : 20701825 : RB (t->base.protected_flag);
5662 : 20701825 : RB (t->base.deprecated_flag);
5663 : 20701825 : RB (t->base.default_def_flag);
5664 : :
5665 : 20701825 : switch (code)
5666 : : {
5667 : 2673901 : case CALL_EXPR:
5668 : 2673901 : case INTEGER_CST:
5669 : 2673901 : case SSA_NAME:
5670 : 2673901 : case TARGET_MEM_REF:
5671 : 2673901 : case TREE_VEC:
5672 : : /* These use different base.u fields. */
5673 : 2673901 : goto done;
5674 : :
5675 : 18027924 : default:
5676 : 18027924 : RB (t->base.u.bits.lang_flag_0);
5677 : 18027924 : RB (t->base.u.bits.lang_flag_1);
5678 : 18027924 : RB (t->base.u.bits.lang_flag_2);
5679 : 18027924 : RB (t->base.u.bits.lang_flag_3);
5680 : 18027924 : RB (t->base.u.bits.lang_flag_4);
5681 : 18027924 : RB (t->base.u.bits.lang_flag_5);
5682 : 18027924 : RB (t->base.u.bits.lang_flag_6);
5683 : 18027924 : RB (t->base.u.bits.saturating_flag);
5684 : 18027924 : RB (t->base.u.bits.unsigned_flag);
5685 : 18027924 : RB (t->base.u.bits.packed_flag);
5686 : 18027924 : RB (t->base.u.bits.user_align);
5687 : 18027924 : RB (t->base.u.bits.nameless_flag);
5688 : 18027924 : RB (t->base.u.bits.atomic_flag);
5689 : 18027924 : RB (t->base.u.bits.unavailable_flag);
5690 : 18027924 : break;
5691 : : }
5692 : :
5693 : 18027924 : if (TREE_CODE_CLASS (code) == tcc_type)
5694 : : {
5695 : 845064 : RB (t->type_common.no_force_blk_flag);
5696 : 845064 : RB (t->type_common.needs_constructing_flag);
5697 : 845064 : RB (t->type_common.transparent_aggr_flag);
5698 : 845064 : RB (t->type_common.restrict_flag);
5699 : 845064 : RB (t->type_common.string_flag);
5700 : 845064 : RB (t->type_common.lang_flag_0);
5701 : 845064 : RB (t->type_common.lang_flag_1);
5702 : 845064 : RB (t->type_common.lang_flag_2);
5703 : 845064 : RB (t->type_common.lang_flag_3);
5704 : 845064 : RB (t->type_common.lang_flag_4);
5705 : 845064 : RB (t->type_common.lang_flag_5);
5706 : 845064 : RB (t->type_common.lang_flag_6);
5707 : 845064 : RB (t->type_common.typeless_storage);
5708 : : }
5709 : :
5710 : 18027924 : if (TREE_CODE_CLASS (code) != tcc_declaration)
5711 : 13289243 : goto done;
5712 : :
5713 : 4738681 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
5714 : : {
5715 : 4738681 : RB (t->decl_common.nonlocal_flag);
5716 : 4738681 : RB (t->decl_common.virtual_flag);
5717 : 4738681 : RB (t->decl_common.ignored_flag);
5718 : 4738681 : RB (t->decl_common.abstract_flag);
5719 : 4738681 : RB (t->decl_common.artificial_flag);
5720 : 4738681 : RB (t->decl_common.preserve_flag);
5721 : 4738681 : RB (t->decl_common.debug_expr_is_from);
5722 : 4738681 : RB (t->decl_common.lang_flag_0);
5723 : 4738681 : RB (t->decl_common.lang_flag_1);
5724 : 4738681 : RB (t->decl_common.lang_flag_2);
5725 : 4738681 : RB (t->decl_common.lang_flag_3);
5726 : 4738681 : RB (t->decl_common.lang_flag_4);
5727 : 4738681 : RB (t->decl_common.lang_flag_5);
5728 : 4738681 : RB (t->decl_common.lang_flag_6);
5729 : 4738681 : RB (t->decl_common.lang_flag_7);
5730 : 4738681 : RB (t->decl_common.lang_flag_8);
5731 : 4738681 : RB (t->decl_common.decl_flag_0);
5732 : 4738681 : RB (t->decl_common.decl_flag_1);
5733 : 4738681 : RB (t->decl_common.decl_flag_2);
5734 : 4738681 : RB (t->decl_common.decl_flag_3);
5735 : 4738681 : RB (t->decl_common.not_gimple_reg_flag);
5736 : 4738681 : RB (t->decl_common.decl_by_reference_flag);
5737 : 4738681 : RB (t->decl_common.decl_read_flag);
5738 : 4738681 : RB (t->decl_common.decl_nonshareable_flag);
5739 : 4738681 : RB (t->decl_common.decl_not_flexarray);
5740 : : }
5741 : : else
5742 : 0 : goto done;
5743 : :
5744 : 4738681 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
5745 : : {
5746 : 2203551 : RB (t->decl_with_vis.defer_output);
5747 : 2203551 : RB (t->decl_with_vis.hard_register);
5748 : 2203551 : RB (t->decl_with_vis.common_flag);
5749 : 2203551 : RB (t->decl_with_vis.in_text_section);
5750 : 2203551 : RB (t->decl_with_vis.in_constant_pool);
5751 : 2203551 : RB (t->decl_with_vis.dllimport_flag);
5752 : 2203551 : RB (t->decl_with_vis.weak_flag);
5753 : 2203551 : RB (t->decl_with_vis.seen_in_bind_expr);
5754 : 2203551 : RB (t->decl_with_vis.comdat_flag);
5755 : 2203551 : RB (t->decl_with_vis.visibility_specified);
5756 : 2203551 : RB (t->decl_with_vis.init_priority_p);
5757 : 2203551 : RB (t->decl_with_vis.shadowed_for_var_p);
5758 : 2203551 : RB (t->decl_with_vis.cxx_constructor);
5759 : 2203551 : RB (t->decl_with_vis.cxx_destructor);
5760 : 2203551 : RB (t->decl_with_vis.final);
5761 : 2203551 : RB (t->decl_with_vis.regdecl_flag);
5762 : : }
5763 : : else
5764 : 2535130 : goto done;
5765 : :
5766 : 2203551 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
5767 : : {
5768 : 687780 : RB (t->function_decl.static_ctor_flag);
5769 : 687780 : RB (t->function_decl.static_dtor_flag);
5770 : 687780 : RB (t->function_decl.uninlinable);
5771 : 687780 : RB (t->function_decl.possibly_inlined);
5772 : 687780 : RB (t->function_decl.novops_flag);
5773 : 687780 : RB (t->function_decl.returns_twice_flag);
5774 : 687780 : RB (t->function_decl.malloc_flag);
5775 : 687780 : RB (t->function_decl.declared_inline_flag);
5776 : 687780 : RB (t->function_decl.no_inline_warning_flag);
5777 : 687780 : RB (t->function_decl.no_instrument_function_entry_exit);
5778 : 687780 : RB (t->function_decl.no_limit_stack);
5779 : 687780 : RB (t->function_decl.disregard_inline_limits);
5780 : 687780 : RB (t->function_decl.pure_flag);
5781 : 687780 : RB (t->function_decl.looping_const_or_pure_flag);
5782 : :
5783 : 687780 : RB (t->function_decl.has_debug_args_flag);
5784 : 687780 : RB (t->function_decl.versioned_function);
5785 : :
5786 : : /* decl_type is a (misnamed) 2 bit discriminator. */
5787 : 687780 : unsigned kind = 0;
5788 : 687780 : kind |= unsigned (bits.b ()) << 0;
5789 : 687780 : kind |= unsigned (bits.b ()) << 1;
5790 : 687780 : t->function_decl.decl_type = function_decl_type (kind);
5791 : : }
5792 : : #undef RB_IF
5793 : : #undef RB
5794 : 1515771 : done:
5795 : 20701825 : return !get_overrun ();
5796 : : }
5797 : :
5798 : : void
5799 : 3166641 : trees_out::lang_decl_bools (tree t, bits_out& bits)
5800 : : {
5801 : : #define WB(X) (bits.b (X))
5802 : 3166641 : const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
5803 : :
5804 : 3166641 : bits.bflush ();
5805 : 3166641 : WB (lang->u.base.language == lang_cplusplus);
5806 : 3166641 : WB ((lang->u.base.use_template >> 0) & 1);
5807 : 3166641 : WB ((lang->u.base.use_template >> 1) & 1);
5808 : : /* Do not write lang->u.base.not_really_extern, importer will set
5809 : : when reading the definition (if any). */
5810 : 3166641 : WB (lang->u.base.initialized_in_class);
5811 : 3166641 : WB (lang->u.base.threadprivate_or_deleted_p);
5812 : : /* Do not write lang->u.base.anticipated_p, it is a property of the
5813 : : current TU. */
5814 : 3166641 : WB (lang->u.base.friend_or_tls);
5815 : 3166641 : WB (lang->u.base.unknown_bound_p);
5816 : : /* Do not write lang->u.base.odr_used, importer will recalculate if
5817 : : they do ODR use this decl. */
5818 : 3166641 : WB (lang->u.base.concept_p);
5819 : 3166641 : WB (lang->u.base.var_declared_inline_p);
5820 : 3166641 : WB (lang->u.base.dependent_init_p);
5821 : : /* When building a header unit, everthing is marked as purview, (so
5822 : : we know which decls to write). But when we import them we do not
5823 : : want to mark them as in module purview. */
5824 : 6146635 : WB (lang->u.base.module_purview_p && !header_module_p ());
5825 : 3166641 : WB (lang->u.base.module_attach_p);
5826 : 3166641 : WB (lang->u.base.module_keyed_decls_p);
5827 : 3166641 : switch (lang->u.base.selector)
5828 : : {
5829 : 0 : default:
5830 : 0 : gcc_unreachable ();
5831 : :
5832 : 693925 : case lds_fn: /* lang_decl_fn. */
5833 : 693925 : WB (lang->u.fn.global_ctor_p);
5834 : 693925 : WB (lang->u.fn.global_dtor_p);
5835 : 693925 : WB (lang->u.fn.static_function);
5836 : 693925 : WB (lang->u.fn.pure_virtual);
5837 : 693925 : WB (lang->u.fn.defaulted_p);
5838 : 693925 : WB (lang->u.fn.has_in_charge_parm_p);
5839 : 693925 : WB (lang->u.fn.has_vtt_parm_p);
5840 : : /* There shouldn't be a pending inline at this point. */
5841 : 693925 : gcc_assert (!lang->u.fn.pending_inline_p);
5842 : 693925 : WB (lang->u.fn.nonconverting);
5843 : 693925 : WB (lang->u.fn.thunk_p);
5844 : 693925 : WB (lang->u.fn.this_thunk_p);
5845 : : /* Do not stream lang->u.hidden_friend_p, it is a property of
5846 : : the TU. */
5847 : 693925 : WB (lang->u.fn.omp_declare_reduction_p);
5848 : 693925 : WB (lang->u.fn.has_dependent_explicit_spec_p);
5849 : 693925 : WB (lang->u.fn.immediate_fn_p);
5850 : 693925 : WB (lang->u.fn.maybe_deleted);
5851 : : /* We do not stream lang->u.fn.implicit_constexpr. */
5852 : 693925 : WB (lang->u.fn.escalated_p);
5853 : 693925 : WB (lang->u.fn.xobj_func);
5854 : 693925 : goto lds_min;
5855 : :
5856 : 1621 : case lds_decomp: /* lang_decl_decomp. */
5857 : : /* No bools. */
5858 : 1621 : goto lds_min;
5859 : :
5860 : : case lds_min: /* lang_decl_min. */
5861 : 3166641 : lds_min:
5862 : : /* No bools. */
5863 : : break;
5864 : :
5865 : : case lds_ns: /* lang_decl_ns. */
5866 : : /* No bools. */
5867 : : break;
5868 : :
5869 : : case lds_parm: /* lang_decl_parm. */
5870 : : /* No bools. */
5871 : : break;
5872 : : }
5873 : : #undef WB
5874 : 3166641 : }
5875 : :
5876 : : bool
5877 : 3083198 : trees_in::lang_decl_bools (tree t, bits_in& bits)
5878 : : {
5879 : : #define RB(X) ((X) = bits.b ())
5880 : 3083198 : struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
5881 : :
5882 : 3083198 : bits.bflush ();
5883 : 3083198 : lang->u.base.language = bits.b () ? lang_cplusplus : lang_c;
5884 : 3083198 : unsigned v;
5885 : 3083198 : v = bits.b () << 0;
5886 : 3083198 : v |= bits.b () << 1;
5887 : 3083198 : lang->u.base.use_template = v;
5888 : : /* lang->u.base.not_really_extern is not streamed. */
5889 : 3083198 : RB (lang->u.base.initialized_in_class);
5890 : 3083198 : RB (lang->u.base.threadprivate_or_deleted_p);
5891 : : /* lang->u.base.anticipated_p is not streamed. */
5892 : 3083198 : RB (lang->u.base.friend_or_tls);
5893 : 3083198 : RB (lang->u.base.unknown_bound_p);
5894 : : /* lang->u.base.odr_used is not streamed. */
5895 : 3083198 : RB (lang->u.base.concept_p);
5896 : 3083198 : RB (lang->u.base.var_declared_inline_p);
5897 : 3083198 : RB (lang->u.base.dependent_init_p);
5898 : 3083198 : RB (lang->u.base.module_purview_p);
5899 : 3083198 : RB (lang->u.base.module_attach_p);
5900 : 3083198 : RB (lang->u.base.module_keyed_decls_p);
5901 : 3083198 : switch (lang->u.base.selector)
5902 : : {
5903 : 0 : default:
5904 : 0 : gcc_unreachable ();
5905 : :
5906 : 687780 : case lds_fn: /* lang_decl_fn. */
5907 : 687780 : RB (lang->u.fn.global_ctor_p);
5908 : 687780 : RB (lang->u.fn.global_dtor_p);
5909 : 687780 : RB (lang->u.fn.static_function);
5910 : 687780 : RB (lang->u.fn.pure_virtual);
5911 : 687780 : RB (lang->u.fn.defaulted_p);
5912 : 687780 : RB (lang->u.fn.has_in_charge_parm_p);
5913 : 687780 : RB (lang->u.fn.has_vtt_parm_p);
5914 : 687780 : RB (lang->u.fn.nonconverting);
5915 : 687780 : RB (lang->u.fn.thunk_p);
5916 : 687780 : RB (lang->u.fn.this_thunk_p);
5917 : : /* lang->u.fn.hidden_friend_p is not streamed. */
5918 : 687780 : RB (lang->u.fn.omp_declare_reduction_p);
5919 : 687780 : RB (lang->u.fn.has_dependent_explicit_spec_p);
5920 : 687780 : RB (lang->u.fn.immediate_fn_p);
5921 : 687780 : RB (lang->u.fn.maybe_deleted);
5922 : : /* We do not stream lang->u.fn.implicit_constexpr. */
5923 : 687780 : RB (lang->u.fn.escalated_p);
5924 : 687780 : RB (lang->u.fn.xobj_func);
5925 : 687780 : goto lds_min;
5926 : :
5927 : 1453 : case lds_decomp: /* lang_decl_decomp. */
5928 : : /* No bools. */
5929 : 1453 : goto lds_min;
5930 : :
5931 : : case lds_min: /* lang_decl_min. */
5932 : 3083198 : lds_min:
5933 : : /* No bools. */
5934 : : break;
5935 : :
5936 : : case lds_ns: /* lang_decl_ns. */
5937 : : /* No bools. */
5938 : : break;
5939 : :
5940 : : case lds_parm: /* lang_decl_parm. */
5941 : : /* No bools. */
5942 : : break;
5943 : : }
5944 : : #undef RB
5945 : 3083198 : return !get_overrun ();
5946 : : }
5947 : :
5948 : : void
5949 : 249695 : trees_out::lang_type_bools (tree t, bits_out& bits)
5950 : : {
5951 : : #define WB(X) (bits.b (X))
5952 : 249695 : const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
5953 : :
5954 : 249695 : bits.bflush ();
5955 : 249695 : WB (lang->has_type_conversion);
5956 : 249695 : WB (lang->has_copy_ctor);
5957 : 249695 : WB (lang->has_default_ctor);
5958 : 249695 : WB (lang->const_needs_init);
5959 : 249695 : WB (lang->ref_needs_init);
5960 : 249695 : WB (lang->has_const_copy_assign);
5961 : 249695 : WB ((lang->use_template >> 0) & 1);
5962 : 249695 : WB ((lang->use_template >> 1) & 1);
5963 : :
5964 : 249695 : WB (lang->has_mutable);
5965 : 249695 : WB (lang->com_interface);
5966 : 249695 : WB (lang->non_pod_class);
5967 : 249695 : WB (lang->nearly_empty_p);
5968 : 249695 : WB (lang->user_align);
5969 : 249695 : WB (lang->has_copy_assign);
5970 : 249695 : WB (lang->has_new);
5971 : 249695 : WB (lang->has_array_new);
5972 : :
5973 : 249695 : WB ((lang->gets_delete >> 0) & 1);
5974 : 249695 : WB ((lang->gets_delete >> 1) & 1);
5975 : 249695 : WB (lang->interface_only);
5976 : 249695 : WB (lang->interface_unknown);
5977 : 249695 : WB (lang->contains_empty_class_p);
5978 : 249695 : WB (lang->anon_aggr);
5979 : 249695 : WB (lang->non_zero_init);
5980 : 249695 : WB (lang->empty_p);
5981 : :
5982 : 249695 : WB (lang->vec_new_uses_cookie);
5983 : 249695 : WB (lang->declared_class);
5984 : 249695 : WB (lang->diamond_shaped);
5985 : 249695 : WB (lang->repeated_base);
5986 : 249695 : gcc_assert (!lang->being_defined);
5987 : : // lang->debug_requested
5988 : 249695 : WB (lang->fields_readonly);
5989 : 249695 : WB (lang->ptrmemfunc_flag);
5990 : :
5991 : 249695 : WB (lang->lazy_default_ctor);
5992 : 249695 : WB (lang->lazy_copy_ctor);
5993 : 249695 : WB (lang->lazy_copy_assign);
5994 : 249695 : WB (lang->lazy_destructor);
5995 : 249695 : WB (lang->has_const_copy_ctor);
5996 : 249695 : WB (lang->has_complex_copy_ctor);
5997 : 249695 : WB (lang->has_complex_copy_assign);
5998 : 249695 : WB (lang->non_aggregate);
5999 : :
6000 : 249695 : WB (lang->has_complex_dflt);
6001 : 249695 : WB (lang->has_list_ctor);
6002 : 249695 : WB (lang->non_std_layout);
6003 : 249695 : WB (lang->is_literal);
6004 : 249695 : WB (lang->lazy_move_ctor);
6005 : 249695 : WB (lang->lazy_move_assign);
6006 : 249695 : WB (lang->has_complex_move_ctor);
6007 : 249695 : WB (lang->has_complex_move_assign);
6008 : :
6009 : 249695 : WB (lang->has_constexpr_ctor);
6010 : 249695 : WB (lang->unique_obj_representations);
6011 : 249695 : WB (lang->unique_obj_representations_set);
6012 : : #undef WB
6013 : 249695 : }
6014 : :
6015 : : bool
6016 : 235067 : trees_in::lang_type_bools (tree t, bits_in& bits)
6017 : : {
6018 : : #define RB(X) ((X) = bits.b ())
6019 : 235067 : struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
6020 : :
6021 : 235067 : bits.bflush ();
6022 : 235067 : RB (lang->has_type_conversion);
6023 : 235067 : RB (lang->has_copy_ctor);
6024 : 235067 : RB (lang->has_default_ctor);
6025 : 235067 : RB (lang->const_needs_init);
6026 : 235067 : RB (lang->ref_needs_init);
6027 : 235067 : RB (lang->has_const_copy_assign);
6028 : 235067 : unsigned v;
6029 : 235067 : v = bits.b () << 0;
6030 : 235067 : v |= bits.b () << 1;
6031 : 235067 : lang->use_template = v;
6032 : :
6033 : 235067 : RB (lang->has_mutable);
6034 : 235067 : RB (lang->com_interface);
6035 : 235067 : RB (lang->non_pod_class);
6036 : 235067 : RB (lang->nearly_empty_p);
6037 : 235067 : RB (lang->user_align);
6038 : 235067 : RB (lang->has_copy_assign);
6039 : 235067 : RB (lang->has_new);
6040 : 235067 : RB (lang->has_array_new);
6041 : :
6042 : 235067 : v = bits.b () << 0;
6043 : 235067 : v |= bits.b () << 1;
6044 : 235067 : lang->gets_delete = v;
6045 : 235067 : RB (lang->interface_only);
6046 : 235067 : RB (lang->interface_unknown);
6047 : 235067 : RB (lang->contains_empty_class_p);
6048 : 235067 : RB (lang->anon_aggr);
6049 : 235067 : RB (lang->non_zero_init);
6050 : 235067 : RB (lang->empty_p);
6051 : :
6052 : 235067 : RB (lang->vec_new_uses_cookie);
6053 : 235067 : RB (lang->declared_class);
6054 : 235067 : RB (lang->diamond_shaped);
6055 : 235067 : RB (lang->repeated_base);
6056 : 235067 : gcc_assert (!lang->being_defined);
6057 : 235067 : gcc_assert (!lang->debug_requested);
6058 : 235067 : RB (lang->fields_readonly);
6059 : 235067 : RB (lang->ptrmemfunc_flag);
6060 : :
6061 : 235067 : RB (lang->lazy_default_ctor);
6062 : 235067 : RB (lang->lazy_copy_ctor);
6063 : 235067 : RB (lang->lazy_copy_assign);
6064 : 235067 : RB (lang->lazy_destructor);
6065 : 235067 : RB (lang->has_const_copy_ctor);
6066 : 235067 : RB (lang->has_complex_copy_ctor);
6067 : 235067 : RB (lang->has_complex_copy_assign);
6068 : 235067 : RB (lang->non_aggregate);
6069 : :
6070 : 235067 : RB (lang->has_complex_dflt);
6071 : 235067 : RB (lang->has_list_ctor);
6072 : 235067 : RB (lang->non_std_layout);
6073 : 235067 : RB (lang->is_literal);
6074 : 235067 : RB (lang->lazy_move_ctor);
6075 : 235067 : RB (lang->lazy_move_assign);
6076 : 235067 : RB (lang->has_complex_move_ctor);
6077 : 235067 : RB (lang->has_complex_move_assign);
6078 : :
6079 : 235067 : RB (lang->has_constexpr_ctor);
6080 : 235067 : RB (lang->unique_obj_representations);
6081 : 235067 : RB (lang->unique_obj_representations_set);
6082 : : #undef RB
6083 : 235067 : return !get_overrun ();
6084 : : }
6085 : :
6086 : : /* Read & write the core values and pointers. */
6087 : :
6088 : : void
6089 : 55750816 : trees_out::core_vals (tree t)
6090 : : {
6091 : : #define WU(X) (u (X))
6092 : : #define WT(X) (tree_node (X))
6093 : 55750816 : tree_code code = TREE_CODE (t);
6094 : :
6095 : : /* First by shape of the tree. */
6096 : :
6097 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
6098 : : {
6099 : : /* Write this early, for better log information. */
6100 : 12770200 : WT (t->decl_minimal.name);
6101 : 12770200 : if (!DECL_TEMPLATE_PARM_P (t))
6102 : 9844974 : WT (t->decl_minimal.context);
6103 : :
6104 : 12770200 : if (state)
6105 : 10447110 : state->write_location (*this, t->decl_minimal.locus);
6106 : :
6107 : 12770200 : if (streaming_p ())
6108 : 4893542 : if (has_warning_spec (t))
6109 : 993 : u (get_warning_spec (t));
6110 : : }
6111 : :
6112 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
6113 : : {
6114 : : /* The only types we write also have TYPE_NON_COMMON. */
6115 : 3206049 : gcc_checking_assert (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON));
6116 : :
6117 : : /* We only stream the main variant. */
6118 : 3206049 : gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
6119 : :
6120 : : /* Stream the name & context first, for better log information */
6121 : 3206049 : WT (t->type_common.name);
6122 : 3206049 : WT (t->type_common.context);
6123 : :
6124 : : /* By construction we want to make sure we have the canonical
6125 : : and main variants already in the type table, so emit them
6126 : : now. */
6127 : 3206049 : WT (t->type_common.main_variant);
6128 : :
6129 : 3206049 : tree canonical = t->type_common.canonical;
6130 : 3206049 : if (canonical && DECL_TEMPLATE_PARM_P (TYPE_NAME (t)))
6131 : : /* We do not want to wander into different templates.
6132 : : Reconstructed on stream in. */
6133 : : canonical = t;
6134 : 3206049 : WT (canonical);
6135 : :
6136 : : /* type_common.next_variant is internally manipulated. */
6137 : : /* type_common.pointer_to, type_common.reference_to. */
6138 : :
6139 : 3206049 : if (streaming_p ())
6140 : : {
6141 : 870041 : WU (t->type_common.precision);
6142 : 870041 : WU (t->type_common.contains_placeholder_bits);
6143 : 870041 : WU (t->type_common.mode);
6144 : 870041 : WU (t->type_common.align);
6145 : : }
6146 : :
6147 : 3206049 : if (!RECORD_OR_UNION_CODE_P (code))
6148 : : {
6149 : 2639797 : WT (t->type_common.size);
6150 : 2639797 : WT (t->type_common.size_unit);
6151 : : }
6152 : 3206049 : WT (t->type_common.attributes);
6153 : :
6154 : 3206049 : WT (t->type_common.common.chain); /* TYPE_STUB_DECL. */
6155 : : }
6156 : :
6157 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
6158 : : {
6159 : 12770200 : if (streaming_p ())
6160 : : {
6161 : 4893542 : WU (t->decl_common.mode);
6162 : 4893542 : WU (t->decl_common.off_align);
6163 : 4893542 : WU (t->decl_common.align);
6164 : : }
6165 : :
6166 : : /* For templates these hold instantiation (partial and/or
6167 : : specialization) information. */
6168 : 12770200 : if (code != TEMPLATE_DECL)
6169 : : {
6170 : 11773284 : WT (t->decl_common.size);
6171 : 11773284 : WT (t->decl_common.size_unit);
6172 : : }
6173 : :
6174 : 12770200 : WT (t->decl_common.attributes);
6175 : : // FIXME: Does this introduce cross-decl links? For instance
6176 : : // from instantiation to the template. If so, we'll need more
6177 : : // deduplication logic. I think we'll need to walk the blocks
6178 : : // of the owning function_decl's abstract origin in tandem, to
6179 : : // generate the locating data needed?
6180 : 12770200 : WT (t->decl_common.abstract_origin);
6181 : : }
6182 : :
6183 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
6184 : : {
6185 : 6073689 : WT (t->decl_with_vis.assembler_name);
6186 : 6073689 : if (streaming_p ())
6187 : 2295115 : WU (t->decl_with_vis.visibility);
6188 : : }
6189 : :
6190 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
6191 : : {
6192 : 3206049 : if (code == ENUMERAL_TYPE)
6193 : : {
6194 : : /* These fields get set even for opaque enums that lack a
6195 : : definition, so we stream them directly for each ENUMERAL_TYPE.
6196 : : We stream TYPE_VALUES as part of the definition. */
6197 : 12297 : WT (t->type_non_common.maxval);
6198 : 12297 : WT (t->type_non_common.minval);
6199 : : }
6200 : : /* Records and unions hold FIELDS, VFIELD & BINFO on these
6201 : : things. */
6202 : 3193752 : else if (!RECORD_OR_UNION_CODE_P (code))
6203 : : {
6204 : : // FIXME: These are from tpl_parm_value's 'type' writing.
6205 : : // Perhaps it should just be doing them directly?
6206 : 2627500 : gcc_checking_assert (code == TEMPLATE_TYPE_PARM
6207 : : || code == TEMPLATE_TEMPLATE_PARM
6208 : : || code == BOUND_TEMPLATE_TEMPLATE_PARM);
6209 : 2627500 : gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
6210 : 2627500 : WT (t->type_non_common.values);
6211 : 2627500 : WT (t->type_non_common.maxval);
6212 : 2627500 : WT (t->type_non_common.minval);
6213 : : }
6214 : :
6215 : 3206049 : WT (t->type_non_common.lang_1);
6216 : : }
6217 : :
6218 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
6219 : : {
6220 : 15946223 : if (state)
6221 : 15671662 : state->write_location (*this, t->exp.locus);
6222 : :
6223 : 15946223 : if (streaming_p ())
6224 : 7773502 : if (has_warning_spec (t))
6225 : 637638 : u (get_warning_spec (t));
6226 : :
6227 : : /* Walk in forward order, as (for instance) REQUIRES_EXPR has a
6228 : : bunch of unscoped parms on its first operand. It's safer to
6229 : : create those in order. */
6230 : 15946223 : bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
6231 : 58610067 : for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
6232 : 14306476 : : TREE_OPERAND_LENGTH (t)),
6233 : 44303591 : ix = unsigned (vl); ix != limit; ix++)
6234 : 28357368 : WT (TREE_OPERAND (t, ix));
6235 : : }
6236 : : else
6237 : : /* The CODE_CONTAINS tables were inaccurate when I started. */
6238 : 39804593 : gcc_checking_assert (TREE_CODE_CLASS (code) != tcc_expression
6239 : : && TREE_CODE_CLASS (code) != tcc_binary
6240 : : && TREE_CODE_CLASS (code) != tcc_unary
6241 : : && TREE_CODE_CLASS (code) != tcc_reference
6242 : : && TREE_CODE_CLASS (code) != tcc_comparison
6243 : : && TREE_CODE_CLASS (code) != tcc_statement
6244 : : && TREE_CODE_CLASS (code) != tcc_vl_exp);
6245 : :
6246 : : /* Then by CODE. Special cases and/or 1:1 tree shape
6247 : : correspondance. */
6248 : 55750816 : switch (code)
6249 : : {
6250 : : default:
6251 : : break;
6252 : :
6253 : 0 : case ARGUMENT_PACK_SELECT: /* Transient during instantiation. */
6254 : 0 : case DEFERRED_PARSE: /* Expanded upon completion of
6255 : : outermost class. */
6256 : 0 : case IDENTIFIER_NODE: /* Streamed specially. */
6257 : 0 : case BINDING_VECTOR: /* Only in namespace-scope symbol
6258 : : table. */
6259 : 0 : case SSA_NAME:
6260 : 0 : case TRANSLATION_UNIT_DECL: /* There is only one, it is a
6261 : : global_tree. */
6262 : 0 : case USERDEF_LITERAL: /* Expanded during parsing. */
6263 : 0 : gcc_unreachable (); /* Should never meet. */
6264 : :
6265 : : /* Constants. */
6266 : 18 : case COMPLEX_CST:
6267 : 18 : WT (TREE_REALPART (t));
6268 : 18 : WT (TREE_IMAGPART (t));
6269 : 18 : break;
6270 : :
6271 : 0 : case FIXED_CST:
6272 : 0 : gcc_unreachable (); /* Not supported in C++. */
6273 : :
6274 : 5282485 : case INTEGER_CST:
6275 : 5282485 : if (streaming_p ())
6276 : : {
6277 : 853563 : unsigned num = TREE_INT_CST_EXT_NUNITS (t);
6278 : 1709679 : for (unsigned ix = 0; ix != num; ix++)
6279 : 856116 : wu (TREE_INT_CST_ELT (t, ix));
6280 : : }
6281 : : break;
6282 : :
6283 : 0 : case POLY_INT_CST:
6284 : 0 : if (streaming_p ())
6285 : 0 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
6286 : 0 : WT (POLY_INT_CST_COEFF (t, ix));
6287 : : break;
6288 : :
6289 : 60430 : case REAL_CST:
6290 : 60430 : if (streaming_p ())
6291 : 30143 : buf (TREE_REAL_CST_PTR (t), sizeof (real_value));
6292 : : break;
6293 : :
6294 : : case STRING_CST:
6295 : : /* Streamed during start. */
6296 : : break;
6297 : :
6298 : 36 : case VECTOR_CST:
6299 : 102 : for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
6300 : 66 : WT (VECTOR_CST_ENCODED_ELT (t, ix));
6301 : : break;
6302 : :
6303 : : /* Decls. */
6304 : 630230 : case VAR_DECL:
6305 : 630230 : if (DECL_CONTEXT (t)
6306 : 630230 : && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
6307 : : break;
6308 : : /* FALLTHROUGH */
6309 : :
6310 : 5722652 : case RESULT_DECL:
6311 : 5722652 : case PARM_DECL:
6312 : 5722652 : if (DECL_HAS_VALUE_EXPR_P (t))
6313 : 46796 : WT (DECL_VALUE_EXPR (t));
6314 : : /* FALLTHROUGH */
6315 : :
6316 : 5961782 : case CONST_DECL:
6317 : 5961782 : case IMPORTED_DECL:
6318 : 5961782 : WT (t->decl_common.initial);
6319 : 5961782 : break;
6320 : :
6321 : 180303 : case FIELD_DECL:
6322 : 180303 : WT (t->field_decl.offset);
6323 : 180303 : WT (t->field_decl.bit_field_type);
6324 : 180303 : WT (t->field_decl.qualifier); /* bitfield unit. */
6325 : 180303 : WT (t->field_decl.bit_offset);
6326 : 180303 : WT (t->field_decl.fcontext);
6327 : 180303 : WT (t->decl_common.initial);
6328 : 180303 : break;
6329 : :
6330 : 47490 : case LABEL_DECL:
6331 : 47490 : if (streaming_p ())
6332 : : {
6333 : 23745 : WU (t->label_decl.label_decl_uid);
6334 : 23745 : WU (t->label_decl.eh_landing_pad_nr);
6335 : : }
6336 : : break;
6337 : :
6338 : 1388022 : case FUNCTION_DECL:
6339 : 1388022 : if (streaming_p ())
6340 : : {
6341 : : /* Builtins can be streamed by value when a header declares
6342 : : them. */
6343 : 693925 : WU (DECL_BUILT_IN_CLASS (t));
6344 : 693925 : if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
6345 : 15241 : WU (DECL_UNCHECKED_FUNCTION_CODE (t));
6346 : : }
6347 : :
6348 : 1388022 : WT (t->function_decl.personality);
6349 : 1388022 : WT (t->function_decl.function_specific_target);
6350 : 1388022 : WT (t->function_decl.function_specific_optimization);
6351 : 1388022 : WT (t->function_decl.vindex);
6352 : :
6353 : 1388022 : if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
6354 : 5736 : WT (lookup_explicit_specifier (t));
6355 : : break;
6356 : :
6357 : 132729 : case USING_DECL:
6358 : : /* USING_DECL_DECLS */
6359 : 132729 : WT (t->decl_common.initial);
6360 : : /* FALLTHROUGH */
6361 : :
6362 : 4054696 : case TYPE_DECL:
6363 : : /* USING_DECL: USING_DECL_SCOPE */
6364 : : /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6365 : 4054696 : WT (t->decl_non_common.result);
6366 : 4054696 : break;
6367 : :
6368 : : /* Miscellaneous common nodes. */
6369 : 850025 : case BLOCK:
6370 : 850025 : if (state)
6371 : : {
6372 : 850025 : state->write_location (*this, t->block.locus);
6373 : 850025 : state->write_location (*this, t->block.end_locus);
6374 : : }
6375 : :
6376 : : /* DECL_LOCAL_DECL_P decls are first encountered here and
6377 : : streamed by value. */
6378 : 1304631 : for (tree decls = t->block.vars; decls; decls = DECL_CHAIN (decls))
6379 : : {
6380 : 454606 : if (VAR_OR_FUNCTION_DECL_P (decls)
6381 : 454606 : && DECL_LOCAL_DECL_P (decls))
6382 : : {
6383 : : /* Make sure this is the first encounter, and mark for
6384 : : walk-by-value. */
6385 : 310 : gcc_checking_assert (!TREE_VISITED (decls)
6386 : : && !DECL_TEMPLATE_INFO (decls));
6387 : 310 : mark_by_value (decls);
6388 : : }
6389 : 454606 : tree_node (decls);
6390 : : }
6391 : 850025 : tree_node (NULL_TREE);
6392 : :
6393 : : /* nonlocalized_vars is a middle-end thing. */
6394 : 850025 : WT (t->block.subblocks);
6395 : 850025 : WT (t->block.supercontext);
6396 : : // FIXME: As for decl's abstract_origin, does this introduce crosslinks?
6397 : 850025 : WT (t->block.abstract_origin);
6398 : : /* fragment_origin, fragment_chain are middle-end things. */
6399 : 850025 : WT (t->block.chain);
6400 : : /* nonlocalized_vars, block_num & die are middle endy/debug
6401 : : things. */
6402 : 850025 : break;
6403 : :
6404 : 1607065 : case CALL_EXPR:
6405 : 1607065 : if (streaming_p ())
6406 : 773582 : WU (t->base.u.ifn);
6407 : : break;
6408 : :
6409 : : case CONSTRUCTOR:
6410 : : // This must be streamed /after/ we've streamed the type,
6411 : : // because it can directly refer to elements of the type. Eg,
6412 : : // FIELD_DECLs of a RECORD_TYPE.
6413 : : break;
6414 : :
6415 : 6 : case OMP_CLAUSE:
6416 : 6 : {
6417 : : /* The ompcode is serialized in start. */
6418 : 6 : if (streaming_p ())
6419 : 3 : WU (t->omp_clause.subcode.map_kind);
6420 : 6 : if (state)
6421 : 6 : state->write_location (*this, t->omp_clause.locus);
6422 : :
6423 : 6 : unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
6424 : 18 : for (unsigned ix = 0; ix != len; ix++)
6425 : 12 : WT (t->omp_clause.ops[ix]);
6426 : : }
6427 : : break;
6428 : :
6429 : 585695 : case STATEMENT_LIST:
6430 : 2348991 : for (tree stmt : tsi_range (t))
6431 : 1763296 : if (stmt)
6432 : 1763296 : WT (stmt);
6433 : 585695 : WT (NULL_TREE);
6434 : 585695 : break;
6435 : :
6436 : 0 : case OPTIMIZATION_NODE:
6437 : 0 : case TARGET_OPTION_NODE:
6438 : : // FIXME: Our representation for these two nodes is a cache of
6439 : : // the resulting set of options. Not a record of the options
6440 : : // that got changed by a particular attribute or pragma. Should
6441 : : // we record that, or should we record the diff from the command
6442 : : // line options? The latter seems the right behaviour, but is
6443 : : // (a) harder, and I guess could introduce strangeness if the
6444 : : // importer has set some incompatible set of optimization flags?
6445 : 0 : gcc_unreachable ();
6446 : 337167 : break;
6447 : :
6448 : 337167 : case TREE_BINFO:
6449 : 337167 : {
6450 : 337167 : WT (t->binfo.common.chain);
6451 : 337167 : WT (t->binfo.offset);
6452 : 337167 : WT (t->binfo.inheritance);
6453 : 337167 : WT (t->binfo.vptr_field);
6454 : :
6455 : 337167 : WT (t->binfo.vtable);
6456 : 337167 : WT (t->binfo.virtuals);
6457 : 337167 : WT (t->binfo.vtt_subvtt);
6458 : 337167 : WT (t->binfo.vtt_vptr);
6459 : :
6460 : 337167 : tree_vec (BINFO_BASE_ACCESSES (t));
6461 : 337167 : unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
6462 : 439221 : for (unsigned ix = 0; ix != num; ix++)
6463 : 102054 : WT (BINFO_BASE_BINFO (t, ix));
6464 : : }
6465 : : break;
6466 : :
6467 : 4432211 : case TREE_LIST:
6468 : 4432211 : WT (t->list.purpose);
6469 : 4432211 : WT (t->list.value);
6470 : 4432211 : WT (t->list.common.chain);
6471 : 4432211 : break;
6472 : :
6473 : 3588067 : case TREE_VEC:
6474 : 10147811 : for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
6475 : 6559744 : WT (TREE_VEC_ELT (t, ix));
6476 : : /* We stash NON_DEFAULT_TEMPLATE_ARGS_COUNT on TREE_CHAIN! */
6477 : 3588067 : gcc_checking_assert (!t->type_common.common.chain
6478 : : || (TREE_CODE (t->type_common.common.chain)
6479 : : == INTEGER_CST));
6480 : 3588067 : WT (t->type_common.common.chain);
6481 : 3588067 : break;
6482 : :
6483 : : /* C++-specific nodes ... */
6484 : 284026 : case BASELINK:
6485 : 284026 : WT (((lang_tree_node *)t)->baselink.binfo);
6486 : 284026 : WT (((lang_tree_node *)t)->baselink.functions);
6487 : 284026 : WT (((lang_tree_node *)t)->baselink.access_binfo);
6488 : 284026 : break;
6489 : :
6490 : 78877 : case CONSTRAINT_INFO:
6491 : 78877 : WT (((lang_tree_node *)t)->constraint_info.template_reqs);
6492 : 78877 : WT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
6493 : 78877 : WT (((lang_tree_node *)t)->constraint_info.associated_constr);
6494 : 78877 : break;
6495 : :
6496 : 17896 : case DEFERRED_NOEXCEPT:
6497 : 17896 : WT (((lang_tree_node *)t)->deferred_noexcept.pattern);
6498 : 17896 : WT (((lang_tree_node *)t)->deferred_noexcept.args);
6499 : 17896 : break;
6500 : :
6501 : 16790 : case LAMBDA_EXPR:
6502 : 16790 : WT (((lang_tree_node *)t)->lambda_expression.capture_list);
6503 : 16790 : WT (((lang_tree_node *)t)->lambda_expression.this_capture);
6504 : 16790 : WT (((lang_tree_node *)t)->lambda_expression.extra_scope);
6505 : 16790 : WT (((lang_tree_node *)t)->lambda_expression.regen_info);
6506 : 16790 : WT (((lang_tree_node *)t)->lambda_expression.extra_args);
6507 : : /* pending_proxies is a parse-time thing. */
6508 : 16790 : gcc_assert (!((lang_tree_node *)t)->lambda_expression.pending_proxies);
6509 : 16790 : if (state)
6510 : 16790 : state->write_location
6511 : 16790 : (*this, ((lang_tree_node *)t)->lambda_expression.locus);
6512 : 16790 : if (streaming_p ())
6513 : : {
6514 : 5615 : WU (((lang_tree_node *)t)->lambda_expression.default_capture_mode);
6515 : 5615 : WU (((lang_tree_node *)t)->lambda_expression.discriminator_scope);
6516 : 5615 : WU (((lang_tree_node *)t)->lambda_expression.discriminator_sig);
6517 : : }
6518 : : break;
6519 : :
6520 : 2907012 : case OVERLOAD:
6521 : 2907012 : WT (((lang_tree_node *)t)->overload.function);
6522 : 2907012 : WT (t->common.chain);
6523 : 2907012 : break;
6524 : :
6525 : 0 : case PTRMEM_CST:
6526 : 0 : WT (((lang_tree_node *)t)->ptrmem.member);
6527 : 0 : break;
6528 : :
6529 : 22152 : case STATIC_ASSERT:
6530 : 22152 : WT (((lang_tree_node *)t)->static_assertion.condition);
6531 : 22152 : WT (((lang_tree_node *)t)->static_assertion.message);
6532 : 22152 : if (state)
6533 : 22152 : state->write_location
6534 : 22152 : (*this, ((lang_tree_node *)t)->static_assertion.location);
6535 : : break;
6536 : :
6537 : 996916 : case TEMPLATE_DECL:
6538 : : /* Streamed with the template_decl node itself. */
6539 : 996916 : gcc_checking_assert
6540 : : (TREE_VISITED (((lang_tree_node *)t)->template_decl.arguments));
6541 : 996916 : gcc_checking_assert
6542 : : (TREE_VISITED (((lang_tree_node *)t)->template_decl.result));
6543 : 996916 : if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
6544 : 13924 : WT (DECL_CHAIN (t));
6545 : : break;
6546 : :
6547 : 2262060 : case TEMPLATE_INFO:
6548 : 2262060 : {
6549 : 2262060 : WT (((lang_tree_node *)t)->template_info.tmpl);
6550 : 2262060 : WT (((lang_tree_node *)t)->template_info.args);
6551 : 2262060 : WT (((lang_tree_node *)t)->template_info.partial);
6552 : :
6553 : 2262060 : const auto *ac = (((lang_tree_node *)t)
6554 : : ->template_info.deferred_access_checks);
6555 : 2262060 : unsigned len = vec_safe_length (ac);
6556 : 2262060 : if (streaming_p ())
6557 : 1129087 : u (len);
6558 : 2262060 : if (len)
6559 : : {
6560 : 0 : for (unsigned ix = 0; ix != len; ix++)
6561 : : {
6562 : 0 : const auto &m = (*ac)[ix];
6563 : 0 : WT (m.binfo);
6564 : 0 : WT (m.decl);
6565 : 0 : WT (m.diag_decl);
6566 : 0 : if (state)
6567 : 0 : state->write_location (*this, m.loc);
6568 : : }
6569 : : }
6570 : : }
6571 : : break;
6572 : :
6573 : 2820103 : case TEMPLATE_PARM_INDEX:
6574 : 2820103 : if (streaming_p ())
6575 : : {
6576 : 620115 : WU (((lang_tree_node *)t)->tpi.index);
6577 : 620115 : WU (((lang_tree_node *)t)->tpi.level);
6578 : 620115 : WU (((lang_tree_node *)t)->tpi.orig_level);
6579 : : }
6580 : 2820103 : WT (((lang_tree_node *)t)->tpi.decl);
6581 : : /* TEMPLATE_PARM_DESCENDANTS (AKA TREE_CHAIN) is an internal
6582 : : cache, do not stream. */
6583 : 2820103 : break;
6584 : :
6585 : 36110 : case TRAIT_EXPR:
6586 : 36110 : WT (((lang_tree_node *)t)->trait_expression.type1);
6587 : 36110 : WT (((lang_tree_node *)t)->trait_expression.type2);
6588 : 36110 : if (streaming_p ())
6589 : 13930 : WU (((lang_tree_node *)t)->trait_expression.kind);
6590 : : break;
6591 : : }
6592 : :
6593 : 55750816 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
6594 : : {
6595 : : /* We want to stream the type of a expression-like nodes /after/
6596 : : we've streamed the operands. The type often contains (bits
6597 : : of the) types of the operands, and with things like decltype
6598 : : and noexcept in play, we really want to stream the decls
6599 : : defining the type before we try and stream the type on its
6600 : : own. Otherwise we can find ourselves trying to read in a
6601 : : decl, when we're already partially reading in a component of
6602 : : its type. And that's bad. */
6603 : 52519806 : tree type = t->typed.type;
6604 : 52519806 : unsigned prec = 0;
6605 : :
6606 : 52519806 : switch (code)
6607 : : {
6608 : : default:
6609 : : break;
6610 : :
6611 : : case TEMPLATE_DECL:
6612 : : /* We fill in the template's type separately. */
6613 : 52519806 : type = NULL_TREE;
6614 : : break;
6615 : :
6616 : 3921967 : case TYPE_DECL:
6617 : 3921967 : if (DECL_ORIGINAL_TYPE (t) && t == TYPE_NAME (type))
6618 : : /* This is a typedef. We set its type separately. */
6619 : : type = NULL_TREE;
6620 : : break;
6621 : :
6622 : 12297 : case ENUMERAL_TYPE:
6623 : 12297 : if (type && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
6624 : : {
6625 : : /* Type is a restricted range integer type derived from the
6626 : : integer_types. Find the right one. */
6627 : 8103 : prec = TYPE_PRECISION (type);
6628 : 8103 : tree name = DECL_NAME (TYPE_NAME (type));
6629 : :
6630 : 105793 : for (unsigned itk = itk_none; itk--;)
6631 : 105793 : if (integer_types[itk]
6632 : 105793 : && DECL_NAME (TYPE_NAME (integer_types[itk])) == name)
6633 : : {
6634 : : type = integer_types[itk];
6635 : : break;
6636 : : }
6637 : 8103 : gcc_assert (type != t->typed.type);
6638 : : }
6639 : : break;
6640 : : }
6641 : :
6642 : 52519806 : WT (type);
6643 : 52519806 : if (prec && streaming_p ())
6644 : 4050 : WU (prec);
6645 : : }
6646 : :
6647 : 55750816 : if (TREE_CODE (t) == CONSTRUCTOR)
6648 : : {
6649 : 129904 : unsigned len = vec_safe_length (t->constructor.elts);
6650 : 129904 : if (streaming_p ())
6651 : 63828 : WU (len);
6652 : 129904 : if (len)
6653 : 307980 : for (unsigned ix = 0; ix != len; ix++)
6654 : : {
6655 : 266015 : const constructor_elt &elt = (*t->constructor.elts)[ix];
6656 : :
6657 : 266015 : WT (elt.index);
6658 : 266015 : WT (elt.value);
6659 : : }
6660 : : }
6661 : :
6662 : : #undef WT
6663 : : #undef WU
6664 : 55750816 : }
6665 : :
6666 : : // Streaming in a reference to a decl can cause that decl to be
6667 : : // TREE_USED, which is the mark_used behaviour we need most of the
6668 : : // time. The trees_in::unused can be incremented to inhibit this,
6669 : : // which is at least needed for vtables.
6670 : :
6671 : : bool
6672 : 20673224 : trees_in::core_vals (tree t)
6673 : : {
6674 : : #define RU(X) ((X) = u ())
6675 : : #define RUC(T,X) ((X) = T (u ()))
6676 : : #define RT(X) ((X) = tree_node ())
6677 : : #define RTU(X) ((X) = tree_node (true))
6678 : 20673224 : tree_code code = TREE_CODE (t);
6679 : :
6680 : : /* First by tree shape. */
6681 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
6682 : : {
6683 : 4738681 : RT (t->decl_minimal.name);
6684 : 4738681 : if (!DECL_TEMPLATE_PARM_P (t))
6685 : 4125749 : RT (t->decl_minimal.context);
6686 : :
6687 : : /* Don't zap the locus just yet, we don't record it correctly
6688 : : and thus lose all location information. */
6689 : 4738681 : t->decl_minimal.locus = state->read_location (*this);
6690 : 4738681 : if (has_warning_spec (t))
6691 : 976 : put_warning_spec (t, u ());
6692 : : }
6693 : :
6694 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
6695 : : {
6696 : 816463 : RT (t->type_common.name);
6697 : 816463 : RT (t->type_common.context);
6698 : :
6699 : 816463 : RT (t->type_common.main_variant);
6700 : 816463 : RT (t->type_common.canonical);
6701 : :
6702 : : /* type_common.next_variant is internally manipulated. */
6703 : : /* type_common.pointer_to, type_common.reference_to. */
6704 : :
6705 : 816463 : RU (t->type_common.precision);
6706 : 816463 : RU (t->type_common.contains_placeholder_bits);
6707 : 816463 : RUC (machine_mode, t->type_common.mode);
6708 : 816463 : RU (t->type_common.align);
6709 : :
6710 : 816463 : if (!RECORD_OR_UNION_CODE_P (code))
6711 : : {
6712 : 551692 : RT (t->type_common.size);
6713 : 551692 : RT (t->type_common.size_unit);
6714 : : }
6715 : 816463 : RT (t->type_common.attributes);
6716 : :
6717 : 816463 : RT (t->type_common.common.chain); /* TYPE_STUB_DECL. */
6718 : : }
6719 : :
6720 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
6721 : : {
6722 : 4738681 : RUC (machine_mode, t->decl_common.mode);
6723 : 4738681 : RU (t->decl_common.off_align);
6724 : 4738681 : RU (t->decl_common.align);
6725 : :
6726 : 4738681 : if (code != TEMPLATE_DECL)
6727 : : {
6728 : 4263423 : RT (t->decl_common.size);
6729 : 4263423 : RT (t->decl_common.size_unit);
6730 : : }
6731 : :
6732 : 4738681 : RT (t->decl_common.attributes);
6733 : 4738681 : RT (t->decl_common.abstract_origin);
6734 : : }
6735 : :
6736 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
6737 : : {
6738 : 2203551 : RT (t->decl_with_vis.assembler_name);
6739 : 2203551 : RUC (symbol_visibility, t->decl_with_vis.visibility);
6740 : : }
6741 : :
6742 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
6743 : : {
6744 : 816463 : if (code == ENUMERAL_TYPE)
6745 : : {
6746 : : /* These fields get set even for opaque enums that lack a
6747 : : definition, so we stream them directly for each ENUMERAL_TYPE.
6748 : : We stream TYPE_VALUES as part of the definition. */
6749 : 5285 : RT (t->type_non_common.maxval);
6750 : 5285 : RT (t->type_non_common.minval);
6751 : : }
6752 : : /* Records and unions hold FIELDS, VFIELD & BINFO on these
6753 : : things. */
6754 : 811178 : else if (!RECORD_OR_UNION_CODE_P (code))
6755 : : {
6756 : : /* This is not clobbering TYPE_CACHED_VALUES, because this
6757 : : is a type that doesn't have any. */
6758 : 546407 : gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
6759 : 546407 : RT (t->type_non_common.values);
6760 : 546407 : RT (t->type_non_common.maxval);
6761 : 546407 : RT (t->type_non_common.minval);
6762 : : }
6763 : :
6764 : 816463 : RT (t->type_non_common.lang_1);
6765 : : }
6766 : :
6767 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
6768 : : {
6769 : 7643529 : t->exp.locus = state->read_location (*this);
6770 : 7643529 : if (has_warning_spec (t))
6771 : 630981 : put_warning_spec (t, u ());
6772 : :
6773 : 7643529 : bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
6774 : 14513199 : for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
6775 : 6869670 : : TREE_OPERAND_LENGTH (t)),
6776 : 21212070 : ix = unsigned (vl); ix != limit; ix++)
6777 : 13568541 : RTU (TREE_OPERAND (t, ix));
6778 : : }
6779 : :
6780 : : /* Then by CODE. Special cases and/or 1:1 tree shape
6781 : : correspondance. */
6782 : 20673224 : switch (code)
6783 : : {
6784 : : default:
6785 : : break;
6786 : :
6787 : : case ARGUMENT_PACK_SELECT:
6788 : : case DEFERRED_PARSE:
6789 : : case IDENTIFIER_NODE:
6790 : : case BINDING_VECTOR:
6791 : : case SSA_NAME:
6792 : : case TRANSLATION_UNIT_DECL:
6793 : : case USERDEF_LITERAL:
6794 : : return false; /* Should never meet. */
6795 : :
6796 : : /* Constants. */
6797 : 9 : case COMPLEX_CST:
6798 : 9 : RT (TREE_REALPART (t));
6799 : 9 : RT (TREE_IMAGPART (t));
6800 : 9 : break;
6801 : :
6802 : : case FIXED_CST:
6803 : : /* Not suported in C++. */
6804 : : return false;
6805 : :
6806 : 807984 : case INTEGER_CST:
6807 : 807984 : {
6808 : 807984 : unsigned num = TREE_INT_CST_EXT_NUNITS (t);
6809 : 1618434 : for (unsigned ix = 0; ix != num; ix++)
6810 : 810450 : TREE_INT_CST_ELT (t, ix) = wu ();
6811 : : }
6812 : : break;
6813 : :
6814 : : case POLY_INT_CST:
6815 : 0 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
6816 : 0 : RT (POLY_INT_CST_COEFF (t, ix));
6817 : : break;
6818 : :
6819 : 35439 : case REAL_CST:
6820 : 35439 : if (const void *bytes = buf (sizeof (real_value)))
6821 : 35439 : memcpy (TREE_REAL_CST_PTR (t), bytes, sizeof (real_value));
6822 : : break;
6823 : :
6824 : : case STRING_CST:
6825 : : /* Streamed during start. */
6826 : : break;
6827 : :
6828 : 24 : case VECTOR_CST:
6829 : 63 : for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
6830 : 39 : RT (VECTOR_CST_ENCODED_ELT (t, ix));
6831 : : break;
6832 : :
6833 : : /* Decls. */
6834 : 306058 : case VAR_DECL:
6835 : 306058 : if (DECL_CONTEXT (t)
6836 : 306058 : && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
6837 : : break;
6838 : : /* FALLTHROUGH */
6839 : :
6840 : 2129401 : case RESULT_DECL:
6841 : 2129401 : case PARM_DECL:
6842 : 2129401 : if (DECL_HAS_VALUE_EXPR_P (t))
6843 : : {
6844 : : /* The DECL_VALUE hash table is a cache, thus if we're
6845 : : reading a duplicate (which we end up discarding), the
6846 : : value expr will also be cleaned up at the next gc. */
6847 : 19080 : tree val = tree_node ();
6848 : 19080 : SET_DECL_VALUE_EXPR (t, val);
6849 : : }
6850 : : /* FALLTHROUGH */
6851 : :
6852 : 2189967 : case CONST_DECL:
6853 : 2189967 : case IMPORTED_DECL:
6854 : 2189967 : RT (t->decl_common.initial);
6855 : 2189967 : break;
6856 : :
6857 : 85434 : case FIELD_DECL:
6858 : 85434 : RT (t->field_decl.offset);
6859 : 85434 : RT (t->field_decl.bit_field_type);
6860 : 85434 : RT (t->field_decl.qualifier);
6861 : 85434 : RT (t->field_decl.bit_offset);
6862 : 85434 : RT (t->field_decl.fcontext);
6863 : 85434 : RT (t->decl_common.initial);
6864 : 85434 : break;
6865 : :
6866 : 22277 : case LABEL_DECL:
6867 : 22277 : RU (t->label_decl.label_decl_uid);
6868 : 22277 : RU (t->label_decl.eh_landing_pad_nr);
6869 : 22277 : break;
6870 : :
6871 : 687780 : case FUNCTION_DECL:
6872 : 687780 : {
6873 : 687780 : unsigned bltin = u ();
6874 : 687780 : t->function_decl.built_in_class = built_in_class (bltin);
6875 : 687780 : if (bltin != NOT_BUILT_IN)
6876 : : {
6877 : 16139 : bltin = u ();
6878 : 16139 : DECL_UNCHECKED_FUNCTION_CODE (t) = built_in_function (bltin);
6879 : : }
6880 : :
6881 : 687780 : RT (t->function_decl.personality);
6882 : 687780 : RT (t->function_decl.function_specific_target);
6883 : 687780 : RT (t->function_decl.function_specific_optimization);
6884 : 687780 : RT (t->function_decl.vindex);
6885 : :
6886 : 687780 : if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
6887 : : {
6888 : 2737 : tree spec;
6889 : 2737 : RT (spec);
6890 : 2737 : store_explicit_specifier (t, spec);
6891 : : }
6892 : : }
6893 : : break;
6894 : :
6895 : 60200 : case USING_DECL:
6896 : : /* USING_DECL_DECLS */
6897 : 60200 : RT (t->decl_common.initial);
6898 : : /* FALLTHROUGH */
6899 : :
6900 : 1209339 : case TYPE_DECL:
6901 : : /* USING_DECL: USING_DECL_SCOPE */
6902 : : /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6903 : 1209339 : RT (t->decl_non_common.result);
6904 : 1209339 : break;
6905 : :
6906 : : /* Miscellaneous common nodes. */
6907 : 420427 : case BLOCK:
6908 : 420427 : t->block.locus = state->read_location (*this);
6909 : 420427 : t->block.end_locus = state->read_location (*this);
6910 : :
6911 : 420427 : for (tree *chain = &t->block.vars;;)
6912 : 648719 : if (tree decl = tree_node ())
6913 : : {
6914 : : /* For a deduplicated local type or enumerator, chain the
6915 : : duplicate decl instead of the canonical in-TU decl. Seeing
6916 : : a duplicate here means the containing function whose body
6917 : : we're streaming in is a duplicate too, so we'll end up
6918 : : discarding this BLOCK (and the rest of the duplicate function
6919 : : body) anyway. */
6920 : 228292 : decl = maybe_duplicate (decl);
6921 : :
6922 : 228292 : if (!DECL_P (decl) || DECL_CHAIN (decl))
6923 : : {
6924 : 0 : set_overrun ();
6925 : 0 : break;
6926 : : }
6927 : 228292 : *chain = decl;
6928 : 228292 : chain = &DECL_CHAIN (decl);
6929 : : }
6930 : : else
6931 : 228292 : break;
6932 : :
6933 : : /* nonlocalized_vars is middle-end. */
6934 : 420427 : RT (t->block.subblocks);
6935 : 420427 : RT (t->block.supercontext);
6936 : 420427 : RT (t->block.abstract_origin);
6937 : : /* fragment_origin, fragment_chain are middle-end. */
6938 : 420427 : RT (t->block.chain);
6939 : : /* nonlocalized_vars, block_num, die are middle endy/debug
6940 : : things. */
6941 : 420427 : break;
6942 : :
6943 : 758415 : case CALL_EXPR:
6944 : 758415 : RUC (internal_fn, t->base.u.ifn);
6945 : 758415 : break;
6946 : :
6947 : : case CONSTRUCTOR:
6948 : : // Streamed after the node's type.
6949 : : break;
6950 : :
6951 : 3 : case OMP_CLAUSE:
6952 : 3 : {
6953 : 3 : RU (t->omp_clause.subcode.map_kind);
6954 : 3 : t->omp_clause.locus = state->read_location (*this);
6955 : :
6956 : 3 : unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
6957 : 9 : for (unsigned ix = 0; ix != len; ix++)
6958 : 6 : RT (t->omp_clause.ops[ix]);
6959 : : }
6960 : : break;
6961 : :
6962 : 286609 : case STATEMENT_LIST:
6963 : 286609 : {
6964 : 286609 : tree_stmt_iterator iter = tsi_start (t);
6965 : 1156035 : for (tree stmt; RT (stmt);)
6966 : : {
6967 : 869426 : if (TREE_CODE (stmt) == DEBUG_BEGIN_STMT
6968 : 0 : && !MAY_HAVE_DEBUG_MARKER_STMTS)
6969 : 0 : continue;
6970 : 869426 : tsi_link_after (&iter, stmt, TSI_CONTINUE_LINKING);
6971 : : }
6972 : : }
6973 : 286609 : break;
6974 : :
6975 : 0 : case OPTIMIZATION_NODE:
6976 : 0 : case TARGET_OPTION_NODE:
6977 : : /* Not yet implemented, see trees_out::core_vals. */
6978 : 0 : gcc_unreachable ();
6979 : 152951 : break;
6980 : :
6981 : 152951 : case TREE_BINFO:
6982 : 152951 : RT (t->binfo.common.chain);
6983 : 152951 : RT (t->binfo.offset);
6984 : 152951 : RT (t->binfo.inheritance);
6985 : 152951 : RT (t->binfo.vptr_field);
6986 : :
6987 : : /* Do not mark the vtables as USED in the address expressions
6988 : : here. */
6989 : 152951 : unused++;
6990 : 152951 : RT (t->binfo.vtable);
6991 : 152951 : RT (t->binfo.virtuals);
6992 : 152951 : RT (t->binfo.vtt_subvtt);
6993 : 152951 : RT (t->binfo.vtt_vptr);
6994 : 152951 : unused--;
6995 : :
6996 : 152951 : BINFO_BASE_ACCESSES (t) = tree_vec ();
6997 : 152951 : if (!get_overrun ())
6998 : : {
6999 : 152951 : unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
7000 : 199719 : for (unsigned ix = 0; ix != num; ix++)
7001 : 46768 : BINFO_BASE_APPEND (t, tree_node ());
7002 : : }
7003 : : break;
7004 : :
7005 : 1895970 : case TREE_LIST:
7006 : 1895970 : RT (t->list.purpose);
7007 : 1895970 : RT (t->list.value);
7008 : 1895970 : RT (t->list.common.chain);
7009 : 1895970 : break;
7010 : :
7011 : 1107502 : case TREE_VEC:
7012 : 3057972 : for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
7013 : 1950470 : RT (TREE_VEC_ELT (t, ix));
7014 : 1107502 : RT (t->type_common.common.chain);
7015 : 1107502 : break;
7016 : :
7017 : : /* C++-specific nodes ... */
7018 : 132220 : case BASELINK:
7019 : 132220 : RT (((lang_tree_node *)t)->baselink.binfo);
7020 : 132220 : RTU (((lang_tree_node *)t)->baselink.functions);
7021 : 132220 : RT (((lang_tree_node *)t)->baselink.access_binfo);
7022 : 132220 : break;
7023 : :
7024 : 30774 : case CONSTRAINT_INFO:
7025 : 30774 : RT (((lang_tree_node *)t)->constraint_info.template_reqs);
7026 : 30774 : RT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
7027 : 30774 : RT (((lang_tree_node *)t)->constraint_info.associated_constr);
7028 : 30774 : break;
7029 : :
7030 : 8559 : case DEFERRED_NOEXCEPT:
7031 : 8559 : RT (((lang_tree_node *)t)->deferred_noexcept.pattern);
7032 : 8559 : RT (((lang_tree_node *)t)->deferred_noexcept.args);
7033 : 8559 : break;
7034 : :
7035 : 4921 : case LAMBDA_EXPR:
7036 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.capture_list);
7037 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.this_capture);
7038 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.extra_scope);
7039 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.regen_info);
7040 : 4921 : RT (((lang_tree_node *)t)->lambda_expression.extra_args);
7041 : : /* lambda_expression.pending_proxies is NULL */
7042 : 4921 : ((lang_tree_node *)t)->lambda_expression.locus
7043 : 4921 : = state->read_location (*this);
7044 : 4921 : RUC (cp_lambda_default_capture_mode_type,
7045 : : ((lang_tree_node *)t)->lambda_expression.default_capture_mode);
7046 : 4921 : RU (((lang_tree_node *)t)->lambda_expression.discriminator_scope);
7047 : 4921 : RU (((lang_tree_node *)t)->lambda_expression.discriminator_sig);
7048 : 4921 : break;
7049 : :
7050 : 789749 : case OVERLOAD:
7051 : 789749 : RT (((lang_tree_node *)t)->overload.function);
7052 : 789749 : RT (t->common.chain);
7053 : 789749 : break;
7054 : :
7055 : 0 : case PTRMEM_CST:
7056 : 0 : RT (((lang_tree_node *)t)->ptrmem.member);
7057 : 0 : break;
7058 : :
7059 : 10795 : case STATIC_ASSERT:
7060 : 10795 : RT (((lang_tree_node *)t)->static_assertion.condition);
7061 : 10795 : RT (((lang_tree_node *)t)->static_assertion.message);
7062 : 10795 : ((lang_tree_node *)t)->static_assertion.location
7063 : 10795 : = state->read_location (*this);
7064 : 10795 : break;
7065 : :
7066 : 475258 : case TEMPLATE_DECL:
7067 : : /* Streamed when reading the raw template decl itself. */
7068 : 475258 : gcc_assert (((lang_tree_node *)t)->template_decl.arguments);
7069 : 475258 : gcc_assert (((lang_tree_node *)t)->template_decl.result);
7070 : 475258 : if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
7071 : 6872 : RT (DECL_CHAIN (t));
7072 : : break;
7073 : :
7074 : 1083444 : case TEMPLATE_INFO:
7075 : 1083444 : RT (((lang_tree_node *)t)->template_info.tmpl);
7076 : 1083444 : RT (((lang_tree_node *)t)->template_info.args);
7077 : 1083444 : RT (((lang_tree_node *)t)->template_info.partial);
7078 : 1083444 : if (unsigned len = u ())
7079 : : {
7080 : 0 : auto &ac = (((lang_tree_node *)t)
7081 : : ->template_info.deferred_access_checks);
7082 : 0 : vec_alloc (ac, len);
7083 : 0 : for (unsigned ix = 0; ix != len; ix++)
7084 : : {
7085 : 0 : deferred_access_check m;
7086 : :
7087 : 0 : RT (m.binfo);
7088 : 0 : RT (m.decl);
7089 : 0 : RT (m.diag_decl);
7090 : 0 : m.loc = state->read_location (*this);
7091 : 0 : ac->quick_push (m);
7092 : : }
7093 : : }
7094 : : break;
7095 : :
7096 : 584846 : case TEMPLATE_PARM_INDEX:
7097 : 584846 : RU (((lang_tree_node *)t)->tpi.index);
7098 : 584846 : RU (((lang_tree_node *)t)->tpi.level);
7099 : 584846 : RU (((lang_tree_node *)t)->tpi.orig_level);
7100 : 584846 : RT (((lang_tree_node *)t)->tpi.decl);
7101 : 584846 : break;
7102 : :
7103 : 12996 : case TRAIT_EXPR:
7104 : 12996 : RT (((lang_tree_node *)t)->trait_expression.type1);
7105 : 12996 : RT (((lang_tree_node *)t)->trait_expression.type2);
7106 : 12996 : RUC (cp_trait_kind, ((lang_tree_node *)t)->trait_expression.kind);
7107 : 12996 : break;
7108 : : }
7109 : :
7110 : 20673224 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
7111 : : {
7112 : 19119225 : tree type = tree_node ();
7113 : :
7114 : 19119225 : if (type && code == ENUMERAL_TYPE && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
7115 : : {
7116 : 3363 : unsigned precision = u ();
7117 : :
7118 : 3363 : type = build_distinct_type_copy (type);
7119 : 3363 : TYPE_PRECISION (type) = precision;
7120 : 6726 : set_min_and_max_values_for_integral_type (type, precision,
7121 : 3363 : TYPE_SIGN (type));
7122 : : }
7123 : :
7124 : 19119225 : if (code != TEMPLATE_DECL)
7125 : 18643967 : t->typed.type = type;
7126 : : }
7127 : :
7128 : 20673224 : if (TREE_CODE (t) == CONSTRUCTOR)
7129 : 60288 : if (unsigned len = u ())
7130 : : {
7131 : 19923 : vec_alloc (t->constructor.elts, len);
7132 : 143244 : for (unsigned ix = 0; ix != len; ix++)
7133 : : {
7134 : 123321 : constructor_elt elt;
7135 : :
7136 : 123321 : RT (elt.index);
7137 : 123321 : RTU (elt.value);
7138 : 123321 : t->constructor.elts->quick_push (elt);
7139 : : }
7140 : : }
7141 : :
7142 : : #undef RT
7143 : : #undef RM
7144 : : #undef RU
7145 : 20673224 : return !get_overrun ();
7146 : : }
7147 : :
7148 : : void
7149 : 7257410 : trees_out::lang_decl_vals (tree t)
7150 : : {
7151 : 7257410 : const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
7152 : : #define WU(X) (u (X))
7153 : : #define WT(X) (tree_node (X))
7154 : : /* Module index already written. */
7155 : 7257410 : switch (lang->u.base.selector)
7156 : : {
7157 : 0 : default:
7158 : 0 : gcc_unreachable ();
7159 : :
7160 : 1388022 : case lds_fn: /* lang_decl_fn. */
7161 : 1388022 : if (streaming_p ())
7162 : : {
7163 : 693925 : if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
7164 : 117932 : WU (lang->u.fn.ovl_op_code);
7165 : : }
7166 : :
7167 : 1388022 : if (DECL_CLASS_SCOPE_P (t))
7168 : 1004146 : WT (lang->u.fn.context);
7169 : :
7170 : 1388022 : if (lang->u.fn.thunk_p)
7171 : : {
7172 : : /* The thunked-to function. */
7173 : 2440 : WT (lang->u.fn.befriending_classes);
7174 : 2440 : if (streaming_p ())
7175 : 1220 : wi (lang->u.fn.u5.fixed_offset);
7176 : : }
7177 : 1385582 : else if (decl_tls_wrapper_p (t))
7178 : : /* The wrapped variable. */
7179 : 6 : WT (lang->u.fn.befriending_classes);
7180 : : else
7181 : 1385576 : WT (lang->u.fn.u5.cloned_function);
7182 : :
7183 : 1388022 : if (FNDECL_USED_AUTO (t))
7184 : 2891 : WT (lang->u.fn.u.saved_auto_return_type);
7185 : :
7186 : 1388022 : goto lds_min;
7187 : :
7188 : 3272 : case lds_decomp: /* lang_decl_decomp. */
7189 : 3272 : WT (lang->u.decomp.base);
7190 : 3272 : goto lds_min;
7191 : :
7192 : 4278404 : case lds_min: /* lang_decl_min. */
7193 : 4278404 : lds_min:
7194 : 4278404 : WT (lang->u.min.template_info);
7195 : 4278404 : {
7196 : 4278404 : tree access = lang->u.min.access;
7197 : :
7198 : : /* DECL_ACCESS needs to be maintained by the definition of the
7199 : : (derived) class that changes the access. The other users
7200 : : of DECL_ACCESS need to write it here. */
7201 : 1388022 : if (!DECL_THUNK_P (t)
7202 : 5663986 : && (DECL_CONTEXT (t) && TYPE_P (DECL_CONTEXT (t))))
7203 : : access = NULL_TREE;
7204 : :
7205 : 4278404 : WT (access);
7206 : : }
7207 : 4278404 : break;
7208 : :
7209 : : case lds_ns: /* lang_decl_ns. */
7210 : : break;
7211 : :
7212 : 2978395 : case lds_parm: /* lang_decl_parm. */
7213 : 2978395 : if (streaming_p ())
7214 : : {
7215 : 1038905 : WU (lang->u.parm.level);
7216 : 1038905 : WU (lang->u.parm.index);
7217 : : }
7218 : : break;
7219 : : }
7220 : : #undef WU
7221 : : #undef WT
7222 : 7257410 : }
7223 : :
7224 : : bool
7225 : 3083198 : trees_in::lang_decl_vals (tree t)
7226 : : {
7227 : 3083198 : struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
7228 : : #define RU(X) ((X) = u ())
7229 : : #define RT(X) ((X) = tree_node ())
7230 : :
7231 : : /* Module index already read. */
7232 : 3083198 : switch (lang->u.base.selector)
7233 : : {
7234 : 0 : default:
7235 : 0 : gcc_unreachable ();
7236 : :
7237 : 687780 : case lds_fn: /* lang_decl_fn. */
7238 : 687780 : if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
7239 : : {
7240 : 117067 : unsigned code = u ();
7241 : :
7242 : : /* Check consistency. */
7243 : 117067 : if (code >= OVL_OP_MAX
7244 : 117067 : || (ovl_op_info[IDENTIFIER_ASSIGN_OP_P (DECL_NAME (t))][code]
7245 : 117067 : .ovl_op_code) == OVL_OP_ERROR_MARK)
7246 : 0 : set_overrun ();
7247 : : else
7248 : 117067 : lang->u.fn.ovl_op_code = code;
7249 : : }
7250 : :
7251 : 687780 : if (DECL_CLASS_SCOPE_P (t))
7252 : 496744 : RT (lang->u.fn.context);
7253 : :
7254 : 687780 : if (lang->u.fn.thunk_p)
7255 : : {
7256 : 1196 : RT (lang->u.fn.befriending_classes);
7257 : 1196 : lang->u.fn.u5.fixed_offset = wi ();
7258 : : }
7259 : 686584 : else if (decl_tls_wrapper_p (t))
7260 : 6 : RT (lang->u.fn.befriending_classes);
7261 : : else
7262 : 686578 : RT (lang->u.fn.u5.cloned_function);
7263 : :
7264 : 687780 : if (FNDECL_USED_AUTO (t))
7265 : 1251 : RT (lang->u.fn.u.saved_auto_return_type);
7266 : 687780 : goto lds_min;
7267 : :
7268 : 1453 : case lds_decomp: /* lang_decl_decomp. */
7269 : 1453 : RT (lang->u.decomp.base);
7270 : 1453 : goto lds_min;
7271 : :
7272 : 2066876 : case lds_min: /* lang_decl_min. */
7273 : 2066876 : lds_min:
7274 : 2066876 : RT (lang->u.min.template_info);
7275 : 2066876 : RT (lang->u.min.access);
7276 : 2066876 : break;
7277 : :
7278 : : case lds_ns: /* lang_decl_ns. */
7279 : : break;
7280 : :
7281 : 1015999 : case lds_parm: /* lang_decl_parm. */
7282 : 1015999 : RU (lang->u.parm.level);
7283 : 1015999 : RU (lang->u.parm.index);
7284 : 1015999 : break;
7285 : : }
7286 : : #undef RU
7287 : : #undef RT
7288 : 3083198 : return !get_overrun ();
7289 : : }
7290 : :
7291 : : /* Most of the value contents of lang_type is streamed in
7292 : : define_class. */
7293 : :
7294 : : void
7295 : 499427 : trees_out::lang_type_vals (tree t)
7296 : : {
7297 : 499427 : const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
7298 : : #define WU(X) (u (X))
7299 : : #define WT(X) (tree_node (X))
7300 : 499427 : if (streaming_p ())
7301 : 249695 : WU (lang->align);
7302 : : #undef WU
7303 : : #undef WT
7304 : 499427 : }
7305 : :
7306 : : bool
7307 : 235067 : trees_in::lang_type_vals (tree t)
7308 : : {
7309 : 235067 : struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
7310 : : #define RU(X) ((X) = u ())
7311 : : #define RT(X) ((X) = tree_node ())
7312 : 235067 : RU (lang->align);
7313 : : #undef RU
7314 : : #undef RT
7315 : 235067 : return !get_overrun ();
7316 : : }
7317 : :
7318 : : /* Write out the bools of T, including information about any
7319 : : LANG_SPECIFIC information. Including allocation of any lang
7320 : : specific object. */
7321 : :
7322 : : void
7323 : 21329344 : trees_out::tree_node_bools (tree t)
7324 : : {
7325 : 21329344 : gcc_checking_assert (streaming_p ());
7326 : :
7327 : : /* We should never stream a namespace. */
7328 : 21329344 : gcc_checking_assert (TREE_CODE (t) != NAMESPACE_DECL
7329 : : || DECL_NAMESPACE_ALIAS (t));
7330 : :
7331 : 21329344 : bits_out bits = stream_bits ();
7332 : 21329344 : core_bools (t, bits);
7333 : :
7334 : 21329344 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7335 : : {
7336 : 4893542 : case tcc_declaration:
7337 : 4893542 : {
7338 : 4893542 : bool specific = DECL_LANG_SPECIFIC (t) != NULL;
7339 : 4893542 : bits.b (specific);
7340 : 4893542 : if (specific && VAR_P (t))
7341 : 475021 : bits.b (DECL_DECOMPOSITION_P (t));
7342 : 3166641 : if (specific)
7343 : 3166641 : lang_decl_bools (t, bits);
7344 : : }
7345 : : break;
7346 : :
7347 : 903285 : case tcc_type:
7348 : 903285 : {
7349 : 903285 : bool specific = (TYPE_MAIN_VARIANT (t) == t
7350 : 903285 : && TYPE_LANG_SPECIFIC (t) != NULL);
7351 : 903285 : gcc_assert (TYPE_LANG_SPECIFIC (t)
7352 : : == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t)));
7353 : :
7354 : 903285 : bits.b (specific);
7355 : 903285 : if (specific)
7356 : 249695 : lang_type_bools (t, bits);
7357 : : }
7358 : : break;
7359 : :
7360 : : default:
7361 : : break;
7362 : : }
7363 : :
7364 : 21329344 : bits.bflush ();
7365 : 21329344 : }
7366 : :
7367 : : bool
7368 : 20701825 : trees_in::tree_node_bools (tree t)
7369 : : {
7370 : 20701825 : bits_in bits = stream_bits ();
7371 : 20701825 : bool ok = core_bools (t, bits);
7372 : :
7373 : 20701825 : if (ok)
7374 : 20701825 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7375 : : {
7376 : 4738681 : case tcc_declaration:
7377 : 4738681 : if (bits.b ())
7378 : : {
7379 : 3083198 : bool decomp = VAR_P (t) && bits.b ();
7380 : :
7381 : 3083198 : ok = maybe_add_lang_decl_raw (t, decomp);
7382 : 3083198 : if (ok)
7383 : 3083198 : ok = lang_decl_bools (t, bits);
7384 : : }
7385 : : break;
7386 : :
7387 : 845064 : case tcc_type:
7388 : 845064 : if (bits.b ())
7389 : : {
7390 : 235067 : ok = maybe_add_lang_type_raw (t);
7391 : 235067 : if (ok)
7392 : 235067 : ok = lang_type_bools (t, bits);
7393 : : }
7394 : : break;
7395 : :
7396 : : default:
7397 : : break;
7398 : : }
7399 : :
7400 : 20701825 : bits.bflush ();
7401 : 20701825 : if (!ok || get_overrun ())
7402 : 0 : return false;
7403 : :
7404 : : return true;
7405 : 20701825 : }
7406 : :
7407 : :
7408 : : /* Write out the lang-specifc vals of node T. */
7409 : :
7410 : : void
7411 : 55750816 : trees_out::lang_vals (tree t)
7412 : : {
7413 : 55750816 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7414 : : {
7415 : 12770200 : case tcc_declaration:
7416 : 12770200 : if (DECL_LANG_SPECIFIC (t))
7417 : 7257410 : lang_decl_vals (t);
7418 : : break;
7419 : :
7420 : 3206049 : case tcc_type:
7421 : 3206049 : if (TYPE_MAIN_VARIANT (t) == t && TYPE_LANG_SPECIFIC (t))
7422 : 499427 : lang_type_vals (t);
7423 : : break;
7424 : :
7425 : : default:
7426 : : break;
7427 : : }
7428 : 55750816 : }
7429 : :
7430 : : bool
7431 : 20673224 : trees_in::lang_vals (tree t)
7432 : : {
7433 : 20673224 : bool ok = true;
7434 : :
7435 : 20673224 : switch (TREE_CODE_CLASS (TREE_CODE (t)))
7436 : : {
7437 : 4738681 : case tcc_declaration:
7438 : 4738681 : if (DECL_LANG_SPECIFIC (t))
7439 : 3083198 : ok = lang_decl_vals (t);
7440 : : break;
7441 : :
7442 : 816463 : case tcc_type:
7443 : 816463 : if (TYPE_LANG_SPECIFIC (t))
7444 : 235067 : ok = lang_type_vals (t);
7445 : : else
7446 : 581396 : TYPE_LANG_SPECIFIC (t) = TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t));
7447 : : break;
7448 : :
7449 : : default:
7450 : : break;
7451 : : }
7452 : :
7453 : 20673224 : return ok;
7454 : : }
7455 : :
7456 : : /* Write out the value fields of node T. */
7457 : :
7458 : : void
7459 : 55750816 : trees_out::tree_node_vals (tree t)
7460 : : {
7461 : 55750816 : core_vals (t);
7462 : 55750816 : lang_vals (t);
7463 : 55750816 : }
7464 : :
7465 : : bool
7466 : 20673224 : trees_in::tree_node_vals (tree t)
7467 : : {
7468 : 20673224 : bool ok = core_vals (t);
7469 : 20673224 : if (ok)
7470 : 20673224 : ok = lang_vals (t);
7471 : :
7472 : 20673224 : return ok;
7473 : : }
7474 : :
7475 : :
7476 : : /* If T is a back reference, fixed reference or NULL, write out its
7477 : : code and return WK_none. Otherwise return WK_value if we must write
7478 : : by value, or WK_normal otherwise. */
7479 : :
7480 : : walk_kind
7481 : 370574729 : trees_out::ref_node (tree t)
7482 : : {
7483 : 370574729 : if (!t)
7484 : : {
7485 : 148449127 : if (streaming_p ())
7486 : : {
7487 : : /* NULL_TREE -> tt_null. */
7488 : 56759043 : null_count++;
7489 : 56759043 : i (tt_null);
7490 : : }
7491 : 148449127 : return WK_none;
7492 : : }
7493 : :
7494 : 222125602 : if (!TREE_VISITED (t))
7495 : : return WK_normal;
7496 : :
7497 : : /* An already-visited tree. It must be in the map. */
7498 : 130157886 : int val = get_tag (t);
7499 : :
7500 : 130157886 : if (val == tag_value)
7501 : : /* An entry we should walk into. */
7502 : : return WK_value;
7503 : :
7504 : 128036109 : const char *kind;
7505 : :
7506 : 128036109 : if (val <= tag_backref)
7507 : : {
7508 : : /* Back reference -> -ve number */
7509 : 97906209 : if (streaming_p ())
7510 : 46560791 : i (val);
7511 : : kind = "backref";
7512 : : }
7513 : 30129900 : else if (val >= tag_fixed)
7514 : : {
7515 : : /* Fixed reference -> tt_fixed */
7516 : 30129900 : val -= tag_fixed;
7517 : 30129900 : if (streaming_p ())
7518 : 10488819 : i (tt_fixed), u (val);
7519 : : kind = "fixed";
7520 : : }
7521 : :
7522 : 128036109 : if (streaming_p ())
7523 : : {
7524 : 57049610 : back_ref_count++;
7525 : 57049610 : dump (dumper::TREE)
7526 : 13182 : && dump ("Wrote %s:%d %C:%N%S", kind, val, TREE_CODE (t), t, t);
7527 : : }
7528 : : return WK_none;
7529 : : }
7530 : :
7531 : : tree
7532 : 45211974 : trees_in::back_ref (int tag)
7533 : : {
7534 : 45211974 : tree res = NULL_TREE;
7535 : :
7536 : 45211974 : if (tag < 0 && unsigned (~tag) < back_refs.length ())
7537 : 45211974 : res = back_refs[~tag];
7538 : :
7539 : 45211974 : if (!res
7540 : : /* Checking TREE_CODE is a dereference, so we know this is not a
7541 : : wild pointer. Checking the code provides evidence we've not
7542 : : corrupted something. */
7543 : 45211974 : || TREE_CODE (res) >= MAX_TREE_CODES)
7544 : 0 : set_overrun ();
7545 : : else
7546 : 45225900 : dump (dumper::TREE) && dump ("Read backref:%d found %C:%N%S", tag,
7547 : : TREE_CODE (res), res, res);
7548 : 45211974 : return res;
7549 : : }
7550 : :
7551 : : unsigned
7552 : 5072769 : trees_out::add_indirect_tpl_parms (tree parms)
7553 : : {
7554 : 5072769 : unsigned len = 0;
7555 : 9473217 : for (; parms; parms = TREE_CHAIN (parms), len++)
7556 : : {
7557 : 5325529 : if (TREE_VISITED (parms))
7558 : : break;
7559 : :
7560 : 4400448 : int tag = insert (parms);
7561 : 4400448 : if (streaming_p ())
7562 : 4410588 : dump (dumper::TREE)
7563 : 153 : && dump ("Indirect:%d template's parameter %u %C:%N",
7564 : 153 : tag, len, TREE_CODE (parms), parms);
7565 : : }
7566 : :
7567 : 5072769 : if (streaming_p ())
7568 : 803230 : u (len);
7569 : :
7570 : 5072769 : return len;
7571 : : }
7572 : :
7573 : : unsigned
7574 : 754065 : trees_in::add_indirect_tpl_parms (tree parms)
7575 : : {
7576 : 754065 : unsigned len = u ();
7577 : 1348312 : for (unsigned ix = 0; ix != len; parms = TREE_CHAIN (parms), ix++)
7578 : : {
7579 : 594247 : int tag = insert (parms);
7580 : 594671 : dump (dumper::TREE)
7581 : 159 : && dump ("Indirect:%d template's parameter %u %C:%N",
7582 : 159 : tag, ix, TREE_CODE (parms), parms);
7583 : : }
7584 : :
7585 : 754065 : return len;
7586 : : }
7587 : :
7588 : : /* We've just found DECL by name. Insert nodes that come with it, but
7589 : : cannot be found by name, so we'll not accidentally walk into them. */
7590 : :
7591 : : void
7592 : 11638660 : trees_out::add_indirects (tree decl)
7593 : : {
7594 : 11638660 : unsigned count = 0;
7595 : :
7596 : : // FIXME:OPTIMIZATION We'll eventually want default fn parms of
7597 : : // templates and perhaps default template parms too. The former can
7598 : : // be referenced from instantiations (as they are lazily
7599 : : // instantiated). Also (deferred?) exception specifications of
7600 : : // templates. See the note about PARM_DECLs in trees_out::decl_node.
7601 : 11638660 : tree inner = decl;
7602 : 11638660 : if (TREE_CODE (decl) == TEMPLATE_DECL)
7603 : : {
7604 : 5072769 : count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));
7605 : :
7606 : 5072769 : inner = DECL_TEMPLATE_RESULT (decl);
7607 : 5072769 : int tag = insert (inner);
7608 : 5072769 : if (streaming_p ())
7609 : 803230 : dump (dumper::TREE)
7610 : 219 : && dump ("Indirect:%d template's result %C:%N",
7611 : 219 : tag, TREE_CODE (inner), inner);
7612 : 5072769 : count++;
7613 : : }
7614 : :
7615 : 11638660 : if (TREE_CODE (inner) == TYPE_DECL)
7616 : : {
7617 : : /* Make sure the type is in the map too. Otherwise we get
7618 : : different RECORD_TYPEs for the same type, and things go
7619 : : south. */
7620 : 6435854 : tree type = TREE_TYPE (inner);
7621 : 6435854 : gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
7622 : : || TYPE_NAME (type) == inner);
7623 : 6435854 : int tag = insert (type);
7624 : 6435854 : if (streaming_p ())
7625 : 695663 : dump (dumper::TREE) && dump ("Indirect:%d decl's type %C:%N", tag,
7626 : 360 : TREE_CODE (type), type);
7627 : 6435854 : count++;
7628 : : }
7629 : :
7630 : 11638660 : if (streaming_p ())
7631 : : {
7632 : 1703816 : u (count);
7633 : 1704329 : dump (dumper::TREE) && dump ("Inserted %u indirects", count);
7634 : : }
7635 : 11638660 : }
7636 : :
7637 : : bool
7638 : 1595752 : trees_in::add_indirects (tree decl)
7639 : : {
7640 : 1595752 : unsigned count = 0;
7641 : :
7642 : 1595752 : tree inner = decl;
7643 : 1595752 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7644 : : {
7645 : 754065 : count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));
7646 : :
7647 : 754065 : inner = DECL_TEMPLATE_RESULT (decl);
7648 : 754065 : int tag = insert (inner);
7649 : 754065 : dump (dumper::TREE)
7650 : 228 : && dump ("Indirect:%d templates's result %C:%N", tag,
7651 : 228 : TREE_CODE (inner), inner);
7652 : 754065 : count++;
7653 : : }
7654 : :
7655 : 1595752 : if (TREE_CODE (inner) == TYPE_DECL)
7656 : : {
7657 : 639151 : tree type = TREE_TYPE (inner);
7658 : 639151 : gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
7659 : : || TYPE_NAME (type) == inner);
7660 : 639151 : int tag = insert (type);
7661 : 639151 : dump (dumper::TREE)
7662 : 360 : && dump ("Indirect:%d decl's type %C:%N", tag, TREE_CODE (type), type);
7663 : 639151 : count++;
7664 : : }
7665 : :
7666 : 1596352 : dump (dumper::TREE) && dump ("Inserted %u indirects", count);
7667 : 1595752 : return count == u ();
7668 : : }
7669 : :
7670 : : /* Stream a template parameter. There are 4.5 kinds of parameter:
7671 : : a) Template - TEMPLATE_DECL->TYPE_DECL->TEMPLATE_TEMPLATE_PARM
7672 : : TEMPLATE_TYPE_PARM_INDEX TPI
7673 : : b) Type - TYPE_DECL->TEMPLATE_TYPE_PARM TEMPLATE_TYPE_PARM_INDEX TPI
7674 : : c.1) NonTYPE - PARM_DECL DECL_INITIAL TPI We meet this first
7675 : : c.2) NonTYPE - CONST_DECL DECL_INITIAL Same TPI
7676 : : d) BoundTemplate - TYPE_DECL->BOUND_TEMPLATE_TEMPLATE_PARM
7677 : : TEMPLATE_TYPE_PARM_INDEX->TPI
7678 : : TEMPLATE_TEMPLATE_PARM_INFO->TEMPLATE_INFO
7679 : :
7680 : : All of these point to a TEMPLATE_PARM_INDEX, and #B also has a TEMPLATE_INFO
7681 : : */
7682 : :
7683 : : void
7684 : 2925226 : trees_out::tpl_parm_value (tree parm)
7685 : : {
7686 : 2925226 : gcc_checking_assert (DECL_P (parm) && DECL_TEMPLATE_PARM_P (parm));
7687 : :
7688 : 2925226 : int parm_tag = insert (parm);
7689 : 2925226 : if (streaming_p ())
7690 : : {
7691 : 649005 : i (tt_tpl_parm);
7692 : 649005 : dump (dumper::TREE) && dump ("Writing template parm:%d %C:%N",
7693 : 114 : parm_tag, TREE_CODE (parm), parm);
7694 : 649005 : start (parm);
7695 : 649005 : tree_node_bools (parm);
7696 : : }
7697 : :
7698 : 2925226 : tree inner = parm;
7699 : 2925226 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7700 : : {
7701 : 6556 : inner = DECL_TEMPLATE_RESULT (inner);
7702 : 6556 : int inner_tag = insert (inner);
7703 : 6556 : if (streaming_p ())
7704 : : {
7705 : 1721 : dump (dumper::TREE) && dump ("Writing inner template parm:%d %C:%N",
7706 : 0 : inner_tag, TREE_CODE (inner), inner);
7707 : 1721 : start (inner);
7708 : 1721 : tree_node_bools (inner);
7709 : : }
7710 : : }
7711 : :
7712 : 2925226 : tree type = NULL_TREE;
7713 : 2925226 : if (TREE_CODE (inner) == TYPE_DECL)
7714 : : {
7715 : 2627500 : type = TREE_TYPE (inner);
7716 : 2627500 : int type_tag = insert (type);
7717 : 2627500 : if (streaming_p ())
7718 : : {
7719 : 580795 : dump (dumper::TREE) && dump ("Writing template parm type:%d %C:%N",
7720 : 108 : type_tag, TREE_CODE (type), type);
7721 : 580795 : start (type);
7722 : 580795 : tree_node_bools (type);
7723 : : }
7724 : : }
7725 : :
7726 : 2925226 : if (inner != parm)
7727 : : {
7728 : : /* This is a template-template parameter. */
7729 : 6556 : unsigned tpl_levels = 0;
7730 : 6556 : tpl_header (parm, &tpl_levels);
7731 : 6556 : tpl_parms_fini (parm, tpl_levels);
7732 : : }
7733 : :
7734 : 2925226 : tree_node_vals (parm);
7735 : 2925226 : if (inner != parm)
7736 : 6556 : tree_node_vals (inner);
7737 : 2925226 : if (type)
7738 : : {
7739 : 2627500 : tree_node_vals (type);
7740 : 2627500 : if (DECL_NAME (inner) == auto_identifier
7741 : 2627500 : || DECL_NAME (inner) == decltype_auto_identifier)
7742 : : {
7743 : : /* Placeholder auto. */
7744 : 85200 : tree_node (DECL_INITIAL (inner));
7745 : 85200 : tree_node (DECL_SIZE_UNIT (inner));
7746 : : }
7747 : : }
7748 : :
7749 : 2925226 : if (streaming_p ())
7750 : 649005 : dump (dumper::TREE) && dump ("Wrote template parm:%d %C:%N",
7751 : 114 : parm_tag, TREE_CODE (parm), parm);
7752 : 2925226 : }
7753 : :
7754 : : tree
7755 : 612932 : trees_in::tpl_parm_value ()
7756 : : {
7757 : 612932 : tree parm = start ();
7758 : 612932 : if (!parm || !tree_node_bools (parm))
7759 : 0 : return NULL_TREE;
7760 : :
7761 : 612932 : int parm_tag = insert (parm);
7762 : 612932 : dump (dumper::TREE) && dump ("Reading template parm:%d %C:%N",
7763 : 198 : parm_tag, TREE_CODE (parm), parm);
7764 : :
7765 : 612932 : tree inner = parm;
7766 : 612932 : if (TREE_CODE (inner) == TEMPLATE_DECL)
7767 : : {
7768 : 1371 : inner = start ();
7769 : 1371 : if (!inner || !tree_node_bools (inner))
7770 : 0 : return NULL_TREE;
7771 : 1371 : int inner_tag = insert (inner);
7772 : 1371 : dump (dumper::TREE) && dump ("Reading inner template parm:%d %C:%N",
7773 : 0 : inner_tag, TREE_CODE (inner), inner);
7774 : 1371 : DECL_TEMPLATE_RESULT (parm) = inner;
7775 : : }
7776 : :
7777 : 612932 : tree type = NULL_TREE;
7778 : 612932 : if (TREE_CODE (inner) == TYPE_DECL)
7779 : : {
7780 : 546407 : type = start ();
7781 : 546407 : if (!type || !tree_node_bools (type))
7782 : 0 : return NULL_TREE;
7783 : 546407 : int type_tag = insert (type);
7784 : 546407 : dump (dumper::TREE) && dump ("Reading template parm type:%d %C:%N",
7785 : 120 : type_tag, TREE_CODE (type), type);
7786 : :
7787 : 546407 : TREE_TYPE (inner) = TREE_TYPE (parm) = type;
7788 : 546407 : TYPE_NAME (type) = parm;
7789 : : }
7790 : :
7791 : 612932 : if (inner != parm)
7792 : : {
7793 : : /* A template template parameter. */
7794 : 1371 : unsigned tpl_levels = 0;
7795 : 1371 : tpl_header (parm, &tpl_levels);
7796 : 1371 : tpl_parms_fini (parm, tpl_levels);
7797 : : }
7798 : :
7799 : 612932 : tree_node_vals (parm);
7800 : 612932 : if (inner != parm)
7801 : 1371 : tree_node_vals (inner);
7802 : 612932 : if (type)
7803 : : {
7804 : 546407 : tree_node_vals (type);
7805 : 546407 : if (DECL_NAME (inner) == auto_identifier
7806 : 546407 : || DECL_NAME (inner) == decltype_auto_identifier)
7807 : : {
7808 : : /* Placeholder auto. */
7809 : 32127 : DECL_INITIAL (inner) = tree_node ();
7810 : 32127 : DECL_SIZE_UNIT (inner) = tree_node ();
7811 : : }
7812 : 546407 : if (TYPE_CANONICAL (type))
7813 : : {
7814 : 546407 : gcc_checking_assert (TYPE_CANONICAL (type) == type);
7815 : 546407 : TYPE_CANONICAL (type) = canonical_type_parameter (type);
7816 : : }
7817 : : }
7818 : :
7819 : 612932 : dump (dumper::TREE) && dump ("Read template parm:%d %C:%N",
7820 : 198 : parm_tag, TREE_CODE (parm), parm);
7821 : :
7822 : : return parm;
7823 : : }
7824 : :
7825 : : void
7826 : 1833746 : trees_out::install_entity (tree decl, depset *dep)
7827 : : {
7828 : 1833746 : gcc_checking_assert (streaming_p ());
7829 : :
7830 : : /* Write the entity index, so we can insert it as soon as we
7831 : : know this is new. */
7832 : 1833746 : u (dep ? dep->cluster + 1 : 0);
7833 : 1833746 : if (CHECKING_P && dep)
7834 : : {
7835 : : /* Add it to the entity map, such that we can tell it is
7836 : : part of us. */
7837 : 1373236 : bool existed;
7838 : 1373236 : unsigned *slot = &entity_map->get_or_insert
7839 : 1373236 : (DECL_UID (decl), &existed);
7840 : 1373236 : if (existed)
7841 : : /* If it existed, it should match. */
7842 : 657 : gcc_checking_assert (decl == (*entity_ary)[*slot]);
7843 : 1373236 : *slot = ~dep->cluster;
7844 : : }
7845 : 1833746 : }
7846 : :
7847 : : bool
7848 : 1770183 : trees_in::install_entity (tree decl)
7849 : : {
7850 : 1770183 : unsigned entity_index = u ();
7851 : 1770183 : if (!entity_index)
7852 : : return false;
7853 : :
7854 : 1323145 : if (entity_index > state->entity_num)
7855 : : {
7856 : 0 : set_overrun ();
7857 : 0 : return false;
7858 : : }
7859 : :
7860 : : /* Insert the real decl into the entity ary. */
7861 : 1323145 : unsigned ident = state->entity_lwm + entity_index - 1;
7862 : 1323145 : (*entity_ary)[ident] = decl;
7863 : :
7864 : : /* And into the entity map, if it's not already there. */
7865 : 1323145 : tree not_tmpl = STRIP_TEMPLATE (decl);
7866 : 1323145 : if (!DECL_LANG_SPECIFIC (not_tmpl)
7867 : 2468733 : || !DECL_MODULE_ENTITY_P (not_tmpl))
7868 : : {
7869 : 1322621 : retrofit_lang_decl (not_tmpl);
7870 : 1322621 : DECL_MODULE_ENTITY_P (not_tmpl) = true;
7871 : :
7872 : : /* Insert into the entity hash (it cannot already be there). */
7873 : 1322621 : bool existed;
7874 : 1322621 : unsigned &slot = entity_map->get_or_insert (DECL_UID (decl), &existed);
7875 : 1322621 : gcc_checking_assert (!existed);
7876 : 1322621 : slot = ident;
7877 : : }
7878 : 524 : else if (state->is_partition ())
7879 : : {
7880 : : /* The decl is already in the entity map, but we see it again now from a
7881 : : partition: we want to overwrite if the original decl wasn't also from
7882 : : a (possibly different) partition. Otherwise, for things like template
7883 : : instantiations, make_dependency might not realise that this is also
7884 : : provided from a partition and should be considered part of this module
7885 : : (and thus always emitted into the primary interface's CMI). */
7886 : 123 : unsigned *slot = entity_map->get (DECL_UID (decl));
7887 : 123 : module_state *imp = import_entity_module (*slot);
7888 : 123 : if (!imp->is_partition ())
7889 : 24 : *slot = ident;
7890 : : }
7891 : :
7892 : : return true;
7893 : : }
7894 : :
7895 : : static bool has_definition (tree decl);
7896 : :
7897 : : /* DECL is a decl node that must be written by value. DEP is the
7898 : : decl's depset. */
7899 : :
7900 : : void
7901 : 5061033 : trees_out::decl_value (tree decl, depset *dep)
7902 : : {
7903 : : /* We should not be writing clones or template parms. */
7904 : 5061033 : gcc_checking_assert (DECL_P (decl)
7905 : : && !DECL_CLONED_FUNCTION_P (decl)
7906 : : && !DECL_TEMPLATE_PARM_P (decl));
7907 : :
7908 : : /* We should never be writing non-typedef ptrmemfuncs by value. */
7909 : 5061033 : gcc_checking_assert (TREE_CODE (decl) != TYPE_DECL
7910 : : || DECL_ORIGINAL_TYPE (decl)
7911 : : || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)));
7912 : :
7913 : : /* There's no need to walk any of the contents of a known TU-local entity,
7914 : : since importers should never see any of it regardless. But make sure we
7915 : : at least note its location so importers can use it for diagnostics. */
7916 : 9181455 : if (dep && dep->is_tu_local ())
7917 : : {
7918 : 381 : gcc_checking_assert (is_initial_scan ());
7919 : 381 : insert (decl, WK_value);
7920 : 381 : state->note_location (DECL_SOURCE_LOCATION (decl));
7921 : 381 : return;
7922 : : }
7923 : :
7924 : 5060652 : merge_kind mk = get_merge_kind (decl, dep);
7925 : 5060652 : bool is_imported_temploid_friend = imported_temploid_friends->get (decl);
7926 : :
7927 : 5060652 : if (CHECKING_P)
7928 : : {
7929 : : /* Never start in the middle of a template. */
7930 : 5060652 : int use_tpl = -1;
7931 : 5060652 : if (tree ti = node_template_info (decl, use_tpl))
7932 : 1797453 : gcc_checking_assert (TREE_CODE (TI_TEMPLATE (ti)) == OVERLOAD
7933 : : || TREE_CODE (TI_TEMPLATE (ti)) == FIELD_DECL
7934 : : || (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti))
7935 : : != decl));
7936 : : }
7937 : :
7938 : 5060652 : if (streaming_p ())
7939 : : {
7940 : : /* A new node -> tt_decl. */
7941 : 1833746 : decl_val_count++;
7942 : 1833746 : i (tt_decl);
7943 : 1833746 : u (mk);
7944 : 1833746 : start (decl);
7945 : :
7946 : 1833746 : if (mk != MK_unique)
7947 : : {
7948 : 1555495 : bits_out bits = stream_bits ();
7949 : 1555495 : if (!(mk & MK_template_mask) && !state->is_header ())
7950 : : {
7951 : : /* Tell the importer whether this is a global module entity,
7952 : : or a module entity. */
7953 : 190618 : tree o = get_originating_module_decl (decl);
7954 : 190618 : bool is_attached = false;
7955 : :
7956 : 190618 : tree not_tmpl = STRIP_TEMPLATE (o);
7957 : 190618 : if (DECL_LANG_SPECIFIC (not_tmpl)
7958 : 318398 : && DECL_MODULE_ATTACH_P (not_tmpl))
7959 : : is_attached = true;
7960 : :
7961 : 190618 : bits.b (is_attached);
7962 : :
7963 : : /* Also tell the importer whether this is an imported temploid
7964 : : friend, which has implications for merging. */
7965 : 190618 : bits.b (is_imported_temploid_friend);
7966 : : }
7967 : 1555495 : bits.b (dep && dep->has_defn ());
7968 : 1555495 : }
7969 : 1833746 : tree_node_bools (decl);
7970 : : }
7971 : :
7972 : 5060652 : int tag = insert (decl, WK_value);
7973 : 5060652 : if (streaming_p ())
7974 : 1833746 : dump (dumper::TREE)
7975 : 642 : && dump ("Writing %s:%d %C:%N%S", merge_kind_name[mk], tag,
7976 : 642 : TREE_CODE (decl), decl, decl);
7977 : :
7978 : 5060652 : tree inner = decl;
7979 : 5060652 : int inner_tag = 0;
7980 : 5060652 : if (TREE_CODE (decl) == TEMPLATE_DECL)
7981 : : {
7982 : 1485530 : inner = DECL_TEMPLATE_RESULT (decl);
7983 : 1485530 : inner_tag = insert (inner, WK_value);
7984 : :
7985 : 1485530 : if (streaming_p ())
7986 : : {
7987 : 495170 : int code = TREE_CODE (inner);
7988 : 495170 : u (code);
7989 : 495170 : start (inner, true);
7990 : 495170 : tree_node_bools (inner);
7991 : 495170 : dump (dumper::TREE)
7992 : 132 : && dump ("Writing %s:%d %C:%N%S", merge_kind_name[mk], inner_tag,
7993 : 132 : TREE_CODE (inner), inner, inner);
7994 : : }
7995 : : }
7996 : :
7997 : 5060652 : tree type = NULL_TREE;
7998 : 5060652 : int type_tag = 0;
7999 : 5060652 : tree stub_decl = NULL_TREE;
8000 : 5060652 : int stub_tag = 0;
8001 : 5060652 : if (TREE_CODE (inner) == TYPE_DECL)
8002 : : {
8003 : 1909612 : type = TREE_TYPE (inner);
8004 : 1909612 : bool has_type = (type == TYPE_MAIN_VARIANT (type)
8005 : 1909612 : && TYPE_NAME (type) == inner);
8006 : :
8007 : 1909612 : if (streaming_p ())
8008 : 644365 : u (has_type ? TREE_CODE (type) : 0);
8009 : :
8010 : 1909612 : if (has_type)
8011 : : {
8012 : 867795 : type_tag = insert (type, WK_value);
8013 : 867795 : if (streaming_p ())
8014 : : {
8015 : 289246 : start (type, true);
8016 : 289246 : tree_node_bools (type);
8017 : 289246 : dump (dumper::TREE)
8018 : 153 : && dump ("Writing type:%d %C:%N", type_tag,
8019 : 153 : TREE_CODE (type), type);
8020 : : }
8021 : :
8022 : 867795 : stub_decl = TYPE_STUB_DECL (type);
8023 : 867795 : bool has_stub = inner != stub_decl;
8024 : 867795 : if (streaming_p ())
8025 : 289246 : u (has_stub ? TREE_CODE (stub_decl) : 0);
8026 : 867795 : if (has_stub)
8027 : : {
8028 : 3234 : stub_tag = insert (stub_decl);
8029 : 3234 : if (streaming_p ())
8030 : : {
8031 : 1077 : start (stub_decl, true);
8032 : 1077 : tree_node_bools (stub_decl);
8033 : 1077 : dump (dumper::TREE)
8034 : 0 : && dump ("Writing stub_decl:%d %C:%N", stub_tag,
8035 : 0 : TREE_CODE (stub_decl), stub_decl);
8036 : : }
8037 : : }
8038 : : else
8039 : : stub_decl = NULL_TREE;
8040 : : }
8041 : : else
8042 : : /* Regular typedef. */
8043 : : type = NULL_TREE;
8044 : : }
8045 : :
8046 : : /* Stream the container, we want it correctly canonicalized before
8047 : : we start emitting keys for this decl. */
8048 : 5060652 : tree container = decl_container (decl);
8049 : 5060652 : unsigned tpl_levels = 0;
8050 : :
8051 : 5060652 : {
8052 : 5060652 : auto wmk = make_temp_override (dep_hash->writing_merge_key, true);
8053 : 5060652 : if (decl != inner)
8054 : 1485530 : tpl_header (decl, &tpl_levels);
8055 : 5060652 : if (TREE_CODE (inner) == FUNCTION_DECL)
8056 : 2080581 : fn_parms_init (inner);
8057 : :
8058 : : /* Now write out the merging information, and then really
8059 : : install the tag values. */
8060 : 5060652 : key_mergeable (tag, mk, decl, inner, container, dep);
8061 : :
8062 : 5060652 : if (streaming_p ())
8063 : 5100098 : dump (dumper::MERGE)
8064 : 798 : && dump ("Wrote:%d's %s merge key %C:%N", tag,
8065 : 798 : merge_kind_name[mk], TREE_CODE (decl), decl);
8066 : 5060652 : }
8067 : :
8068 : 5060652 : if (TREE_CODE (inner) == FUNCTION_DECL)
8069 : 5060652 : fn_parms_fini (inner);
8070 : :
8071 : 5060652 : if (!is_key_order ())
8072 : 3685058 : tree_node_vals (decl);
8073 : :
8074 : 5060652 : if (inner_tag)
8075 : : {
8076 : 1485530 : if (!is_key_order ())
8077 : 990360 : tree_node_vals (inner);
8078 : 1485530 : tpl_parms_fini (decl, tpl_levels);
8079 : : }
8080 : :
8081 : 5060652 : if (type && !is_key_order ())
8082 : : {
8083 : 578549 : tree_node_vals (type);
8084 : 578549 : if (stub_decl)
8085 : 2157 : tree_node_vals (stub_decl);
8086 : : }
8087 : :
8088 : 5060652 : if (!is_key_order ())
8089 : : {
8090 : 3685058 : if (mk & MK_template_mask
8091 : 2542908 : || mk == MK_partial
8092 : 2542908 : || mk == MK_friend_spec)
8093 : : {
8094 : 50532 : if (mk != MK_partial)
8095 : : {
8096 : : // FIXME: We should make use of the merge-key by
8097 : : // exposing it outside of key_mergeable. But this gets
8098 : : // the job done.
8099 : 1142150 : auto *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);
8100 : :
8101 : 1142150 : if (streaming_p ())
8102 : 571075 : u (get_mergeable_specialization_flags (mk & MK_tmpl_decl_mask,
8103 : : entry->tmpl, decl));
8104 : 1142150 : tree_node (entry->tmpl);
8105 : 1142150 : tree_node (entry->args);
8106 : : }
8107 : : else
8108 : : {
8109 : 50532 : tree ti = get_template_info (inner);
8110 : 50532 : tree_node (TI_TEMPLATE (ti));
8111 : 50532 : tree_node (TI_ARGS (ti));
8112 : : }
8113 : : }
8114 : 3685058 : tree_node (get_constraints (decl));
8115 : : }
8116 : :
8117 : 5060652 : if (streaming_p ())
8118 : : {
8119 : : /* Do not stray outside this section. */
8120 : 1833746 : gcc_checking_assert (!dep || dep->section == dep_hash->section);
8121 : :
8122 : : /* Write the entity index, so we can insert it as soon as we
8123 : : know this is new. */
8124 : 1833746 : install_entity (decl, dep);
8125 : : }
8126 : :
8127 : 5060652 : if (DECL_LANG_SPECIFIC (inner)
8128 : 4625314 : && DECL_MODULE_KEYED_DECLS_P (inner)
8129 : 5060772 : && !is_key_order ())
8130 : : {
8131 : : /* Stream the keyed entities. */
8132 : 82 : auto *attach_vec = keyed_table->get (inner);
8133 : 82 : unsigned num = attach_vec->length ();
8134 : 82 : if (streaming_p ())
8135 : 38 : u (num);
8136 : 164 : for (unsigned ix = 0; ix != num; ix++)
8137 : : {
8138 : 82 : tree attached = (*attach_vec)[ix];
8139 : 82 : tree_node (attached);
8140 : 82 : if (streaming_p ())
8141 : 97 : dump (dumper::MERGE)
8142 : 15 : && dump ("Written %d[%u] attached decl %N", tag, ix, attached);
8143 : : }
8144 : : }
8145 : :
8146 : 5060652 : if (is_imported_temploid_friend)
8147 : : {
8148 : : /* Write imported temploid friends so that importers can reconstruct
8149 : : this information on stream-in. */
8150 : 81 : tree* slot = imported_temploid_friends->get (decl);
8151 : 81 : tree_node (*slot);
8152 : : }
8153 : :
8154 : 5060652 : bool is_typedef = false;
8155 : 5060652 : if (!type && TREE_CODE (inner) == TYPE_DECL)
8156 : : {
8157 : 1041817 : tree t = TREE_TYPE (inner);
8158 : 1041817 : unsigned tdef_flags = 0;
8159 : 1041817 : if (DECL_ORIGINAL_TYPE (inner)
8160 : 1041817 : && TYPE_NAME (TREE_TYPE (inner)) == inner)
8161 : : {
8162 : 1041817 : tdef_flags |= 1;
8163 : 1041817 : if (TYPE_STRUCTURAL_EQUALITY_P (t)
8164 : 220668 : && TYPE_DEPENDENT_P_VALID (t)
8165 : 1195957 : && TYPE_DEPENDENT_P (t))
8166 : : tdef_flags |= 2;
8167 : : }
8168 : 1041817 : if (streaming_p ())
8169 : 355119 : u (tdef_flags);
8170 : :
8171 : 1041817 : if (tdef_flags & 1)
8172 : : {
8173 : : /* A typedef type. */
8174 : 1041817 : int type_tag = insert (t);
8175 : 1041817 : if (streaming_p ())
8176 : 355119 : dump (dumper::TREE)
8177 : 198 : && dump ("Cloned:%d %s %C:%N", type_tag,
8178 : : tdef_flags & 2 ? "depalias" : "typedef",
8179 : 198 : TREE_CODE (t), t);
8180 : :
8181 : : is_typedef = true;
8182 : : }
8183 : : }
8184 : :
8185 : 5060652 : if (streaming_p () && DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
8186 : : {
8187 : 145380 : bool cloned_p
8188 : 145380 : = (DECL_CHAIN (decl) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
8189 : 100783 : bool needs_vtt_parm_p
8190 : 100783 : = (cloned_p && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (decl)));
8191 : 100783 : bool omit_inherited_parms_p
8192 : 100783 : = (cloned_p && DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
8193 : 80629 : && base_ctor_omit_inherited_parms (decl));
8194 : 145380 : unsigned flags = (int (cloned_p) << 0
8195 : 145380 : | int (needs_vtt_parm_p) << 1
8196 : 145380 : | int (omit_inherited_parms_p) << 2);
8197 : 145380 : u (flags);
8198 : 145455 : dump (dumper::TREE) && dump ("CDTOR %N is %scloned",
8199 : : decl, cloned_p ? "" : "not ");
8200 : : }
8201 : :
8202 : 5060652 : if (streaming_p () && VAR_P (decl) && CP_DECL_THREAD_LOCAL_P (decl))
8203 : 48 : u (decl_tls_model (decl));
8204 : :
8205 : 5060652 : if (streaming_p ())
8206 : 1833746 : dump (dumper::TREE) && dump ("Written decl:%d %C:%N", tag,
8207 : 642 : TREE_CODE (decl), decl);
8208 : :
8209 : 5060652 : if (NAMESPACE_SCOPE_P (inner))
8210 : 3053726 : gcc_checking_assert (!dep == (VAR_OR_FUNCTION_DECL_P (inner)
8211 : : && DECL_LOCAL_DECL_P (inner)));
8212 : 3533634 : else if ((TREE_CODE (inner) == TYPE_DECL
8213 : 1034808 : && !is_typedef
8214 : 181958 : && TYPE_NAME (TREE_TYPE (inner)) == inner)
8215 : 4386484 : || TREE_CODE (inner) == FUNCTION_DECL)
8216 : : {
8217 : 1686901 : bool write_defn = !dep && has_definition (decl);
8218 : 1686901 : if (streaming_p ())
8219 : 562661 : u (write_defn);
8220 : 1686901 : if (write_defn)
8221 : 0 : write_definition (decl);
8222 : : }
8223 : : }
8224 : :
8225 : : tree
8226 : 1770183 : trees_in::decl_value ()
8227 : : {
8228 : 1770183 : int tag = 0;
8229 : 1770183 : bool is_attached = false;
8230 : 1770183 : bool is_imported_temploid_friend = false;
8231 : 1770183 : bool has_defn = false;
8232 : 1770183 : unsigned mk_u = u ();
8233 : 1770183 : if (mk_u >= MK_hwm || !merge_kind_name[mk_u])
8234 : : {
8235 : 0 : set_overrun ();
8236 : 0 : return NULL_TREE;
8237 : : }
8238 : :
8239 : 1770183 : unsigned saved_unused = unused;
8240 : 1770183 : unused = 0;
8241 : :
8242 : 1770183 : merge_kind mk = merge_kind (mk_u);
8243 : :
8244 : 1770183 : tree decl = start ();
8245 : 1770183 : if (decl)
8246 : : {
8247 : 1770183 : if (mk != MK_unique)
8248 : : {
8249 : 1493620 : bits_in bits = stream_bits ();
8250 : 1493620 : if (!(mk & MK_template_mask) && !state->is_header ())
8251 : : {
8252 : 42842 : is_attached = bits.b ();
8253 : 42842 : is_imported_temploid_friend = bits.b ();
8254 : : }
8255 : :
8256 : 1493620 : has_defn = bits.b ();
8257 : 1493620 : }
8258 : :
8259 : 1770183 : if (!tree_node_bools (decl))
8260 : 0 : decl = NULL_TREE;
8261 : : }
8262 : :
8263 : : /* Insert into map. */
8264 : 1770183 : tag = insert (decl);
8265 : 1770183 : if (decl)
8266 : 1770183 : dump (dumper::TREE)
8267 : 936 : && dump ("Reading:%d %C", tag, TREE_CODE (decl));
8268 : :
8269 : 1770183 : tree inner = decl;
8270 : 1770183 : int inner_tag = 0;
8271 : 1770183 : if (decl && TREE_CODE (decl) == TEMPLATE_DECL)
8272 : : {
8273 : 473887 : int code = u ();
8274 : 473887 : inner = start (code);
8275 : 473887 : if (inner && tree_node_bools (inner))
8276 : 473887 : DECL_TEMPLATE_RESULT (decl) = inner;
8277 : : else
8278 : 0 : decl = NULL_TREE;
8279 : :
8280 : 473887 : inner_tag = insert (inner);
8281 : 473887 : if (decl)
8282 : 473887 : dump (dumper::TREE)
8283 : 204 : && dump ("Reading:%d %C", inner_tag, TREE_CODE (inner));
8284 : : }
8285 : :
8286 : 1770183 : tree type = NULL_TREE;
8287 : 1770183 : int type_tag = 0;
8288 : 1770183 : tree stub_decl = NULL_TREE;
8289 : 1770183 : int stub_tag = 0;
8290 : 1770183 : if (decl && TREE_CODE (inner) == TYPE_DECL)
8291 : : {
8292 : 601792 : if (unsigned type_code = u ())
8293 : : {
8294 : 270056 : type = start (type_code);
8295 : 270056 : if (type && tree_node_bools (type))
8296 : : {
8297 : 270056 : TREE_TYPE (inner) = type;
8298 : 270056 : TYPE_NAME (type) = inner;
8299 : : }
8300 : : else
8301 : 0 : decl = NULL_TREE;
8302 : :
8303 : 270056 : type_tag = insert (type);
8304 : 270056 : if (decl)
8305 : 270056 : dump (dumper::TREE)
8306 : 210 : && dump ("Reading type:%d %C", type_tag, TREE_CODE (type));
8307 : :
8308 : 270056 : if (unsigned stub_code = u ())
8309 : : {
8310 : 940 : stub_decl = start (stub_code);
8311 : 940 : if (stub_decl && tree_node_bools (stub_decl))
8312 : : {
8313 : 940 : TREE_TYPE (stub_decl) = type;
8314 : 940 : TYPE_STUB_DECL (type) = stub_decl;
8315 : : }
8316 : : else
8317 : 0 : decl = NULL_TREE;
8318 : :
8319 : 940 : stub_tag = insert (stub_decl);
8320 : 940 : if (decl)
8321 : 940 : dump (dumper::TREE)
8322 : 0 : && dump ("Reading stub_decl:%d %C", stub_tag,
8323 : 0 : TREE_CODE (stub_decl));
8324 : : }
8325 : : }
8326 : : }
8327 : :
8328 : 1770183 : if (!decl)
8329 : : {
8330 : 0 : bail:
8331 : 0 : if (inner_tag != 0)
8332 : 0 : back_refs[~inner_tag] = NULL_TREE;
8333 : 0 : if (type_tag != 0)
8334 : 0 : back_refs[~type_tag] = NULL_TREE;
8335 : 0 : if (stub_tag != 0)
8336 : 0 : back_refs[~stub_tag] = NULL_TREE;
8337 : 0 : if (tag != 0)
8338 : 0 : back_refs[~tag] = NULL_TREE;
8339 : 0 : set_overrun ();
8340 : : /* Bail. */
8341 : 0 : unused = saved_unused;
8342 : 0 : return NULL_TREE;
8343 : : }
8344 : :
8345 : : /* Read the container, to ensure it's already been streamed in. */
8346 : 1770183 : tree container = decl_container ();
8347 : 1770183 : unsigned tpl_levels = 0;
8348 : :
8349 : : /* Figure out if this decl is already known about. */
8350 : 1770183 : int parm_tag = 0;
8351 : :
8352 : 1770183 : if (decl != inner)
8353 : 473887 : if (!tpl_header (decl, &tpl_levels))
8354 : 0 : goto bail;
8355 : 1770183 : if (TREE_CODE (inner) == FUNCTION_DECL)
8356 : 687780 : parm_tag = fn_parms_init (inner);
8357 : :
8358 : 1770183 : tree existing = key_mergeable (tag, mk, decl, inner, type, container,
8359 : 1770183 : is_attached, is_imported_temploid_friend);
8360 : 1770183 : tree existing_inner = existing;
8361 : 1770183 : if (existing)
8362 : : {
8363 : 910194 : if (existing == error_mark_node)
8364 : 0 : goto bail;
8365 : :
8366 : 910194 : if (TREE_CODE (STRIP_TEMPLATE (existing)) == TYPE_DECL)
8367 : : {
8368 : 343364 : tree etype = TREE_TYPE (existing);
8369 : 343364 : if (TYPE_LANG_SPECIFIC (etype)
8370 : 250310 : && COMPLETE_TYPE_P (etype)
8371 : 489332 : && !CLASSTYPE_MEMBER_VEC (etype))
8372 : : /* Give it a member vec, we're likely gonna be looking
8373 : : inside it. */
8374 : 30575 : set_class_bindings (etype, -1);
8375 : : }
8376 : :
8377 : : /* Install the existing decl into the back ref array. */
8378 : 910194 : register_duplicate (decl, existing);
8379 : 910194 : back_refs[~tag] = existing;
8380 : 910194 : if (inner_tag != 0)
8381 : : {
8382 : 302941 : existing_inner = DECL_TEMPLATE_RESULT (existing);
8383 : 302941 : back_refs[~inner_tag] = existing_inner;
8384 : : }
8385 : :
8386 : 910194 : if (type_tag != 0)
8387 : : {
8388 : 163632 : tree existing_type = TREE_TYPE (existing);
8389 : 163632 : back_refs[~type_tag] = existing_type;
8390 : 163632 : if (stub_tag != 0)
8391 : 564 : back_refs[~stub_tag] = TYPE_STUB_DECL (existing_type);
8392 : : }
8393 : : }
8394 : :
8395 : 1770183 : if (parm_tag)
8396 : 687780 : fn_parms_fini (parm_tag, inner, existing_inner, has_defn);
8397 : :
8398 : 1770183 : if (!tree_node_vals (decl))
8399 : 0 : goto bail;
8400 : :
8401 : 1770183 : if (inner_tag)
8402 : : {
8403 : 473887 : gcc_checking_assert (DECL_TEMPLATE_RESULT (decl) == inner);
8404 : :
8405 : 473887 : if (!tree_node_vals (inner))
8406 : 0 : goto bail;
8407 : :
8408 : 473887 : if (!tpl_parms_fini (decl, tpl_levels))
8409 : 0 : goto bail;
8410 : : }
8411 : :
8412 : 1770183 : if (type && (!tree_node_vals (type)
8413 : 270056 : || (stub_decl && !tree_node_vals (stub_decl))))
8414 : 0 : goto bail;
8415 : :
8416 : 1770183 : spec_entry spec;
8417 : 1770183 : unsigned spec_flags = 0;
8418 : 1770183 : if (mk & MK_template_mask
8419 : 1213256 : || mk == MK_partial
8420 : 1213256 : || mk == MK_friend_spec)
8421 : : {
8422 : 20869 : if (mk == MK_partial)
8423 : : spec_flags = 2;
8424 : : else
8425 : 556927 : spec_flags = u ();
8426 : :
8427 : 577796 : spec.tmpl = tree_node ();
8428 : 577796 : spec.args = tree_node ();
8429 : : }
8430 : : /* Hold constraints on the spec field, for a short while. */
8431 : 1770183 : spec.spec = tree_node ();
8432 : :
8433 : 1771119 : dump (dumper::TREE) && dump ("Read:%d %C:%N", tag, TREE_CODE (decl), decl);
8434 : :
8435 : 1770183 : existing = back_refs[~tag];
8436 : 1770183 : bool installed = install_entity (existing);
8437 : 1770183 : bool is_new = existing == decl;
8438 : :
8439 : 1770183 : if (DECL_LANG_SPECIFIC (inner)
8440 : 3365910 : && DECL_MODULE_KEYED_DECLS_P (inner))
8441 : : {
8442 : : /* Read and maybe install the attached entities. */
8443 : 56 : bool existed;
8444 : 56 : auto &set = keyed_table->get_or_insert (STRIP_TEMPLATE (existing),
8445 : : &existed);
8446 : 56 : unsigned num = u ();
8447 : 56 : if (is_new == existed)
8448 : 0 : set_overrun ();
8449 : 56 : if (is_new)
8450 : 24 : set.reserve (num);
8451 : 112 : for (unsigned ix = 0; !get_overrun () && ix != num; ix++)
8452 : : {
8453 : 56 : tree attached = tree_node ();
8454 : 56 : dump (dumper::MERGE)
8455 : 58 : && dump ("Read %d[%u] %s attached decl %N", tag, ix,
8456 : : is_new ? "new" : "matched", attached);
8457 : 56 : if (is_new)
8458 : 24 : set.quick_push (attached);
8459 : 32 : else if (set[ix] != attached)
8460 : 0 : set_overrun ();
8461 : : }
8462 : : }
8463 : :
8464 : 1770183 : if (is_imported_temploid_friend)
8465 : 33 : if (tree owner = tree_node ())
8466 : 33 : if (is_new)
8467 : 21 : imported_temploid_friends->put (decl, owner);
8468 : :
8469 : : /* Regular typedefs will have a NULL TREE_TYPE at this point. */
8470 : 1770183 : unsigned tdef_flags = 0;
8471 : 1770183 : bool is_typedef = false;
8472 : 1770183 : if (!type && TREE_CODE (inner) == TYPE_DECL)
8473 : : {
8474 : 331736 : tdef_flags = u ();
8475 : 331736 : if (tdef_flags & 1)
8476 : 331736 : is_typedef = true;
8477 : : }
8478 : :
8479 : 1770183 : if (is_new)
8480 : : {
8481 : : /* A newly discovered node. */
8482 : 859989 : if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
8483 : : /* Mark this identifier as naming a virtual function --
8484 : : lookup_overrides relies on this optimization. */
8485 : 7898 : IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = true;
8486 : :
8487 : 859989 : if (installed)
8488 : : {
8489 : : /* Mark the entity as imported. */
8490 : 517953 : retrofit_lang_decl (inner);
8491 : 517953 : DECL_MODULE_IMPORT_P (inner) = true;
8492 : : }
8493 : :
8494 : 859989 : if (spec.spec)
8495 : 17067 : set_constraints (decl, spec.spec);
8496 : :
8497 : 859989 : if (TREE_CODE (decl) == INTEGER_CST && !TREE_OVERFLOW (decl))
8498 : : {
8499 : 0 : decl = cache_integer_cst (decl, true);
8500 : 0 : back_refs[~tag] = decl;
8501 : : }
8502 : :
8503 : 859989 : if (is_typedef)
8504 : : {
8505 : : /* Frob it to be ready for cloning. */
8506 : 152004 : TREE_TYPE (inner) = DECL_ORIGINAL_TYPE (inner);
8507 : 152004 : DECL_ORIGINAL_TYPE (inner) = NULL_TREE;
8508 : 152004 : if (TREE_CODE (TREE_TYPE (inner)) != TU_LOCAL_ENTITY)
8509 : : {
8510 : 152001 : set_underlying_type (inner);
8511 : 152001 : if (tdef_flags & 2)
8512 : : {
8513 : : /* Match instantiate_alias_template's handling. */
8514 : 29309 : tree type = TREE_TYPE (inner);
8515 : 29309 : TYPE_DEPENDENT_P (type) = true;
8516 : 29309 : TYPE_DEPENDENT_P_VALID (type) = true;
8517 : 29309 : SET_TYPE_STRUCTURAL_EQUALITY (type);
8518 : : }
8519 : : }
8520 : : }
8521 : :
8522 : 859989 : if (inner_tag)
8523 : : /* Set the TEMPLATE_DECL's type. */
8524 : 170946 : TREE_TYPE (decl) = TREE_TYPE (inner);
8525 : :
8526 : : /* Redetermine whether we need to import or export this declaration
8527 : : for this TU. But for extern templates we know we must import:
8528 : : they'll be defined in a different TU.
8529 : : FIXME: How do dllexport and dllimport interact across a module?
8530 : : See also https://github.com/itanium-cxx-abi/cxx-abi/issues/170.
8531 : : May have to revisit? */
8532 : 859989 : if (type
8533 : 106424 : && CLASS_TYPE_P (type)
8534 : 90517 : && TYPE_LANG_SPECIFIC (type)
8535 : 950506 : && !(CLASSTYPE_EXPLICIT_INSTANTIATION (type)
8536 : 930 : && CLASSTYPE_INTERFACE_KNOWN (type)
8537 : 930 : && CLASSTYPE_INTERFACE_ONLY (type)))
8538 : : {
8539 : 89621 : CLASSTYPE_INTERFACE_ONLY (type) = false;
8540 : 89621 : CLASSTYPE_INTERFACE_UNKNOWN (type) = true;
8541 : : }
8542 : :
8543 : : /* Add to specialization tables now that constraints etc are
8544 : : added. */
8545 : 859989 : if (mk == MK_partial)
8546 : : {
8547 : 7676 : bool is_type = TREE_CODE (inner) == TYPE_DECL;
8548 : 7676 : spec.spec = is_type ? type : inner;
8549 : 7676 : add_mergeable_specialization (!is_type, &spec, decl, spec_flags);
8550 : : }
8551 : 852313 : else if (mk & MK_template_mask)
8552 : : {
8553 : 232495 : bool is_type = !(mk & MK_tmpl_decl_mask);
8554 : 232495 : spec.spec = is_type ? type : mk & MK_tmpl_tmpl_mask ? inner : decl;
8555 : 232495 : add_mergeable_specialization (!is_type, &spec, decl, spec_flags);
8556 : : }
8557 : :
8558 : 859989 : if (NAMESPACE_SCOPE_P (decl)
8559 : 184574 : && (mk == MK_named || mk == MK_unique
8560 : 184574 : || mk == MK_enum || mk == MK_friend_spec)
8561 : 950797 : && !(VAR_OR_FUNCTION_DECL_P (decl) && DECL_LOCAL_DECL_P (decl)))
8562 : 90679 : add_module_namespace_decl (CP_DECL_CONTEXT (decl), decl);
8563 : :
8564 : 859989 : if (DECL_ARTIFICIAL (decl)
8565 : 229378 : && TREE_CODE (decl) == FUNCTION_DECL
8566 : 20530 : && !DECL_TEMPLATE_INFO (decl)
8567 : 20260 : && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
8568 : 20118 : && TYPE_SIZE (DECL_CONTEXT (decl))
8569 : 862677 : && !DECL_THUNK_P (decl))
8570 : : /* A new implicit member function, when the class is
8571 : : complete. This means the importee declared it, and
8572 : : we must now add it to the class. Note that implicit
8573 : : member fns of template instantiations do not themselves
8574 : : look like templates. */
8575 : 1492 : if (!install_implicit_member (inner))
8576 : 0 : set_overrun ();
8577 : :
8578 : : /* When importing a TLS wrapper from a header unit, we haven't
8579 : : actually emitted its definition yet. Remember it so we can
8580 : : do this later. */
8581 : 859989 : if (state->is_header ()
8582 : 859989 : && decl_tls_wrapper_p (decl))
8583 : 6 : note_vague_linkage_fn (decl);
8584 : :
8585 : : /* Setup aliases for the declaration. */
8586 : 859989 : if (tree alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
8587 : : {
8588 : 3 : alias = TREE_VALUE (TREE_VALUE (alias));
8589 : 3 : alias = get_identifier (TREE_STRING_POINTER (alias));
8590 : 3 : assemble_alias (decl, alias);
8591 : : }
8592 : : }
8593 : : else
8594 : : {
8595 : : /* DECL is the to-be-discarded decl. Its internal pointers will
8596 : : be to the EXISTING's structure. Frob it to point to its
8597 : : own other structures, so loading its definition will alter
8598 : : it, and not the existing decl. */
8599 : 911584 : dump (dumper::MERGE) && dump ("Deduping %N", existing);
8600 : :
8601 : 910194 : if (inner_tag)
8602 : 302941 : DECL_TEMPLATE_RESULT (decl) = inner;
8603 : :
8604 : 910194 : if (type)
8605 : : {
8606 : : /* Point at the to-be-discarded type & decl. */
8607 : 163632 : TYPE_NAME (type) = inner;
8608 : 163632 : TREE_TYPE (inner) = type;
8609 : :
8610 : 326700 : TYPE_STUB_DECL (type) = stub_decl ? stub_decl : inner;
8611 : 163632 : if (stub_decl)
8612 : 564 : TREE_TYPE (stub_decl) = type;
8613 : : }
8614 : :
8615 : 910194 : if (inner_tag)
8616 : : /* Set the TEMPLATE_DECL's type. */
8617 : 302941 : TREE_TYPE (decl) = TREE_TYPE (inner);
8618 : :
8619 : 910194 : if (!is_matching_decl (existing, decl, is_typedef))
8620 : 30 : unmatched_duplicate (existing);
8621 : :
8622 : 910194 : if (TREE_CODE (inner) == FUNCTION_DECL)
8623 : : {
8624 : 424469 : tree e_inner = STRIP_TEMPLATE (existing);
8625 : 424469 : for (auto parm = DECL_ARGUMENTS (inner);
8626 : 1287653 : parm; parm = DECL_CHAIN (parm))
8627 : 863184 : DECL_CONTEXT (parm) = e_inner;
8628 : : }
8629 : :
8630 : : /* And our result is the existing node. */
8631 : 910194 : decl = existing;
8632 : : }
8633 : :
8634 : 1770183 : if (mk == MK_friend_spec)
8635 : : {
8636 : 0 : tree e = match_mergeable_specialization (true, &spec);
8637 : 0 : if (!e)
8638 : : {
8639 : 0 : spec.spec = inner;
8640 : 0 : add_mergeable_specialization (true, &spec, decl, spec_flags);
8641 : : }
8642 : 0 : else if (e != existing)
8643 : 0 : set_overrun ();
8644 : : }
8645 : :
8646 : 1770183 : if (is_typedef)
8647 : : {
8648 : : /* Insert the type into the array now. */
8649 : 331736 : tag = insert (TREE_TYPE (decl));
8650 : 331736 : dump (dumper::TREE)
8651 : 243 : && dump ("Cloned:%d typedef %C:%N",
8652 : 243 : tag, TREE_CODE (TREE_TYPE (decl)), TREE_TYPE (decl));
8653 : : }
8654 : :
8655 : 1770183 : unused = saved_unused;
8656 : :
8657 : 1770183 : if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
8658 : : {
8659 : 142179 : unsigned flags = u ();
8660 : :
8661 : 142179 : if (is_new)
8662 : : {
8663 : 57651 : bool cloned_p = flags & 1;
8664 : 57747 : dump (dumper::TREE) && dump ("CDTOR %N is %scloned",
8665 : : decl, cloned_p ? "" : "not ");
8666 : 57651 : if (cloned_p)
8667 : 84264 : build_cdtor_clones (decl, flags & 2, flags & 4,
8668 : : /* Update the member vec, if there is
8669 : : one (we're in a different cluster
8670 : : to the class defn). */
8671 : 42132 : CLASSTYPE_MEMBER_VEC (DECL_CONTEXT (decl)));
8672 : : }
8673 : : }
8674 : :
8675 : 1770183 : if (VAR_P (decl) && CP_DECL_THREAD_LOCAL_P (decl))
8676 : : {
8677 : 45 : enum tls_model model = tls_model (u ());
8678 : 45 : if (is_new)
8679 : 21 : set_decl_tls_model (decl, model);
8680 : : }
8681 : :
8682 : 1770183 : if (!NAMESPACE_SCOPE_P (inner)
8683 : 1281575 : && ((TREE_CODE (inner) == TYPE_DECL
8684 : 326602 : && !is_typedef
8685 : 53955 : && TYPE_NAME (TREE_TYPE (inner)) == inner)
8686 : 1227620 : || TREE_CODE (inner) == FUNCTION_DECL)
8687 : 2320882 : && u ())
8688 : 0 : read_definition (decl);
8689 : :
8690 : : return decl;
8691 : : }
8692 : :
8693 : : /* DECL is an unnameable member of CTX. Return a suitable identifying
8694 : : index. */
8695 : :
8696 : : static unsigned
8697 : 1509 : get_field_ident (tree ctx, tree decl)
8698 : : {
8699 : 1509 : gcc_checking_assert (TREE_CODE (decl) == USING_DECL
8700 : : || !DECL_NAME (decl)
8701 : : || IDENTIFIER_ANON_P (DECL_NAME (decl)));
8702 : :
8703 : 1509 : unsigned ix = 0;
8704 : 1509 : for (tree fields = TYPE_FIELDS (ctx);
8705 : 11674 : fields; fields = DECL_CHAIN (fields))
8706 : : {
8707 : 11674 : if (fields == decl)
8708 : 1509 : return ix;
8709 : :
8710 : 10165 : if (DECL_CONTEXT (fields) == ctx
8711 : 10165 : && (TREE_CODE (fields) == USING_DECL
8712 : 10157 : || (TREE_CODE (fields) == FIELD_DECL
8713 : 43 : && (!DECL_NAME (fields)
8714 : 7 : || IDENTIFIER_ANON_P (DECL_NAME (fields))))))
8715 : : /* Count this field. */
8716 : 36 : ix++;
8717 : : }
8718 : 0 : gcc_unreachable ();
8719 : : }
8720 : :
8721 : : static tree
8722 : 1461 : lookup_field_ident (tree ctx, unsigned ix)
8723 : : {
8724 : 1461 : for (tree fields = TYPE_FIELDS (ctx);
8725 : 11111 : fields; fields = DECL_CHAIN (fields))
8726 : 11111 : if (DECL_CONTEXT (fields) == ctx
8727 : 11111 : && (TREE_CODE (fields) == USING_DECL
8728 : 11105 : || (TREE_CODE (fields) == FIELD_DECL
8729 : 1500 : && (!DECL_NAME (fields)
8730 : 3 : || IDENTIFIER_ANON_P (DECL_NAME (fields))))))
8731 : 1497 : if (!ix--)
8732 : : return fields;
8733 : :
8734 : : return NULL_TREE;
8735 : : }
8736 : :
8737 : : /* Reference DECL. REF indicates the walk kind we are performing.
8738 : : Return true if we should write this decl by value. */
8739 : :
8740 : : bool
8741 : 17185645 : trees_out::decl_node (tree decl, walk_kind ref)
8742 : : {
8743 : 17185645 : gcc_checking_assert (DECL_P (decl) && !DECL_TEMPLATE_PARM_P (decl)
8744 : : && DECL_CONTEXT (decl));
8745 : :
8746 : 17185645 : if (ref == WK_value)
8747 : : {
8748 : 1741009 : depset *dep = dep_hash->find_dependency (decl);
8749 : 1741009 : decl_value (decl, dep);
8750 : 1741009 : return false;
8751 : : }
8752 : :
8753 : 15444636 : switch (TREE_CODE (decl))
8754 : : {
8755 : : default:
8756 : : break;
8757 : :
8758 : 1592347 : case FUNCTION_DECL:
8759 : 1592347 : gcc_checking_assert (!DECL_LOCAL_DECL_P (decl));
8760 : : break;
8761 : :
8762 : : case RESULT_DECL:
8763 : : /* Unlike PARM_DECLs, RESULT_DECLs are only generated and
8764 : : referenced when we're inside the function itself. */
8765 : : return true;
8766 : :
8767 : 371967 : case PARM_DECL:
8768 : 371967 : {
8769 : 371967 : if (streaming_p ())
8770 : 87313 : i (tt_parm);
8771 : 371967 : tree_node (DECL_CONTEXT (decl));
8772 : 371967 : if (streaming_p ())
8773 : : {
8774 : : /* That must have put this in the map. */
8775 : 87313 : walk_kind ref = ref_node (decl);
8776 : 87313 : if (ref != WK_none)
8777 : : // FIXME:OPTIMIZATION We can wander into bits of the
8778 : : // template this was instantiated from. For instance
8779 : : // deferred noexcept and default parms. Currently we'll
8780 : : // end up cloning those bits of tree. It would be nice
8781 : : // to reference those specific nodes. I think putting
8782 : : // those things in the map when we reference their
8783 : : // template by name. See the note in add_indirects.
8784 : : return true;
8785 : :
8786 : 0 : dump (dumper::TREE)
8787 : 0 : && dump ("Wrote %s reference %N",
8788 : 0 : TREE_CODE (decl) == PARM_DECL ? "parameter" : "result",
8789 : : decl);
8790 : : }
8791 : : }
8792 : : return false;
8793 : :
8794 : : case IMPORTED_DECL:
8795 : : /* This describes a USING_DECL to the ME's debug machinery. It
8796 : : originates from the fortran FE, and has nothing to do with
8797 : : C++ modules. */
8798 : : return true;
8799 : :
8800 : : case LABEL_DECL:
8801 : : return true;
8802 : :
8803 : 67875 : case CONST_DECL:
8804 : 67875 : {
8805 : : /* If I end up cloning enum decls, implementing C++20 using
8806 : : E::v, this will need tweaking. */
8807 : 67875 : if (streaming_p ())
8808 : 11397 : i (tt_enum_decl);
8809 : 67875 : tree ctx = DECL_CONTEXT (decl);
8810 : 67875 : gcc_checking_assert (TREE_CODE (ctx) == ENUMERAL_TYPE);
8811 : 67875 : tree_node (ctx);
8812 : 67875 : tree_node (DECL_NAME (decl));
8813 : :
8814 : 67875 : int tag = insert (decl);
8815 : 67875 : if (streaming_p ())
8816 : 11397 : dump (dumper::TREE)
8817 : 21 : && dump ("Wrote enum decl:%d %C:%N", tag, TREE_CODE (decl), decl);
8818 : : return false;
8819 : : }
8820 : 7186 : break;
8821 : :
8822 : 7186 : case USING_DECL:
8823 : 7186 : if (TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
8824 : : break;
8825 : : /* FALLTHROUGH */
8826 : :
8827 : 210415 : case FIELD_DECL:
8828 : 210415 : {
8829 : 210415 : if (streaming_p ())
8830 : 10612 : i (tt_data_member);
8831 : :
8832 : 210415 : tree ctx = DECL_CONTEXT (decl);
8833 : 210415 : tree_node (ctx);
8834 : :
8835 : 210415 : tree name = NULL_TREE;
8836 : :
8837 : 210415 : if (TREE_CODE (decl) == USING_DECL)
8838 : : ;
8839 : : else
8840 : : {
8841 : 208701 : name = DECL_NAME (decl);
8842 : 405987 : if (name && IDENTIFIER_ANON_P (name))
8843 : : name = NULL_TREE;
8844 : : }
8845 : :
8846 : 210415 : tree_node (name);
8847 : 210415 : if (!name && streaming_p ())
8848 : : {
8849 : 1509 : unsigned ix = get_field_ident (ctx, decl);
8850 : 1509 : u (ix);
8851 : : }
8852 : :
8853 : 210415 : int tag = insert (decl);
8854 : 210415 : if (streaming_p ())
8855 : 10612 : dump (dumper::TREE)
8856 : 21 : && dump ("Wrote member:%d %C:%N", tag, TREE_CODE (decl), decl);
8857 : : return false;
8858 : : }
8859 : 640003 : break;
8860 : :
8861 : 640003 : case VAR_DECL:
8862 : 640003 : gcc_checking_assert (!DECL_LOCAL_DECL_P (decl));
8863 : 640003 : if (DECL_VTABLE_OR_VTT_P (decl))
8864 : : {
8865 : : /* VTT or VTABLE, they are all on the vtables list. */
8866 : 2435 : tree ctx = CP_DECL_CONTEXT (decl);
8867 : 2435 : tree vtable = CLASSTYPE_VTABLES (ctx);
8868 : 2447 : for (unsigned ix = 0; ; vtable = DECL_CHAIN (vtable), ix++)
8869 : 2447 : if (vtable == decl)
8870 : : {
8871 : 2435 : gcc_checking_assert (DECL_VIRTUAL_P (decl));
8872 : 2435 : if (streaming_p ())
8873 : : {
8874 : 18 : u (tt_vtable);
8875 : 18 : u (ix);
8876 : 18 : dump (dumper::TREE)
8877 : 0 : && dump ("Writing vtable %N[%u]", ctx, ix);
8878 : : }
8879 : 2435 : tree_node (ctx);
8880 : 2435 : return false;
8881 : : }
8882 : : gcc_unreachable ();
8883 : : }
8884 : :
8885 : 637568 : if (DECL_TINFO_P (decl))
8886 : : {
8887 : 10490 : tinfo:
8888 : : /* A typeinfo, tt_tinfo_typedef or tt_tinfo_var. */
8889 : 19159 : bool is_var = VAR_P (decl);
8890 : 19159 : tree type = TREE_TYPE (decl);
8891 : 19159 : unsigned ix = get_pseudo_tinfo_index (type);
8892 : 19159 : if (streaming_p ())
8893 : : {
8894 : 12020 : i (is_var ? tt_tinfo_var : tt_tinfo_typedef);
8895 : 8570 : u (ix);
8896 : : }
8897 : :
8898 : 19159 : if (is_var)
8899 : : {
8900 : : /* We also need the type it is for and mangled name, so
8901 : : the reader doesn't need to complete the type (which
8902 : : would break section ordering). The type it is for is
8903 : : stashed on the name's TREE_TYPE. */
8904 : 10490 : tree name = DECL_NAME (decl);
8905 : 10490 : tree_node (name);
8906 : 10490 : type = TREE_TYPE (name);
8907 : 10490 : tree_node (type);
8908 : : }
8909 : :
8910 : 19159 : int tag = insert (decl);
8911 : 19159 : if (streaming_p ())
8912 : 8570 : dump (dumper::TREE)
8913 : 27 : && dump ("Wrote tinfo_%s:%d %u %N", is_var ? "var" : "type",
8914 : : tag, ix, type);
8915 : :
8916 : 19159 : if (!is_var)
8917 : : {
8918 : 8669 : tag = insert (type);
8919 : 8669 : if (streaming_p ())
8920 : 3450 : dump (dumper::TREE)
8921 : 9 : && dump ("Wrote tinfo_type:%d %u %N", tag, ix, type);
8922 : : }
8923 : 19159 : return false;
8924 : : }
8925 : :
8926 : 627078 : if (DECL_NTTP_OBJECT_P (decl))
8927 : : {
8928 : : /* A NTTP parm object. */
8929 : 20 : if (streaming_p ())
8930 : 4 : i (tt_nttp_var);
8931 : 20 : tree_node (tparm_object_argument (decl));
8932 : 20 : tree_node (DECL_NAME (decl));
8933 : 20 : int tag = insert (decl);
8934 : 20 : if (streaming_p ())
8935 : 4 : dump (dumper::TREE)
8936 : 0 : && dump ("Wrote nttp object:%d %N", tag, DECL_NAME (decl));
8937 : 20 : return false;
8938 : : }
8939 : :
8940 : : break;
8941 : :
8942 : 5528652 : case TYPE_DECL:
8943 : 5528652 : if (DECL_TINFO_P (decl))
8944 : 8669 : goto tinfo;
8945 : : break;
8946 : : }
8947 : :
8948 : 13987361 : if (DECL_THUNK_P (decl))
8949 : : {
8950 : : /* Thunks are similar to binfos -- write the thunked-to decl and
8951 : : then thunk-specific key info. */
8952 : 0 : if (streaming_p ())
8953 : : {
8954 : 0 : i (tt_thunk);
8955 : 0 : i (THUNK_FIXED_OFFSET (decl));
8956 : : }
8957 : :
8958 : : tree target = decl;
8959 : 0 : while (DECL_THUNK_P (target))
8960 : 0 : target = THUNK_TARGET (target);
8961 : 0 : tree_node (target);
8962 : 0 : tree_node (THUNK_VIRTUAL_OFFSET (decl));
8963 : 0 : int tag = insert (decl);
8964 : 0 : if (streaming_p ())
8965 : 0 : dump (dumper::TREE)
8966 : 0 : && dump ("Wrote:%d thunk %N to %N", tag, DECL_NAME (decl), target);
8967 : 0 : return false;
8968 : : }
8969 : :
8970 : 13987361 : if (DECL_CLONED_FUNCTION_P (decl))
8971 : : {
8972 : 464020 : tree target = get_clone_target (decl);
8973 : 464020 : if (streaming_p ())
8974 : 219455 : i (tt_clone_ref);
8975 : :
8976 : 464020 : tree_node (target);
8977 : 464020 : tree_node (DECL_NAME (decl));
8978 : 464020 : if (DECL_VIRTUAL_P (decl))
8979 : 39615 : tree_node (DECL_VINDEX (decl));
8980 : 464020 : int tag = insert (decl);
8981 : 464020 : if (streaming_p ())
8982 : 219455 : dump (dumper::TREE)
8983 : 156 : && dump ("Wrote:%d clone %N of %N", tag, DECL_NAME (decl), target);
8984 : 464020 : return false;
8985 : : }
8986 : :
8987 : : /* Everything left should be a thing that is in the entity table.
8988 : : Mostly things that can be defined outside of their (original
8989 : : declaration) context. */
8990 : 13523341 : gcc_checking_assert (TREE_CODE (decl) == TEMPLATE_DECL
8991 : : || VAR_P (decl)
8992 : : || TREE_CODE (decl) == FUNCTION_DECL
8993 : : || TREE_CODE (decl) == TYPE_DECL
8994 : : || TREE_CODE (decl) == USING_DECL
8995 : : || TREE_CODE (decl) == CONCEPT_DECL
8996 : : || TREE_CODE (decl) == NAMESPACE_DECL);
8997 : :
8998 : 13523341 : int use_tpl = -1;
8999 : 13523341 : tree ti = node_template_info (decl, use_tpl);
9000 : 13523341 : tree tpl = NULL_TREE;
9001 : :
9002 : : /* If this is the TEMPLATE_DECL_RESULT of a TEMPLATE_DECL, get the
9003 : : TEMPLATE_DECL. Note TI_TEMPLATE is not a TEMPLATE_DECL for
9004 : : (some) friends, so we need to check that. */
9005 : : // FIXME: Should local friend template specializations be by value?
9006 : : // They don't get idents so we'll never know they're imported, but I
9007 : : // think we can only reach them from the TU that defines the
9008 : : // befriending class?
9009 : 5135205 : if (ti && TREE_CODE (TI_TEMPLATE (ti)) == TEMPLATE_DECL
9010 : 18658495 : && DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == decl)
9011 : : {
9012 : : tpl = TI_TEMPLATE (ti);
9013 : 1311621 : partial_template:
9014 : 1311621 : if (streaming_p ())
9015 : : {
9016 : 3875 : i (tt_template);
9017 : 3875 : dump (dumper::TREE)
9018 : 9 : && dump ("Writing implicit template %C:%N%S",
9019 : 9 : TREE_CODE (tpl), tpl, tpl);
9020 : : }
9021 : 1311621 : tree_node (tpl);
9022 : :
9023 : : /* Streaming TPL caused us to visit DECL and maybe its type,
9024 : : if it wasn't TU-local. */
9025 : 1311621 : if (CHECKING_P && !has_tu_local_dep (tpl))
9026 : : {
9027 : 1311573 : gcc_checking_assert (TREE_VISITED (decl));
9028 : 1311573 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
9029 : 670148 : gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl)));
9030 : : }
9031 : : return false;
9032 : : }
9033 : :
9034 : 12355153 : tree ctx = CP_DECL_CONTEXT (decl);
9035 : 12355153 : depset *dep = NULL;
9036 : 12355153 : if (streaming_p ())
9037 : 1980451 : dep = dep_hash->find_dependency (decl);
9038 : 10374702 : else if (TREE_CODE (ctx) != FUNCTION_DECL
9039 : 364767 : || TREE_CODE (decl) == TEMPLATE_DECL
9040 : 328983 : || DECL_IMPLICIT_TYPEDEF_P (decl)
9041 : 10670905 : || (DECL_LANG_SPECIFIC (decl)
9042 : 225531 : && DECL_MODULE_IMPORT_P (decl)))
9043 : : {
9044 : 10078499 : auto kind = (TREE_CODE (decl) == NAMESPACE_DECL
9045 : 822688 : && !DECL_NAMESPACE_ALIAS (decl)
9046 : 10078499 : ? depset::EK_NAMESPACE : depset::EK_DECL);
9047 : 10078499 : dep = dep_hash->add_dependency (decl, kind);
9048 : : }
9049 : :
9050 : 23841265 : if (!dep || dep->is_tu_local ())
9051 : : {
9052 : : /* Some internal entity of context. Do by value. */
9053 : 573060 : decl_value (decl, dep);
9054 : 573060 : return false;
9055 : : }
9056 : :
9057 : 11782093 : if (dep->get_entity_kind () == depset::EK_REDIRECT)
9058 : : {
9059 : : /* The DECL_TEMPLATE_RESULT of a partial specialization.
9060 : : Write the partial specialization's template. */
9061 : 143433 : depset *redirect = dep->deps[0];
9062 : 143433 : gcc_checking_assert (redirect->get_entity_kind () == depset::EK_PARTIAL);
9063 : 143433 : tpl = redirect->get_entity ();
9064 : 143433 : goto partial_template;
9065 : : }
9066 : :
9067 : 11638660 : if (streaming_p ())
9068 : : {
9069 : : /* Locate the entity. */
9070 : 1703816 : unsigned index = dep->cluster;
9071 : 1703816 : unsigned import = 0;
9072 : :
9073 : 1703816 : if (dep->is_import ())
9074 : 641 : import = dep->section;
9075 : 1703175 : else if (CHECKING_P)
9076 : : /* It should be what we put there. */
9077 : 1703175 : gcc_checking_assert (index == ~import_entity_index (decl));
9078 : :
9079 : : #if CHECKING_P
9080 : 641 : gcc_assert (!import || importedness >= 0);
9081 : : #endif
9082 : 1703816 : i (tt_entity);
9083 : 1703816 : u (import);
9084 : 1703816 : u (index);
9085 : : }
9086 : :
9087 : 11638660 : int tag = insert (decl);
9088 : 11638660 : if (streaming_p () && dump (dumper::TREE))
9089 : : {
9090 : 513 : char const *kind = "import";
9091 : 513 : module_state *from = (*modules)[0];
9092 : 513 : if (dep->is_import ())
9093 : : /* Rediscover the unremapped index. */
9094 : 78 : from = import_entity_module (import_entity_index (decl));
9095 : : else
9096 : : {
9097 : 435 : tree o = get_originating_module_decl (decl);
9098 : 435 : o = STRIP_TEMPLATE (o);
9099 : 870 : kind = (DECL_LANG_SPECIFIC (o) && DECL_MODULE_PURVIEW_P (o)
9100 : 435 : ? "purview" : "GMF");
9101 : : }
9102 : 513 : dump ("Wrote %s:%d %C:%N@%M", kind,
9103 : 513 : tag, TREE_CODE (decl), decl, from);
9104 : : }
9105 : :
9106 : 11638660 : add_indirects (decl);
9107 : :
9108 : 11638660 : return false;
9109 : : }
9110 : :
9111 : : void
9112 : 14223189 : trees_out::type_node (tree type)
9113 : : {
9114 : 14223189 : gcc_assert (TYPE_P (type));
9115 : :
9116 : 14223189 : tree root = (TYPE_NAME (type)
9117 : 14223189 : ? TREE_TYPE (TYPE_NAME (type)) : TYPE_MAIN_VARIANT (type));
9118 : :
9119 : 14223189 : if (type != root)
9120 : : {
9121 : 3178167 : if (streaming_p ())
9122 : 657652 : i (tt_variant_type);
9123 : 3178167 : tree_node (root);
9124 : :
9125 : 3178167 : int flags = -1;
9126 : :
9127 : 3178167 : if (TREE_CODE (type) == FUNCTION_TYPE
9128 : 3178167 : || TREE_CODE (type) == METHOD_TYPE)
9129 : : {
9130 : 767558 : int quals = type_memfn_quals (type);
9131 : 767558 : int rquals = type_memfn_rqual (type);
9132 : 767558 : tree raises = TYPE_RAISES_EXCEPTIONS (type);
9133 : 767558 : bool late = TYPE_HAS_LATE_RETURN_TYPE (type);
9134 : :
9135 : 767558 : if (raises != TYPE_RAISES_EXCEPTIONS (root)
9136 : 22469 : || rquals != type_memfn_rqual (root)
9137 : 16563 : || quals != type_memfn_quals (root)
9138 : 783815 : || late != TYPE_HAS_LATE_RETURN_TYPE (root))
9139 : 767558 : flags = rquals | (int (late) << 2) | (quals << 3);
9140 : : }
9141 : : else
9142 : : {
9143 : 2410609 : if (TYPE_USER_ALIGN (type))
9144 : 27112 : flags = TYPE_ALIGN_RAW (type);
9145 : : }
9146 : :
9147 : 3178167 : if (streaming_p ())
9148 : 657652 : i (flags);
9149 : :
9150 : 3178167 : if (flags < 0)
9151 : : ;
9152 : 794670 : else if (TREE_CODE (type) == FUNCTION_TYPE
9153 : 794670 : || TREE_CODE (type) == METHOD_TYPE)
9154 : : {
9155 : 767558 : tree raises = TYPE_RAISES_EXCEPTIONS (type);
9156 : 767558 : if (raises == TYPE_RAISES_EXCEPTIONS (root))
9157 : 22469 : raises = error_mark_node;
9158 : 767558 : tree_node (raises);
9159 : : }
9160 : :
9161 : 3178167 : tree_node (TYPE_ATTRIBUTES (type));
9162 : :
9163 : 3178167 : if (streaming_p ())
9164 : : {
9165 : : /* Qualifiers. */
9166 : 657652 : int rquals = cp_type_quals (root);
9167 : 657652 : int quals = cp_type_quals (type);
9168 : 657652 : if (quals == rquals)
9169 : 316226 : quals = -1;
9170 : 657652 : i (quals);
9171 : : }
9172 : :
9173 : 3178167 : if (ref_node (type) != WK_none)
9174 : : {
9175 : 3178167 : int tag = insert (type);
9176 : 3178167 : if (streaming_p ())
9177 : : {
9178 : 657652 : i (0);
9179 : 657652 : dump (dumper::TREE)
9180 : 183 : && dump ("Wrote:%d variant type %C", tag, TREE_CODE (type));
9181 : : }
9182 : : }
9183 : 3178167 : return;
9184 : : }
9185 : :
9186 : 11045022 : if (tree name = TYPE_NAME (type))
9187 : 4425807 : if ((TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9188 : 3458990 : || DECL_TEMPLATE_PARM_P (name)
9189 : 2383839 : || TREE_CODE (type) == RECORD_TYPE
9190 : 405275 : || TREE_CODE (type) == UNION_TYPE
9191 : 4819702 : || TREE_CODE (type) == ENUMERAL_TYPE)
9192 : : {
9193 : : /* We can meet template parms that we didn't meet in the
9194 : : tpl_parms walk, because we're referring to a derived type
9195 : : that was previously constructed from equivalent template
9196 : : parms. */
9197 : 4148775 : if (streaming_p ())
9198 : : {
9199 : 271943 : i (tt_typedef_type);
9200 : 271943 : dump (dumper::TREE)
9201 : 57 : && dump ("Writing %stypedef %C:%N",
9202 : 57 : DECL_IMPLICIT_TYPEDEF_P (name) ? "implicit " : "",
9203 : 57 : TREE_CODE (name), name);
9204 : : }
9205 : 4148775 : tree_node (name);
9206 : 4148775 : if (streaming_p ())
9207 : 271943 : dump (dumper::TREE) && dump ("Wrote typedef %C:%N%S",
9208 : 57 : TREE_CODE (name), name, name);
9209 : :
9210 : : /* We'll have either visited this type or have newly discovered
9211 : : that it's TU-local; either way we won't need to visit it again. */
9212 : 4148775 : gcc_checking_assert (TREE_VISITED (type) || has_tu_local_dep (name));
9213 : 4148775 : return;
9214 : : }
9215 : :
9216 : 6896247 : if (TYPE_PTRMEMFUNC_P (type))
9217 : : {
9218 : : /* This is a distinct type node, masquerading as a structure. */
9219 : 10813 : tree fn_type = TYPE_PTRMEMFUNC_FN_TYPE (type);
9220 : 10813 : if (streaming_p ())
9221 : 3242 : i (tt_ptrmem_type);
9222 : 10813 : tree_node (fn_type);
9223 : 10813 : int tag = insert (type);
9224 : 10813 : if (streaming_p ())
9225 : 3245 : dump (dumper::TREE) && dump ("Written:%d ptrmem type", tag);
9226 : 10813 : return;
9227 : : }
9228 : :
9229 : 6885434 : if (streaming_p ())
9230 : : {
9231 : 2187464 : u (tt_derived_type);
9232 : 2187464 : u (TREE_CODE (type));
9233 : : }
9234 : :
9235 : 6885434 : tree_node (TREE_TYPE (type));
9236 : 6885434 : switch (TREE_CODE (type))
9237 : : {
9238 : 0 : default:
9239 : : /* We should never meet a type here that is indescribable in
9240 : : terms of other types. */
9241 : 0 : gcc_unreachable ();
9242 : :
9243 : 115966 : case ARRAY_TYPE:
9244 : 115966 : tree_node (TYPE_DOMAIN (type));
9245 : 115966 : if (streaming_p ())
9246 : : /* Dependent arrays are constructed with TYPE_DEPENENT_P
9247 : : already set. */
9248 : 32847 : u (TYPE_DEPENDENT_P (type));
9249 : : break;
9250 : :
9251 : : case COMPLEX_TYPE:
9252 : : /* No additional data. */
9253 : : break;
9254 : :
9255 : 12 : case BOOLEAN_TYPE:
9256 : : /* A non-standard boolean type. */
9257 : 12 : if (streaming_p ())
9258 : 6 : u (TYPE_PRECISION (type));
9259 : : break;
9260 : :
9261 : 106392 : case INTEGER_TYPE:
9262 : 106392 : if (TREE_TYPE (type))
9263 : : {
9264 : : /* A range type (representing an array domain). */
9265 : 102587 : tree_node (TYPE_MIN_VALUE (type));
9266 : 102587 : tree_node (TYPE_MAX_VALUE (type));
9267 : : }
9268 : : else
9269 : : {
9270 : : /* A new integral type (representing a bitfield). */
9271 : 3805 : if (streaming_p ())
9272 : : {
9273 : 891 : unsigned prec = TYPE_PRECISION (type);
9274 : 891 : bool unsigned_p = TYPE_UNSIGNED (type);
9275 : :
9276 : 891 : u ((prec << 1) | unsigned_p);
9277 : : }
9278 : : }
9279 : : break;
9280 : :
9281 : 1535237 : case METHOD_TYPE:
9282 : 1535237 : case FUNCTION_TYPE:
9283 : 1535237 : {
9284 : 1535237 : gcc_checking_assert (type_memfn_rqual (type) == REF_QUAL_NONE);
9285 : :
9286 : 1535237 : tree arg_types = TYPE_ARG_TYPES (type);
9287 : 1535237 : if (TREE_CODE (type) == METHOD_TYPE)
9288 : : {
9289 : 951212 : tree_node (TREE_TYPE (TREE_VALUE (arg_types)));
9290 : 951212 : arg_types = TREE_CHAIN (arg_types);
9291 : : }
9292 : 1535237 : tree_node (arg_types);
9293 : : }
9294 : 1535237 : break;
9295 : :
9296 : 2187 : case OFFSET_TYPE:
9297 : 2187 : tree_node (TYPE_OFFSET_BASETYPE (type));
9298 : 2187 : break;
9299 : :
9300 : : case POINTER_TYPE:
9301 : : /* No additional data. */
9302 : : break;
9303 : :
9304 : 1146072 : case REFERENCE_TYPE:
9305 : 1146072 : if (streaming_p ())
9306 : 245935 : u (TYPE_REF_IS_RVALUE (type));
9307 : : break;
9308 : :
9309 : 1396992 : case DECLTYPE_TYPE:
9310 : 1396992 : case TYPEOF_TYPE:
9311 : 1396992 : case DEPENDENT_OPERATOR_TYPE:
9312 : 1396992 : tree_node (TYPE_VALUES_RAW (type));
9313 : 1396992 : if (TREE_CODE (type) == DECLTYPE_TYPE)
9314 : : /* We stash a whole bunch of things into decltype's
9315 : : flags. */
9316 : 97468 : if (streaming_p ())
9317 : 33244 : tree_node_bools (type);
9318 : : break;
9319 : :
9320 : 11553 : case TRAIT_TYPE:
9321 : 11553 : tree_node (TRAIT_TYPE_KIND_RAW (type));
9322 : 11553 : tree_node (TRAIT_TYPE_TYPE1 (type));
9323 : 11553 : tree_node (TRAIT_TYPE_TYPE2 (type));
9324 : 11553 : break;
9325 : :
9326 : : case TYPE_ARGUMENT_PACK:
9327 : : /* No additional data. */
9328 : : break;
9329 : :
9330 : 223621 : case TYPE_PACK_EXPANSION:
9331 : 223621 : if (streaming_p ())
9332 : 90640 : u (PACK_EXPANSION_LOCAL_P (type));
9333 : 447242 : tree_node (PACK_EXPANSION_PARAMETER_PACKS (type));
9334 : 223621 : tree_node (PACK_EXPANSION_EXTRA_ARGS (type));
9335 : 223621 : break;
9336 : :
9337 : 2 : case PACK_INDEX_TYPE:
9338 : 2 : tree_node (PACK_INDEX_PACK (type));
9339 : 2 : tree_node (PACK_INDEX_INDEX (type));
9340 : 2 : break;
9341 : :
9342 : 279744 : case TYPENAME_TYPE:
9343 : 279744 : {
9344 : 279744 : tree_node (TYPE_CONTEXT (type));
9345 : 279744 : tree_node (DECL_NAME (TYPE_NAME (type)));
9346 : 279744 : tree_node (TYPENAME_TYPE_FULLNAME (type));
9347 : 279744 : if (streaming_p ())
9348 : : {
9349 : 99101 : enum tag_types tag_type = none_type;
9350 : 99101 : if (TYPENAME_IS_ENUM_P (type))
9351 : : tag_type = enum_type;
9352 : 99101 : else if (TYPENAME_IS_CLASS_P (type))
9353 : 0 : tag_type = class_type;
9354 : 99101 : u (int (tag_type));
9355 : : }
9356 : : }
9357 : : break;
9358 : :
9359 : 303 : case UNBOUND_CLASS_TEMPLATE:
9360 : 303 : {
9361 : 303 : tree decl = TYPE_NAME (type);
9362 : 303 : tree_node (DECL_CONTEXT (decl));
9363 : 303 : tree_node (DECL_NAME (decl));
9364 : 303 : tree_node (DECL_TEMPLATE_PARMS (decl));
9365 : : }
9366 : 303 : break;
9367 : :
9368 : 42 : case VECTOR_TYPE:
9369 : 42 : if (streaming_p ())
9370 : : {
9371 : 21 : poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type);
9372 : 42 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
9373 : 21 : wu (nunits.coeffs[ix]);
9374 : : }
9375 : : break;
9376 : : }
9377 : :
9378 : : /* We may have met the type during emitting the above. */
9379 : 6885434 : if (ref_node (type) != WK_none)
9380 : : {
9381 : 6235672 : int tag = insert (type);
9382 : 6235672 : if (streaming_p ())
9383 : : {
9384 : 1879236 : i (0);
9385 : 1879236 : dump (dumper::TREE)
9386 : 525 : && dump ("Wrote:%d derived type %C", tag, TREE_CODE (type));
9387 : : }
9388 : : }
9389 : :
9390 : : return;
9391 : : }
9392 : :
9393 : : /* T is (mostly*) a non-mergeable node that must be written by value.
9394 : : The mergeable case is a BINFO, which are as-if DECLSs. */
9395 : :
9396 : : void
9397 : 40674977 : trees_out::tree_value (tree t)
9398 : : {
9399 : : /* We should never be writing a type by value. tree_type should
9400 : : have streamed it, or we're going via its TYPE_DECL. */
9401 : 40674977 : gcc_checking_assert (!TYPE_P (t));
9402 : :
9403 : 40674977 : if (DECL_P (t))
9404 : : /* No template, type, var or function, except anonymous
9405 : : non-context vars. */
9406 : 900410 : gcc_checking_assert ((TREE_CODE (t) != TEMPLATE_DECL
9407 : : && TREE_CODE (t) != TYPE_DECL
9408 : : && (TREE_CODE (t) != VAR_DECL
9409 : : || (!DECL_NAME (t) && !DECL_CONTEXT (t)))
9410 : : && TREE_CODE (t) != FUNCTION_DECL));
9411 : :
9412 : 40674977 : if (streaming_p ())
9413 : : {
9414 : : /* A new node -> tt_node. */
9415 : 16025227 : tree_val_count++;
9416 : 16025227 : i (tt_node);
9417 : 16025227 : start (t);
9418 : 16025227 : tree_node_bools (t);
9419 : : }
9420 : :
9421 : 40674977 : if (TREE_CODE (t) == TREE_BINFO)
9422 : : /* Binfos are decl-like and need merging information. */
9423 : 337167 : binfo_mergeable (t);
9424 : :
9425 : 40674977 : int tag = insert (t, WK_value);
9426 : 40674977 : if (streaming_p ())
9427 : 16025227 : dump (dumper::TREE)
9428 : 2457 : && dump ("Writing tree:%d %C:%N", tag, TREE_CODE (t), t);
9429 : :
9430 : 40674977 : tree_node_vals (t);
9431 : :
9432 : 40674977 : if (streaming_p ())
9433 : 16027684 : dump (dumper::TREE) && dump ("Written tree:%d %C:%N", tag, TREE_CODE (t), t);
9434 : 40674977 : }
9435 : :
9436 : : tree
9437 : 15598884 : trees_in::tree_value ()
9438 : : {
9439 : 15598884 : tree t = start ();
9440 : 15598884 : if (!t || !tree_node_bools (t))
9441 : 0 : return NULL_TREE;
9442 : :
9443 : 15598884 : tree existing = t;
9444 : 15598884 : if (TREE_CODE (t) == TREE_BINFO)
9445 : : {
9446 : 152951 : tree type;
9447 : 152951 : unsigned ix = binfo_mergeable (&type);
9448 : 152951 : if (TYPE_BINFO (type))
9449 : : {
9450 : : /* We already have a definition, this must be a duplicate. */
9451 : 90524 : dump (dumper::MERGE)
9452 : 223 : && dump ("Deduping binfo %N[%u]", type, ix);
9453 : 90524 : existing = TYPE_BINFO (type);
9454 : 126803 : while (existing && ix--)
9455 : 36279 : existing = TREE_CHAIN (existing);
9456 : 90524 : if (existing)
9457 : 90524 : register_duplicate (t, existing);
9458 : : else
9459 : : /* Error, mismatch -- diagnose in read_class_def's
9460 : : checking. */
9461 : : existing = t;
9462 : : }
9463 : : }
9464 : :
9465 : : /* Insert into map. */
9466 : 15598884 : int tag = insert (existing);
9467 : 15598884 : dump (dumper::TREE)
9468 : 3351 : && dump ("Reading tree:%d %C", tag, TREE_CODE (t));
9469 : :
9470 : 15598884 : if (!tree_node_vals (t))
9471 : : {
9472 : 0 : back_refs[~tag] = NULL_TREE;
9473 : 0 : set_overrun ();
9474 : : /* Bail. */
9475 : 0 : return NULL_TREE;
9476 : : }
9477 : :
9478 : 15598884 : if (TREE_CODE (t) == LAMBDA_EXPR
9479 : 15598884 : && CLASSTYPE_LAMBDA_EXPR (TREE_TYPE (t)))
9480 : : {
9481 : 3226 : existing = CLASSTYPE_LAMBDA_EXPR (TREE_TYPE (t));
9482 : 3226 : back_refs[~tag] = existing;
9483 : : }
9484 : :
9485 : 15602235 : dump (dumper::TREE) && dump ("Read tree:%d %C:%N", tag, TREE_CODE (t), t);
9486 : :
9487 : 15598884 : if (TREE_CODE (existing) == INTEGER_CST && !TREE_OVERFLOW (existing))
9488 : : {
9489 : 807984 : existing = cache_integer_cst (t, true);
9490 : 807984 : back_refs[~tag] = existing;
9491 : : }
9492 : :
9493 : : return existing;
9494 : : }
9495 : :
9496 : : /* Whether DECL has a TU-local dependency in the hash. */
9497 : :
9498 : : bool
9499 : 1311963 : trees_out::has_tu_local_dep (tree decl) const
9500 : : {
9501 : : /* Only the contexts of fields or enums remember that they're
9502 : : TU-local. */
9503 : 1311963 : if (DECL_CONTEXT (decl)
9504 : 1311963 : && (TREE_CODE (decl) == FIELD_DECL
9505 : 1311960 : || TREE_CODE (decl) == CONST_DECL))
9506 : 3 : decl = TYPE_NAME (DECL_CONTEXT (decl));
9507 : :
9508 : 1311963 : depset *dep = dep_hash->find_dependency (decl);
9509 : 1311963 : return dep && dep->is_tu_local ();
9510 : : }
9511 : :
9512 : : /* If T depends on a TU-local entity, return that decl. */
9513 : :
9514 : : tree
9515 : 351 : trees_out::find_tu_local_decl (tree t)
9516 : : {
9517 : : /* We need to have walked all deps first before we can check. */
9518 : 351 : gcc_checking_assert (!is_initial_scan ());
9519 : :
9520 : 729 : auto walker = [](tree *tp, int *walk_subtrees, void *data) -> tree
9521 : : {
9522 : 378 : auto self = (trees_out *)data;
9523 : :
9524 : 378 : tree decl = NULL_TREE;
9525 : 378 : if (TYPE_P (*tp))
9526 : : {
9527 : : /* A PMF type is a record type, which we otherwise wouldn't walk;
9528 : : return whether the function type is TU-local. */
9529 : 339 : if (TYPE_PTRMEMFUNC_P (*tp))
9530 : : {
9531 : 3 : *walk_subtrees = 0;
9532 : 3 : return self->find_tu_local_decl (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
9533 : : }
9534 : : else
9535 : 336 : decl = TYPE_MAIN_DECL (*tp);
9536 : : }
9537 : 39 : else if (DECL_P (*tp))
9538 : : decl = *tp;
9539 : :
9540 : 342 : if (decl)
9541 : : {
9542 : : /* We found a DECL, this will tell us whether we're TU-local. */
9543 : 57 : *walk_subtrees = 0;
9544 : 57 : return self->has_tu_local_dep (decl) ? decl : NULL_TREE;
9545 : : }
9546 : : return NULL_TREE;
9547 : : };
9548 : :
9549 : : /* We need to walk without duplicates so that we step into the pointed-to
9550 : : types of array types. */
9551 : 351 : return cp_walk_tree_without_duplicates (&t, walker, this);
9552 : : }
9553 : :
9554 : : /* Stream out tree node T. We automatically create local back
9555 : : references, which is essentially a single pass lisp
9556 : : self-referential structure pretty-printer. */
9557 : :
9558 : : void
9559 : 359718129 : trees_out::tree_node (tree t)
9560 : : {
9561 : 359718129 : dump.indent ();
9562 : 359718129 : walk_kind ref = ref_node (t);
9563 : 359718129 : if (ref == WK_none)
9564 : 275129788 : goto done;
9565 : :
9566 : : /* Find TU-local entities and intercept streaming to instead write a
9567 : : placeholder value; this way we don't need to emit such decls.
9568 : : We only need to do this when writing a definition of an entity
9569 : : that we know names a TU-local entity. */
9570 : 99476734 : if (!is_initial_scan () && writing_local_entities)
9571 : : {
9572 : 837 : tree local_decl = NULL_TREE;
9573 : 837 : if (DECL_P (t) && has_tu_local_dep (t))
9574 : : local_decl = t;
9575 : : /* Consider a type to be TU-local if it refers to any TU-local decl,
9576 : : no matter how deep.
9577 : :
9578 : : This worsens diagnostics slightly, as we often no longer point
9579 : : directly to the at-fault entity when instantiating. However, this
9580 : : reduces the module size slightly and means that much less of pt.cc
9581 : : needs to know about us. */
9582 : 747 : else if (TYPE_P (t))
9583 : 141 : local_decl = find_tu_local_decl (t);
9584 : 606 : else if (EXPR_P (t))
9585 : 207 : local_decl = find_tu_local_decl (TREE_TYPE (t));
9586 : :
9587 : 438 : if (local_decl)
9588 : : {
9589 : 144 : int tag = insert (t, WK_value);
9590 : 144 : if (streaming_p ())
9591 : : {
9592 : 144 : tu_local_count++;
9593 : 144 : i (tt_tu_local);
9594 : 144 : dump (dumper::TREE)
9595 : 0 : && dump ("Writing TU-local entity:%d %C:%N",
9596 : 0 : tag, TREE_CODE (t), t);
9597 : : }
9598 : : /* TODO: Get a more descriptive name? */
9599 : 144 : tree_node (DECL_NAME (local_decl));
9600 : 144 : if (state)
9601 : 144 : state->write_location (*this, DECL_SOURCE_LOCATION (local_decl));
9602 : 144 : goto done;
9603 : : }
9604 : : }
9605 : :
9606 : 84588197 : if (ref != WK_normal)
9607 : 2121777 : goto skip_normal;
9608 : :
9609 : 82466420 : if (TREE_CODE (t) == IDENTIFIER_NODE)
9610 : : {
9611 : : /* An identifier node -> tt_id, tt_conv_id, tt_anon_id, tt_lambda_id. */
9612 : 10336418 : int code = tt_id;
9613 : 10336418 : if (IDENTIFIER_ANON_P (t))
9614 : 36267 : code = IDENTIFIER_LAMBDA_P (t) ? tt_lambda_id : tt_anon_id;
9615 : 10300151 : else if (IDENTIFIER_CONV_OP_P (t))
9616 : 13288 : code = tt_conv_id;
9617 : :
9618 : 10336418 : if (streaming_p ())
9619 : 2015895 : i (code);
9620 : :
9621 : 10336418 : if (code == tt_conv_id)
9622 : : {
9623 : 13288 : tree type = TREE_TYPE (t);
9624 : 13288 : gcc_checking_assert (type || t == conv_op_identifier);
9625 : 13288 : tree_node (type);
9626 : : }
9627 : 10323130 : else if (code == tt_id && streaming_p ())
9628 : 2000445 : str (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
9629 : :
9630 : 10336418 : int tag = insert (t);
9631 : 10336418 : if (streaming_p ())
9632 : : {
9633 : : /* We know the ordering of the 4 id tags. */
9634 : 2015895 : static const char *const kinds[] =
9635 : : {"", "conv_op ", "anon ", "lambda "};
9636 : 2015895 : dump (dumper::TREE)
9637 : 1008 : && dump ("Written:%d %sidentifier:%N", tag,
9638 : 1005 : kinds[code - tt_id],
9639 : 3 : code == tt_conv_id ? TREE_TYPE (t) : t);
9640 : : }
9641 : 10336418 : goto done;
9642 : : }
9643 : :
9644 : 72130002 : if (TREE_CODE (t) == TREE_BINFO)
9645 : : {
9646 : : /* A BINFO -> tt_binfo.
9647 : : We must do this by reference. We stream the binfo tree
9648 : : itself when streaming its owning RECORD_TYPE. That we got
9649 : : here means the dominating type is not in this SCC. */
9650 : 79642 : if (streaming_p ())
9651 : 2215 : i (tt_binfo);
9652 : 79642 : binfo_mergeable (t);
9653 : 79642 : gcc_checking_assert (!TREE_VISITED (t));
9654 : 79642 : int tag = insert (t);
9655 : 79642 : if (streaming_p ())
9656 : 2215 : dump (dumper::TREE) && dump ("Inserting binfo:%d %N", tag, t);
9657 : 79642 : goto done;
9658 : : }
9659 : :
9660 : 72050360 : if (TREE_CODE (t) == INTEGER_CST
9661 : 5274701 : && !TREE_OVERFLOW (t)
9662 : 77325061 : && TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE)
9663 : : {
9664 : : /* An integral constant of enumeral type. See if it matches one
9665 : : of the enumeration values. */
9666 : 37969 : for (tree values = TYPE_VALUES (TREE_TYPE (t));
9667 : 341871 : values; values = TREE_CHAIN (values))
9668 : : {
9669 : 339719 : tree decl = TREE_VALUE (values);
9670 : 339719 : if (tree_int_cst_equal (DECL_INITIAL (decl), t))
9671 : : {
9672 : 35817 : if (streaming_p ())
9673 : 9631 : u (tt_enum_value);
9674 : 35817 : tree_node (decl);
9675 : 35859 : dump (dumper::TREE) && dump ("Written enum value %N", decl);
9676 : 35817 : goto done;
9677 : : }
9678 : : }
9679 : : /* It didn't match. We'll write it a an explicit INTEGER_CST
9680 : : node. */
9681 : : }
9682 : :
9683 : 72014543 : if (TYPE_P (t))
9684 : : {
9685 : 14223189 : type_node (t);
9686 : 14223189 : goto done;
9687 : : }
9688 : :
9689 : 57791354 : if (DECL_P (t))
9690 : : {
9691 : 18397555 : if (DECL_TEMPLATE_PARM_P (t))
9692 : : {
9693 : 2925226 : tpl_parm_value (t);
9694 : 2925226 : goto done;
9695 : : }
9696 : :
9697 : 15472329 : if (!DECL_CONTEXT (t))
9698 : : {
9699 : : /* There are a few cases of decls with no context. We'll write
9700 : : these by value, but first assert they are cases we expect. */
9701 : 27693 : gcc_checking_assert (ref == WK_normal);
9702 : 27693 : switch (TREE_CODE (t))
9703 : : {
9704 : 0 : default: gcc_unreachable ();
9705 : :
9706 : 10176 : case LABEL_DECL:
9707 : : /* CASE_LABEL_EXPRs contain uncontexted LABEL_DECLs. */
9708 : 10176 : gcc_checking_assert (!DECL_NAME (t));
9709 : : break;
9710 : :
9711 : 494 : case VAR_DECL:
9712 : : /* AGGR_INIT_EXPRs cons up anonymous uncontexted VAR_DECLs. */
9713 : 494 : gcc_checking_assert (!DECL_NAME (t)
9714 : : && DECL_ARTIFICIAL (t));
9715 : : break;
9716 : :
9717 : : case PARM_DECL:
9718 : : /* REQUIRES_EXPRs have a tree list of uncontexted
9719 : : PARM_DECLS. It'd be nice if they had a
9720 : : distinguishing flag to double check. */
9721 : : break;
9722 : : }
9723 : 27693 : goto by_value;
9724 : : }
9725 : : }
9726 : :
9727 : 39393799 : skip_normal:
9728 : 56960212 : if (DECL_P (t) && !decl_node (t, ref))
9729 : 16312928 : goto done;
9730 : :
9731 : : /* Otherwise by value */
9732 : 40674977 : by_value:
9733 : 40674977 : tree_value (t);
9734 : :
9735 : 359718129 : done:
9736 : : /* And, breath out. */
9737 : 359718129 : dump.outdent ();
9738 : 359718129 : }
9739 : :
9740 : : /* Stream in a tree node. */
9741 : :
9742 : : tree
9743 : 134540896 : trees_in::tree_node (bool is_use)
9744 : : {
9745 : 134540896 : if (get_overrun ())
9746 : : return NULL_TREE;
9747 : :
9748 : 134540896 : dump.indent ();
9749 : 134540896 : int tag = i ();
9750 : 134540896 : tree res = NULL_TREE;
9751 : 134540896 : switch (tag)
9752 : : {
9753 : 44618118 : default:
9754 : : /* backref, pull it out of the map. */
9755 : 44618118 : res = back_ref (tag);
9756 : 44618118 : break;
9757 : :
9758 : : case tt_null:
9759 : : /* NULL_TREE. */
9760 : : break;
9761 : :
9762 : 144 : case tt_tu_local:
9763 : 144 : {
9764 : : /* A translation-unit-local entity. */
9765 : 144 : res = make_node (TU_LOCAL_ENTITY);
9766 : 144 : int tag = insert (res);
9767 : :
9768 : 144 : TU_LOCAL_ENTITY_NAME (res) = tree_node ();
9769 : 144 : TU_LOCAL_ENTITY_LOCATION (res) = state->read_location (*this);
9770 : 144 : dump (dumper::TREE) && dump ("Read TU-local entity:%d %N", tag, res);
9771 : : }
9772 : : break;
9773 : :
9774 : 10252587 : case tt_fixed:
9775 : : /* A fixed ref, find it in the fixed_ref array. */
9776 : 10252587 : {
9777 : 10252587 : unsigned fix = u ();
9778 : 10252587 : if (fix < (*fixed_trees).length ())
9779 : : {
9780 : 10252587 : res = (*fixed_trees)[fix];
9781 : 10252587 : dump (dumper::TREE) && dump ("Read fixed:%u %C:%N%S", fix,
9782 : 4851 : TREE_CODE (res), res, res);
9783 : : }
9784 : :
9785 : 10247736 : if (!res)
9786 : 0 : set_overrun ();
9787 : : }
9788 : : break;
9789 : :
9790 : 82607 : case tt_parm:
9791 : 82607 : {
9792 : 82607 : tree fn = tree_node ();
9793 : 82607 : if (fn && TREE_CODE (fn) == FUNCTION_DECL)
9794 : 82607 : res = tree_node ();
9795 : 82607 : if (res)
9796 : 82607 : dump (dumper::TREE)
9797 : 15 : && dump ("Read %s reference %N",
9798 : 15 : TREE_CODE (res) == PARM_DECL ? "parameter" : "result",
9799 : : res);
9800 : : }
9801 : : break;
9802 : :
9803 : 15598884 : case tt_node:
9804 : : /* A new node. Stream it in. */
9805 : 15598884 : res = tree_value ();
9806 : 15598884 : break;
9807 : :
9808 : 1770183 : case tt_decl:
9809 : : /* A new decl. Stream it in. */
9810 : 1770183 : res = decl_value ();
9811 : 1770183 : break;
9812 : :
9813 : 612932 : case tt_tpl_parm:
9814 : : /* A template parameter. Stream it in. */
9815 : 612932 : res = tpl_parm_value ();
9816 : 612932 : break;
9817 : :
9818 : 1912116 : case tt_id:
9819 : : /* An identifier node. */
9820 : 1912116 : {
9821 : 1912116 : size_t l;
9822 : 1912116 : const char *chars = str (&l);
9823 : 1912116 : res = get_identifier_with_length (chars, l);
9824 : 1912116 : int tag = insert (res);
9825 : 1912116 : dump (dumper::TREE)
9826 : 1428 : && dump ("Read identifier:%d %N", tag, res);
9827 : : }
9828 : 1912116 : break;
9829 : :
9830 : 3947 : case tt_conv_id:
9831 : : /* A conversion operator. Get the type and recreate the
9832 : : identifier. */
9833 : 3947 : {
9834 : 3947 : tree type = tree_node ();
9835 : 3947 : if (!get_overrun ())
9836 : : {
9837 : 3947 : res = type ? make_conv_op_name (type) : conv_op_identifier;
9838 : 3947 : int tag = insert (res);
9839 : 3947 : dump (dumper::TREE)
9840 : 27 : && dump ("Created conv_op:%d %S for %N", tag, res, type);
9841 : : }
9842 : : }
9843 : : break;
9844 : :
9845 : 9857 : case tt_anon_id:
9846 : 9857 : case tt_lambda_id:
9847 : : /* An anonymous or lambda id. */
9848 : 9857 : {
9849 : 9857 : res = make_anon_name ();
9850 : 9857 : if (tag == tt_lambda_id)
9851 : 4802 : IDENTIFIER_LAMBDA_P (res) = true;
9852 : 9857 : int tag = insert (res);
9853 : 9860 : dump (dumper::TREE)
9854 : 3 : && dump ("Read %s identifier:%d %N",
9855 : 3 : IDENTIFIER_LAMBDA_P (res) ? "lambda" : "anon", tag, res);
9856 : : }
9857 : : break;
9858 : :
9859 : 261999 : case tt_typedef_type:
9860 : 261999 : res = tree_node ();
9861 : 261999 : if (res)
9862 : : {
9863 : 261999 : dump (dumper::TREE)
9864 : 72 : && dump ("Read %stypedef %C:%N",
9865 : 72 : DECL_IMPLICIT_TYPEDEF_P (res) ? "implicit " : "",
9866 : 72 : TREE_CODE (res), res);
9867 : 261999 : res = TREE_TYPE (res);
9868 : : }
9869 : : break;
9870 : :
9871 : 2126771 : case tt_derived_type:
9872 : : /* A type derived from some other type. */
9873 : 2126771 : {
9874 : 2126771 : enum tree_code code = tree_code (u ());
9875 : 2126771 : res = tree_node ();
9876 : :
9877 : 2126771 : switch (code)
9878 : : {
9879 : 0 : default:
9880 : 0 : set_overrun ();
9881 : 0 : break;
9882 : :
9883 : 31906 : case ARRAY_TYPE:
9884 : 31906 : {
9885 : 31906 : tree domain = tree_node ();
9886 : 31906 : int dep = u ();
9887 : 31906 : if (!get_overrun ())
9888 : 31906 : res = build_cplus_array_type (res, domain, dep);
9889 : : }
9890 : : break;
9891 : :
9892 : 102 : case COMPLEX_TYPE:
9893 : 102 : if (!get_overrun ())
9894 : 102 : res = build_complex_type (res);
9895 : : break;
9896 : :
9897 : 9 : case BOOLEAN_TYPE:
9898 : 9 : {
9899 : 9 : unsigned precision = u ();
9900 : 9 : if (!get_overrun ())
9901 : 9 : res = build_nonstandard_boolean_type (precision);
9902 : : }
9903 : : break;
9904 : :
9905 : 28993 : case INTEGER_TYPE:
9906 : 28993 : if (res)
9907 : : {
9908 : : /* A range type (representing an array domain). */
9909 : 28189 : tree min = tree_node ();
9910 : 28189 : tree max = tree_node ();
9911 : :
9912 : 28189 : if (!get_overrun ())
9913 : 28189 : res = build_range_type (res, min, max);
9914 : : }
9915 : : else
9916 : : {
9917 : : /* A new integral type (representing a bitfield). */
9918 : 804 : unsigned enc = u ();
9919 : 804 : if (!get_overrun ())
9920 : 804 : res = build_nonstandard_integer_type (enc >> 1, enc & 1);
9921 : : }
9922 : : break;
9923 : :
9924 : 624171 : case FUNCTION_TYPE:
9925 : 624171 : case METHOD_TYPE:
9926 : 624171 : {
9927 : 624171 : tree klass = code == METHOD_TYPE ? tree_node () : NULL_TREE;
9928 : 624171 : tree args = tree_node ();
9929 : 624171 : if (!get_overrun ())
9930 : : {
9931 : 624171 : if (klass)
9932 : 372615 : res = build_method_type_directly (klass, res, args);
9933 : : else
9934 : 251556 : res = build_function_type (res, args);
9935 : : }
9936 : : }
9937 : : break;
9938 : :
9939 : 560 : case OFFSET_TYPE:
9940 : 560 : {
9941 : 560 : tree base = tree_node ();
9942 : 560 : if (!get_overrun ())
9943 : 560 : res = build_offset_type (base, res);
9944 : : }
9945 : : break;
9946 : :
9947 : 296331 : case POINTER_TYPE:
9948 : 296331 : if (!get_overrun ())
9949 : 296331 : res = build_pointer_type (res);
9950 : : break;
9951 : :
9952 : 231776 : case REFERENCE_TYPE:
9953 : 231776 : {
9954 : 231776 : bool rval = bool (u ());
9955 : 231776 : if (!get_overrun ())
9956 : 231776 : res = cp_build_reference_type (res, rval);
9957 : : }
9958 : : break;
9959 : :
9960 : 649726 : case DECLTYPE_TYPE:
9961 : 649726 : case TYPEOF_TYPE:
9962 : 649726 : case DEPENDENT_OPERATOR_TYPE:
9963 : 649726 : {
9964 : 649726 : tree expr = tree_node ();
9965 : 649726 : if (!get_overrun ())
9966 : : {
9967 : 649726 : res = cxx_make_type (code);
9968 : 649726 : TYPE_VALUES_RAW (res) = expr;
9969 : 649726 : if (code == DECLTYPE_TYPE)
9970 : 28601 : tree_node_bools (res);
9971 : 649726 : SET_TYPE_STRUCTURAL_EQUALITY (res);
9972 : : }
9973 : : }
9974 : : break;
9975 : :
9976 : 3914 : case TRAIT_TYPE:
9977 : 3914 : {
9978 : 3914 : tree kind = tree_node ();
9979 : 3914 : tree type1 = tree_node ();
9980 : 3914 : tree type2 = tree_node ();
9981 : 3914 : if (!get_overrun ())
9982 : : {
9983 : 3914 : res = cxx_make_type (TRAIT_TYPE);
9984 : 3914 : TRAIT_TYPE_KIND_RAW (res) = kind;
9985 : 3914 : TRAIT_TYPE_TYPE1 (res) = type1;
9986 : 3914 : TRAIT_TYPE_TYPE2 (res) = type2;
9987 : 3914 : SET_TYPE_STRUCTURAL_EQUALITY (res);
9988 : : }
9989 : : }
9990 : : break;
9991 : :
9992 : 82832 : case TYPE_ARGUMENT_PACK:
9993 : 82832 : if (!get_overrun ())
9994 : : {
9995 : 82832 : tree pack = cxx_make_type (TYPE_ARGUMENT_PACK);
9996 : 82832 : ARGUMENT_PACK_ARGS (pack) = res;
9997 : : res = pack;
9998 : : }
9999 : : break;
10000 : :
10001 : 81960 : case TYPE_PACK_EXPANSION:
10002 : 81960 : {
10003 : 81960 : bool local = u ();
10004 : 81960 : tree param_packs = tree_node ();
10005 : 81960 : tree extra_args = tree_node ();
10006 : 81960 : if (!get_overrun ())
10007 : : {
10008 : 81960 : tree expn = cxx_make_type (TYPE_PACK_EXPANSION);
10009 : 81960 : SET_TYPE_STRUCTURAL_EQUALITY (expn);
10010 : 81960 : PACK_EXPANSION_PATTERN (expn) = res;
10011 : 163920 : PACK_EXPANSION_PARAMETER_PACKS (expn) = param_packs;
10012 : 81960 : PACK_EXPANSION_EXTRA_ARGS (expn) = extra_args;
10013 : 81960 : PACK_EXPANSION_LOCAL_P (expn) = local;
10014 : 81960 : res = expn;
10015 : : }
10016 : : }
10017 : : break;
10018 : :
10019 : 1 : case PACK_INDEX_TYPE:
10020 : 1 : {
10021 : 1 : tree pack = tree_node ();
10022 : 1 : tree index = tree_node ();
10023 : 1 : if (!get_overrun ())
10024 : 1 : res = make_pack_index (pack, index);
10025 : : }
10026 : : break;
10027 : :
10028 : 94391 : case TYPENAME_TYPE:
10029 : 94391 : {
10030 : 94391 : tree ctx = tree_node ();
10031 : 94391 : tree name = tree_node ();
10032 : 94391 : tree fullname = tree_node ();
10033 : 94391 : enum tag_types tag_type = tag_types (u ());
10034 : :
10035 : 94391 : if (!get_overrun ())
10036 : 94391 : res = build_typename_type (ctx, name, fullname, tag_type);
10037 : : }
10038 : : break;
10039 : :
10040 : 69 : case UNBOUND_CLASS_TEMPLATE:
10041 : 69 : {
10042 : 69 : tree ctx = tree_node ();
10043 : 69 : tree name = tree_node ();
10044 : 69 : tree parms = tree_node ();
10045 : :
10046 : 69 : if (!get_overrun ())
10047 : 69 : res = make_unbound_class_template_raw (ctx, name, parms);
10048 : : }
10049 : : break;
10050 : :
10051 : : case VECTOR_TYPE:
10052 : : {
10053 : : poly_uint64 nunits;
10054 : 60 : for (unsigned ix = 0; ix != NUM_POLY_INT_COEFFS; ix++)
10055 : 30 : nunits.coeffs[ix] = wu ();
10056 : 30 : if (!get_overrun ())
10057 : 30 : res = build_vector_type (res, nunits);
10058 : : }
10059 : : break;
10060 : : }
10061 : :
10062 : 2126771 : int tag = i ();
10063 : 2126771 : if (!tag)
10064 : : {
10065 : 1816210 : tag = insert (res);
10066 : 1816210 : if (res)
10067 : 1816210 : dump (dumper::TREE)
10068 : 654 : && dump ("Created:%d derived type %C", tag, code);
10069 : : }
10070 : : else
10071 : 310561 : res = back_ref (tag);
10072 : : }
10073 : : break;
10074 : :
10075 : 635079 : case tt_variant_type:
10076 : : /* Variant of some type. */
10077 : 635079 : {
10078 : 635079 : res = tree_node ();
10079 : 635079 : int flags = i ();
10080 : 635079 : if (get_overrun ())
10081 : : ;
10082 : 635079 : else if (flags < 0)
10083 : : /* No change. */;
10084 : 315029 : else if (TREE_CODE (res) == FUNCTION_TYPE
10085 : 315029 : || TREE_CODE (res) == METHOD_TYPE)
10086 : : {
10087 : 312350 : cp_ref_qualifier rqual = cp_ref_qualifier (flags & 3);
10088 : 312350 : bool late = (flags >> 2) & 1;
10089 : 312350 : cp_cv_quals quals = cp_cv_quals (flags >> 3);
10090 : :
10091 : 312350 : tree raises = tree_node ();
10092 : 312350 : if (raises == error_mark_node)
10093 : 10021 : raises = TYPE_RAISES_EXCEPTIONS (res);
10094 : :
10095 : 312350 : res = build_cp_fntype_variant (res, rqual, raises, late);
10096 : 312350 : if (TREE_CODE (res) == FUNCTION_TYPE)
10097 : 127267 : res = apply_memfn_quals (res, quals, rqual);
10098 : : }
10099 : : else
10100 : : {
10101 : 2679 : res = build_aligned_type (res, (1u << flags) >> 1);
10102 : 2679 : TYPE_USER_ALIGN (res) = true;
10103 : : }
10104 : :
10105 : 635079 : if (tree attribs = tree_node ())
10106 : 21589 : res = cp_build_type_attribute_variant (res, attribs);
10107 : :
10108 : 635079 : int quals = i ();
10109 : 635079 : if (quals >= 0 && !get_overrun ())
10110 : 322060 : res = cp_build_qualified_type (res, quals);
10111 : :
10112 : 635079 : int tag = i ();
10113 : 635079 : if (!tag)
10114 : : {
10115 : 635079 : tag = insert (res);
10116 : 635079 : if (res)
10117 : 635079 : dump (dumper::TREE)
10118 : 276 : && dump ("Created:%d variant type %C", tag, TREE_CODE (res));
10119 : : }
10120 : : else
10121 : 0 : res = back_ref (tag);
10122 : : }
10123 : : break;
10124 : :
10125 : 8512 : case tt_tinfo_var:
10126 : 8512 : case tt_tinfo_typedef:
10127 : : /* A tinfo var or typedef. */
10128 : 8512 : {
10129 : 8512 : bool is_var = tag == tt_tinfo_var;
10130 : 8512 : unsigned ix = u ();
10131 : 8512 : tree type = NULL_TREE;
10132 : :
10133 : 8512 : if (is_var)
10134 : : {
10135 : 5112 : tree name = tree_node ();
10136 : 5112 : type = tree_node ();
10137 : :
10138 : 5112 : if (!get_overrun ())
10139 : 5112 : res = get_tinfo_decl_direct (type, name, int (ix));
10140 : : }
10141 : : else
10142 : : {
10143 : 3400 : if (!get_overrun ())
10144 : : {
10145 : 3400 : type = get_pseudo_tinfo_type (ix);
10146 : 3400 : res = TYPE_NAME (type);
10147 : : }
10148 : : }
10149 : 8512 : if (res)
10150 : : {
10151 : 8512 : int tag = insert (res);
10152 : 8512 : dump (dumper::TREE)
10153 : 36 : && dump ("Created tinfo_%s:%d %S:%u for %N",
10154 : : is_var ? "var" : "decl", tag, res, ix, type);
10155 : 8512 : if (!is_var)
10156 : : {
10157 : 3400 : tag = insert (type);
10158 : 3400 : dump (dumper::TREE)
10159 : 12 : && dump ("Created tinfo_type:%d %u %N", tag, ix, type);
10160 : : }
10161 : : }
10162 : : }
10163 : : break;
10164 : :
10165 : 2726 : case tt_ptrmem_type:
10166 : : /* A pointer to member function. */
10167 : 2726 : {
10168 : 2726 : tree type = tree_node ();
10169 : 2726 : if (type && TREE_CODE (type) == POINTER_TYPE
10170 : 5452 : && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
10171 : : {
10172 : 2726 : res = build_ptrmemfunc_type (type);
10173 : 2726 : int tag = insert (res);
10174 : 2729 : dump (dumper::TREE) && dump ("Created:%d ptrmem type", tag);
10175 : : }
10176 : : else
10177 : 0 : set_overrun ();
10178 : : }
10179 : : break;
10180 : :
10181 : 3 : case tt_nttp_var:
10182 : : /* An NTTP object. */
10183 : 3 : {
10184 : 3 : tree init = tree_node ();
10185 : 3 : tree name = tree_node ();
10186 : 3 : if (!get_overrun ())
10187 : : {
10188 : : /* We don't want to check the initializer as that may require
10189 : : name lookup, which could recursively start lazy loading.
10190 : : Instead we know that INIT is already valid so we can just
10191 : : apply that directly. */
10192 : 3 : res = get_template_parm_object (init, name, /*check_init=*/false);
10193 : 3 : int tag = insert (res);
10194 : 3 : dump (dumper::TREE)
10195 : 0 : && dump ("Created nttp object:%d %N", tag, name);
10196 : : }
10197 : : }
10198 : : break;
10199 : :
10200 : 9554 : case tt_enum_value:
10201 : : /* An enum const value. */
10202 : 9554 : {
10203 : 9554 : if (tree decl = tree_node ())
10204 : : {
10205 : 9572 : dump (dumper::TREE) && dump ("Read enum value %N", decl);
10206 : 9554 : res = DECL_INITIAL (decl);
10207 : : }
10208 : :
10209 : 9554 : if (!res)
10210 : 0 : set_overrun ();
10211 : : }
10212 : : break;
10213 : :
10214 : 11266 : case tt_enum_decl:
10215 : : /* An enum decl. */
10216 : 11266 : {
10217 : 11266 : tree ctx = tree_node ();
10218 : 11266 : tree name = tree_node ();
10219 : :
10220 : 11266 : if (!get_overrun ()
10221 : 11266 : && TREE_CODE (ctx) == ENUMERAL_TYPE)
10222 : 11266 : res = find_enum_member (ctx, name);
10223 : :
10224 : 11266 : if (!res)
10225 : 0 : set_overrun ();
10226 : : else
10227 : : {
10228 : 11266 : int tag = insert (res);
10229 : 11266 : dump (dumper::TREE)
10230 : 18 : && dump ("Read enum decl:%d %C:%N", tag, TREE_CODE (res), res);
10231 : : }
10232 : : }
10233 : : break;
10234 : :
10235 : 10343 : case tt_data_member:
10236 : : /* A data member. */
10237 : 10343 : {
10238 : 10343 : tree ctx = tree_node ();
10239 : 10343 : tree name = tree_node ();
10240 : :
10241 : 10343 : if (!get_overrun ()
10242 : 10343 : && RECORD_OR_UNION_TYPE_P (ctx))
10243 : : {
10244 : 10343 : if (name)
10245 : 8882 : res = lookup_class_binding (ctx, name);
10246 : : else
10247 : 1461 : res = lookup_field_ident (ctx, u ());
10248 : :
10249 : 10343 : if (!res
10250 : 10343 : || TREE_CODE (res) != FIELD_DECL
10251 : 20686 : || DECL_CONTEXT (res) != ctx)
10252 : : res = NULL_TREE;
10253 : : }
10254 : :
10255 : 10343 : if (!res)
10256 : 0 : set_overrun ();
10257 : : else
10258 : : {
10259 : 10343 : int tag = insert (res);
10260 : 10343 : dump (dumper::TREE)
10261 : 21 : && dump ("Read member:%d %C:%N", tag, TREE_CODE (res), res);
10262 : : }
10263 : : }
10264 : : break;
10265 : :
10266 : 2117 : case tt_binfo:
10267 : : /* A BINFO. Walk the tree of the dominating type. */
10268 : 2117 : {
10269 : 2117 : tree type;
10270 : 2117 : unsigned ix = binfo_mergeable (&type);
10271 : 2117 : if (type)
10272 : : {
10273 : 2117 : res = TYPE_BINFO (type);
10274 : 2234 : for (; ix && res; res = TREE_CHAIN (res))
10275 : 117 : ix--;
10276 : 2117 : if (!res)
10277 : 0 : set_overrun ();
10278 : : }
10279 : :
10280 : 2117 : if (get_overrun ())
10281 : : break;
10282 : :
10283 : : /* Insert binfo into backreferences. */
10284 : 2117 : tag = insert (res);
10285 : 2117 : dump (dumper::TREE) && dump ("Read binfo:%d %N", tag, res);
10286 : : }
10287 : 2117 : break;
10288 : :
10289 : 21 : case tt_vtable:
10290 : 21 : {
10291 : 21 : unsigned ix = u ();
10292 : 21 : tree ctx = tree_node ();
10293 : 21 : dump (dumper::TREE) && dump ("Reading vtable %N[%u]", ctx, ix);
10294 : 21 : if (TREE_CODE (ctx) == RECORD_TYPE && TYPE_LANG_SPECIFIC (ctx))
10295 : 21 : for (res = CLASSTYPE_VTABLES (ctx); res; res = DECL_CHAIN (res))
10296 : 21 : if (!ix--)
10297 : : break;
10298 : 21 : if (!res)
10299 : 0 : set_overrun ();
10300 : : }
10301 : : break;
10302 : :
10303 : 0 : case tt_thunk:
10304 : 0 : {
10305 : 0 : int fixed = i ();
10306 : 0 : tree target = tree_node ();
10307 : 0 : tree virt = tree_node ();
10308 : :
10309 : 0 : for (tree thunk = DECL_THUNKS (target);
10310 : 0 : thunk; thunk = DECL_CHAIN (thunk))
10311 : 0 : if (THUNK_FIXED_OFFSET (thunk) == fixed
10312 : 0 : && !THUNK_VIRTUAL_OFFSET (thunk) == !virt
10313 : 0 : && (!virt
10314 : 0 : || tree_int_cst_equal (virt, THUNK_VIRTUAL_OFFSET (thunk))))
10315 : : {
10316 : : res = thunk;
10317 : : break;
10318 : : }
10319 : :
10320 : 0 : int tag = insert (res);
10321 : 0 : if (res)
10322 : 0 : dump (dumper::TREE)
10323 : 0 : && dump ("Read:%d thunk %N to %N", tag, DECL_NAME (res), target);
10324 : : else
10325 : 0 : set_overrun ();
10326 : : }
10327 : : break;
10328 : :
10329 : 212268 : case tt_clone_ref:
10330 : 212268 : {
10331 : 212268 : tree target = tree_node ();
10332 : 212268 : tree name = tree_node ();
10333 : :
10334 : 212268 : if (DECL_P (target) && DECL_MAYBE_IN_CHARGE_CDTOR_P (target))
10335 : : {
10336 : 212268 : tree clone;
10337 : 333858 : FOR_EVERY_CLONE (clone, target)
10338 : 333858 : if (DECL_NAME (clone) == name)
10339 : : {
10340 : : res = clone;
10341 : : break;
10342 : : }
10343 : : }
10344 : :
10345 : : /* A clone might have a different vtable entry. */
10346 : 212268 : if (res && DECL_VIRTUAL_P (res))
10347 : 16336 : DECL_VINDEX (res) = tree_node ();
10348 : :
10349 : 212268 : if (!res)
10350 : 0 : set_overrun ();
10351 : 212268 : int tag = insert (res);
10352 : 212268 : if (res)
10353 : 212268 : dump (dumper::TREE)
10354 : 222 : && dump ("Read:%d clone %N of %N", tag, DECL_NAME (res), target);
10355 : : else
10356 : 0 : set_overrun ();
10357 : : }
10358 : : break;
10359 : :
10360 : 1595752 : case tt_entity:
10361 : : /* Index into the entity table. Perhaps not loaded yet! */
10362 : 1595752 : {
10363 : 1595752 : unsigned origin = state->slurp->remap_module (u ());
10364 : 1595752 : unsigned ident = u ();
10365 : 1595752 : module_state *from = (*modules)[origin];
10366 : :
10367 : 1595752 : if (!origin || ident >= from->entity_num)
10368 : 0 : set_overrun ();
10369 : 1595752 : if (!get_overrun ())
10370 : : {
10371 : 1595752 : binding_slot *slot = &(*entity_ary)[from->entity_lwm + ident];
10372 : 1595752 : if (slot->is_lazy ())
10373 : 30824 : if (!from->lazy_load (ident, slot))
10374 : 0 : set_overrun ();
10375 : 1595752 : res = *slot;
10376 : : }
10377 : :
10378 : 1595752 : if (res)
10379 : : {
10380 : 1595752 : const char *kind = (origin != state->mod ? "Imported" : "Named");
10381 : 1595752 : int tag = insert (res);
10382 : 1595752 : dump (dumper::TREE)
10383 : 600 : && dump ("%s:%d %C:%N@%M", kind, tag, TREE_CODE (res),
10384 : 600 : res, (*modules)[origin]);
10385 : :
10386 : 1595752 : if (!add_indirects (res))
10387 : : {
10388 : 0 : set_overrun ();
10389 : 0 : res = NULL_TREE;
10390 : : }
10391 : : }
10392 : : }
10393 : : break;
10394 : :
10395 : 3815 : case tt_template:
10396 : : /* A template. */
10397 : 3815 : if (tree tpl = tree_node ())
10398 : : {
10399 : 3815 : res = (TREE_CODE (tpl) == TU_LOCAL_ENTITY ?
10400 : 3791 : tpl : DECL_TEMPLATE_RESULT (tpl));
10401 : 3815 : dump (dumper::TREE)
10402 : 9 : && dump ("Read template %C:%N", TREE_CODE (res), res);
10403 : : }
10404 : : break;
10405 : : }
10406 : :
10407 : 134540896 : if (is_use && !unused && res && DECL_P (res) && !TREE_USED (res))
10408 : : {
10409 : : /* Mark decl used as mark_used does -- we cannot call
10410 : : mark_used in the middle of streaming, we only need a subset
10411 : : of its functionality. */
10412 : 870353 : TREE_USED (res) = true;
10413 : :
10414 : : /* And for structured bindings also the underlying decl. */
10415 : 870353 : if (DECL_DECOMPOSITION_P (res) && !DECL_DECOMP_IS_BASE (res))
10416 : 936 : TREE_USED (DECL_DECOMP_BASE (res)) = true;
10417 : :
10418 : 870353 : if (DECL_CLONED_FUNCTION_P (res))
10419 : 8401 : TREE_USED (DECL_CLONED_FUNCTION (res)) = true;
10420 : : }
10421 : :
10422 : 134540896 : dump.outdent ();
10423 : 134540896 : return res;
10424 : : }
10425 : :
10426 : : void
10427 : 2418781 : trees_out::tpl_parms (tree parms, unsigned &tpl_levels)
10428 : : {
10429 : 2418781 : if (!parms)
10430 : : return;
10431 : :
10432 : 1632381 : if (TREE_VISITED (parms))
10433 : : {
10434 : 705686 : ref_node (parms);
10435 : 705686 : return;
10436 : : }
10437 : :
10438 : 926695 : tpl_parms (TREE_CHAIN (parms), tpl_levels);
10439 : :
10440 : 926695 : tree vec = TREE_VALUE (parms);
10441 : 926695 : unsigned len = TREE_VEC_LENGTH (vec);
10442 : : /* Depth. */
10443 : 926695 : int tag = insert (parms);
10444 : 926695 : if (streaming_p ())
10445 : : {
10446 : 249847 : i (len + 1);
10447 : 249913 : dump (dumper::TREE)
10448 : 66 : && dump ("Writing template parms:%d level:%N length:%d",
10449 : 66 : tag, TREE_PURPOSE (parms), len);
10450 : : }
10451 : 926695 : tree_node (TREE_PURPOSE (parms));
10452 : :
10453 : 2628194 : for (unsigned ix = 0; ix != len; ix++)
10454 : : {
10455 : 1701499 : tree parm = TREE_VEC_ELT (vec, ix);
10456 : 1701499 : tree decl = TREE_VALUE (parm);
10457 : :
10458 : 1701499 : gcc_checking_assert (DECL_TEMPLATE_PARM_P (decl));
10459 : 1701499 : if (CHECKING_P)
10460 : 1701499 : switch (TREE_CODE (decl))
10461 : : {
10462 : 0 : default: gcc_unreachable ();
10463 : :
10464 : 3834 : case TEMPLATE_DECL:
10465 : 3834 : gcc_assert ((TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TEMPLATE_PARM)
10466 : : && (TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == TYPE_DECL)
10467 : : && (TYPE_NAME (TREE_TYPE (decl)) == decl));
10468 : : break;
10469 : :
10470 : 1592510 : case TYPE_DECL:
10471 : 1592510 : gcc_assert ((TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM)
10472 : : && (TYPE_NAME (TREE_TYPE (decl)) == decl));
10473 : : break;
10474 : :
10475 : 105155 : case PARM_DECL:
10476 : 105155 : gcc_assert ((TREE_CODE (DECL_INITIAL (decl)) == TEMPLATE_PARM_INDEX)
10477 : : && (TREE_CODE (TEMPLATE_PARM_DECL (DECL_INITIAL (decl)))
10478 : : == CONST_DECL)
10479 : : && (DECL_TEMPLATE_PARM_P
10480 : : (TEMPLATE_PARM_DECL (DECL_INITIAL (decl)))));
10481 : : break;
10482 : : }
10483 : :
10484 : 1701499 : tree_node (decl);
10485 : 1701499 : tree_node (TEMPLATE_PARM_CONSTRAINTS (parm));
10486 : : }
10487 : :
10488 : 926695 : tpl_levels++;
10489 : : }
10490 : :
10491 : : tree
10492 : 475258 : trees_in::tpl_parms (unsigned &tpl_levels)
10493 : : {
10494 : 475258 : tree parms = NULL_TREE;
10495 : :
10496 : 993975 : while (int len = i ())
10497 : : {
10498 : 518717 : if (len < 0)
10499 : : {
10500 : 283295 : parms = back_ref (len);
10501 : 283295 : continue;
10502 : : }
10503 : :
10504 : 235422 : len -= 1;
10505 : 235422 : parms = tree_cons (NULL_TREE, NULL_TREE, parms);
10506 : 235422 : int tag = insert (parms);
10507 : 235422 : TREE_PURPOSE (parms) = tree_node ();
10508 : :
10509 : 235422 : dump (dumper::TREE)
10510 : 105 : && dump ("Reading template parms:%d level:%N length:%d",
10511 : 105 : tag, TREE_PURPOSE (parms), len);
10512 : :
10513 : 235422 : tree vec = make_tree_vec (len);
10514 : 642528 : for (int ix = 0; ix != len; ix++)
10515 : : {
10516 : 407106 : tree decl = tree_node ();
10517 : 407106 : if (!decl)
10518 : : return NULL_TREE;
10519 : :
10520 : 407106 : tree parm = build_tree_list (NULL, decl);
10521 : 407106 : TEMPLATE_PARM_CONSTRAINTS (parm) = tree_node ();
10522 : :
10523 : 407106 : TREE_VEC_ELT (vec, ix) = parm;
10524 : : }
10525 : :
10526 : 235422 : TREE_VALUE (parms) = vec;
10527 : 235422 : tpl_levels++;
10528 : : }
10529 : :
10530 : : return parms;
10531 : : }
10532 : :
10533 : : void
10534 : 1492086 : trees_out::tpl_parms_fini (tree tmpl, unsigned tpl_levels)
10535 : : {
10536 : 1492086 : for (tree parms = DECL_TEMPLATE_PARMS (tmpl);
10537 : 2418781 : tpl_levels--; parms = TREE_CHAIN (parms))
10538 : : {
10539 : 926695 : tree vec = TREE_VALUE (parms);
10540 : :
10541 : 926695 : tree_node (TREE_TYPE (vec));
10542 : 2628194 : for (unsigned ix = TREE_VEC_LENGTH (vec); ix--;)
10543 : : {
10544 : 1701499 : tree parm = TREE_VEC_ELT (vec, ix);
10545 : 1701499 : tree dflt = TREE_PURPOSE (parm);
10546 : 1701499 : tree_node (dflt);
10547 : :
10548 : : /* Template template parameters need a context of their owning
10549 : : template. This is quite tricky to infer correctly on stream-in
10550 : : (see PR c++/98881) so we'll just provide it directly. */
10551 : 1701499 : tree decl = TREE_VALUE (parm);
10552 : 1701499 : if (TREE_CODE (decl) == TEMPLATE_DECL)
10553 : 3834 : tree_node (DECL_CONTEXT (decl));
10554 : : }
10555 : : }
10556 : 1492086 : }
10557 : :
10558 : : bool
10559 : 475258 : trees_in::tpl_parms_fini (tree tmpl, unsigned tpl_levels)
10560 : : {
10561 : 475258 : for (tree parms = DECL_TEMPLATE_PARMS (tmpl);
10562 : 710680 : tpl_levels--; parms = TREE_CHAIN (parms))
10563 : : {
10564 : 235422 : tree vec = TREE_VALUE (parms);
10565 : :
10566 : 235422 : TREE_TYPE (vec) = tree_node ();
10567 : 642528 : for (unsigned ix = TREE_VEC_LENGTH (vec); ix--;)
10568 : : {
10569 : 407106 : tree parm = TREE_VEC_ELT (vec, ix);
10570 : 407106 : tree dflt = tree_node ();
10571 : 407106 : TREE_PURPOSE (parm) = dflt;
10572 : :
10573 : 407106 : tree decl = TREE_VALUE (parm);
10574 : 407106 : if (TREE_CODE (decl) == TEMPLATE_DECL)
10575 : 1018 : DECL_CONTEXT (decl) = tree_node ();
10576 : :
10577 : 407106 : if (get_overrun ())
10578 : : return false;
10579 : : }
10580 : : }
10581 : : return true;
10582 : : }
10583 : :
10584 : : /* PARMS is a LIST, one node per level.
10585 : : TREE_VALUE is a TREE_VEC of parm info for that level.
10586 : : each ELT is a TREE_LIST
10587 : : TREE_VALUE is PARM_DECL, TYPE_DECL or TEMPLATE_DECL
10588 : : TREE_PURPOSE is the default value. */
10589 : :
10590 : : void
10591 : 1492086 : trees_out::tpl_header (tree tpl, unsigned *tpl_levels)
10592 : : {
10593 : 1492086 : tree parms = DECL_TEMPLATE_PARMS (tpl);
10594 : 1492086 : tpl_parms (parms, *tpl_levels);
10595 : :
10596 : : /* Mark end. */
10597 : 1492086 : if (streaming_p ())
10598 : 496891 : u (0);
10599 : :
10600 : 1492086 : if (*tpl_levels)
10601 : 881431 : tree_node (TEMPLATE_PARMS_CONSTRAINTS (parms));
10602 : 1492086 : }
10603 : :
10604 : : bool
10605 : 475258 : trees_in::tpl_header (tree tpl, unsigned *tpl_levels)
10606 : : {
10607 : 475258 : tree parms = tpl_parms (*tpl_levels);
10608 : 475258 : if (!parms)
10609 : : return false;
10610 : :
10611 : 475258 : DECL_TEMPLATE_PARMS (tpl) = parms;
10612 : :
10613 : 475258 : if (*tpl_levels)
10614 : 232978 : TEMPLATE_PARMS_CONSTRAINTS (parms) = tree_node ();
10615 : :
10616 : : return true;
10617 : : }
10618 : :
10619 : : /* Stream skeleton parm nodes, with their flags, type & parm indices.
10620 : : All the parms will have consecutive tags. */
10621 : :
10622 : : void
10623 : 2080581 : trees_out::fn_parms_init (tree fn)
10624 : : {
10625 : : /* First init them. */
10626 : 2080581 : int base_tag = ref_num - 1;
10627 : 2080581 : int ix = 0;
10628 : 2080581 : for (tree parm = DECL_ARGUMENTS (fn);
10629 : 6341014 : parm; parm = DECL_CHAIN (parm), ix++)
10630 : : {
10631 : 4260433 : if (streaming_p ())
10632 : : {
10633 : 1420113 : start (parm);
10634 : 1420113 : tree_node_bools (parm);
10635 : : }
10636 : 4260433 : int tag = insert (parm);
10637 : 4260433 : gcc_checking_assert (base_tag - ix == tag);
10638 : : }
10639 : : /* Mark the end. */
10640 : 2080581 : if (streaming_p ())
10641 : 693925 : u (0);
10642 : :
10643 : : /* Now stream their contents. */
10644 : 2080581 : ix = 0;
10645 : 2080581 : for (tree parm = DECL_ARGUMENTS (fn);
10646 : 6341014 : parm; parm = DECL_CHAIN (parm), ix++)
10647 : : {
10648 : 4260433 : if (streaming_p ())
10649 : 1420113 : dump (dumper::TREE)
10650 : 207 : && dump ("Writing parm:%d %u (%N) of %N",
10651 : : base_tag - ix, ix, parm, fn);
10652 : 4260433 : tree_node_vals (parm);
10653 : : }
10654 : :
10655 : 2080581 : if (!streaming_p ())
10656 : : {
10657 : : /* We must walk contract attrs so the dependency graph is complete. */
10658 : 1386656 : for (tree contract = DECL_CONTRACTS (fn);
10659 : 1386758 : contract;
10660 : 102 : contract = CONTRACT_CHAIN (contract))
10661 : 102 : tree_node (contract);
10662 : : }
10663 : :
10664 : : /* Write a reference to contracts pre/post functions, if any, to avoid
10665 : : regenerating them in importers. */
10666 : 2080581 : tree_node (DECL_PRE_FN (fn));
10667 : 2080581 : tree_node (DECL_POST_FN (fn));
10668 : 2080581 : }
10669 : :
10670 : : /* Build skeleton parm nodes, read their flags, type & parm indices. */
10671 : :
10672 : : int
10673 : 687780 : trees_in::fn_parms_init (tree fn)
10674 : : {
10675 : 687780 : int base_tag = ~(int)back_refs.length ();
10676 : :
10677 : 687780 : tree *parm_ptr = &DECL_ARGUMENTS (fn);
10678 : 687780 : int ix = 0;
10679 : 2086344 : for (; int code = u (); ix++)
10680 : : {
10681 : 1398564 : tree parm = start (code);
10682 : 1398564 : if (!tree_node_bools (parm))
10683 : : return 0;
10684 : :
10685 : 1398564 : int tag = insert (parm);
10686 : 1398564 : gcc_checking_assert (base_tag - ix == tag);
10687 : 1398564 : *parm_ptr = parm;
10688 : 1398564 : parm_ptr = &DECL_CHAIN (parm);
10689 : 1398564 : }
10690 : :
10691 : 687780 : ix = 0;
10692 : 687780 : for (tree parm = DECL_ARGUMENTS (fn);
10693 : 2086344 : parm; parm = DECL_CHAIN (parm), ix++)
10694 : : {
10695 : 1398564 : dump (dumper::TREE)
10696 : 351 : && dump ("Reading parm:%d %u (%N) of %N",
10697 : : base_tag - ix, ix, parm, fn);
10698 : 1398564 : if (!tree_node_vals (parm))
10699 : : return 0;
10700 : : }
10701 : :
10702 : : /* Reload references to contract functions, if any. */
10703 : 687780 : tree pre_fn = tree_node ();
10704 : 687780 : tree post_fn = tree_node ();
10705 : 687780 : set_contract_functions (fn, pre_fn, post_fn);
10706 : :
10707 : 687780 : return base_tag;
10708 : : }
10709 : :
10710 : : /* Read the remaining parm node data. Replace with existing (if
10711 : : non-null) in the map. */
10712 : :
10713 : : void
10714 : 687780 : trees_in::fn_parms_fini (int tag, tree fn, tree existing, bool is_defn)
10715 : : {
10716 : 1112249 : tree existing_parm = existing ? DECL_ARGUMENTS (existing) : NULL_TREE;
10717 : 687780 : tree parms = DECL_ARGUMENTS (fn);
10718 : 687780 : unsigned ix = 0;
10719 : 2086344 : for (tree parm = parms; parm; parm = DECL_CHAIN (parm), ix++)
10720 : : {
10721 : 1398564 : if (existing_parm)
10722 : : {
10723 : 1255325 : if (is_defn && !DECL_SAVED_TREE (existing))
10724 : : {
10725 : : /* If we're about to become the definition, set the
10726 : : names of the parms from us. */
10727 : 33951 : DECL_NAME (existing_parm) = DECL_NAME (parm);
10728 : 33951 : DECL_SOURCE_LOCATION (existing_parm) = DECL_SOURCE_LOCATION (parm);
10729 : : }
10730 : :
10731 : 859566 : back_refs[~tag] = existing_parm;
10732 : 859566 : existing_parm = DECL_CHAIN (existing_parm);
10733 : : }
10734 : 1398564 : tag--;
10735 : : }
10736 : 687780 : }
10737 : :
10738 : : /* Encode into KEY the position of the local type (class or enum)
10739 : : declaration DECL within FN. The position is encoded as the
10740 : : index of the innermost BLOCK (numbered in BFS order) along with
10741 : : the index within its BLOCK_VARS list. */
10742 : :
10743 : : void
10744 : 18711 : trees_out::key_local_type (merge_key& key, tree decl, tree fn)
10745 : : {
10746 : 18711 : auto_vec<tree, 4> blocks;
10747 : 18711 : blocks.quick_push (DECL_INITIAL (fn));
10748 : 18711 : unsigned block_ix = 0;
10749 : 91311 : while (block_ix != blocks.length ())
10750 : : {
10751 : 36300 : tree block = blocks[block_ix];
10752 : 36300 : unsigned decl_ix = 0;
10753 : 109188 : for (tree var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
10754 : : {
10755 : 91599 : if (TREE_CODE (var) != TYPE_DECL)
10756 : 55623 : continue;
10757 : 35976 : if (var == decl)
10758 : : {
10759 : 18711 : key.index = (block_ix << 10) | decl_ix;
10760 : 18711 : return;
10761 : : }
10762 : 17265 : ++decl_ix;
10763 : : }
10764 : 36684 : for (tree sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
10765 : 19095 : blocks.safe_push (sub);
10766 : 17589 : ++block_ix;
10767 : : }
10768 : :
10769 : : /* Not-found value. */
10770 : 0 : key.index = 1023;
10771 : 18711 : }
10772 : :
10773 : : /* Look up the local type corresponding at the position encoded by
10774 : : KEY within FN and named NAME. */
10775 : :
10776 : : tree
10777 : 5496 : trees_in::key_local_type (const merge_key& key, tree fn, tree name)
10778 : : {
10779 : 5496 : if (!DECL_INITIAL (fn))
10780 : : return NULL_TREE;
10781 : :
10782 : 3528 : const unsigned block_pos = key.index >> 10;
10783 : 3528 : const unsigned decl_pos = key.index & 1023;
10784 : :
10785 : 3528 : if (decl_pos == 1023)
10786 : : return NULL_TREE;
10787 : :
10788 : 3528 : auto_vec<tree, 4> blocks;
10789 : 3528 : blocks.quick_push (DECL_INITIAL (fn));
10790 : 3528 : unsigned block_ix = 0;
10791 : 17144 : while (block_ix != blocks.length ())
10792 : : {
10793 : 6808 : tree block = blocks[block_ix];
10794 : 6808 : if (block_ix == block_pos)
10795 : : {
10796 : 3528 : unsigned decl_ix = 0;
10797 : 9529 : for (tree var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
10798 : : {
10799 : 9529 : if (TREE_CODE (var) != TYPE_DECL)
10800 : 3706 : continue;
10801 : : /* Prefer using the identifier as the key for more robustness
10802 : : to ODR violations, except for anonymous types since their
10803 : : compiler-generated identifiers aren't stable. */
10804 : 11646 : if (IDENTIFIER_ANON_P (name)
10805 : 5823 : ? decl_ix == decl_pos
10806 : 581 : : DECL_NAME (var) == name)
10807 : : return var;
10808 : 2295 : ++decl_ix;
10809 : : }
10810 : : return NULL_TREE;
10811 : : }
10812 : 6806 : for (tree sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
10813 : 3526 : blocks.safe_push (sub);
10814 : 3280 : ++block_ix;
10815 : : }
10816 : :
10817 : : return NULL_TREE;
10818 : 3528 : }
10819 : :
10820 : : /* DEP is the depset of some decl we're streaming by value. Determine
10821 : : the merging behaviour. */
10822 : :
10823 : : merge_kind
10824 : 5060652 : trees_out::get_merge_kind (tree decl, depset *dep)
10825 : : {
10826 : 5060652 : if (!dep)
10827 : : {
10828 : 940611 : if (VAR_OR_FUNCTION_DECL_P (decl))
10829 : : {
10830 : : /* Any var or function with template info should have DEP. */
10831 : 519201 : gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
10832 : : || !DECL_TEMPLATE_INFO (decl));
10833 : 519201 : if (DECL_LOCAL_DECL_P (decl))
10834 : : return MK_unique;
10835 : : }
10836 : :
10837 : : /* Either unique, or some member of a class that cannot have an
10838 : : out-of-class definition. For instance a FIELD_DECL. */
10839 : 940301 : tree ctx = CP_DECL_CONTEXT (decl);
10840 : 940301 : if (TREE_CODE (ctx) == FUNCTION_DECL)
10841 : : {
10842 : : /* USING_DECLs and NAMESPACE_DECLs cannot have DECL_TEMPLATE_INFO --
10843 : : this isn't permitting them to have one. */
10844 : 572838 : gcc_checking_assert (TREE_CODE (decl) == USING_DECL
10845 : : || TREE_CODE (decl) == NAMESPACE_DECL
10846 : : || !DECL_LANG_SPECIFIC (decl)
10847 : : || !DECL_TEMPLATE_INFO (decl));
10848 : :
10849 : : return MK_unique;
10850 : : }
10851 : :
10852 : 367463 : if (TREE_CODE (decl) == TEMPLATE_DECL
10853 : 367463 : && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
10854 : : return MK_local_friend;
10855 : :
10856 : 367463 : gcc_checking_assert (TYPE_P (ctx));
10857 : 367463 : if (TREE_CODE (decl) == USING_DECL)
10858 : : return MK_field;
10859 : :
10860 : 240206 : if (TREE_CODE (decl) == FIELD_DECL)
10861 : : {
10862 : 180303 : if (DECL_NAME (decl))
10863 : : {
10864 : : /* Anonymous FIELD_DECLs have a NULL name. */
10865 : 140542 : gcc_checking_assert (!IDENTIFIER_ANON_P (DECL_NAME (decl)));
10866 : : return MK_named;
10867 : : }
10868 : :
10869 : 39761 : if (!DECL_NAME (decl)
10870 : 39761 : && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))
10871 : 41161 : && !DECL_BIT_FIELD_REPRESENTATIVE (decl))
10872 : : {
10873 : : /* The underlying storage unit for a bitfield. We do not
10874 : : need to dedup it, because it's only reachable through
10875 : : the bitfields it represents. And those are deduped. */
10876 : : // FIXME: Is that assertion correct -- do we ever fish it
10877 : : // out and put it in an expr?
10878 : 428 : gcc_checking_assert ((TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
10879 : : ? TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
10880 : : : TREE_CODE (TREE_TYPE (decl)))
10881 : : == INTEGER_TYPE);
10882 : : return MK_unique;
10883 : : }
10884 : :
10885 : : return MK_field;
10886 : : }
10887 : :
10888 : 59903 : if (TREE_CODE (decl) == CONST_DECL)
10889 : : return MK_named;
10890 : :
10891 : 13506 : if (TREE_CODE (decl) == VAR_DECL
10892 : 13506 : && DECL_VTABLE_OR_VTT_P (decl))
10893 : : return MK_vtable;
10894 : :
10895 : 2440 : if (DECL_THUNK_P (decl))
10896 : : /* Thunks are unique-enough, because they're only referenced
10897 : : from the vtable. And that's either new (so we want the
10898 : : thunks), or it's a duplicate (so it will be dropped). */
10899 : : return MK_unique;
10900 : :
10901 : : /* There should be no other cases. */
10902 : 0 : gcc_unreachable ();
10903 : : }
10904 : :
10905 : 4120041 : gcc_checking_assert (TREE_CODE (decl) != FIELD_DECL
10906 : : && TREE_CODE (decl) != USING_DECL
10907 : : && TREE_CODE (decl) != CONST_DECL);
10908 : :
10909 : 4120041 : if (is_key_order ())
10910 : : {
10911 : : /* When doing the mergeablilty graph, there's an indirection to
10912 : : the actual depset. */
10913 : 1373236 : gcc_assert (dep->is_special ());
10914 : 1373236 : dep = dep->deps[0];
10915 : : }
10916 : :
10917 : 4120041 : gcc_checking_assert (decl == dep->get_entity ());
10918 : :
10919 : 4120041 : merge_kind mk = MK_named;
10920 : 4120041 : switch (dep->get_entity_kind ())
10921 : : {
10922 : 0 : default:
10923 : 0 : gcc_unreachable ();
10924 : :
10925 : : case depset::EK_PARTIAL:
10926 : : mk = MK_partial;
10927 : : break;
10928 : :
10929 : 2331018 : case depset::EK_DECL:
10930 : 2331018 : {
10931 : 2331018 : tree ctx = CP_DECL_CONTEXT (decl);
10932 : :
10933 : 2331018 : switch (TREE_CODE (ctx))
10934 : : {
10935 : 0 : default:
10936 : 0 : gcc_unreachable ();
10937 : :
10938 : 18711 : case FUNCTION_DECL:
10939 : 18711 : gcc_checking_assert
10940 : : (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl)));
10941 : :
10942 : : mk = MK_local_type;
10943 : : break;
10944 : :
10945 : 2312307 : case RECORD_TYPE:
10946 : 2312307 : case UNION_TYPE:
10947 : 2312307 : case NAMESPACE_DECL:
10948 : 2312307 : if (DECL_NAME (decl) == as_base_identifier)
10949 : : {
10950 : : mk = MK_as_base;
10951 : : break;
10952 : : }
10953 : :
10954 : : /* A lambda may have a class as its context, even though it
10955 : : isn't a member in the traditional sense; see the test
10956 : : g++.dg/modules/lambda-6_a.C. */
10957 : 2922135 : if (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl))
10958 : 2528076 : && LAMBDA_TYPE_P (TREE_TYPE (decl)))
10959 : 241 : if (tree scope = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl)))
10960 : : {
10961 : : /* Lambdas attached to fields are keyed to its class. */
10962 : 138 : if (TREE_CODE (scope) == FIELD_DECL)
10963 : 9 : scope = TYPE_NAME (DECL_CONTEXT (scope));
10964 : 138 : if (DECL_LANG_SPECIFIC (scope)
10965 : 276 : && DECL_MODULE_KEYED_DECLS_P (scope))
10966 : : {
10967 : : mk = MK_keyed;
10968 : : break;
10969 : : }
10970 : : }
10971 : :
10972 : 2211940 : if (TREE_CODE (decl) == TEMPLATE_DECL
10973 : 2211940 : && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
10974 : : {
10975 : : mk = MK_local_friend;
10976 : : break;
10977 : : }
10978 : :
10979 : 2191054 : if (IDENTIFIER_ANON_P (DECL_NAME (decl)))
10980 : : {
10981 : 35213 : if (RECORD_OR_UNION_TYPE_P (ctx))
10982 : : mk = MK_field;
10983 : 1982 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
10984 : 1982 : && UNSCOPED_ENUM_P (TREE_TYPE (decl))
10985 : 4027 : && TYPE_VALUES (TREE_TYPE (decl)))
10986 : : /* Keyed by first enum value, and underlying type. */
10987 : : mk = MK_enum;
10988 : : else
10989 : : /* No way to merge it, it is an ODR land-mine. */
10990 : : mk = MK_unique;
10991 : : }
10992 : : }
10993 : : }
10994 : : break;
10995 : :
10996 : 1713225 : case depset::EK_SPECIALIZATION:
10997 : 1713225 : {
10998 : 1713225 : gcc_checking_assert (dep->is_special ());
10999 : :
11000 : 1713225 : if (TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
11001 : : /* An block-scope classes of templates are themselves
11002 : : templates. */
11003 : 6240 : gcc_checking_assert (DECL_IMPLICIT_TYPEDEF_P (decl));
11004 : :
11005 : 1713225 : if (dep->is_friend_spec ())
11006 : : mk = MK_friend_spec;
11007 : 1713225 : else if (dep->is_type_spec ())
11008 : : mk = MK_type_spec;
11009 : : else
11010 : 1202394 : mk = MK_decl_spec;
11011 : :
11012 : 1713225 : if (TREE_CODE (decl) == TEMPLATE_DECL)
11013 : : {
11014 : 119019 : spec_entry *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);
11015 : 119019 : if (TREE_CODE (entry->spec) != TEMPLATE_DECL)
11016 : 14790 : mk = merge_kind (mk | MK_tmpl_tmpl_mask);
11017 : : }
11018 : : }
11019 : : break;
11020 : : }
11021 : :
11022 : : return mk;
11023 : : }
11024 : :
11025 : :
11026 : : /* The container of DECL -- not necessarily its context! */
11027 : :
11028 : : tree
11029 : 5060652 : trees_out::decl_container (tree decl)
11030 : : {
11031 : 5060652 : int use_tpl;
11032 : 5060652 : tree tpl = NULL_TREE;
11033 : 5060652 : if (tree template_info = node_template_info (decl, use_tpl))
11034 : 1797453 : tpl = TI_TEMPLATE (template_info);
11035 : 5060652 : if (tpl == decl)
11036 : 0 : tpl = nullptr;
11037 : :
11038 : : /* Stream the template we're instantiated from. */
11039 : 5060652 : tree_node (tpl);
11040 : :
11041 : 5060652 : tree container = NULL_TREE;
11042 : 5060652 : if (TREE_CODE (decl) == TEMPLATE_DECL
11043 : 5060652 : && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
11044 : 20886 : container = DECL_CHAIN (decl);
11045 : : else
11046 : 5039766 : container = CP_DECL_CONTEXT (decl);
11047 : :
11048 : 5060652 : if (TYPE_P (container))
11049 : 2956650 : container = TYPE_NAME (container);
11050 : :
11051 : 5060652 : tree_node (container);
11052 : :
11053 : 5060652 : return container;
11054 : : }
11055 : :
11056 : : tree
11057 : 1770183 : trees_in::decl_container ()
11058 : : {
11059 : : /* The maybe-template. */
11060 : 1770183 : (void)tree_node ();
11061 : :
11062 : 1770183 : tree container = tree_node ();
11063 : :
11064 : 1770183 : return container;
11065 : : }
11066 : :
11067 : : /* Write out key information about a mergeable DEP. Does not write
11068 : : the contents of DEP itself. The context has already been
11069 : : written. The container has already been streamed. */
11070 : :
11071 : : void
11072 : 5060652 : trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
11073 : : tree container, depset *dep)
11074 : : {
11075 : 5060652 : if (dep && is_key_order ())
11076 : : {
11077 : 1373236 : gcc_checking_assert (dep->is_special ());
11078 : 1373236 : dep = dep->deps[0];
11079 : : }
11080 : :
11081 : 5060652 : if (streaming_p ())
11082 : 1833746 : dump (dumper::MERGE)
11083 : 798 : && dump ("Writing:%d's %s merge key (%s) %C:%N", tag, merge_kind_name[mk],
11084 : 723 : dep ? dep->entity_kind_name () : "contained",
11085 : 798 : TREE_CODE (decl), decl);
11086 : :
11087 : : /* Now write the locating information. */
11088 : 5060652 : if (mk & MK_template_mask)
11089 : : {
11090 : : /* Specializations are located via their originating template,
11091 : : and the set of template args they specialize. */
11092 : 1713225 : gcc_checking_assert (dep && dep->is_special ());
11093 : 1713225 : spec_entry *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);
11094 : :
11095 : 1713225 : tree_node (entry->tmpl);
11096 : 1713225 : tree_node (entry->args);
11097 : 1713225 : if (mk & MK_tmpl_decl_mask)
11098 : 1202394 : if (flag_concepts && TREE_CODE (inner) == VAR_DECL)
11099 : : {
11100 : : /* Variable template partial specializations might need
11101 : : constraints (see spec_hasher::equal). It's simpler to
11102 : : write NULL when we don't need them. */
11103 : 18924 : tree constraints = NULL_TREE;
11104 : :
11105 : 18924 : if (uses_template_parms (entry->args))
11106 : 357 : constraints = get_constraints (inner);
11107 : 18924 : tree_node (constraints);
11108 : : }
11109 : :
11110 : 1713225 : if (CHECKING_P)
11111 : : {
11112 : : /* Make sure we can locate the decl. */
11113 : 1713225 : tree existing = match_mergeable_specialization
11114 : 1713225 : (bool (mk & MK_tmpl_decl_mask), entry);
11115 : :
11116 : 1713225 : gcc_assert (existing);
11117 : 1713225 : if (mk & MK_tmpl_decl_mask)
11118 : : {
11119 : 1202394 : if (mk & MK_tmpl_tmpl_mask)
11120 : 11784 : existing = DECL_TI_TEMPLATE (existing);
11121 : : }
11122 : : else
11123 : : {
11124 : 510831 : if (mk & MK_tmpl_tmpl_mask)
11125 : 3006 : existing = CLASSTYPE_TI_TEMPLATE (existing);
11126 : : else
11127 : 507825 : existing = TYPE_NAME (existing);
11128 : : }
11129 : :
11130 : : /* The walkabout should have found ourselves. */
11131 : 1713225 : gcc_checking_assert (TREE_CODE (decl) == TYPE_DECL
11132 : : ? same_type_p (TREE_TYPE (decl),
11133 : : TREE_TYPE (existing))
11134 : : : existing == decl);
11135 : : }
11136 : : }
11137 : 3347427 : else if (mk != MK_unique)
11138 : : {
11139 : 2771326 : merge_key key;
11140 : 2771326 : tree name = DECL_NAME (decl);
11141 : :
11142 : 2771326 : switch (mk)
11143 : : {
11144 : 0 : default:
11145 : 0 : gcc_unreachable ();
11146 : :
11147 : 2342780 : case MK_named:
11148 : 2342780 : case MK_friend_spec:
11149 : 2342780 : if (IDENTIFIER_CONV_OP_P (name))
11150 : 6980 : name = conv_op_identifier;
11151 : :
11152 : 2342780 : if (TREE_CODE (inner) == FUNCTION_DECL)
11153 : : {
11154 : : /* Functions are distinguished by parameter types. */
11155 : 1322770 : tree fn_type = TREE_TYPE (inner);
11156 : :
11157 : 1322770 : key.ref_q = type_memfn_rqual (fn_type);
11158 : 1322770 : key.args = TYPE_ARG_TYPES (fn_type);
11159 : :
11160 : 1322770 : if (tree reqs = get_constraints (inner))
11161 : : {
11162 : 56025 : if (cxx_dialect < cxx20)
11163 : 42 : reqs = CI_ASSOCIATED_CONSTRAINTS (reqs);
11164 : : else
11165 : 112008 : reqs = CI_DECLARATOR_REQS (reqs);
11166 : 56025 : key.constraints = reqs;
11167 : : }
11168 : :
11169 : 1322770 : if (IDENTIFIER_CONV_OP_P (name)
11170 : 1322770 : || (decl != inner
11171 : 708749 : && !(name == fun_identifier
11172 : : /* In case the user names something _FUN */
11173 : 72 : && LAMBDA_TYPE_P (DECL_CONTEXT (inner)))))
11174 : : /* And a function template, or conversion operator needs
11175 : : the return type. Except for the _FUN thunk of a
11176 : : generic lambda, which has a recursive decl_type'd
11177 : : return type. */
11178 : : // FIXME: What if the return type is a voldemort?
11179 : 715693 : key.ret = fndecl_declared_return_type (inner);
11180 : : }
11181 : : break;
11182 : :
11183 : 199747 : case MK_field:
11184 : 199747 : {
11185 : 199747 : unsigned ix = 0;
11186 : 199747 : if (TREE_CODE (inner) != FIELD_DECL)
11187 : : name = NULL_TREE;
11188 : : else
11189 : 39333 : gcc_checking_assert (!name || !IDENTIFIER_ANON_P (name));
11190 : :
11191 : 199747 : for (tree field = TYPE_FIELDS (TREE_TYPE (container));
11192 : 433962 : ; field = DECL_CHAIN (field))
11193 : : {
11194 : 633709 : tree finner = STRIP_TEMPLATE (field);
11195 : 633709 : if (TREE_CODE (finner) == TREE_CODE (inner))
11196 : : {
11197 : 270642 : if (finner == inner)
11198 : : break;
11199 : 70895 : ix++;
11200 : : }
11201 : 433962 : }
11202 : 199747 : key.index = ix;
11203 : : }
11204 : 199747 : break;
11205 : :
11206 : 11066 : case MK_vtable:
11207 : 11066 : {
11208 : 11066 : tree vtable = CLASSTYPE_VTABLES (TREE_TYPE (container));
11209 : 14674 : for (unsigned ix = 0; ; vtable = DECL_CHAIN (vtable), ix++)
11210 : 14674 : if (vtable == decl)
11211 : : {
11212 : 11066 : key.index = ix;
11213 : 11066 : break;
11214 : : }
11215 : 11066 : name = NULL_TREE;
11216 : : }
11217 : 11066 : break;
11218 : :
11219 : 100229 : case MK_as_base:
11220 : 100229 : gcc_checking_assert
11221 : : (decl == TYPE_NAME (CLASSTYPE_AS_BASE (TREE_TYPE (container))));
11222 : : break;
11223 : :
11224 : 20886 : case MK_local_friend:
11225 : 20886 : {
11226 : : /* Find by index on the class's DECL_LIST */
11227 : 20886 : unsigned ix = 0;
11228 : 20886 : for (tree decls = CLASSTYPE_DECL_LIST (TREE_CHAIN (decl));
11229 : 570024 : decls; decls = TREE_CHAIN (decls))
11230 : 570024 : if (!TREE_PURPOSE (decls))
11231 : : {
11232 : 72321 : tree frnd = friend_from_decl_list (TREE_VALUE (decls));
11233 : 72321 : if (frnd == decl)
11234 : : break;
11235 : 51435 : ix++;
11236 : : }
11237 : 20886 : key.index = ix;
11238 : 20886 : name = NULL_TREE;
11239 : : }
11240 : 20886 : break;
11241 : :
11242 : 18711 : case MK_local_type:
11243 : 18711 : key_local_type (key, STRIP_TEMPLATE (decl), container);
11244 : 18711 : break;
11245 : :
11246 : 1971 : case MK_enum:
11247 : 1971 : {
11248 : : /* Anonymous enums are located by their first identifier,
11249 : : and underlying type. */
11250 : 1971 : tree type = TREE_TYPE (decl);
11251 : :
11252 : 1971 : gcc_checking_assert (UNSCOPED_ENUM_P (type));
11253 : : /* Using the type name drops the bit precision we might
11254 : : have been using on the enum. */
11255 : 1971 : key.ret = TYPE_NAME (ENUM_UNDERLYING_TYPE (type));
11256 : 1971 : if (tree values = TYPE_VALUES (type))
11257 : 1971 : name = DECL_NAME (TREE_VALUE (values));
11258 : : }
11259 : : break;
11260 : :
11261 : 138 : case MK_keyed:
11262 : 138 : {
11263 : 276 : gcc_checking_assert (LAMBDA_TYPE_P (TREE_TYPE (inner)));
11264 : 138 : tree scope = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (inner));
11265 : 138 : gcc_checking_assert (TREE_CODE (scope) == VAR_DECL
11266 : : || TREE_CODE (scope) == FIELD_DECL
11267 : : || TREE_CODE (scope) == PARM_DECL
11268 : : || TREE_CODE (scope) == TYPE_DECL);
11269 : : /* Lambdas attached to fields are keyed to the class. */
11270 : 138 : if (TREE_CODE (scope) == FIELD_DECL)
11271 : 9 : scope = TYPE_NAME (DECL_CONTEXT (scope));
11272 : 138 : auto *root = keyed_table->get (scope);
11273 : 138 : unsigned ix = root->length ();
11274 : : /* If we don't find it, we'll write a really big number
11275 : : that the reader will ignore. */
11276 : 138 : while (ix--)
11277 : 138 : if ((*root)[ix] == inner)
11278 : : break;
11279 : :
11280 : : /* Use the keyed-to decl as the 'name'. */
11281 : 138 : name = scope;
11282 : 138 : key.index = ix;
11283 : : }
11284 : 138 : break;
11285 : :
11286 : 75798 : case MK_partial:
11287 : 75798 : {
11288 : 75798 : tree ti = get_template_info (inner);
11289 : 75798 : key.constraints = get_constraints (inner);
11290 : 75798 : key.ret = TI_TEMPLATE (ti);
11291 : 75798 : key.args = TI_ARGS (ti);
11292 : : }
11293 : 75798 : break;
11294 : : }
11295 : :
11296 : 2771326 : tree_node (name);
11297 : 2771326 : if (streaming_p ())
11298 : : {
11299 : 984420 : unsigned code = (key.ref_q << 0) | (key.index << 2);
11300 : 984420 : u (code);
11301 : : }
11302 : :
11303 : 2771326 : if (mk == MK_enum)
11304 : 1971 : tree_node (key.ret);
11305 : 2769355 : else if (mk == MK_partial
11306 : 2693557 : || (mk == MK_named && inner
11307 : 2342780 : && TREE_CODE (inner) == FUNCTION_DECL))
11308 : : {
11309 : 1398568 : tree_node (key.ret);
11310 : 1398568 : tree arg = key.args;
11311 : 1398568 : if (mk == MK_named)
11312 : 3896977 : while (arg && arg != void_list_node)
11313 : : {
11314 : 2574207 : tree_node (TREE_VALUE (arg));
11315 : 2574207 : arg = TREE_CHAIN (arg);
11316 : : }
11317 : 1398568 : tree_node (arg);
11318 : 1398568 : tree_node (key.constraints);
11319 : : }
11320 : : }
11321 : 5060652 : }
11322 : :
11323 : : /* DECL is a new declaration that may be duplicated in OVL. Use RET &
11324 : : ARGS to find its clone, or NULL. If DECL's DECL_NAME is NULL, this
11325 : : has been found by a proxy. It will be an enum type located by its
11326 : : first member.
11327 : :
11328 : : We're conservative with matches, so ambiguous decls will be
11329 : : registered as different, then lead to a lookup error if the two
11330 : : modules are both visible. Perhaps we want to do something similar
11331 : : to duplicate decls to get ODR errors on loading? We already have
11332 : : some special casing for namespaces. */
11333 : :
11334 : : static tree
11335 : 568693 : check_mergeable_decl (merge_kind mk, tree decl, tree ovl, merge_key const &key)
11336 : : {
11337 : 568693 : tree found = NULL_TREE;
11338 : 2339808 : for (ovl_iterator iter (ovl); !found && iter; ++iter)
11339 : : {
11340 : 1135758 : tree match = *iter;
11341 : :
11342 : 1135758 : tree d_inner = decl;
11343 : 1135758 : tree m_inner = match;
11344 : :
11345 : 1330119 : again:
11346 : 1330119 : if (TREE_CODE (d_inner) != TREE_CODE (m_inner))
11347 : : {
11348 : 172827 : if (TREE_CODE (match) == NAMESPACE_DECL
11349 : 172827 : && !DECL_NAMESPACE_ALIAS (match))
11350 : : /* Namespaces are never overloaded. */
11351 : : found = match;
11352 : :
11353 : 172827 : continue;
11354 : : }
11355 : :
11356 : 1157292 : switch (TREE_CODE (d_inner))
11357 : : {
11358 : 405101 : case TEMPLATE_DECL:
11359 : 405101 : if (template_heads_equivalent_p (d_inner, m_inner))
11360 : : {
11361 : 194361 : d_inner = DECL_TEMPLATE_RESULT (d_inner);
11362 : 194361 : m_inner = DECL_TEMPLATE_RESULT (m_inner);
11363 : 194361 : if (d_inner == error_mark_node
11364 : 194361 : && TYPE_DECL_ALIAS_P (m_inner))
11365 : : {
11366 : : found = match;
11367 : : break;
11368 : : }
11369 : 194361 : goto again;
11370 : : }
11371 : : break;
11372 : :
11373 : 551865 : case FUNCTION_DECL:
11374 : 551865 : if (tree m_type = TREE_TYPE (m_inner))
11375 : 551865 : if ((!key.ret
11376 : 312011 : || same_type_p (key.ret, fndecl_declared_return_type (m_inner)))
11377 : 509036 : && type_memfn_rqual (m_type) == key.ref_q
11378 : 508677 : && compparms (key.args, TYPE_ARG_TYPES (m_type))
11379 : : /* Reject if old is a "C" builtin and new is not "C".
11380 : : Matches decls_match behaviour. */
11381 : 278677 : && (!DECL_IS_UNDECLARED_BUILTIN (m_inner)
11382 : 12054 : || !DECL_EXTERN_C_P (m_inner)
11383 : 11814 : || DECL_EXTERN_C_P (d_inner))
11384 : : /* Reject if one is a different member of a
11385 : : guarded/pre/post fn set. */
11386 : 278662 : && (!flag_contracts
11387 : 340 : || (DECL_IS_PRE_FN_P (d_inner)
11388 : 170 : == DECL_IS_PRE_FN_P (m_inner)))
11389 : 830527 : && (!flag_contracts
11390 : 340 : || (DECL_IS_POST_FN_P (d_inner)
11391 : 170 : == DECL_IS_POST_FN_P (m_inner))))
11392 : : {
11393 : 278662 : tree m_reqs = get_constraints (m_inner);
11394 : 278662 : if (m_reqs)
11395 : : {
11396 : 10756 : if (cxx_dialect < cxx20)
11397 : 8 : m_reqs = CI_ASSOCIATED_CONSTRAINTS (m_reqs);
11398 : : else
11399 : 21504 : m_reqs = CI_DECLARATOR_REQS (m_reqs);
11400 : : }
11401 : :
11402 : 278662 : if (cp_tree_equal (key.constraints, m_reqs))
11403 : 351452 : found = match;
11404 : : }
11405 : : break;
11406 : :
11407 : 127601 : case TYPE_DECL:
11408 : 255202 : if (DECL_IMPLICIT_TYPEDEF_P (d_inner)
11409 : 127601 : == DECL_IMPLICIT_TYPEDEF_P (m_inner))
11410 : : {
11411 : 127549 : if (!IDENTIFIER_ANON_P (DECL_NAME (m_inner)))
11412 : 127184 : return match;
11413 : 365 : else if (mk == MK_enum
11414 : 365 : && (TYPE_NAME (ENUM_UNDERLYING_TYPE (TREE_TYPE (m_inner)))
11415 : 365 : == key.ret))
11416 : : found = match;
11417 : : }
11418 : : break;
11419 : :
11420 : : default:
11421 : : found = match;
11422 : : break;
11423 : : }
11424 : : }
11425 : :
11426 : 441509 : return found;
11427 : : }
11428 : :
11429 : : /* DECL, INNER & TYPE are a skeleton set of nodes for a decl. Only
11430 : : the bools have been filled in. Read its merging key and merge it.
11431 : : Returns the existing decl if there is one. */
11432 : :
11433 : : tree
11434 : 1770183 : trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
11435 : : tree type, tree container, bool is_attached,
11436 : : bool is_imported_temploid_friend)
11437 : : {
11438 : 1770183 : const char *kind = "new";
11439 : 1770183 : tree existing = NULL_TREE;
11440 : :
11441 : 1770183 : if (mk & MK_template_mask)
11442 : : {
11443 : : // FIXME: We could stream the specialization hash?
11444 : 556927 : spec_entry spec;
11445 : 556927 : spec.tmpl = tree_node ();
11446 : 556927 : spec.args = tree_node ();
11447 : :
11448 : 556927 : if (get_overrun ())
11449 : 0 : return error_mark_node;
11450 : :
11451 : 556927 : DECL_NAME (decl) = DECL_NAME (spec.tmpl);
11452 : 556927 : DECL_CONTEXT (decl) = DECL_CONTEXT (spec.tmpl);
11453 : 556927 : DECL_NAME (inner) = DECL_NAME (decl);
11454 : 556927 : DECL_CONTEXT (inner) = DECL_CONTEXT (decl);
11455 : :
11456 : 556927 : tree constr = NULL_TREE;
11457 : 556927 : bool is_decl = mk & MK_tmpl_decl_mask;
11458 : 556927 : if (is_decl)
11459 : : {
11460 : 393720 : if (flag_concepts && TREE_CODE (inner) == VAR_DECL)
11461 : : {
11462 : 6162 : constr = tree_node ();
11463 : 6162 : if (constr)
11464 : 0 : set_constraints (inner, constr);
11465 : : }
11466 : 783373 : spec.spec = (mk & MK_tmpl_tmpl_mask) ? inner : decl;
11467 : : }
11468 : : else
11469 : 163207 : spec.spec = type;
11470 : 556927 : existing = match_mergeable_specialization (is_decl, &spec);
11471 : 556927 : if (constr)
11472 : : /* We'll add these back later, if this is the new decl. */
11473 : 0 : remove_constraints (inner);
11474 : :
11475 : 556927 : if (!existing)
11476 : : ; /* We'll add to the table once read. */
11477 : 324432 : else if (mk & MK_tmpl_decl_mask)
11478 : : {
11479 : : /* A declaration specialization. */
11480 : 224564 : if (mk & MK_tmpl_tmpl_mask)
11481 : 2561 : existing = DECL_TI_TEMPLATE (existing);
11482 : : }
11483 : : else
11484 : : {
11485 : : /* A type specialization. */
11486 : 99868 : if (mk & MK_tmpl_tmpl_mask)
11487 : 638 : existing = CLASSTYPE_TI_TEMPLATE (existing);
11488 : : else
11489 : 99230 : existing = TYPE_NAME (existing);
11490 : : }
11491 : : }
11492 : 1213256 : else if (mk == MK_unique)
11493 : : kind = "unique";
11494 : : else
11495 : : {
11496 : 936693 : tree name = tree_node ();
11497 : :
11498 : 936693 : merge_key key;
11499 : 936693 : unsigned code = u ();
11500 : 936693 : key.ref_q = cp_ref_qualifier ((code >> 0) & 3);
11501 : 936693 : key.index = code >> 2;
11502 : :
11503 : 936693 : if (mk == MK_enum)
11504 : 607 : key.ret = tree_node ();
11505 : 936086 : else if (mk == MK_partial
11506 : 915217 : || ((mk == MK_named || mk == MK_friend_spec)
11507 : 782029 : && TREE_CODE (inner) == FUNCTION_DECL))
11508 : : {
11509 : 456765 : key.ret = tree_node ();
11510 : 456765 : tree arg, *arg_ptr = &key.args;
11511 : 456765 : while ((arg = tree_node ())
11512 : 1294021 : && arg != void_list_node
11513 : 2158136 : && mk != MK_partial)
11514 : : {
11515 : 840251 : *arg_ptr = tree_cons (NULL_TREE, arg, NULL_TREE);
11516 : 840251 : arg_ptr = &TREE_CHAIN (*arg_ptr);
11517 : : }
11518 : 456765 : *arg_ptr = arg;
11519 : 456765 : key.constraints = tree_node ();
11520 : : }
11521 : :
11522 : 936693 : if (get_overrun ())
11523 : 0 : return error_mark_node;
11524 : :
11525 : 936693 : if (mk < MK_indirect_lwm)
11526 : : {
11527 : 923650 : DECL_NAME (decl) = name;
11528 : 923650 : DECL_CONTEXT (decl) = FROB_CONTEXT (container);
11529 : : }
11530 : 936693 : DECL_NAME (inner) = DECL_NAME (decl);
11531 : 936693 : DECL_CONTEXT (inner) = DECL_CONTEXT (decl);
11532 : :
11533 : 936693 : if (mk == MK_partial)
11534 : : {
11535 : 20869 : for (tree spec = DECL_TEMPLATE_SPECIALIZATIONS (key.ret);
11536 : 103149 : spec; spec = TREE_CHAIN (spec))
11537 : : {
11538 : 95473 : tree tmpl = TREE_VALUE (spec);
11539 : 95473 : tree ti = get_template_info (tmpl);
11540 : 95473 : if (template_args_equal (key.args, TI_ARGS (ti))
11541 : 109614 : && cp_tree_equal (key.constraints,
11542 : : get_constraints
11543 : 14141 : (DECL_TEMPLATE_RESULT (tmpl))))
11544 : : {
11545 : : existing = tmpl;
11546 : : break;
11547 : : }
11548 : : }
11549 : : }
11550 : 915824 : else if (mk == MK_keyed
11551 : 68 : && DECL_LANG_SPECIFIC (name)
11552 : 915892 : && DECL_MODULE_KEYED_DECLS_P (name))
11553 : : {
11554 : 68 : gcc_checking_assert (TREE_CODE (container) == NAMESPACE_DECL
11555 : : || TREE_CODE (container) == TYPE_DECL);
11556 : 68 : if (auto *set = keyed_table->get (name))
11557 : 936731 : if (key.index < set->length ())
11558 : : {
11559 : 38 : existing = (*set)[key.index];
11560 : 38 : if (existing)
11561 : : {
11562 : 38 : gcc_checking_assert
11563 : : (DECL_IMPLICIT_TYPEDEF_P (existing));
11564 : 38 : if (inner != decl)
11565 : 8 : existing
11566 : 8 : = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (existing));
11567 : : }
11568 : : }
11569 : : }
11570 : : else
11571 : 915756 : switch (TREE_CODE (container))
11572 : : {
11573 : 0 : default:
11574 : 0 : gcc_unreachable ();
11575 : :
11576 : 253547 : case NAMESPACE_DECL:
11577 : 253547 : if (is_attached
11578 : 253547 : && !is_imported_temploid_friend
11579 : 253547 : && !(state->is_module () || state->is_partition ()))
11580 : : kind = "unique";
11581 : : else
11582 : : {
11583 : 252052 : gcc_checking_assert (mk == MK_named || mk == MK_enum);
11584 : 252052 : tree mvec;
11585 : 252052 : tree *vslot = mergeable_namespace_slots (container, name,
11586 : : is_attached, &mvec);
11587 : 252052 : existing = check_mergeable_decl (mk, decl, *vslot, key);
11588 : 252052 : if (!existing)
11589 : 89147 : add_mergeable_namespace_entity (vslot, decl);
11590 : : else
11591 : : {
11592 : : /* Note that we now have duplicates to deal with in
11593 : : name lookup. */
11594 : 162905 : if (is_attached)
11595 : 33 : BINDING_VECTOR_PARTITION_DUPS_P (mvec) = true;
11596 : : else
11597 : 162872 : BINDING_VECTOR_GLOBAL_DUPS_P (mvec) = true;
11598 : : }
11599 : : }
11600 : : break;
11601 : :
11602 : 5496 : case FUNCTION_DECL:
11603 : 5496 : gcc_checking_assert (mk == MK_local_type);
11604 : 5496 : existing = key_local_type (key, container, name);
11605 : 5496 : if (existing && inner != decl)
11606 : 6532 : existing = TYPE_TI_TEMPLATE (TREE_TYPE (existing));
11607 : : break;
11608 : :
11609 : 656713 : case TYPE_DECL:
11610 : 656713 : gcc_checking_assert (!is_imported_temploid_friend);
11611 : 3763 : if (is_attached && !(state->is_module () || state->is_partition ())
11612 : : /* Implicit member functions can come from
11613 : : anywhere. */
11614 : 659649 : && !(DECL_ARTIFICIAL (decl)
11615 : 1729 : && TREE_CODE (decl) == FUNCTION_DECL
11616 : 559 : && !DECL_THUNK_P (decl)))
11617 : : kind = "unique";
11618 : : else
11619 : : {
11620 : 654336 : tree ctx = TREE_TYPE (container);
11621 : :
11622 : : /* For some reason templated enumeral types are not marked
11623 : : as COMPLETE_TYPE_P, even though they have members.
11624 : : This may well be a bug elsewhere. */
11625 : 654336 : if (TREE_CODE (ctx) == ENUMERAL_TYPE)
11626 : 21973 : existing = find_enum_member (ctx, name);
11627 : 632363 : else if (COMPLETE_TYPE_P (ctx))
11628 : : {
11629 : 394298 : switch (mk)
11630 : : {
11631 : 0 : default:
11632 : 0 : gcc_unreachable ();
11633 : :
11634 : 317223 : case MK_named:
11635 : 317223 : existing = lookup_class_binding (ctx, name);
11636 : 317223 : if (existing)
11637 : : {
11638 : 316641 : tree inner = decl;
11639 : 316641 : if (TREE_CODE (inner) == TEMPLATE_DECL
11640 : 316641 : && !DECL_MEMBER_TEMPLATE_P (inner))
11641 : 150016 : inner = DECL_TEMPLATE_RESULT (inner);
11642 : :
11643 : 316641 : existing = check_mergeable_decl
11644 : 316641 : (mk, inner, existing, key);
11645 : :
11646 : 316641 : if (!existing && DECL_ALIAS_TEMPLATE_P (decl))
11647 : : {} // FIXME: Insert into specialization
11648 : : // tables, we'll need the arguments for that!
11649 : : }
11650 : : break;
11651 : :
11652 : 53104 : case MK_field:
11653 : 53104 : {
11654 : 53104 : unsigned ix = key.index;
11655 : 53104 : for (tree field = TYPE_FIELDS (ctx);
11656 : 153285 : field; field = DECL_CHAIN (field))
11657 : : {
11658 : 153285 : tree finner = STRIP_TEMPLATE (field);
11659 : 153285 : if (TREE_CODE (finner) == TREE_CODE (inner))
11660 : 71332 : if (!ix--)
11661 : : {
11662 : : existing = field;
11663 : : break;
11664 : : }
11665 : : }
11666 : : }
11667 : : break;
11668 : :
11669 : 3548 : case MK_vtable:
11670 : 3548 : {
11671 : 3548 : unsigned ix = key.index;
11672 : 3548 : for (tree vtable = CLASSTYPE_VTABLES (ctx);
11673 : 4616 : vtable; vtable = DECL_CHAIN (vtable))
11674 : 4237 : if (!ix--)
11675 : : {
11676 : : existing = vtable;
11677 : : break;
11678 : : }
11679 : : }
11680 : : break;
11681 : :
11682 : 15839 : case MK_as_base:
11683 : 15839 : {
11684 : 15839 : tree as_base = CLASSTYPE_AS_BASE (ctx);
11685 : 15839 : if (as_base && as_base != ctx)
11686 : 15839 : existing = TYPE_NAME (as_base);
11687 : : }
11688 : : break;
11689 : :
11690 : 4584 : case MK_local_friend:
11691 : 4584 : {
11692 : 4584 : unsigned ix = key.index;
11693 : 4584 : for (tree decls = CLASSTYPE_DECL_LIST (ctx);
11694 : 126790 : decls; decls = TREE_CHAIN (decls))
11695 : 126790 : if (!TREE_PURPOSE (decls) && !ix--)
11696 : : {
11697 : 4584 : existing
11698 : 4584 : = friend_from_decl_list (TREE_VALUE (decls));
11699 : 4584 : break;
11700 : : }
11701 : : }
11702 : : break;
11703 : : }
11704 : :
11705 : 394298 : if (existing && mk < MK_indirect_lwm && mk != MK_partial
11706 : 387843 : && TREE_CODE (decl) == TEMPLATE_DECL
11707 : 580613 : && !DECL_MEMBER_TEMPLATE_P (decl))
11708 : : {
11709 : 153664 : tree ti;
11710 : 153664 : if (DECL_IMPLICIT_TYPEDEF_P (existing))
11711 : 1859 : ti = TYPE_TEMPLATE_INFO (TREE_TYPE (existing));
11712 : : else
11713 : 151805 : ti = DECL_TEMPLATE_INFO (existing);
11714 : 153664 : existing = TI_TEMPLATE (ti);
11715 : : }
11716 : : }
11717 : : }
11718 : : }
11719 : : }
11720 : :
11721 : 1770183 : dump (dumper::MERGE)
11722 : 2329 : && dump ("Read:%d's %s merge key (%s) %C:%N", tag, merge_kind_name[mk],
11723 : 2329 : existing ? "matched" : kind, TREE_CODE (decl), decl);
11724 : :
11725 : : return existing;
11726 : : }
11727 : :
11728 : : void
11729 : 416809 : trees_out::binfo_mergeable (tree binfo)
11730 : : {
11731 : 416809 : tree dom = binfo;
11732 : 538145 : while (tree parent = BINFO_INHERITANCE_CHAIN (dom))
11733 : : dom = parent;
11734 : 416809 : tree type = BINFO_TYPE (dom);
11735 : 416809 : gcc_checking_assert (TYPE_BINFO (type) == dom);
11736 : 416809 : tree_node (type);
11737 : 416809 : if (streaming_p ())
11738 : : {
11739 : : unsigned ix = 0;
11740 : 235155 : for (; dom != binfo; dom = TREE_CHAIN (dom))
11741 : 64375 : ix++;
11742 : 170780 : u (ix);
11743 : : }
11744 : 416809 : }
11745 : :
11746 : : unsigned
11747 : 155068 : trees_in::binfo_mergeable (tree *type)
11748 : : {
11749 : 155068 : *type = tree_node ();
11750 : 155068 : return u ();
11751 : : }
11752 : :
11753 : : /* DECL is a just streamed mergeable decl that should match EXISTING. Check
11754 : : it does and issue an appropriate diagnostic if not. Merge any
11755 : : bits from DECL to EXISTING. This is stricter matching than
11756 : : decls_match, because we can rely on ODR-sameness, and we cannot use
11757 : : decls_match because it can cause instantiations of constraints. */
11758 : :
11759 : : bool
11760 : 910194 : trees_in::is_matching_decl (tree existing, tree decl, bool is_typedef)
11761 : : {
11762 : : // FIXME: We should probably do some duplicate decl-like stuff here
11763 : : // (beware, default parms should be the same?) Can we just call
11764 : : // duplicate_decls and teach it how to handle the module-specific
11765 : : // permitted/required duplications?
11766 : :
11767 : : // We know at this point that the decls have matched by key, so we
11768 : : // can elide some of the checking
11769 : 910194 : gcc_checking_assert (TREE_CODE (existing) == TREE_CODE (decl));
11770 : :
11771 : 910194 : tree d_inner = decl;
11772 : 910194 : tree e_inner = existing;
11773 : 910194 : if (TREE_CODE (decl) == TEMPLATE_DECL)
11774 : : {
11775 : 302941 : d_inner = DECL_TEMPLATE_RESULT (d_inner);
11776 : 302941 : e_inner = DECL_TEMPLATE_RESULT (e_inner);
11777 : 302941 : gcc_checking_assert (TREE_CODE (e_inner) == TREE_CODE (d_inner));
11778 : : }
11779 : :
11780 : 910194 : if (TREE_CODE (d_inner) == FUNCTION_DECL)
11781 : : {
11782 : 424469 : tree e_ret = fndecl_declared_return_type (existing);
11783 : 424469 : tree d_ret = fndecl_declared_return_type (decl);
11784 : :
11785 : 178725 : if (decl != d_inner && DECL_NAME (d_inner) == fun_identifier
11786 : 424485 : && LAMBDA_TYPE_P (DECL_CONTEXT (d_inner)))
11787 : : /* This has a recursive type that will compare different. */;
11788 : 424461 : else if (!same_type_p (d_ret, e_ret))
11789 : 6 : goto mismatch;
11790 : :
11791 : 424463 : tree e_type = TREE_TYPE (e_inner);
11792 : 424463 : tree d_type = TREE_TYPE (d_inner);
11793 : :
11794 : 424463 : if (DECL_EXTERN_C_P (d_inner) != DECL_EXTERN_C_P (e_inner))
11795 : 0 : goto mismatch;
11796 : :
11797 : 424463 : for (tree e_args = TYPE_ARG_TYPES (e_type),
11798 : 424463 : d_args = TYPE_ARG_TYPES (d_type);
11799 : 719942 : e_args != d_args && (e_args || d_args);
11800 : 295479 : e_args = TREE_CHAIN (e_args), d_args = TREE_CHAIN (d_args))
11801 : : {
11802 : 295479 : if (!(e_args && d_args))
11803 : 0 : goto mismatch;
11804 : :
11805 : 295479 : if (!same_type_p (TREE_VALUE (d_args), TREE_VALUE (e_args)))
11806 : 0 : goto mismatch;
11807 : : }
11808 : :
11809 : : /* If EXISTING has an undeduced or uninstantiated exception
11810 : : specification, but DECL does not, propagate the exception
11811 : : specification. Otherwise we end up asserting or trying to
11812 : : instantiate it in the middle of loading. */
11813 : 424463 : tree e_spec = TYPE_RAISES_EXCEPTIONS (e_type);
11814 : 424463 : tree d_spec = TYPE_RAISES_EXCEPTIONS (d_type);
11815 : 623165 : if (DEFERRED_NOEXCEPT_SPEC_P (e_spec))
11816 : : {
11817 : 30495 : if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec)
11818 : 60707 : || (UNEVALUATED_NOEXCEPT_SPEC_P (e_spec)
11819 : 24763 : && !UNEVALUATED_NOEXCEPT_SPEC_P (d_spec)))
11820 : : {
11821 : 283 : dump (dumper::MERGE)
11822 : 3 : && dump ("Propagating instantiated noexcept to %N", existing);
11823 : 283 : TREE_TYPE (existing) = d_type;
11824 : :
11825 : : /* Propagate to existing clones. */
11826 : 283 : tree clone;
11827 : 813 : FOR_EACH_CLONE (clone, existing)
11828 : : {
11829 : 530 : if (TREE_TYPE (clone) == e_type)
11830 : 530 : TREE_TYPE (clone) = d_type;
11831 : : else
11832 : 0 : TREE_TYPE (clone)
11833 : 0 : = build_exception_variant (TREE_TYPE (clone), d_spec);
11834 : : }
11835 : : }
11836 : : }
11837 : 170364 : else if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec)
11838 : 564332 : && !comp_except_specs (d_spec, e_spec, ce_type))
11839 : 2235 : goto mismatch;
11840 : :
11841 : : /* Similarly if EXISTING has an undeduced return type, but DECL's
11842 : : is already deduced. */
11843 : 422228 : if (undeduced_auto_decl (existing) && !undeduced_auto_decl (decl))
11844 : : {
11845 : 13 : dump (dumper::MERGE)
11846 : 0 : && dump ("Propagating deduced return type to %N", existing);
11847 : 13 : TREE_TYPE (existing) = change_return_type (TREE_TYPE (d_type), e_type);
11848 : : }
11849 : : }
11850 : 485725 : else if (is_typedef)
11851 : : {
11852 : 179732 : if (!DECL_ORIGINAL_TYPE (e_inner)
11853 : 179732 : || !same_type_p (DECL_ORIGINAL_TYPE (d_inner),
11854 : : DECL_ORIGINAL_TYPE (e_inner)))
11855 : 0 : goto mismatch;
11856 : : }
11857 : : /* Using cp_tree_equal because we can meet TYPE_ARGUMENT_PACKs
11858 : : here. I suspect the entities that directly do that are things
11859 : : that shouldn't go to duplicate_decls (FIELD_DECLs etc). */
11860 : 305993 : else if (!cp_tree_equal (TREE_TYPE (decl), TREE_TYPE (existing)))
11861 : : {
11862 : 1608 : mismatch:
11863 : 3849 : if (DECL_IS_UNDECLARED_BUILTIN (existing))
11864 : : /* Just like duplicate_decls, presum the user knows what
11865 : : they're doing in overriding a builtin. */
11866 : 2238 : TREE_TYPE (existing) = TREE_TYPE (decl);
11867 : 1611 : else if (decl_function_context (decl))
11868 : : /* The type of a mergeable local entity (such as a function scope
11869 : : capturing lambda's closure type fields) can depend on an
11870 : : unmergeable local entity (such as a local variable), so type
11871 : : equality isn't feasible in general for local entities. */;
11872 : : else
11873 : : {
11874 : : // FIXME:QOI Might be template specialization from a module,
11875 : : // not necessarily global module
11876 : 9 : auto_diagnostic_group d;
11877 : 9 : error_at (DECL_SOURCE_LOCATION (decl),
11878 : : "conflicting global module declaration %#qD", decl);
11879 : 9 : inform (DECL_SOURCE_LOCATION (existing),
11880 : : "existing declaration %#qD", existing);
11881 : 9 : return false;
11882 : 9 : }
11883 : : }
11884 : :
11885 : 910185 : if (DECL_IS_UNDECLARED_BUILTIN (existing)
11886 : 910185 : && !DECL_IS_UNDECLARED_BUILTIN (decl))
11887 : : {
11888 : : /* We're matching a builtin that the user has yet to declare.
11889 : : We are the one! This is very much duplicate-decl
11890 : : shenanigans. */
11891 : 2609 : DECL_SOURCE_LOCATION (existing) = DECL_SOURCE_LOCATION (decl);
11892 : 2609 : if (TREE_CODE (decl) != TYPE_DECL)
11893 : : {
11894 : : /* Propagate exceptions etc. */
11895 : 2589 : TREE_TYPE (existing) = TREE_TYPE (decl);
11896 : 2589 : TREE_NOTHROW (existing) = TREE_NOTHROW (decl);
11897 : : }
11898 : : /* This is actually an import! */
11899 : 2609 : DECL_MODULE_IMPORT_P (existing) = true;
11900 : :
11901 : : /* Yay, sliced! */
11902 : 2609 : existing->base = decl->base;
11903 : :
11904 : 2609 : if (TREE_CODE (decl) == FUNCTION_DECL)
11905 : : {
11906 : : /* Ew :( */
11907 : 2589 : memcpy (&existing->decl_common.size,
11908 : : &decl->decl_common.size,
11909 : : (offsetof (tree_decl_common, pt_uid)
11910 : : - offsetof (tree_decl_common, size)));
11911 : 2589 : auto bltin_class = DECL_BUILT_IN_CLASS (decl);
11912 : 2589 : existing->function_decl.built_in_class = bltin_class;
11913 : 2589 : auto fncode = DECL_UNCHECKED_FUNCTION_CODE (decl);
11914 : 2589 : DECL_UNCHECKED_FUNCTION_CODE (existing) = fncode;
11915 : 2589 : if (existing->function_decl.built_in_class == BUILT_IN_NORMAL)
11916 : : {
11917 : 2355 : if (builtin_decl_explicit_p (built_in_function (fncode)))
11918 : 2355 : switch (fncode)
11919 : : {
11920 : 0 : case BUILT_IN_STPCPY:
11921 : 0 : set_builtin_decl_implicit_p
11922 : 0 : (built_in_function (fncode), true);
11923 : 0 : break;
11924 : 2355 : default:
11925 : 2355 : set_builtin_decl_declared_p
11926 : 2355 : (built_in_function (fncode), true);
11927 : 2355 : break;
11928 : : }
11929 : 2355 : copy_attributes_to_builtin (decl);
11930 : : }
11931 : : }
11932 : : }
11933 : :
11934 : 910185 : if (VAR_OR_FUNCTION_DECL_P (decl)
11935 : 910185 : && DECL_TEMPLATE_INSTANTIATED (decl))
11936 : : /* Don't instantiate again! */
11937 : 17173 : DECL_TEMPLATE_INSTANTIATED (existing) = true;
11938 : :
11939 : 910185 : if (TREE_CODE (d_inner) == FUNCTION_DECL
11940 : 910185 : && DECL_DECLARED_INLINE_P (d_inner))
11941 : 328954 : DECL_DECLARED_INLINE_P (e_inner) = true;
11942 : 910185 : if (!DECL_EXTERNAL (d_inner))
11943 : 413162 : DECL_EXTERNAL (e_inner) = false;
11944 : :
11945 : 910185 : if (TREE_CODE (decl) == TEMPLATE_DECL)
11946 : : {
11947 : : /* Merge default template arguments. */
11948 : 302941 : tree d_parms = DECL_INNERMOST_TEMPLATE_PARMS (decl);
11949 : 302941 : tree e_parms = DECL_INNERMOST_TEMPLATE_PARMS (existing);
11950 : 302941 : gcc_checking_assert (TREE_VEC_LENGTH (d_parms)
11951 : : == TREE_VEC_LENGTH (e_parms));
11952 : 904790 : for (int i = 0; i < TREE_VEC_LENGTH (d_parms); ++i)
11953 : : {
11954 : 601858 : tree d_default = TREE_PURPOSE (TREE_VEC_ELT (d_parms, i));
11955 : 601858 : tree& e_default = TREE_PURPOSE (TREE_VEC_ELT (e_parms, i));
11956 : 601858 : if (e_default == NULL_TREE)
11957 : 503811 : e_default = d_default;
11958 : 98047 : else if (d_default != NULL_TREE
11959 : 98047 : && !cp_tree_equal (d_default, e_default))
11960 : : {
11961 : 9 : auto_diagnostic_group d;
11962 : 9 : tree d_parm = TREE_VALUE (TREE_VEC_ELT (d_parms, i));
11963 : 9 : tree e_parm = TREE_VALUE (TREE_VEC_ELT (e_parms, i));
11964 : 9 : error_at (DECL_SOURCE_LOCATION (d_parm),
11965 : : "conflicting default argument for %#qD", d_parm);
11966 : 9 : inform (DECL_SOURCE_LOCATION (e_parm),
11967 : : "existing default declared here");
11968 : 9 : return false;
11969 : 9 : }
11970 : : }
11971 : : }
11972 : :
11973 : 910176 : if (TREE_CODE (d_inner) == FUNCTION_DECL)
11974 : : {
11975 : : /* Merge default function arguments. */
11976 : 424463 : tree d_parm = FUNCTION_FIRST_USER_PARMTYPE (d_inner);
11977 : 424463 : tree e_parm = FUNCTION_FIRST_USER_PARMTYPE (e_inner);
11978 : 424463 : int i = 0;
11979 : 1022724 : for (; d_parm && d_parm != void_list_node;
11980 : 598261 : d_parm = TREE_CHAIN (d_parm), e_parm = TREE_CHAIN (e_parm), ++i)
11981 : : {
11982 : 598273 : tree d_default = TREE_PURPOSE (d_parm);
11983 : 598273 : tree& e_default = TREE_PURPOSE (e_parm);
11984 : 598273 : if (e_default == NULL_TREE)
11985 : 565355 : e_default = d_default;
11986 : 32918 : else if (d_default != NULL_TREE
11987 : 32918 : && !cp_tree_equal (d_default, e_default))
11988 : : {
11989 : 12 : auto_diagnostic_group d;
11990 : 12 : error_at (get_fndecl_argument_location (d_inner, i),
11991 : : "conflicting default argument for parameter %P of %#qD",
11992 : : i, decl);
11993 : 12 : inform (get_fndecl_argument_location (e_inner, i),
11994 : : "existing default declared here");
11995 : 12 : return false;
11996 : 12 : }
11997 : : }
11998 : : }
11999 : :
12000 : : return true;
12001 : : }
12002 : :
12003 : : /* FN is an implicit member function that we've discovered is new to
12004 : : the class. Add it to the TYPE_FIELDS chain and the method vector.
12005 : : Reset the appropriate classtype lazy flag. */
12006 : :
12007 : : bool
12008 : 1492 : trees_in::install_implicit_member (tree fn)
12009 : : {
12010 : 1492 : tree ctx = DECL_CONTEXT (fn);
12011 : 1492 : tree name = DECL_NAME (fn);
12012 : : /* We know these are synthesized, so the set of expected prototypes
12013 : : is quite restricted. We're not validating correctness, just
12014 : : distinguishing beteeen the small set of possibilities. */
12015 : 1492 : tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (fn));
12016 : 1492 : if (IDENTIFIER_CTOR_P (name))
12017 : : {
12018 : 1081 : if (CLASSTYPE_LAZY_DEFAULT_CTOR (ctx)
12019 : 1081 : && VOID_TYPE_P (parm_type))
12020 : 213 : CLASSTYPE_LAZY_DEFAULT_CTOR (ctx) = false;
12021 : 868 : else if (!TYPE_REF_P (parm_type))
12022 : : return false;
12023 : 868 : else if (CLASSTYPE_LAZY_COPY_CTOR (ctx)
12024 : 868 : && !TYPE_REF_IS_RVALUE (parm_type))
12025 : 455 : CLASSTYPE_LAZY_COPY_CTOR (ctx) = false;
12026 : 413 : else if (CLASSTYPE_LAZY_MOVE_CTOR (ctx))
12027 : 413 : CLASSTYPE_LAZY_MOVE_CTOR (ctx) = false;
12028 : : else
12029 : : return false;
12030 : : }
12031 : 411 : else if (IDENTIFIER_DTOR_P (name))
12032 : : {
12033 : 327 : if (CLASSTYPE_LAZY_DESTRUCTOR (ctx))
12034 : 327 : CLASSTYPE_LAZY_DESTRUCTOR (ctx) = false;
12035 : : else
12036 : : return false;
12037 : 327 : if (DECL_VIRTUAL_P (fn))
12038 : : /* A virtual dtor should have been created when the class
12039 : : became complete. */
12040 : : return false;
12041 : : }
12042 : 84 : else if (name == assign_op_identifier)
12043 : : {
12044 : 84 : if (!TYPE_REF_P (parm_type))
12045 : : return false;
12046 : 84 : else if (CLASSTYPE_LAZY_COPY_ASSIGN (ctx)
12047 : 84 : && !TYPE_REF_IS_RVALUE (parm_type))
12048 : 42 : CLASSTYPE_LAZY_COPY_ASSIGN (ctx) = false;
12049 : 42 : else if (CLASSTYPE_LAZY_MOVE_ASSIGN (ctx))
12050 : 42 : CLASSTYPE_LAZY_MOVE_ASSIGN (ctx) = false;
12051 : : else
12052 : : return false;
12053 : : }
12054 : : else
12055 : : return false;
12056 : :
12057 : 1522 : dump (dumper::MERGE) && dump ("Adding implicit member %N", fn);
12058 : :
12059 : 1492 : DECL_CHAIN (fn) = TYPE_FIELDS (ctx);
12060 : 1492 : TYPE_FIELDS (ctx) = fn;
12061 : :
12062 : 1492 : add_method (ctx, fn, false);
12063 : :
12064 : : /* Propagate TYPE_FIELDS. */
12065 : 1492 : fixup_type_variants (ctx);
12066 : :
12067 : 1492 : return true;
12068 : : }
12069 : :
12070 : : /* Return non-zero if DECL has a definition that would be interesting to
12071 : : write out. */
12072 : :
12073 : : static bool
12074 : 1918384 : has_definition (tree decl)
12075 : : {
12076 : 1918384 : bool is_tmpl = TREE_CODE (decl) == TEMPLATE_DECL;
12077 : 1918384 : if (is_tmpl)
12078 : 500784 : decl = DECL_TEMPLATE_RESULT (decl);
12079 : :
12080 : 1918384 : switch (TREE_CODE (decl))
12081 : : {
12082 : : default:
12083 : : break;
12084 : :
12085 : 740282 : case FUNCTION_DECL:
12086 : 740282 : if (!DECL_SAVED_TREE (decl))
12087 : : /* Not defined. */
12088 : : break;
12089 : :
12090 : 324830 : if (DECL_DECLARED_INLINE_P (decl))
12091 : : return true;
12092 : :
12093 : 25440 : if (header_module_p ())
12094 : : /* We always need to write definitions in header modules,
12095 : : since there's no TU to emit them in otherwise. */
12096 : : return true;
12097 : :
12098 : 5920 : if (DECL_TEMPLATE_INFO (decl))
12099 : : {
12100 : 5448 : int use_tpl = DECL_USE_TEMPLATE (decl);
12101 : :
12102 : : // FIXME: Partial specializations have definitions too.
12103 : 5448 : if (use_tpl < 2)
12104 : : return true;
12105 : : }
12106 : : break;
12107 : :
12108 : 782011 : case TYPE_DECL:
12109 : 782011 : {
12110 : 782011 : tree type = TREE_TYPE (decl);
12111 : 782011 : if (type == TYPE_MAIN_VARIANT (type)
12112 : 363146 : && decl == TYPE_NAME (type)
12113 : 1145157 : && (TREE_CODE (type) == ENUMERAL_TYPE
12114 : 363146 : ? TYPE_VALUES (type) : TYPE_FIELDS (type)))
12115 : : return true;
12116 : : }
12117 : : break;
12118 : :
12119 : 76837 : case VAR_DECL:
12120 : : /* DECL_INITIALIZED_P might not be set on a dependent VAR_DECL. */
12121 : 76837 : if (DECL_LANG_SPECIFIC (decl)
12122 : 76804 : && DECL_TEMPLATE_INFO (decl)
12123 : 121111 : && DECL_INITIAL (decl))
12124 : : return true;
12125 : : else
12126 : : {
12127 : 37429 : if (!DECL_INITIALIZED_P (decl))
12128 : : /* Not defined. */
12129 : : return false;
12130 : :
12131 : 30562 : if (header_module_p ())
12132 : : /* We always need to write definitions in header modules,
12133 : : since there's no TU to emit them in otherwise. */
12134 : : return true;
12135 : :
12136 : 5289 : if (decl_maybe_constant_var_p (decl))
12137 : : /* We might need its constant value. */
12138 : : return true;
12139 : :
12140 : 315 : if (vague_linkage_p (decl))
12141 : : /* These are emitted as needed. */
12142 : : return true;
12143 : :
12144 : : return false;
12145 : : }
12146 : 7476 : break;
12147 : :
12148 : 7476 : case CONCEPT_DECL:
12149 : 7476 : if (DECL_INITIAL (decl))
12150 : : return true;
12151 : :
12152 : : break;
12153 : : }
12154 : :
12155 : : return false;
12156 : : }
12157 : :
12158 : : uintptr_t *
12159 : 1001340 : trees_in::find_duplicate (tree existing)
12160 : : {
12161 : 512134 : if (!duplicates)
12162 : : return NULL;
12163 : :
12164 : 727253 : return duplicates->get (existing);
12165 : : }
12166 : :
12167 : : /* We're starting to read a duplicate DECL. EXISTING is the already
12168 : : known node. */
12169 : :
12170 : : void
12171 : 1303659 : trees_in::register_duplicate (tree decl, tree existing)
12172 : : {
12173 : 1303659 : if (!duplicates)
12174 : 212004 : duplicates = new duplicate_hash_map (40);
12175 : :
12176 : 1303659 : bool existed;
12177 : 1303659 : uintptr_t &slot = duplicates->get_or_insert (existing, &existed);
12178 : 1303659 : gcc_checking_assert (!existed);
12179 : 1303659 : slot = reinterpret_cast<uintptr_t> (decl);
12180 : :
12181 : 1303659 : if (TREE_CODE (decl) == TEMPLATE_DECL)
12182 : : /* Also register the DECL_TEMPLATE_RESULT as a duplicate so
12183 : : that passing decl's _RESULT to maybe_duplicate naturally
12184 : : gives us existing's _RESULT back. */
12185 : 605882 : register_duplicate (DECL_TEMPLATE_RESULT (decl),
12186 : 302941 : DECL_TEMPLATE_RESULT (existing));
12187 : 1303659 : }
12188 : :
12189 : : /* We've read a definition of MAYBE_EXISTING. If not a duplicate,
12190 : : return MAYBE_EXISTING (into which the definition should be
12191 : : installed). Otherwise return NULL if already known bad, or the
12192 : : duplicate we read (for ODR checking, or extracting additional merge
12193 : : information). */
12194 : :
12195 : : tree
12196 : 489206 : trees_in::odr_duplicate (tree maybe_existing, bool has_defn)
12197 : : {
12198 : 489206 : tree res = NULL_TREE;
12199 : :
12200 : 797180 : if (uintptr_t *dup = find_duplicate (maybe_existing))
12201 : : {
12202 : 296719 : if (!(*dup & 1))
12203 : 296719 : res = reinterpret_cast<tree> (*dup);
12204 : : }
12205 : : else
12206 : : res = maybe_existing;
12207 : :
12208 : 489206 : assert_definition (maybe_existing, res && !has_defn);
12209 : :
12210 : : // FIXME: We probably need to return the template, so that the
12211 : : // template header can be checked?
12212 : 489206 : return res ? STRIP_TEMPLATE (res) : NULL_TREE;
12213 : : }
12214 : :
12215 : : /* The following writer functions rely on the current behaviour of
12216 : : depset::hash::add_dependency making the decl and defn depset nodes
12217 : : depend on eachother. That way we don't have to worry about seeding
12218 : : the tree map with named decls that cannot be looked up by name (I.e
12219 : : template and function parms). We know the decl and definition will
12220 : : be in the same cluster, which is what we want. */
12221 : :
12222 : : void
12223 : 634013 : trees_out::write_function_def (tree decl)
12224 : : {
12225 : 634013 : tree_node (DECL_RESULT (decl));
12226 : :
12227 : 634013 : {
12228 : : /* The function body for a non-inline function or function template
12229 : : is ignored for determining exposures. This should only matter
12230 : : for templates (we don't emit the bodies of non-inline functions
12231 : : to begin with). */
12232 : 634013 : auto ovr = make_temp_override (dep_hash->ignore_tu_local,
12233 : 634013 : !DECL_DECLARED_INLINE_P (decl));
12234 : 634013 : tree_node (DECL_INITIAL (decl));
12235 : 634013 : tree_node (DECL_SAVED_TREE (decl));
12236 : 634013 : }
12237 : :
12238 : 1258138 : tree_node (DECL_FRIEND_CONTEXT (decl));
12239 : :
12240 : 634013 : constexpr_fundef *cexpr = retrieve_constexpr_fundef (decl);
12241 : :
12242 : 634013 : if (streaming_p ())
12243 : 316974 : u (cexpr != nullptr);
12244 : 634013 : if (cexpr)
12245 : : {
12246 : 115435 : chained_decls (cexpr->parms);
12247 : 115435 : tree_node (cexpr->result);
12248 : 115435 : tree_node (cexpr->body);
12249 : : }
12250 : :
12251 : 634013 : function* f = DECL_STRUCT_FUNCTION (decl);
12252 : :
12253 : 634013 : if (streaming_p ())
12254 : : {
12255 : 316974 : unsigned flags = 0;
12256 : :
12257 : 316974 : if (f)
12258 : 316245 : flags |= 2;
12259 : 316974 : if (DECL_NOT_REALLY_EXTERN (decl))
12260 : 99449 : flags |= 1;
12261 : :
12262 : 316974 : u (flags);
12263 : : }
12264 : :
12265 : 634013 : if (state && f)
12266 : : {
12267 : 632555 : state->write_location (*this, f->function_start_locus);
12268 : 632555 : state->write_location (*this, f->function_end_locus);
12269 : : }
12270 : 634013 : }
12271 : :
12272 : : void
12273 : 0 : trees_out::mark_function_def (tree)
12274 : : {
12275 : 0 : }
12276 : :
12277 : : bool
12278 : 313345 : trees_in::read_function_def (tree decl, tree maybe_template)
12279 : : {
12280 : 313736 : dump () && dump ("Reading function definition %N", decl);
12281 : 313345 : tree result = tree_node ();
12282 : 313345 : tree initial = tree_node ();
12283 : 313345 : tree saved = tree_node ();
12284 : 313345 : tree context = tree_node ();
12285 : 313345 : constexpr_fundef cexpr;
12286 : 313345 : post_process_data pdata {};
12287 : 313345 : pdata.decl = maybe_template;
12288 : :
12289 : 313345 : tree maybe_dup = odr_duplicate (maybe_template, DECL_SAVED_TREE (decl));
12290 : 626690 : bool installing = maybe_dup && !DECL_SAVED_TREE (decl);
12291 : :
12292 : 313345 : if (u ())
12293 : : {
12294 : 56199 : cexpr.parms = chained_decls ();
12295 : 56199 : cexpr.result = tree_node ();
12296 : 56199 : cexpr.body = tree_node ();
12297 : 56199 : cexpr.decl = decl;
12298 : : }
12299 : : else
12300 : 257146 : cexpr.decl = NULL_TREE;
12301 : :
12302 : 313345 : unsigned flags = u ();
12303 : :
12304 : 313345 : if (flags & 2)
12305 : : {
12306 : 312612 : pdata.start_locus = state->read_location (*this);
12307 : 312612 : pdata.end_locus = state->read_location (*this);
12308 : : }
12309 : :
12310 : 313345 : if (get_overrun ())
12311 : : return NULL_TREE;
12312 : :
12313 : 313345 : if (installing)
12314 : : {
12315 : 137893 : DECL_NOT_REALLY_EXTERN (decl) = flags & 1;
12316 : 137893 : DECL_RESULT (decl) = result;
12317 : 137893 : DECL_INITIAL (decl) = initial;
12318 : 137893 : DECL_SAVED_TREE (decl) = saved;
12319 : :
12320 : 137893 : if (context)
12321 : 3712 : SET_DECL_FRIEND_CONTEXT (decl, context);
12322 : 137893 : if (cexpr.decl)
12323 : 34278 : register_constexpr_fundef (cexpr);
12324 : 137893 : post_process (pdata);
12325 : : }
12326 : : else if (maybe_dup)
12327 : : {
12328 : : // FIXME:QOI Check matching defn
12329 : : }
12330 : :
12331 : : return true;
12332 : : }
12333 : :
12334 : : /* Also for CONCEPT_DECLs. */
12335 : :
12336 : : void
12337 : 127819 : trees_out::write_var_def (tree decl)
12338 : : {
12339 : : /* The initializer of a variable or variable template is ignored for
12340 : : determining exposures. */
12341 : 127819 : auto ovr = make_temp_override (dep_hash->ignore_tu_local, VAR_P (decl));
12342 : :
12343 : 127819 : tree init = DECL_INITIAL (decl);
12344 : 127819 : tree_node (init);
12345 : 127819 : if (!init)
12346 : : {
12347 : 1354 : tree dyn_init = NULL_TREE;
12348 : :
12349 : : /* We only need to write initializers in header modules. */
12350 : 2432 : if (header_module_p () && DECL_NONTRIVIALLY_INITIALIZED_P (decl))
12351 : : {
12352 : 52 : dyn_init = value_member (decl,
12353 : 52 : CP_DECL_THREAD_LOCAL_P (decl)
12354 : : ? tls_aggregates : static_aggregates);
12355 : 52 : gcc_checking_assert (dyn_init);
12356 : : /* Mark it so write_inits knows this is needed. */
12357 : 52 : TREE_LANG_FLAG_0 (dyn_init) = true;
12358 : 52 : dyn_init = TREE_PURPOSE (dyn_init);
12359 : : }
12360 : 1354 : tree_node (dyn_init);
12361 : : }
12362 : 127819 : }
12363 : :
12364 : : void
12365 : 0 : trees_out::mark_var_def (tree)
12366 : : {
12367 : 0 : }
12368 : :
12369 : : bool
12370 : 62253 : trees_in::read_var_def (tree decl, tree maybe_template)
12371 : : {
12372 : : /* Do not mark the virtual table entries as used. */
12373 : 62253 : bool vtable = VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl);
12374 : 62253 : unused += vtable;
12375 : 62253 : tree init = tree_node ();
12376 : 62253 : tree dyn_init = init ? NULL_TREE : tree_node ();
12377 : 62253 : unused -= vtable;
12378 : :
12379 : 62253 : if (get_overrun ())
12380 : : return false;
12381 : :
12382 : 62253 : bool initialized = (VAR_P (decl) ? bool (DECL_INITIALIZED_P (decl))
12383 : 6767 : : bool (DECL_INITIAL (decl)));
12384 : 62253 : tree maybe_dup = odr_duplicate (maybe_template, initialized);
12385 : 62253 : bool installing = maybe_dup && !initialized;
12386 : 62253 : if (installing)
12387 : : {
12388 : 34078 : if (DECL_EXTERNAL (decl))
12389 : 4616 : DECL_NOT_REALLY_EXTERN (decl) = true;
12390 : 34078 : if (VAR_P (decl))
12391 : : {
12392 : 31186 : DECL_INITIALIZED_P (decl) = true;
12393 : 31186 : if (maybe_dup && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (maybe_dup))
12394 : 31009 : DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
12395 : 31186 : if (DECL_IMPLICIT_INSTANTIATION (decl)
12396 : 31186 : || (DECL_CLASS_SCOPE_P (decl)
12397 : 18931 : && !DECL_VTABLE_OR_VTT_P (decl)
12398 : 16589 : && !DECL_TEMPLATE_INFO (decl)))
12399 : 11909 : note_vague_linkage_variable (decl);
12400 : : }
12401 : 34078 : DECL_INITIAL (decl) = init;
12402 : 34078 : if (!dyn_init)
12403 : : ;
12404 : 18 : else if (CP_DECL_THREAD_LOCAL_P (decl))
12405 : 0 : tls_aggregates = tree_cons (dyn_init, decl, tls_aggregates);
12406 : : else
12407 : 18 : static_aggregates = tree_cons (dyn_init, decl, static_aggregates);
12408 : : }
12409 : : else if (maybe_dup)
12410 : : {
12411 : : // FIXME:QOI Check matching defn
12412 : : }
12413 : :
12414 : : return true;
12415 : : }
12416 : :
12417 : : /* If MEMBER doesn't have an independent life outside the class,
12418 : : return it (or its TEMPLATE_DECL). Otherwise NULL. */
12419 : :
12420 : : static tree
12421 : 307142 : member_owned_by_class (tree member)
12422 : : {
12423 : 307142 : gcc_assert (DECL_P (member));
12424 : :
12425 : : /* Clones are owned by their origin. */
12426 : 307142 : if (DECL_CLONED_FUNCTION_P (member))
12427 : : return NULL;
12428 : :
12429 : 307142 : if (TREE_CODE (member) == FIELD_DECL)
12430 : : /* FIELD_DECLS can have template info in some cases. We always
12431 : : want the FIELD_DECL though, as there's never a TEMPLATE_DECL
12432 : : wrapping them. */
12433 : : return member;
12434 : :
12435 : 127267 : int use_tpl = -1;
12436 : 127267 : if (tree ti = node_template_info (member, use_tpl))
12437 : : {
12438 : : // FIXME: Don't bail on things that CANNOT have their own
12439 : : // template header. No, make sure they're in the same cluster.
12440 : 0 : if (use_tpl > 0)
12441 : : return NULL_TREE;
12442 : :
12443 : 0 : if (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == member)
12444 : 307142 : member = TI_TEMPLATE (ti);
12445 : : }
12446 : : return member;
12447 : : }
12448 : :
12449 : : void
12450 : 239575 : trees_out::write_class_def (tree defn)
12451 : : {
12452 : 239575 : gcc_assert (DECL_P (defn));
12453 : 239575 : if (streaming_p ())
12454 : 122535 : dump () && dump ("Writing class definition %N", defn);
12455 : :
12456 : 239575 : tree type = TREE_TYPE (defn);
12457 : 239575 : tree_node (TYPE_SIZE (type));
12458 : 239575 : tree_node (TYPE_SIZE_UNIT (type));
12459 : 239575 : tree_node (TYPE_VFIELD (type));
12460 : 239575 : tree_node (TYPE_BINFO (type));
12461 : :
12462 : 239575 : vec_chained_decls (TYPE_FIELDS (type));
12463 : :
12464 : : /* Every class but __as_base has a type-specific. */
12465 : 474984 : gcc_checking_assert (!TYPE_LANG_SPECIFIC (type) == IS_FAKE_BASE_TYPE (type));
12466 : :
12467 : 239575 : if (TYPE_LANG_SPECIFIC (type))
12468 : : {
12469 : 235409 : {
12470 : 235409 : vec<tree, va_gc> *v = CLASSTYPE_MEMBER_VEC (type);
12471 : 235409 : if (!v)
12472 : : {
12473 : 61585 : gcc_checking_assert (!streaming_p ());
12474 : : /* Force a class vector. */
12475 : 61585 : v = set_class_bindings (type, -1);
12476 : 61585 : gcc_checking_assert (v);
12477 : : }
12478 : :
12479 : 235409 : unsigned len = v->length ();
12480 : 235409 : if (streaming_p ())
12481 : 117686 : u (len);
12482 : 1877096 : for (unsigned ix = 0; ix != len; ix++)
12483 : : {
12484 : 1641687 : tree m = (*v)[ix];
12485 : 1641687 : if (TREE_CODE (m) == TYPE_DECL
12486 : 518599 : && DECL_ARTIFICIAL (m)
12487 : 1895084 : && TYPE_STUB_DECL (TREE_TYPE (m)) == m)
12488 : : /* This is a using-decl for a type, or an anonymous
12489 : : struct (maybe with a typedef name). Write the type. */
12490 : 16809 : m = TREE_TYPE (m);
12491 : 1641687 : tree_node (m);
12492 : : }
12493 : : }
12494 : 235409 : tree_node (CLASSTYPE_LAMBDA_EXPR (type));
12495 : :
12496 : : /* TYPE_CONTAINS_VPTR_P looks at the vbase vector, which the
12497 : : reader won't know at this point. */
12498 : 235409 : int has_vptr = TYPE_CONTAINS_VPTR_P (type);
12499 : :
12500 : 235409 : if (streaming_p ())
12501 : : {
12502 : 117686 : unsigned nvbases = vec_safe_length (CLASSTYPE_VBASECLASSES (type));
12503 : 117686 : u (nvbases);
12504 : 117686 : i (has_vptr);
12505 : : }
12506 : :
12507 : 235409 : if (has_vptr)
12508 : : {
12509 : 9226 : tree_vec (CLASSTYPE_PURE_VIRTUALS (type));
12510 : 9226 : tree_pair_vec (CLASSTYPE_VCALL_INDICES (type));
12511 : 9226 : tree_node (CLASSTYPE_KEY_METHOD (type));
12512 : : }
12513 : : }
12514 : :
12515 : 239575 : if (TYPE_LANG_SPECIFIC (type))
12516 : : {
12517 : 235409 : tree_node (CLASSTYPE_PRIMARY_BINFO (type));
12518 : :
12519 : 235409 : tree as_base = CLASSTYPE_AS_BASE (type);
12520 : 235409 : if (as_base)
12521 : 117474 : as_base = TYPE_NAME (as_base);
12522 : 235409 : tree_node (as_base);
12523 : :
12524 : : /* Write the vtables. */
12525 : 235409 : tree vtables = CLASSTYPE_VTABLES (type);
12526 : 235409 : vec_chained_decls (vtables);
12527 : 481884 : for (; vtables; vtables = TREE_CHAIN (vtables))
12528 : 11066 : write_definition (vtables);
12529 : :
12530 : 235409 : {
12531 : : /* Friend declarations in class definitions are ignored when
12532 : : determining exposures. */
12533 : 235409 : auto ovr = make_temp_override (dep_hash->ignore_tu_local, true);
12534 : :
12535 : : /* Write the friend classes. */
12536 : 235409 : tree_list (CLASSTYPE_FRIEND_CLASSES (type), false);
12537 : :
12538 : : /* Write the friend functions. */
12539 : 235409 : for (tree friends = DECL_FRIENDLIST (defn);
12540 : 260937 : friends; friends = TREE_CHAIN (friends))
12541 : : {
12542 : 25528 : tree_node (FRIEND_NAME (friends));
12543 : 25528 : tree_list (FRIEND_DECLS (friends), false);
12544 : : }
12545 : : /* End of friend fns. */
12546 : 235409 : tree_node (NULL_TREE);
12547 : 235409 : }
12548 : :
12549 : : /* Write the decl list. We don't need to ignore exposures of friend
12550 : : decls here as any such decls should already have been added and
12551 : : ignored above. */
12552 : 235409 : tree_list (CLASSTYPE_DECL_LIST (type), true);
12553 : :
12554 : 235409 : if (TYPE_CONTAINS_VPTR_P (type))
12555 : : {
12556 : : /* Write the thunks. */
12557 : 9226 : for (tree decls = TYPE_FIELDS (type);
12558 : 267920 : decls; decls = DECL_CHAIN (decls))
12559 : 258694 : if (TREE_CODE (decls) == FUNCTION_DECL
12560 : 187720 : && DECL_VIRTUAL_P (decls)
12561 : 307938 : && DECL_THUNKS (decls))
12562 : : {
12563 : 1836 : tree_node (decls);
12564 : : /* Thunks are always unique, so chaining is ok. */
12565 : 1836 : chained_decls (DECL_THUNKS (decls));
12566 : : }
12567 : 9226 : tree_node (NULL_TREE);
12568 : : }
12569 : : }
12570 : 239575 : }
12571 : :
12572 : : void
12573 : 307142 : trees_out::mark_class_member (tree member, bool do_defn)
12574 : : {
12575 : 307142 : gcc_assert (DECL_P (member));
12576 : :
12577 : 307142 : member = member_owned_by_class (member);
12578 : 307142 : if (member)
12579 : 614284 : mark_declaration (member, do_defn && has_definition (member));
12580 : 307142 : }
12581 : :
12582 : : void
12583 : 239575 : trees_out::mark_class_def (tree defn)
12584 : : {
12585 : 239575 : gcc_assert (DECL_P (defn));
12586 : 239575 : tree type = TREE_TYPE (defn);
12587 : : /* Mark the class members that are not type-decls and cannot have
12588 : : independent definitions. */
12589 : 2570550 : for (tree member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
12590 : 2330975 : if (TREE_CODE (member) == FIELD_DECL
12591 : 2330975 : || TREE_CODE (member) == USING_DECL
12592 : : /* A cloned enum-decl from 'using enum unrelated;' */
12593 : 2330975 : || (TREE_CODE (member) == CONST_DECL
12594 : 11678 : && DECL_CONTEXT (member) == type))
12595 : : {
12596 : 307142 : mark_class_member (member);
12597 : 307142 : if (TREE_CODE (member) == FIELD_DECL)
12598 : 179875 : if (tree repr = DECL_BIT_FIELD_REPRESENTATIVE (member))
12599 : : /* If we're marking a class template definition, then
12600 : : this'll contain the width (as set by grokbitfield)
12601 : : instead of a decl. */
12602 : 3154 : if (DECL_P (repr))
12603 : 2702 : mark_declaration (repr, false);
12604 : : }
12605 : :
12606 : : /* Mark the binfo hierarchy. */
12607 : 576742 : for (tree child = TYPE_BINFO (type); child; child = TREE_CHAIN (child))
12608 : 337167 : mark_by_value (child);
12609 : :
12610 : 239575 : if (TYPE_LANG_SPECIFIC (type))
12611 : : {
12612 : 235409 : for (tree vtable = CLASSTYPE_VTABLES (type);
12613 : 246475 : vtable; vtable = TREE_CHAIN (vtable))
12614 : 11066 : mark_declaration (vtable, true);
12615 : :
12616 : 235409 : if (TYPE_CONTAINS_VPTR_P (type))
12617 : : /* Mark the thunks, they belong to the class definition,
12618 : : /not/ the thunked-to function. */
12619 : 9226 : for (tree decls = TYPE_FIELDS (type);
12620 : 267920 : decls; decls = DECL_CHAIN (decls))
12621 : 258694 : if (TREE_CODE (decls) == FUNCTION_DECL)
12622 : 187720 : for (tree thunks = DECL_THUNKS (decls);
12623 : 190160 : thunks; thunks = DECL_CHAIN (thunks))
12624 : 2440 : mark_declaration (thunks, false);
12625 : : }
12626 : 239575 : }
12627 : :
12628 : : /* Nop sorting, needed for resorting the member vec. */
12629 : :
12630 : : static void
12631 : 10728308 : nop (void *, void *, void *)
12632 : : {
12633 : 10728308 : }
12634 : :
12635 : : bool
12636 : 108442 : trees_in::read_class_def (tree defn, tree maybe_template)
12637 : : {
12638 : 108442 : gcc_assert (DECL_P (defn));
12639 : 108923 : dump () && dump ("Reading class definition %N", defn);
12640 : 108442 : tree type = TREE_TYPE (defn);
12641 : 108442 : tree size = tree_node ();
12642 : 108442 : tree size_unit = tree_node ();
12643 : 108442 : tree vfield = tree_node ();
12644 : 108442 : tree binfo = tree_node ();
12645 : 108442 : vec<tree, va_gc> *vbase_vec = NULL;
12646 : 108442 : vec<tree, va_gc> *member_vec = NULL;
12647 : 108442 : vec<tree, va_gc> *pure_virts = NULL;
12648 : 108442 : vec<tree_pair_s, va_gc> *vcall_indices = NULL;
12649 : 108442 : tree key_method = NULL_TREE;
12650 : 108442 : tree lambda = NULL_TREE;
12651 : :
12652 : : /* Read the fields. */
12653 : 108442 : vec<tree, va_heap> *fields = vec_chained_decls ();
12654 : :
12655 : 108442 : if (TYPE_LANG_SPECIFIC (type))
12656 : : {
12657 : 106328 : if (unsigned len = u ())
12658 : : {
12659 : 106328 : vec_alloc (member_vec, len);
12660 : 891919 : for (unsigned ix = 0; ix != len; ix++)
12661 : : {
12662 : 785591 : tree m = tree_node ();
12663 : 785591 : if (get_overrun ())
12664 : : break;
12665 : 785591 : if (TYPE_P (m))
12666 : 7568 : m = TYPE_STUB_DECL (m);
12667 : 785591 : member_vec->quick_push (m);
12668 : : }
12669 : : }
12670 : 106328 : lambda = tree_node ();
12671 : :
12672 : 106328 : if (!get_overrun ())
12673 : : {
12674 : 106328 : unsigned nvbases = u ();
12675 : 106328 : if (nvbases)
12676 : : {
12677 : 551 : vec_alloc (vbase_vec, nvbases);
12678 : 2618 : for (tree child = binfo; child; child = TREE_CHAIN (child))
12679 : 2067 : if (BINFO_VIRTUAL_P (child))
12680 : 551 : vbase_vec->quick_push (child);
12681 : : }
12682 : : }
12683 : :
12684 : 106328 : if (!get_overrun ())
12685 : : {
12686 : 106328 : int has_vptr = i ();
12687 : 106328 : if (has_vptr)
12688 : : {
12689 : 4584 : pure_virts = tree_vec ();
12690 : 4584 : vcall_indices = tree_pair_vec ();
12691 : 4584 : key_method = tree_node ();
12692 : : }
12693 : : }
12694 : : }
12695 : :
12696 : 108442 : tree maybe_dup = odr_duplicate (maybe_template, TYPE_SIZE (type));
12697 : 108442 : bool installing = maybe_dup && !TYPE_SIZE (type);
12698 : 45101 : if (installing)
12699 : : {
12700 : 45101 : if (maybe_dup != defn)
12701 : : {
12702 : : // FIXME: This is needed on other defns too, almost
12703 : : // duplicate-decl like? See is_matching_decl too.
12704 : : /* Copy flags from the duplicate. */
12705 : 390 : tree type_dup = TREE_TYPE (maybe_dup);
12706 : :
12707 : : /* Core pieces. */
12708 : 390 : TYPE_MODE_RAW (type) = TYPE_MODE_RAW (type_dup);
12709 : 390 : TYPE_ALIGN_RAW (type) = TYPE_ALIGN_RAW (type_dup);
12710 : 780 : TYPE_WARN_IF_NOT_ALIGN_RAW (type)
12711 : 390 : = TYPE_WARN_IF_NOT_ALIGN_RAW (type_dup);
12712 : 390 : TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (type_dup);
12713 : :
12714 : 390 : SET_DECL_MODE (defn, DECL_MODE (maybe_dup));
12715 : 390 : DECL_SIZE (defn) = DECL_SIZE (maybe_dup);
12716 : 390 : DECL_SIZE_UNIT (defn) = DECL_SIZE_UNIT (maybe_dup);
12717 : 390 : DECL_ALIGN_RAW (defn) = DECL_ALIGN_RAW (maybe_dup);
12718 : 780 : DECL_WARN_IF_NOT_ALIGN_RAW (defn)
12719 : 390 : = DECL_WARN_IF_NOT_ALIGN_RAW (maybe_dup);
12720 : 390 : DECL_USER_ALIGN (defn) = DECL_USER_ALIGN (maybe_dup);
12721 : :
12722 : 390 : TYPE_TYPELESS_STORAGE (type) = TYPE_TYPELESS_STORAGE (type_dup);
12723 : 390 : TYPE_CXX_ODR_P (type) = TYPE_CXX_ODR_P (type_dup);
12724 : 390 : TYPE_NO_FORCE_BLK (type) = TYPE_NO_FORCE_BLK (type_dup);
12725 : 390 : TYPE_TRANSPARENT_AGGR (type) = TYPE_TRANSPARENT_AGGR (type_dup);
12726 : 780 : TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type)
12727 : 390 : = TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type_dup);
12728 : :
12729 : 390 : TYPE_EMPTY_P (type) = TYPE_EMPTY_P (type_dup);
12730 : 390 : TREE_ADDRESSABLE (type) = TREE_ADDRESSABLE (type_dup);
12731 : :
12732 : : /* C++ pieces. */
12733 : 390 : TYPE_POLYMORPHIC_P (type) = TYPE_POLYMORPHIC_P (type_dup);
12734 : 390 : CLASSTYPE_FINAL (type) = CLASSTYPE_FINAL (type_dup);
12735 : :
12736 : 780 : TYPE_HAS_USER_CONSTRUCTOR (type)
12737 : 390 : = TYPE_HAS_USER_CONSTRUCTOR (type_dup);
12738 : 780 : TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
12739 : 390 : = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type_dup);
12740 : 780 : TYPE_NEEDS_CONSTRUCTING (type)
12741 : 390 : = TYPE_NEEDS_CONSTRUCTING (type_dup);
12742 : :
12743 : 390 : if (auto ls = TYPE_LANG_SPECIFIC (type_dup))
12744 : : {
12745 : 390 : if (TYPE_LANG_SPECIFIC (type))
12746 : : {
12747 : 1170 : CLASSTYPE_BEFRIENDING_CLASSES (type_dup)
12748 : 390 : = CLASSTYPE_BEFRIENDING_CLASSES (type);
12749 : 390 : if (!ANON_AGGR_TYPE_P (type))
12750 : 1170 : CLASSTYPE_TYPEINFO_VAR (type_dup)
12751 : 390 : = CLASSTYPE_TYPEINFO_VAR (type);
12752 : : }
12753 : 2001 : for (tree v = type; v; v = TYPE_NEXT_VARIANT (v))
12754 : 1611 : TYPE_LANG_SPECIFIC (v) = ls;
12755 : : }
12756 : : }
12757 : :
12758 : 45101 : TYPE_SIZE (type) = size;
12759 : 45101 : TYPE_SIZE_UNIT (type) = size_unit;
12760 : :
12761 : 45101 : if (fields)
12762 : : {
12763 : 45101 : tree *chain = &TYPE_FIELDS (type);
12764 : 45101 : unsigned len = fields->length ();
12765 : 489442 : for (unsigned ix = 0; ix != len; ix++)
12766 : : {
12767 : 444341 : tree decl = (*fields)[ix];
12768 : :
12769 : 444341 : if (!decl)
12770 : : {
12771 : : /* An anonymous struct with typedef name. */
12772 : 3 : tree tdef = (*fields)[ix+1];
12773 : 3 : decl = TYPE_STUB_DECL (TREE_TYPE (tdef));
12774 : 3 : gcc_checking_assert (IDENTIFIER_ANON_P (DECL_NAME (decl))
12775 : : && decl != tdef);
12776 : : }
12777 : :
12778 : 807811 : gcc_checking_assert (!*chain == !DECL_CLONED_FUNCTION_P (decl));
12779 : 444341 : *chain = decl;
12780 : 444341 : chain = &DECL_CHAIN (decl);
12781 : :
12782 : 444341 : if (TREE_CODE (decl) == FIELD_DECL
12783 : 444341 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
12784 : : {
12785 : 226 : tree anon_type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12786 : 226 : if (DECL_NAME (defn) == as_base_identifier)
12787 : : /* ANON_AGGR_TYPE_FIELD should already point to the
12788 : : original FIELD_DECL; don't overwrite it to point
12789 : : to the as-base FIELD_DECL copy. */
12790 : 11 : gcc_checking_assert (ANON_AGGR_TYPE_FIELD (anon_type));
12791 : : else
12792 : 215 : ANON_AGGR_TYPE_FIELD (anon_type) = decl;
12793 : : }
12794 : :
12795 : 444341 : if (TREE_CODE (decl) == USING_DECL
12796 : 444341 : && TREE_CODE (USING_DECL_SCOPE (decl)) == RECORD_TYPE)
12797 : : {
12798 : : /* Reconstruct DECL_ACCESS. */
12799 : 21225 : tree decls = USING_DECL_DECLS (decl);
12800 : 21225 : tree access = declared_access (decl);
12801 : :
12802 : 24313 : for (ovl_iterator iter (decls); iter; ++iter)
12803 : : {
12804 : 1977 : tree d = *iter;
12805 : :
12806 : 1977 : retrofit_lang_decl (d);
12807 : 1977 : tree list = DECL_ACCESS (d);
12808 : :
12809 : 1977 : if (!purpose_member (type, list))
12810 : 2290 : DECL_ACCESS (d) = tree_cons (type, access, list);
12811 : : }
12812 : : }
12813 : : }
12814 : : }
12815 : :
12816 : 45101 : TYPE_VFIELD (type) = vfield;
12817 : 45101 : TYPE_BINFO (type) = binfo;
12818 : :
12819 : 45101 : if (TYPE_LANG_SPECIFIC (type))
12820 : : {
12821 : 44225 : CLASSTYPE_LAMBDA_EXPR (type) = lambda;
12822 : :
12823 : 44225 : CLASSTYPE_MEMBER_VEC (type) = member_vec;
12824 : 44225 : CLASSTYPE_PURE_VIRTUALS (type) = pure_virts;
12825 : 44225 : CLASSTYPE_VCALL_INDICES (type) = vcall_indices;
12826 : :
12827 : 44225 : CLASSTYPE_KEY_METHOD (type) = key_method;
12828 : :
12829 : 44225 : CLASSTYPE_VBASECLASSES (type) = vbase_vec;
12830 : :
12831 : : /* Resort the member vector. */
12832 : 44225 : resort_type_member_vec (member_vec, NULL, nop, NULL);
12833 : : }
12834 : : }
12835 : : else if (maybe_dup)
12836 : : {
12837 : : // FIXME:QOI Check matching defn
12838 : : }
12839 : :
12840 : 108442 : if (TYPE_LANG_SPECIFIC (type))
12841 : : {
12842 : 106328 : tree primary = tree_node ();
12843 : 106328 : tree as_base = tree_node ();
12844 : :
12845 : 106328 : if (as_base)
12846 : 53342 : as_base = TREE_TYPE (as_base);
12847 : :
12848 : : /* Read the vtables. */
12849 : 106328 : vec<tree, va_heap> *vtables = vec_chained_decls ();
12850 : 106328 : if (vtables)
12851 : : {
12852 : 4510 : unsigned len = vtables->length ();
12853 : 10021 : for (unsigned ix = 0; ix != len; ix++)
12854 : : {
12855 : 5511 : tree vtable = (*vtables)[ix];
12856 : 5511 : read_var_def (vtable, vtable);
12857 : : }
12858 : : }
12859 : :
12860 : 106328 : tree friend_classes = tree_list (false);
12861 : 106328 : tree friend_functions = NULL_TREE;
12862 : 106328 : for (tree *chain = &friend_functions;
12863 : 118946 : tree name = tree_node (); chain = &TREE_CHAIN (*chain))
12864 : : {
12865 : 12618 : tree val = tree_list (false);
12866 : 12618 : *chain = build_tree_list (name, val);
12867 : 12618 : }
12868 : 106328 : tree decl_list = tree_list (true);
12869 : :
12870 : 106328 : if (installing)
12871 : : {
12872 : 44225 : CLASSTYPE_PRIMARY_BINFO (type) = primary;
12873 : 44225 : CLASSTYPE_AS_BASE (type) = as_base;
12874 : :
12875 : 44225 : if (vtables)
12876 : : {
12877 : 1918 : if ((!CLASSTYPE_KEY_METHOD (type)
12878 : : /* Sneaky user may have defined it inline
12879 : : out-of-class. */
12880 : 653 : || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type)))
12881 : : /* An imported non-template class attached to a module
12882 : : doesn't need to have its vtables emitted here. */
12883 : 1924 : && (CLASSTYPE_USE_TEMPLATE (type)
12884 : 123 : || !DECL_MODULE_ATTACH_P (defn)))
12885 : 1232 : vec_safe_push (keyed_classes, type);
12886 : 1918 : unsigned len = vtables->length ();
12887 : 1918 : tree *chain = &CLASSTYPE_VTABLES (type);
12888 : 4260 : for (unsigned ix = 0; ix != len; ix++)
12889 : : {
12890 : 2342 : tree vtable = (*vtables)[ix];
12891 : 2342 : gcc_checking_assert (!*chain);
12892 : 2342 : *chain = vtable;
12893 : 2342 : chain = &DECL_CHAIN (vtable);
12894 : : }
12895 : : }
12896 : 44225 : CLASSTYPE_FRIEND_CLASSES (type) = friend_classes;
12897 : 44225 : DECL_FRIENDLIST (defn) = friend_functions;
12898 : 44225 : CLASSTYPE_DECL_LIST (type) = decl_list;
12899 : :
12900 : 46668 : for (; friend_classes; friend_classes = TREE_CHAIN (friend_classes))
12901 : : {
12902 : 2443 : tree f = TREE_VALUE (friend_classes);
12903 : 2443 : if (TREE_CODE (f) == TEMPLATE_DECL)
12904 : 912 : f = TREE_TYPE (f);
12905 : :
12906 : 2443 : if (CLASS_TYPE_P (f))
12907 : : {
12908 : 2412 : CLASSTYPE_BEFRIENDING_CLASSES (f)
12909 : 4824 : = tree_cons (NULL_TREE, type,
12910 : 2412 : CLASSTYPE_BEFRIENDING_CLASSES (f));
12911 : 2449 : dump () && dump ("Class %N befriending %C:%N",
12912 : 6 : type, TREE_CODE (f), f);
12913 : : }
12914 : : }
12915 : :
12916 : 49066 : for (; friend_functions;
12917 : 4841 : friend_functions = TREE_CHAIN (friend_functions))
12918 : 4841 : for (tree friend_decls = TREE_VALUE (friend_functions);
12919 : 10790 : friend_decls; friend_decls = TREE_CHAIN (friend_decls))
12920 : : {
12921 : 5949 : tree f = TREE_VALUE (friend_decls);
12922 : 5949 : if (TREE_CODE (f) == TU_LOCAL_ENTITY)
12923 : 36 : continue;
12924 : :
12925 : 5913 : DECL_BEFRIENDING_CLASSES (f)
12926 : 5913 : = tree_cons (NULL_TREE, type, DECL_BEFRIENDING_CLASSES (f));
12927 : 5976 : dump () && dump ("Class %N befriending %C:%N",
12928 : 27 : type, TREE_CODE (f), f);
12929 : : }
12930 : : }
12931 : :
12932 : 106328 : if (TYPE_CONTAINS_VPTR_P (type))
12933 : : /* Read and install the thunks. */
12934 : 5490 : while (tree vfunc = tree_node ())
12935 : : {
12936 : 906 : tree thunks = chained_decls ();
12937 : 906 : if (installing)
12938 : 378 : SET_DECL_THUNKS (vfunc, thunks);
12939 : : }
12940 : :
12941 : 106328 : vec_free (vtables);
12942 : : }
12943 : :
12944 : : /* Propagate to all variants. */
12945 : 108442 : if (installing)
12946 : 45101 : fixup_type_variants (type);
12947 : :
12948 : : /* IS_FAKE_BASE_TYPE is inaccurate at this point, because if this is
12949 : : the fake base, we've not hooked it into the containing class's
12950 : : data structure yet. Fortunately it has a unique name. */
12951 : 45101 : if (installing
12952 : 45101 : && DECL_NAME (defn) != as_base_identifier
12953 : 44225 : && (!CLASSTYPE_TEMPLATE_INFO (type)
12954 : 38574 : || !uses_template_parms (TI_ARGS (CLASSTYPE_TEMPLATE_INFO (type)))))
12955 : : /* Emit debug info. It'd be nice to know if the interface TU
12956 : : already emitted this. */
12957 : 24531 : rest_of_type_compilation (type, !LOCAL_CLASS_P (type));
12958 : :
12959 : 108442 : vec_free (fields);
12960 : :
12961 : 108442 : return !get_overrun ();
12962 : : }
12963 : :
12964 : : void
12965 : 12039 : trees_out::write_enum_def (tree decl)
12966 : : {
12967 : 12039 : tree type = TREE_TYPE (decl);
12968 : :
12969 : 12039 : tree_node (TYPE_VALUES (type));
12970 : : /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
12971 : : ENUMERAL_TYPE. */
12972 : 12039 : }
12973 : :
12974 : : void
12975 : 12039 : trees_out::mark_enum_def (tree decl)
12976 : : {
12977 : 12039 : tree type = TREE_TYPE (decl);
12978 : :
12979 : 58426 : for (tree values = TYPE_VALUES (type); values; values = TREE_CHAIN (values))
12980 : : {
12981 : 46387 : tree cst = TREE_VALUE (values);
12982 : 46387 : mark_by_value (cst);
12983 : : /* We must mark the init to avoid circularity in tt_enum_int. */
12984 : 46387 : if (tree init = DECL_INITIAL (cst))
12985 : 45927 : if (TREE_CODE (init) == INTEGER_CST)
12986 : 45083 : mark_by_value (init);
12987 : : }
12988 : 12039 : }
12989 : :
12990 : : bool
12991 : 5166 : trees_in::read_enum_def (tree defn, tree maybe_template)
12992 : : {
12993 : 5166 : tree type = TREE_TYPE (defn);
12994 : 5166 : tree values = tree_node ();
12995 : :
12996 : 5166 : if (get_overrun ())
12997 : : return false;
12998 : :
12999 : 5166 : tree maybe_dup = odr_duplicate (maybe_template, TYPE_VALUES (type));
13000 : 10332 : bool installing = maybe_dup && !TYPE_VALUES (type);
13001 : :
13002 : 5166 : if (installing)
13003 : : {
13004 : 2017 : TYPE_VALUES (type) = values;
13005 : : /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
13006 : : ENUMERAL_TYPE. */
13007 : :
13008 : 3368 : rest_of_type_compilation (type, DECL_NAMESPACE_SCOPE_P (defn));
13009 : : }
13010 : 3149 : else if (maybe_dup)
13011 : : {
13012 : 3149 : tree known = TYPE_VALUES (type);
13013 : 16817 : for (; known && values;
13014 : 13668 : known = TREE_CHAIN (known), values = TREE_CHAIN (values))
13015 : : {
13016 : 13677 : tree known_decl = TREE_VALUE (known);
13017 : 13677 : tree new_decl = TREE_VALUE (values);
13018 : :
13019 : 13677 : if (DECL_NAME (known_decl) != DECL_NAME (new_decl))
13020 : : break;
13021 : :
13022 : 13671 : new_decl = maybe_duplicate (new_decl);
13023 : :
13024 : 13671 : if (!cp_tree_equal (DECL_INITIAL (known_decl),
13025 : 13671 : DECL_INITIAL (new_decl)))
13026 : : break;
13027 : : }
13028 : :
13029 : 3149 : if (known || values)
13030 : : {
13031 : 12 : auto_diagnostic_group d;
13032 : 12 : error_at (DECL_SOURCE_LOCATION (maybe_dup),
13033 : : "definition of %qD does not match", maybe_dup);
13034 : 12 : inform (DECL_SOURCE_LOCATION (defn),
13035 : : "existing definition %qD", defn);
13036 : :
13037 : 12 : tree known_decl = NULL_TREE, new_decl = NULL_TREE;
13038 : :
13039 : 12 : if (known)
13040 : 9 : known_decl = TREE_VALUE (known);
13041 : 12 : if (values)
13042 : 12 : new_decl = maybe_duplicate (TREE_VALUE (values));
13043 : :
13044 : 12 : if (known_decl && new_decl)
13045 : : {
13046 : 9 : inform (DECL_SOURCE_LOCATION (new_decl),
13047 : : "enumerator %qD does not match ...", new_decl);
13048 : 9 : inform (DECL_SOURCE_LOCATION (known_decl),
13049 : : "... this enumerator %qD", known_decl);
13050 : : }
13051 : 3 : else if (known_decl || new_decl)
13052 : : {
13053 : 3 : tree extra = known_decl ? known_decl : new_decl;
13054 : 3 : inform (DECL_SOURCE_LOCATION (extra),
13055 : : "additional enumerators beginning with %qD", extra);
13056 : : }
13057 : : else
13058 : 0 : inform (DECL_SOURCE_LOCATION (maybe_dup),
13059 : : "enumeration range differs");
13060 : :
13061 : : /* Mark it bad. */
13062 : 12 : unmatched_duplicate (maybe_template);
13063 : 12 : }
13064 : : }
13065 : :
13066 : : return true;
13067 : : }
13068 : :
13069 : : /* Write out the body of DECL. See above circularity note. */
13070 : :
13071 : : void
13072 : 1013446 : trees_out::write_definition (tree decl, bool refs_tu_local)
13073 : : {
13074 : 1013446 : auto ovr = make_temp_override (writing_local_entities,
13075 : 1013446 : writing_local_entities || refs_tu_local);
13076 : :
13077 : 1013446 : if (streaming_p ())
13078 : : {
13079 : 506665 : assert_definition (decl);
13080 : 506665 : dump ()
13081 : 11347 : && dump ("Writing definition %C:%N", TREE_CODE (decl), decl);
13082 : : }
13083 : : else
13084 : 506781 : dump (dumper::DEPEND)
13085 : 10861 : && dump ("Depending definition %C:%N", TREE_CODE (decl), decl);
13086 : :
13087 : 1613911 : again:
13088 : 1613911 : switch (TREE_CODE (decl))
13089 : : {
13090 : 0 : default:
13091 : 0 : gcc_unreachable ();
13092 : :
13093 : 600465 : case TEMPLATE_DECL:
13094 : 600465 : decl = DECL_TEMPLATE_RESULT (decl);
13095 : 600465 : goto again;
13096 : :
13097 : 634013 : case FUNCTION_DECL:
13098 : 634013 : write_function_def (decl);
13099 : 634013 : break;
13100 : :
13101 : 251614 : case TYPE_DECL:
13102 : 251614 : {
13103 : 251614 : tree type = TREE_TYPE (decl);
13104 : 251614 : gcc_assert (TYPE_MAIN_VARIANT (type) == type
13105 : : && TYPE_NAME (type) == decl);
13106 : 251614 : if (TREE_CODE (type) == ENUMERAL_TYPE)
13107 : 12039 : write_enum_def (decl);
13108 : : else
13109 : 239575 : write_class_def (decl);
13110 : : }
13111 : : break;
13112 : :
13113 : 127819 : case VAR_DECL:
13114 : 127819 : case CONCEPT_DECL:
13115 : 127819 : write_var_def (decl);
13116 : 127819 : break;
13117 : : }
13118 : 1013446 : }
13119 : :
13120 : : /* Mark a declaration for by-value walking. If DO_DEFN is true, mark
13121 : : its body too. */
13122 : :
13123 : : void
13124 : 4443550 : trees_out::mark_declaration (tree decl, bool do_defn)
13125 : : {
13126 : 4443550 : mark_by_value (decl);
13127 : :
13128 : 4443550 : if (TREE_CODE (decl) == TEMPLATE_DECL)
13129 : 1485557 : decl = DECL_TEMPLATE_RESULT (decl);
13130 : :
13131 : 4443550 : if (!do_defn)
13132 : : return;
13133 : :
13134 : 1013446 : switch (TREE_CODE (decl))
13135 : : {
13136 : 0 : default:
13137 : 0 : gcc_unreachable ();
13138 : :
13139 : : case FUNCTION_DECL:
13140 : : mark_function_def (decl);
13141 : : break;
13142 : :
13143 : 251614 : case TYPE_DECL:
13144 : 251614 : {
13145 : 251614 : tree type = TREE_TYPE (decl);
13146 : 251614 : gcc_assert (TYPE_MAIN_VARIANT (type) == type
13147 : : && TYPE_NAME (type) == decl);
13148 : 251614 : if (TREE_CODE (type) == ENUMERAL_TYPE)
13149 : 12039 : mark_enum_def (decl);
13150 : : else
13151 : 239575 : mark_class_def (decl);
13152 : : }
13153 : : break;
13154 : :
13155 : : case VAR_DECL:
13156 : : case CONCEPT_DECL:
13157 : : mark_var_def (decl);
13158 : : break;
13159 : : }
13160 : : }
13161 : :
13162 : : /* Read in the body of DECL. See above circularity note. */
13163 : :
13164 : : bool
13165 : 483695 : trees_in::read_definition (tree decl)
13166 : : {
13167 : 484683 : dump () && dump ("Reading definition %C %N", TREE_CODE (decl), decl);
13168 : :
13169 : : tree maybe_template = decl;
13170 : :
13171 : 483695 : again:
13172 : 774032 : switch (TREE_CODE (decl))
13173 : : {
13174 : : default:
13175 : : break;
13176 : :
13177 : 290337 : case TEMPLATE_DECL:
13178 : 290337 : decl = DECL_TEMPLATE_RESULT (decl);
13179 : 290337 : goto again;
13180 : :
13181 : 313345 : case FUNCTION_DECL:
13182 : 313345 : return read_function_def (decl, maybe_template);
13183 : :
13184 : 113608 : case TYPE_DECL:
13185 : 113608 : {
13186 : 113608 : tree type = TREE_TYPE (decl);
13187 : 113608 : gcc_assert (TYPE_MAIN_VARIANT (type) == type
13188 : : && TYPE_NAME (type) == decl);
13189 : 113608 : if (TREE_CODE (type) == ENUMERAL_TYPE)
13190 : 5166 : return read_enum_def (decl, maybe_template);
13191 : : else
13192 : 108442 : return read_class_def (decl, maybe_template);
13193 : : }
13194 : 56742 : break;
13195 : :
13196 : 56742 : case VAR_DECL:
13197 : 56742 : case CONCEPT_DECL:
13198 : 56742 : return read_var_def (decl, maybe_template);
13199 : : }
13200 : :
13201 : : return false;
13202 : : }
13203 : :
13204 : : /* Lookup an maybe insert a slot for depset for KEY. */
13205 : :
13206 : : depset **
13207 : 21019727 : depset::hash::entity_slot (tree entity, bool insert)
13208 : : {
13209 : 21019727 : traits::compare_type key (entity, NULL);
13210 : 31840365 : depset **slot = find_slot_with_hash (key, traits::hash (key),
13211 : : insert ? INSERT : NO_INSERT);
13212 : :
13213 : 21019727 : return slot;
13214 : : }
13215 : :
13216 : : depset **
13217 : 265923 : depset::hash::binding_slot (tree ctx, tree name, bool insert)
13218 : : {
13219 : 265923 : traits::compare_type key (ctx, name);
13220 : 318227 : depset **slot = find_slot_with_hash (key, traits::hash (key),
13221 : : insert ? INSERT : NO_INSERT);
13222 : :
13223 : 265923 : return slot;
13224 : : }
13225 : :
13226 : : depset *
13227 : 10319854 : depset::hash::find_dependency (tree decl)
13228 : : {
13229 : 10319854 : depset **slot = entity_slot (decl, false);
13230 : :
13231 : 10319854 : return slot ? *slot : NULL;
13232 : : }
13233 : :
13234 : : depset *
13235 : 52304 : depset::hash::find_binding (tree ctx, tree name)
13236 : : {
13237 : 52304 : depset **slot = binding_slot (ctx, name, false);
13238 : :
13239 : 52304 : return slot ? *slot : NULL;
13240 : : }
13241 : :
13242 : : /* Returns true if DECL is a TU-local entity, as defined by [basic.link].
13243 : : If EXPLAIN is true, emit an informative note about why DECL is TU-local. */
13244 : :
13245 : : bool
13246 : 1093689 : depset::hash::is_tu_local_entity (tree decl, bool explain/*=false*/)
13247 : : {
13248 : 1093689 : gcc_checking_assert (DECL_P (decl));
13249 : :
13250 : : /* An explicit type alias is not an entity, and so is never TU-local.
13251 : : Neither are the built-in declarations of 'int' and such. */
13252 : 1093689 : if (TREE_CODE (decl) == TYPE_DECL
13253 : 527422 : && !DECL_SELF_REFERENCE_P (decl)
13254 : 1596280 : && !DECL_IMPLICIT_TYPEDEF_P (decl))
13255 : : return false;
13256 : :
13257 : 823502 : location_t loc = DECL_SOURCE_LOCATION (decl);
13258 : 823502 : tree type = TREE_TYPE (decl);
13259 : :
13260 : : /* Check specializations first for slightly better explanations. */
13261 : 823502 : int use_tpl = -1;
13262 : 823502 : tree ti = node_template_info (decl, use_tpl);
13263 : 1123736 : if (use_tpl > 0 && TREE_CODE (TI_TEMPLATE (ti)) == TEMPLATE_DECL)
13264 : : {
13265 : : /* A specialization of a TU-local template. */
13266 : 300216 : tree tmpl = TI_TEMPLATE (ti);
13267 : 300216 : if (is_tu_local_entity (tmpl))
13268 : : {
13269 : 42 : if (explain)
13270 : : {
13271 : 9 : inform (loc, "%qD is a specialization of TU-local template %qD",
13272 : : decl, tmpl);
13273 : 9 : is_tu_local_entity (tmpl, /*explain=*/true);
13274 : : }
13275 : 42 : return true;
13276 : : }
13277 : :
13278 : : /* A specialization of a template with any TU-local template argument. */
13279 : 300174 : if (has_tu_local_tmpl_arg (decl, TI_ARGS (ti), explain))
13280 : : return true;
13281 : :
13282 : : /* FIXME A specialization of a template whose (possibly instantiated)
13283 : : declaration is an exposure. This should always be covered by the
13284 : : above cases?? */
13285 : : }
13286 : :
13287 : : /* A type, function, variable, or template with internal linkage. */
13288 : 823433 : linkage_kind kind = decl_linkage (decl);
13289 : 823433 : if (kind == lk_internal
13290 : : /* But although weakrefs are marked static, don't consider them
13291 : : to be TU-local. */
13292 : 823433 : && !lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
13293 : : {
13294 : 519 : if (explain)
13295 : 99 : inform (loc, "%qD declared with internal linkage", decl);
13296 : 519 : return true;
13297 : : }
13298 : :
13299 : : /* Does not have a name with linkage and is declared, or introduced by a
13300 : : lambda-expression, within the definition of a TU-local entity. */
13301 : 822914 : if (kind == lk_none)
13302 : : {
13303 : 24801 : tree ctx = CP_DECL_CONTEXT (decl);
13304 : 41133 : if (LAMBDA_TYPE_P (type))
13305 : 7171 : if (tree extra = LAMBDA_TYPE_EXTRA_SCOPE (type))
13306 : 24801 : ctx = extra;
13307 : :
13308 : 24801 : if (TREE_CODE (ctx) == NAMESPACE_DECL)
13309 : : {
13310 : 1011 : if (!TREE_PUBLIC (ctx))
13311 : : {
13312 : 0 : if (explain)
13313 : 0 : inform (loc, "%qD has no linkage and is declared in an "
13314 : : "anonymous namespace", decl);
13315 : 0 : return true;
13316 : : }
13317 : : }
13318 : 23790 : else if (TYPE_P (ctx))
13319 : : {
13320 : 8873 : tree ctx_decl = TYPE_MAIN_DECL (ctx);
13321 : 8873 : if (is_tu_local_entity (ctx_decl))
13322 : : {
13323 : 0 : if (explain)
13324 : : {
13325 : 0 : inform (loc, "%qD has no linkage and is declared within "
13326 : : "TU-local entity %qT", decl, ctx);
13327 : 0 : is_tu_local_entity (ctx_decl, /*explain=*/true);
13328 : : }
13329 : 0 : return true;
13330 : : }
13331 : : }
13332 : 14917 : else if (is_tu_local_entity (ctx))
13333 : : {
13334 : 21 : if (explain)
13335 : : {
13336 : 9 : inform (loc, "%qD has no linkage and is declared within "
13337 : : "TU-local entity %qD", decl, ctx);
13338 : 9 : is_tu_local_entity (ctx, /*explain=*/true);
13339 : : }
13340 : 21 : return true;
13341 : : }
13342 : : }
13343 : :
13344 : : /* A type with no name that is defined outside a class-specifier, function
13345 : : body, or initializer; or is introduced by a defining-type-specifier that
13346 : : is used to declare only TU-local entities.
13347 : :
13348 : : We consider types with names for linkage purposes as having names, since
13349 : : these aren't really TU-local. */
13350 : 822893 : if (TREE_CODE (decl) == TYPE_DECL
13351 : 514224 : && TYPE_ANON_P (type)
13352 : 7207 : && !DECL_SELF_REFERENCE_P (decl)
13353 : : /* An enum with an enumerator name for linkage. */
13354 : 829790 : && !(UNSCOPED_ENUM_P (type) && TYPE_VALUES (type)))
13355 : : {
13356 : 4875 : tree main_decl = TYPE_MAIN_DECL (type);
13357 : 9750 : if (!DECL_CLASS_SCOPE_P (main_decl)
13358 : 4741 : && !decl_function_context (main_decl)
13359 : : /* FIXME: Lambdas defined outside initializers. We'll need to more
13360 : : thoroughly set LAMBDA_TYPE_EXTRA_SCOPE to check this. */
13361 : 5113 : && !LAMBDA_TYPE_P (type))
13362 : : {
13363 : 27 : if (explain)
13364 : 12 : inform (loc, "%qT has no name and is not defined within a class, "
13365 : : "function, or initializer", type);
13366 : 27 : return true;
13367 : : }
13368 : :
13369 : : // FIXME introduced by a defining-type-specifier only declaring TU-local
13370 : : // entities; does this refer to e.g. 'static struct {} a;"? I can't
13371 : : // think of any cases where this isn't covered by earlier cases. */
13372 : : }
13373 : :
13374 : : return false;
13375 : : }
13376 : :
13377 : : /* Helper for is_tu_local_entity. Returns true if one of the ARGS of
13378 : : DECL is TU-local. Emits an explanation if EXPLAIN is true. */
13379 : :
13380 : : bool
13381 : 339032 : depset::hash::has_tu_local_tmpl_arg (tree decl, tree args, bool explain)
13382 : : {
13383 : 339032 : if (!args || TREE_CODE (args) != TREE_VEC)
13384 : : return false;
13385 : :
13386 : 912790 : for (tree a : tree_vec_range (args))
13387 : : {
13388 : 573785 : if (TREE_CODE (a) == TREE_VEC)
13389 : : {
13390 : 38858 : if (has_tu_local_tmpl_arg (decl, a, explain))
13391 : 27 : return true;
13392 : : }
13393 : 534927 : else if (!WILDCARD_TYPE_P (a))
13394 : : {
13395 : 478532 : if (DECL_P (a) && is_tu_local_entity (a))
13396 : : {
13397 : 0 : if (explain)
13398 : : {
13399 : 0 : inform (DECL_SOURCE_LOCATION (decl),
13400 : : "%qD has TU-local template argument %qD",
13401 : : decl, a);
13402 : 0 : is_tu_local_entity (a, /*explain=*/true);
13403 : : }
13404 : 0 : return true;
13405 : : }
13406 : :
13407 : 478532 : if (TYPE_P (a) && TYPE_NAME (a) && is_tu_local_entity (TYPE_NAME (a)))
13408 : : {
13409 : 12 : if (explain)
13410 : : {
13411 : 0 : inform (DECL_SOURCE_LOCATION (decl),
13412 : : "%qD has TU-local template argument %qT",
13413 : : decl, a);
13414 : 0 : is_tu_local_entity (TYPE_NAME (a), /*explain=*/true);
13415 : : }
13416 : 12 : return true;
13417 : : }
13418 : :
13419 : 478520 : if (EXPR_P (a) && is_tu_local_value (decl, a, explain))
13420 : : return true;
13421 : : }
13422 : : }
13423 : :
13424 : 339005 : return false;
13425 : : }
13426 : :
13427 : : /* Returns true if EXPR (part of the initializer for DECL) is a TU-local value
13428 : : or object. Emits an explanation if EXPLAIN is true. */
13429 : :
13430 : : bool
13431 : 34467 : depset::hash::is_tu_local_value (tree decl, tree expr, bool explain)
13432 : : {
13433 : 34467 : if (!expr)
13434 : : return false;
13435 : :
13436 : 33352 : tree e = expr;
13437 : 33352 : STRIP_ANY_LOCATION_WRAPPER (e);
13438 : 33352 : STRIP_NOPS (e);
13439 : 33352 : if (TREE_CODE (e) == TARGET_EXPR)
13440 : 0 : e = TARGET_EXPR_INITIAL (e);
13441 : 0 : if (!e)
13442 : : return false;
13443 : :
13444 : : /* It is, or is a pointer to, a TU-local function or the object associated
13445 : : with a TU-local variable. */
13446 : 33352 : tree object = NULL_TREE;
13447 : 33352 : if (TREE_CODE (e) == ADDR_EXPR)
13448 : 69 : object = TREE_OPERAND (e, 0);
13449 : 33283 : else if (TREE_CODE (e) == PTRMEM_CST)
13450 : 0 : object = PTRMEM_CST_MEMBER (e);
13451 : 33283 : else if (VAR_OR_FUNCTION_DECL_P (e))
13452 : : object = e;
13453 : :
13454 : 69 : if (object
13455 : 377 : && VAR_OR_FUNCTION_DECL_P (object)
13456 : 446 : && is_tu_local_entity (object))
13457 : : {
13458 : 39 : if (explain)
13459 : : {
13460 : : /* We've lost a lot of location information by the time we get here,
13461 : : so let's just do our best effort. */
13462 : 12 : auto loc = cp_expr_loc_or_loc (expr, DECL_SOURCE_LOCATION (decl));
13463 : 12 : if (VAR_P (object))
13464 : 6 : inform (loc, "%qD refers to TU-local object %qD", decl, object);
13465 : : else
13466 : 6 : inform (loc, "%qD refers to TU-local function %qD", decl, object);
13467 : 12 : is_tu_local_entity (object, true);
13468 : : }
13469 : 39 : return true;
13470 : : }
13471 : :
13472 : : /* It is an object of class or array type and any of its subobjects or
13473 : : any of the objects or functions to which its non-static data members
13474 : : of reference type refer is TU-local and is usable in constant
13475 : : expressions. */
13476 : 33313 : if (TREE_CODE (e) == CONSTRUCTOR && AGGREGATE_TYPE_P (TREE_TYPE (e)))
13477 : 14154 : for (auto &f : CONSTRUCTOR_ELTS (e))
13478 : 12829 : if (is_tu_local_value (decl, f.value, explain))
13479 : : return true;
13480 : :
13481 : : return false;
13482 : : }
13483 : :
13484 : : /* DECL is a newly discovered dependency. Create the depset, if it
13485 : : doesn't already exist. Add it to the worklist if so.
13486 : :
13487 : : DECL will be an OVL_USING_P OVERLOAD, if it's from a binding that's
13488 : : a using decl.
13489 : :
13490 : : We do not have to worry about adding the same dependency more than
13491 : : once. First it's harmless, but secondly the TREE_VISITED marking
13492 : : prevents us wanting to do it anyway. */
13493 : :
13494 : : depset *
13495 : 8825853 : depset::hash::make_dependency (tree decl, entity_kind ek)
13496 : : {
13497 : : /* Make sure we're being told consistent information. */
13498 : 16380212 : gcc_checking_assert ((ek == EK_NAMESPACE)
13499 : : == (TREE_CODE (decl) == NAMESPACE_DECL
13500 : : && !DECL_NAMESPACE_ALIAS (decl)));
13501 : 8825853 : gcc_checking_assert (ek != EK_BINDING && ek != EK_REDIRECT);
13502 : 8825853 : gcc_checking_assert (TREE_CODE (decl) != FIELD_DECL
13503 : : && (TREE_CODE (decl) != USING_DECL
13504 : : || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL));
13505 : 8825853 : gcc_checking_assert (!is_key_order ());
13506 : 8825853 : if (ek == EK_USING)
13507 : 29179 : gcc_checking_assert (TREE_CODE (decl) == OVERLOAD);
13508 : :
13509 : 8825853 : if (TREE_CODE (decl) == TEMPLATE_DECL)
13510 : : /* The template should have copied these from its result decl. */
13511 : 3316721 : gcc_checking_assert (DECL_MODULE_EXPORT_P (decl)
13512 : : == DECL_MODULE_EXPORT_P (DECL_TEMPLATE_RESULT (decl)));
13513 : :
13514 : 8825853 : depset **slot = entity_slot (decl, true);
13515 : 8825853 : depset *dep = *slot;
13516 : 8825853 : bool for_binding = ek == EK_FOR_BINDING;
13517 : :
13518 : 8825853 : if (!dep)
13519 : : {
13520 : 610960 : if ((DECL_IMPLICIT_TYPEDEF_P (decl)
13521 : : /* ... not an enum, for instance. */
13522 : 318193 : && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))
13523 : 312085 : && TYPE_LANG_SPECIFIC (TREE_TYPE (decl))
13524 : 278649 : && CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)) == 2)
13525 : 2234365 : || (VAR_P (decl)
13526 : 62820 : && DECL_LANG_SPECIFIC (decl)
13527 : 62787 : && DECL_USE_TEMPLATE (decl) == 2))
13528 : : {
13529 : : /* A partial or explicit specialization. Partial
13530 : : specializations might not be in the hash table, because
13531 : : there can be multiple differently-constrained variants.
13532 : :
13533 : : template<typename T> class silly;
13534 : : template<typename T> requires true class silly {};
13535 : :
13536 : : We need to find them, insert their TEMPLATE_DECL in the
13537 : : dep_hash, and then convert the dep we just found into a
13538 : : redirect. */
13539 : :
13540 : 47788 : tree ti = get_template_info (decl);
13541 : 47788 : tree tmpl = TI_TEMPLATE (ti);
13542 : 47788 : tree partial = NULL_TREE;
13543 : 47788 : for (tree spec = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
13544 : 181301 : spec; spec = TREE_CHAIN (spec))
13545 : 161608 : if (DECL_TEMPLATE_RESULT (TREE_VALUE (spec)) == decl)
13546 : : {
13547 : : partial = TREE_VALUE (spec);
13548 : : break;
13549 : : }
13550 : :
13551 : 47788 : if (partial)
13552 : : {
13553 : : /* Eagerly create an empty redirect. The following
13554 : : make_dependency call could cause hash reallocation,
13555 : : and invalidate slot's value. */
13556 : 28095 : depset *redirect = make_entity (decl, EK_REDIRECT);
13557 : :
13558 : : /* Redirects are never reached -- always snap to their target. */
13559 : 28095 : redirect->set_flag_bit<DB_UNREACHED_BIT> ();
13560 : :
13561 : 28095 : *slot = redirect;
13562 : :
13563 : 28095 : depset *tmpl_dep = make_dependency (partial, EK_PARTIAL);
13564 : 28095 : gcc_checking_assert (tmpl_dep->get_entity_kind () == EK_PARTIAL);
13565 : :
13566 : 28095 : redirect->deps.safe_push (tmpl_dep);
13567 : :
13568 : 28095 : return redirect;
13569 : : }
13570 : : }
13571 : :
13572 : 1637981 : bool has_def = ek != EK_USING && has_definition (decl);
13573 : 1608802 : if (ek > EK_BINDING)
13574 : 239132 : ek = EK_DECL;
13575 : :
13576 : : /* The only OVERLOADS we should see are USING decls from
13577 : : bindings. */
13578 : 1637981 : *slot = dep = make_entity (decl, ek, has_def);
13579 : :
13580 : 1637981 : if (CHECKING_P && TREE_CODE (decl) == TEMPLATE_DECL)
13581 : : /* The template_result should otherwise not be in the
13582 : : table, or be an empty redirect (created above). */
13583 : 500784 : if (auto *eslot = entity_slot (DECL_TEMPLATE_RESULT (decl), false))
13584 : 28095 : gcc_checking_assert ((*eslot)->get_entity_kind () == EK_REDIRECT
13585 : : && !(*eslot)->deps.length ());
13586 : :
13587 : 1637981 : if (ek != EK_USING)
13588 : : {
13589 : 1608802 : tree not_tmpl = STRIP_TEMPLATE (decl);
13590 : 1608802 : bool imported_from_module_p = false;
13591 : :
13592 : 1608802 : if (DECL_LANG_SPECIFIC (not_tmpl)
13593 : 3171474 : && DECL_MODULE_IMPORT_P (not_tmpl))
13594 : : {
13595 : : /* Store the module number and index in cluster/section,
13596 : : so we don't have to look them up again. */
13597 : 2073 : unsigned index = import_entity_index (decl);
13598 : 2073 : module_state *from = import_entity_module (index);
13599 : : /* Remap will be zero for imports from partitions, which
13600 : : we want to treat as-if declared in this TU. */
13601 : 2073 : if (from->remap)
13602 : : {
13603 : 1683 : dep->cluster = index - from->entity_lwm;
13604 : 1683 : dep->section = from->remap;
13605 : 1683 : dep->set_flag_bit<DB_IMPORTED_BIT> ();
13606 : :
13607 : 1683 : if (!from->is_header ())
13608 : 1608802 : imported_from_module_p = true;
13609 : : }
13610 : : }
13611 : :
13612 : : /* Check for TU-local entities. This is unnecessary in header
13613 : : units because we can export internal-linkage decls, and
13614 : : no declarations are exposures. Similarly, if the decl was
13615 : : imported from a non-header module we know it cannot have
13616 : : been TU-local. */
13617 : 1608802 : if (!header_module_p () && !imported_from_module_p)
13618 : : {
13619 : 365677 : if (is_tu_local_entity (decl))
13620 : 213 : dep->set_flag_bit<DB_TU_LOCAL_BIT> ();
13621 : :
13622 : 365677 : if (VAR_P (decl)
13623 : 13958 : && decl_maybe_constant_var_p (decl)
13624 : 378827 : && is_tu_local_value (decl, DECL_INITIAL (decl)))
13625 : : {
13626 : : /* A potentially-constant variable initialized to a TU-local
13627 : : value is not usable in constant expressions within other
13628 : : translation units. We can achieve this by simply not
13629 : : streaming the definition in such cases. */
13630 : 15 : dep->clear_flag_bit<DB_DEFN_BIT> ();
13631 : :
13632 : 15 : if (DECL_DECLARED_CONSTEXPR_P (decl))
13633 : : /* Also, a constexpr variable initialized to a TU-local
13634 : : value is an exposure. */
13635 : 9 : dep->set_flag_bit<DB_EXPOSURE_BIT> ();
13636 : : }
13637 : : }
13638 : :
13639 : : /* A namespace-scope type may be declared in one module unit
13640 : : and defined in another; make sure that we're found when
13641 : : completing the class. */
13642 : 1608802 : if (ek == EK_DECL
13643 : 777778 : && !dep->is_import ()
13644 : 777342 : && dep->has_defn ()
13645 : 386686 : && DECL_NAMESPACE_SCOPE_P (not_tmpl)
13646 : 148073 : && DECL_IMPLICIT_TYPEDEF_P (not_tmpl)
13647 : : /* Anonymous types can't be forward-declared. */
13648 : 1650242 : && !IDENTIFIER_ANON_P (DECL_NAME (not_tmpl)))
13649 : 40718 : dep->set_flag_bit<DB_IS_PENDING_BIT> ();
13650 : : }
13651 : :
13652 : 1637981 : if (!dep->is_import ())
13653 : 1636298 : worklist.safe_push (dep);
13654 : : }
13655 : :
13656 : 8797758 : dump (dumper::DEPEND)
13657 : 175002 : && dump ("%s on %s %C:%N found",
13658 : : ek == EK_REDIRECT ? "Redirect"
13659 : 175002 : : for_binding ? "Binding" : "Dependency",
13660 : 175002 : dep->entity_kind_name (), TREE_CODE (decl), decl);
13661 : :
13662 : 8797758 : return dep;
13663 : : }
13664 : :
13665 : : /* DEP is a newly discovered dependency. Append it to current's
13666 : : depset. */
13667 : :
13668 : : void
13669 : 6747667 : depset::hash::add_dependency (depset *dep)
13670 : : {
13671 : 6747667 : gcc_checking_assert (current && !is_key_order ());
13672 : 6747667 : current->deps.safe_push (dep);
13673 : :
13674 : 6747667 : if (dep->is_tu_local ())
13675 : : {
13676 : 222 : current->set_flag_bit<DB_REFS_TU_LOCAL_BIT> ();
13677 : 222 : if (!ignore_tu_local)
13678 : 63 : current->set_flag_bit<DB_EXPOSURE_BIT> ();
13679 : : }
13680 : :
13681 : 6747667 : if (current->get_entity_kind () == EK_USING
13682 : 29179 : && DECL_IMPLICIT_TYPEDEF_P (dep->get_entity ())
13683 : 6759043 : && TREE_CODE (TREE_TYPE (dep->get_entity ())) == ENUMERAL_TYPE)
13684 : : {
13685 : : /* CURRENT is an unwrapped using-decl and DECL is an enum's
13686 : : implicit typedef. Is CURRENT a member of the enum? */
13687 : 11144 : tree c_decl = OVL_FUNCTION (current->get_entity ());
13688 : :
13689 : 11144 : if (TREE_CODE (c_decl) == CONST_DECL
13690 : 22261 : && (current->deps[0]->get_entity ()
13691 : 11117 : == CP_DECL_CONTEXT (dep->get_entity ())))
13692 : : /* Make DECL depend on CURRENT. */
13693 : 11024 : dep->deps.safe_push (current);
13694 : : }
13695 : :
13696 : : /* If two dependencies recursively depend on each other existing within
13697 : : their own merge keys, we must ensure that the first dep we saw while
13698 : : walking is written first in this cluster. See sort_cluster for more
13699 : : details. */
13700 : 6747667 : if (writing_merge_key)
13701 : : {
13702 : 1215515 : dep->set_flag_bit<DB_MAYBE_RECURSIVE_BIT> ();
13703 : 1215515 : if (!current->is_maybe_recursive ())
13704 : 1144244 : current->set_flag_bit<DB_ENTRY_BIT> ();
13705 : : }
13706 : :
13707 : 6747667 : if (dep->is_unreached ())
13708 : : {
13709 : : /* The dependency is reachable now. */
13710 : 514068 : reached_unreached = true;
13711 : 514068 : dep->clear_flag_bit<DB_UNREACHED_BIT> ();
13712 : 514068 : dump (dumper::DEPEND)
13713 : 9790 : && dump ("Reaching unreached %s %C:%N", dep->entity_kind_name (),
13714 : 9790 : TREE_CODE (dep->get_entity ()), dep->get_entity ());
13715 : : }
13716 : 6747667 : }
13717 : :
13718 : : depset *
13719 : 10078499 : depset::hash::add_dependency (tree decl, entity_kind ek)
13720 : : {
13721 : 10078499 : depset *dep;
13722 : :
13723 : 10078499 : if (is_key_order ())
13724 : : {
13725 : 3257323 : dep = find_dependency (decl);
13726 : 3257323 : if (dep)
13727 : : {
13728 : 1626681 : current->deps.safe_push (dep);
13729 : 1626681 : dump (dumper::MERGE)
13730 : 471 : && dump ("Key dependency on %s %C:%N found",
13731 : 471 : dep->entity_kind_name (), TREE_CODE (decl), decl);
13732 : : }
13733 : : else
13734 : : {
13735 : : /* It's not a mergeable decl, look for it in the original
13736 : : table. */
13737 : 1630642 : dep = chain->find_dependency (decl);
13738 : 1630642 : gcc_checking_assert (dep);
13739 : : }
13740 : : }
13741 : : else
13742 : : {
13743 : 6821176 : dep = make_dependency (decl, ek);
13744 : 6821176 : if (dep->get_entity_kind () != EK_REDIRECT)
13745 : 6747667 : add_dependency (dep);
13746 : : }
13747 : :
13748 : 10078499 : return dep;
13749 : : }
13750 : :
13751 : : void
13752 : 853392 : depset::hash::add_namespace_context (depset *dep, tree ns)
13753 : : {
13754 : 853392 : depset *ns_dep = make_dependency (ns, depset::EK_NAMESPACE);
13755 : 853392 : dep->deps.safe_push (ns_dep);
13756 : :
13757 : : /* Mark it as special if imported so we don't walk connect when
13758 : : SCCing. */
13759 : 853392 : if (!dep->is_binding () && ns_dep->is_import ())
13760 : 0 : dep->set_special ();
13761 : 853392 : }
13762 : :
13763 : : struct add_binding_data
13764 : : {
13765 : : tree ns;
13766 : : bitmap partitions;
13767 : : depset *binding;
13768 : : depset::hash *hash;
13769 : : bool met_namespace;
13770 : : };
13771 : :
13772 : : /* Return true if we are, or contain something that is exported. */
13773 : :
13774 : : bool
13775 : 4467561 : depset::hash::add_binding_entity (tree decl, WMB_Flags flags, void *data_)
13776 : : {
13777 : 4467561 : auto data = static_cast <add_binding_data *> (data_);
13778 : 4467561 : decl = strip_using_decl (decl);
13779 : :
13780 : 4467561 : if (!(TREE_CODE (decl) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (decl)))
13781 : : {
13782 : 4460498 : tree inner = decl;
13783 : :
13784 : 4460498 : if (TREE_CODE (inner) == CONST_DECL
13785 : 11951 : && TREE_CODE (DECL_CONTEXT (inner)) == ENUMERAL_TYPE
13786 : : /* A using-decl could make a CONST_DECL purview for a non-purview
13787 : : enumeration. */
13788 : 4472449 : && (!DECL_LANG_SPECIFIC (inner) || !DECL_MODULE_PURVIEW_P (inner)))
13789 : 11948 : inner = TYPE_NAME (DECL_CONTEXT (inner));
13790 : 4448550 : else if (TREE_CODE (inner) == TEMPLATE_DECL)
13791 : 136106 : inner = DECL_TEMPLATE_RESULT (inner);
13792 : :
13793 : 8784292 : if ((!DECL_LANG_SPECIFIC (inner) || !DECL_MODULE_PURVIEW_P (inner))
13794 : 8516042 : && !((flags & WMB_Using) && (flags & WMB_Purview)))
13795 : : /* Ignore entities not within the module purview. */
13796 : : return false;
13797 : :
13798 : 268340 : if (!header_module_p () && data->hash->is_tu_local_entity (decl))
13799 : : /* Ignore TU-local entitites. */
13800 : : return false;
13801 : :
13802 : 268163 : if ((TREE_CODE (decl) == VAR_DECL
13803 : 268163 : || TREE_CODE (decl) == TYPE_DECL)
13804 : 268163 : && DECL_TINFO_P (decl))
13805 : : /* Ignore TINFO things. */
13806 : : return false;
13807 : :
13808 : 268163 : if (TREE_CODE (decl) == VAR_DECL && DECL_NTTP_OBJECT_P (decl))
13809 : : /* Ignore NTTP objects. */
13810 : : return false;
13811 : :
13812 : 268163 : if (deduction_guide_p (decl))
13813 : : {
13814 : : /* Ignore deduction guides, bindings for them will be created within
13815 : : find_dependencies for their class template. But still build a dep
13816 : : for them so that we don't discard them. */
13817 : 2034 : data->hash->make_dependency (decl, EK_FOR_BINDING);
13818 : 2034 : return false;
13819 : : }
13820 : :
13821 : 266129 : if (!(flags & WMB_Using) && CP_DECL_CONTEXT (decl) != data->ns)
13822 : : {
13823 : : /* An unscoped enum constant implicitly brought into the containing
13824 : : namespace. We treat this like a using-decl. */
13825 : 11024 : gcc_checking_assert (TREE_CODE (decl) == CONST_DECL);
13826 : :
13827 : 11024 : flags = WMB_Flags (flags | WMB_Using);
13828 : 11024 : if (DECL_MODULE_EXPORT_P (TYPE_NAME (TREE_TYPE (decl)))
13829 : : /* A using-decl can make an enum constant exported for a
13830 : : non-exported enumeration. */
13831 : 11024 : || (DECL_LANG_SPECIFIC (decl) && DECL_MODULE_EXPORT_P (decl)))
13832 : 9649 : flags = WMB_Flags (flags | WMB_Export);
13833 : : }
13834 : :
13835 : 266129 : if (!data->binding)
13836 : : /* No binding to check. */;
13837 : 53439 : else if (flags & WMB_Using)
13838 : : {
13839 : : /* Look in the binding to see if we already have this
13840 : : using. */
13841 : 27488 : for (unsigned ix = data->binding->deps.length (); --ix;)
13842 : : {
13843 : 20104 : depset *d = data->binding->deps[ix];
13844 : 40208 : if (d->get_entity_kind () == EK_USING
13845 : 20104 : && OVL_FUNCTION (d->get_entity ()) == decl)
13846 : : {
13847 : 0 : if (!(flags & WMB_Hidden))
13848 : 0 : d->clear_hidden_binding ();
13849 : 0 : OVL_PURVIEW_P (d->get_entity ()) = true;
13850 : 0 : if (flags & WMB_Export)
13851 : 0 : OVL_EXPORT_P (d->get_entity ()) = true;
13852 : 0 : return bool (flags & WMB_Export);
13853 : : }
13854 : : }
13855 : : }
13856 : 49747 : else if (flags & WMB_Dups)
13857 : : {
13858 : : /* Look in the binding to see if we already have this decl. */
13859 : 78 : for (unsigned ix = data->binding->deps.length (); --ix;)
13860 : : {
13861 : 39 : depset *d = data->binding->deps[ix];
13862 : 39 : if (d->get_entity () == decl)
13863 : : {
13864 : 33 : if (!(flags & WMB_Hidden))
13865 : 30 : d->clear_hidden_binding ();
13866 : 33 : return false;
13867 : : }
13868 : : }
13869 : : }
13870 : :
13871 : : /* We're adding something. */
13872 : 266096 : if (!data->binding)
13873 : : {
13874 : 212690 : data->binding = make_binding (data->ns, DECL_NAME (decl));
13875 : 212690 : data->hash->add_namespace_context (data->binding, data->ns);
13876 : :
13877 : 212690 : depset **slot = data->hash->binding_slot (data->ns,
13878 : 212690 : DECL_NAME (decl), true);
13879 : 212690 : gcc_checking_assert (!*slot);
13880 : 212690 : *slot = data->binding;
13881 : : }
13882 : :
13883 : : /* Make sure nobody left a tree visited lying about. */
13884 : 266096 : gcc_checking_assert (!TREE_VISITED (decl));
13885 : :
13886 : 266096 : if (flags & WMB_Using)
13887 : : {
13888 : 29179 : decl = ovl_make (decl, NULL_TREE);
13889 : 29179 : OVL_USING_P (decl) = true;
13890 : 29179 : OVL_PURVIEW_P (decl) = true;
13891 : 29179 : if (flags & WMB_Export)
13892 : 26169 : OVL_EXPORT_P (decl) = true;
13893 : : }
13894 : :
13895 : 266096 : depset *dep = data->hash->make_dependency
13896 : 503013 : (decl, flags & WMB_Using ? EK_USING : EK_FOR_BINDING);
13897 : 266096 : if (flags & WMB_Hidden)
13898 : 6131 : dep->set_hidden_binding ();
13899 : 266096 : data->binding->deps.safe_push (dep);
13900 : : /* Binding and contents are mutually dependent. */
13901 : 266096 : dep->deps.safe_push (data->binding);
13902 : :
13903 : 266096 : return (flags & WMB_Using
13904 : 266096 : ? flags & WMB_Export : DECL_MODULE_EXPORT_P (decl));
13905 : : }
13906 : 7063 : else if (!data->met_namespace)
13907 : : {
13908 : : /* Namespace, walk exactly once. */
13909 : 7054 : data->met_namespace = true;
13910 : 7054 : if (data->hash->add_namespace_entities (decl, data->partitions))
13911 : : {
13912 : : /* It contains an exported thing, so it is exported. */
13913 : 1862 : gcc_checking_assert (DECL_MODULE_PURVIEW_P (decl));
13914 : 1862 : gcc_checking_assert (TREE_PUBLIC (decl) || header_module_p ());
13915 : 1862 : DECL_MODULE_EXPORT_P (decl) = true;
13916 : : }
13917 : :
13918 : 7054 : if (DECL_MODULE_PURVIEW_P (decl))
13919 : : {
13920 : 2290 : data->hash->make_dependency (decl, depset::EK_NAMESPACE);
13921 : :
13922 : 2290 : return DECL_MODULE_EXPORT_P (decl);
13923 : : }
13924 : : }
13925 : :
13926 : : return false;
13927 : : }
13928 : :
13929 : : /* Recursively find all the namespace bindings of NS. Add a depset
13930 : : for every binding that contains an export or module-linkage entity.
13931 : : Add a defining depset for every such decl that we need to write a
13932 : : definition. Such defining depsets depend on the binding depset.
13933 : : Returns true if we contain something exported. */
13934 : :
13935 : : bool
13936 : 9224 : depset::hash::add_namespace_entities (tree ns, bitmap partitions)
13937 : : {
13938 : 10087 : dump () && dump ("Looking for writables in %N", ns);
13939 : 9224 : dump.indent ();
13940 : :
13941 : 9224 : unsigned count = 0;
13942 : 9224 : add_binding_data data;
13943 : 9224 : data.ns = ns;
13944 : 9224 : data.partitions = partitions;
13945 : 9224 : data.hash = this;
13946 : :
13947 : 9224 : hash_table<named_decl_hash>::iterator end
13948 : 9224 : (DECL_NAMESPACE_BINDINGS (ns)->end ());
13949 : 5822220 : for (hash_table<named_decl_hash>::iterator iter
13950 : 11644440 : (DECL_NAMESPACE_BINDINGS (ns)->begin ()); iter != end; ++iter)
13951 : : {
13952 : 5812996 : data.binding = nullptr;
13953 : 5812996 : data.met_namespace = false;
13954 : 5812996 : if (walk_module_binding (*iter, partitions, add_binding_entity, &data))
13955 : 191953 : count++;
13956 : : }
13957 : :
13958 : 9224 : if (count)
13959 : 3711 : dump () && dump ("Found %u entries", count);
13960 : 9224 : dump.outdent ();
13961 : :
13962 : 9224 : return count != 0;
13963 : : }
13964 : :
13965 : : void
13966 : 176 : depset::hash::add_partial_entities (vec<tree, va_gc> *partial_classes)
13967 : : {
13968 : 25103 : for (unsigned ix = 0; ix != partial_classes->length (); ix++)
13969 : : {
13970 : 24927 : tree inner = (*partial_classes)[ix];
13971 : :
13972 : 24927 : depset *dep = make_dependency (inner, depset::EK_DECL);
13973 : :
13974 : 24927 : if (dep->get_entity_kind () == depset::EK_REDIRECT)
13975 : : {
13976 : 24927 : dep = dep->deps[0];
13977 : : /* We should have recorded the template as a partial
13978 : : specialization. */
13979 : 24927 : gcc_checking_assert (dep->get_entity_kind ()
13980 : : == depset::EK_PARTIAL);
13981 : :
13982 : : /* Only emit GM entities if reached. */
13983 : 24927 : if (!DECL_LANG_SPECIFIC (inner)
13984 : 45154 : || !DECL_MODULE_PURVIEW_P (inner))
13985 : 4731 : dep->set_flag_bit<DB_UNREACHED_BIT> ();
13986 : : }
13987 : : else
13988 : : {
13989 : : /* It was an explicit specialization, not a partial one.
13990 : : We should have already added this. */
13991 : 0 : gcc_checking_assert (dep->get_entity_kind ()
13992 : : == depset::EK_SPECIALIZATION);
13993 : 0 : gcc_checking_assert (dep->is_special ());
13994 : : }
13995 : : }
13996 : 176 : }
13997 : :
13998 : : /* Add the members of imported classes that we defined in this TU.
13999 : : This will also include lazily created implicit member function
14000 : : declarations. (All others will be definitions.) */
14001 : :
14002 : : void
14003 : 12 : depset::hash::add_class_entities (vec<tree, va_gc> *class_members)
14004 : : {
14005 : 24 : for (unsigned ix = 0; ix != class_members->length (); ix++)
14006 : : {
14007 : 12 : tree defn = (*class_members)[ix];
14008 : 12 : depset *dep = make_dependency (defn, EK_INNER_DECL);
14009 : :
14010 : 12 : if (dep->get_entity_kind () == EK_REDIRECT)
14011 : 0 : dep = dep->deps[0];
14012 : :
14013 : : /* Only non-instantiations need marking as pendings. */
14014 : 24 : if (dep->get_entity_kind () == EK_DECL)
14015 : 12 : dep->set_flag_bit <DB_IS_PENDING_BIT> ();
14016 : : }
14017 : 12 : }
14018 : :
14019 : : /* We add the partial & explicit specializations, and the explicit
14020 : : instantiations. */
14021 : :
14022 : : static void
14023 : 828973 : specialization_add (bool decl_p, spec_entry *entry, void *data_)
14024 : : {
14025 : 828973 : vec<spec_entry *> *data = reinterpret_cast <vec<spec_entry *> *> (data_);
14026 : :
14027 : 828973 : if (!decl_p)
14028 : : {
14029 : : /* We exclusively use decls to locate things. Make sure there's
14030 : : no mismatch between the two specialization tables we keep.
14031 : : pt.cc optimizes instantiation lookup using a complicated
14032 : : heuristic. We don't attempt to replicate that algorithm, but
14033 : : observe its behaviour and reproduce it upon read back. */
14034 : :
14035 : 265490 : gcc_checking_assert (TREE_CODE (entry->spec) == ENUMERAL_TYPE
14036 : : || DECL_CLASS_TEMPLATE_P (entry->tmpl));
14037 : :
14038 : 265490 : gcc_checking_assert (!match_mergeable_specialization (true, entry));
14039 : : }
14040 : 563483 : else if (VAR_OR_FUNCTION_DECL_P (entry->spec))
14041 : 285952 : gcc_checking_assert (!DECL_LOCAL_DECL_P (entry->spec));
14042 : :
14043 : 828973 : data->safe_push (entry);
14044 : 828973 : }
14045 : :
14046 : : /* Arbitrary stable comparison. */
14047 : :
14048 : : static int
14049 : 49075766 : specialization_cmp (const void *a_, const void *b_)
14050 : : {
14051 : 49075766 : const spec_entry *ea = *reinterpret_cast<const spec_entry *const *> (a_);
14052 : 49075766 : const spec_entry *eb = *reinterpret_cast<const spec_entry *const *> (b_);
14053 : :
14054 : 49075766 : if (ea == eb)
14055 : : return 0;
14056 : :
14057 : 49075766 : tree a = ea->spec;
14058 : 49075766 : tree b = eb->spec;
14059 : 49075766 : if (TYPE_P (a))
14060 : : {
14061 : 14993506 : a = TYPE_NAME (a);
14062 : 14993506 : b = TYPE_NAME (b);
14063 : : }
14064 : :
14065 : 49075766 : if (a == b)
14066 : : /* This can happen with friend specializations. Just order by
14067 : : entry address. See note in depset_cmp. */
14068 : 233 : return ea < eb ? -1 : +1;
14069 : :
14070 : 49075598 : return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
14071 : : }
14072 : :
14073 : : /* We add all kinds of specialializations. Implicit specializations
14074 : : should only streamed and walked if they are reachable from
14075 : : elsewhere. Hence the UNREACHED flag. This is making the
14076 : : assumption that it is cheaper to reinstantiate them on demand
14077 : : elsewhere, rather than stream them in when we instantiate their
14078 : : general template. Also, if we do stream them, we can only do that
14079 : : if they are not internal (which they can become if they themselves
14080 : : touch an internal entity?). */
14081 : :
14082 : : void
14083 : 4340 : depset::hash::add_specializations (bool decl_p)
14084 : : {
14085 : 4340 : vec<spec_entry *> data;
14086 : 4340 : data.create (100);
14087 : 4340 : walk_specializations (decl_p, specialization_add, &data);
14088 : 4340 : data.qsort (specialization_cmp);
14089 : 833313 : while (data.length ())
14090 : : {
14091 : 828973 : spec_entry *entry = data.pop ();
14092 : 828973 : tree spec = entry->spec;
14093 : 828973 : int use_tpl = 0;
14094 : 828973 : bool is_friend = false;
14095 : :
14096 : 828973 : if (decl_p && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (entry->tmpl))
14097 : : /* A friend of a template. This is keyed to the
14098 : : instantiation. */
14099 : : is_friend = true;
14100 : :
14101 : 828973 : if (decl_p)
14102 : : {
14103 : 563483 : if (tree ti = DECL_TEMPLATE_INFO (spec))
14104 : : {
14105 : 563483 : tree tmpl = TI_TEMPLATE (ti);
14106 : :
14107 : 563483 : use_tpl = DECL_USE_TEMPLATE (spec);
14108 : 563483 : if (spec == DECL_TEMPLATE_RESULT (tmpl))
14109 : : {
14110 : 4719 : spec = tmpl;
14111 : 4719 : gcc_checking_assert (DECL_USE_TEMPLATE (spec) == use_tpl);
14112 : : }
14113 : 558764 : else if (is_friend)
14114 : : {
14115 : 3345 : if (TI_TEMPLATE (ti) != entry->tmpl
14116 : 3345 : || !template_args_equal (TI_ARGS (ti), entry->tmpl))
14117 : 3345 : goto template_friend;
14118 : : }
14119 : : }
14120 : : else
14121 : : {
14122 : 0 : template_friend:;
14123 : 3345 : gcc_checking_assert (is_friend);
14124 : : /* This is a friend of a template class, but not the one
14125 : : that generated entry->spec itself (i.e. it's an
14126 : : equivalent clone). We do not need to record
14127 : : this. */
14128 : 3345 : continue;
14129 : : }
14130 : : }
14131 : : else
14132 : : {
14133 : 265490 : if (TREE_CODE (spec) == ENUMERAL_TYPE)
14134 : : {
14135 : 1535 : tree ctx = DECL_CONTEXT (TYPE_NAME (spec));
14136 : :
14137 : 1535 : if (TYPE_P (ctx))
14138 : 1529 : use_tpl = CLASSTYPE_USE_TEMPLATE (ctx);
14139 : : else
14140 : 6 : use_tpl = DECL_USE_TEMPLATE (ctx);
14141 : : }
14142 : : else
14143 : 263955 : use_tpl = CLASSTYPE_USE_TEMPLATE (spec);
14144 : :
14145 : 265490 : tree ti = TYPE_TEMPLATE_INFO (spec);
14146 : 265490 : tree tmpl = TI_TEMPLATE (ti);
14147 : :
14148 : 265490 : spec = TYPE_NAME (spec);
14149 : 265490 : if (spec == DECL_TEMPLATE_RESULT (tmpl))
14150 : : {
14151 : 1171 : spec = tmpl;
14152 : 1171 : use_tpl = DECL_USE_TEMPLATE (spec);
14153 : : }
14154 : : }
14155 : :
14156 : 825628 : bool needs_reaching = false;
14157 : 825628 : if (use_tpl == 1)
14158 : : /* Implicit instantiations only walked if we reach them. */
14159 : : needs_reaching = true;
14160 : 88786 : else if (!DECL_LANG_SPECIFIC (STRIP_TEMPLATE (spec))
14161 : 168349 : || !DECL_MODULE_PURVIEW_P (STRIP_TEMPLATE (spec)))
14162 : : /* Likewise, GMF explicit or partial specializations. */
14163 : : needs_reaching = true;
14164 : :
14165 : : #if false && CHECKING_P
14166 : : /* The instantiation isn't always on
14167 : : DECL_TEMPLATE_INSTANTIATIONS, */
14168 : : // FIXME: we probably need to remember this information?
14169 : : /* Verify the specialization is on the
14170 : : DECL_TEMPLATE_INSTANTIATIONS of the template. */
14171 : : for (tree cons = DECL_TEMPLATE_INSTANTIATIONS (entry->tmpl);
14172 : : cons; cons = TREE_CHAIN (cons))
14173 : : if (TREE_VALUE (cons) == entry->spec)
14174 : : {
14175 : : gcc_assert (entry->args == TREE_PURPOSE (cons));
14176 : : goto have_spec;
14177 : : }
14178 : : gcc_unreachable ();
14179 : : have_spec:;
14180 : : #endif
14181 : :
14182 : : /* Make sure nobody left a tree visited lying about. */
14183 : 825628 : gcc_checking_assert (!TREE_VISITED (spec));
14184 : 825628 : depset *dep = make_dependency (spec, depset::EK_SPECIALIZATION);
14185 : 825628 : if (dep->is_special ())
14186 : 0 : gcc_unreachable ();
14187 : : else
14188 : : {
14189 : 825628 : if (dep->get_entity_kind () == depset::EK_REDIRECT)
14190 : 27300 : dep = dep->deps[0];
14191 : 798328 : else if (dep->get_entity_kind () == depset::EK_SPECIALIZATION)
14192 : : {
14193 : 798328 : dep->set_special ();
14194 : 798328 : dep->deps.safe_push (reinterpret_cast<depset *> (entry));
14195 : 798328 : if (!decl_p)
14196 : 241358 : dep->set_flag_bit<DB_TYPE_SPEC_BIT> ();
14197 : : }
14198 : :
14199 : 825628 : if (needs_reaching)
14200 : 751759 : dep->set_flag_bit<DB_UNREACHED_BIT> ();
14201 : 825628 : if (is_friend)
14202 : 0 : dep->set_flag_bit<DB_FRIEND_SPEC_BIT> ();
14203 : : }
14204 : : }
14205 : 4340 : data.release ();
14206 : 4340 : }
14207 : :
14208 : : /* Add a depset into the mergeable hash. */
14209 : :
14210 : : void
14211 : 1373236 : depset::hash::add_mergeable (depset *mergeable)
14212 : : {
14213 : 1373236 : gcc_checking_assert (is_key_order ());
14214 : 1373236 : entity_kind ek = mergeable->get_entity_kind ();
14215 : 1373236 : tree decl = mergeable->get_entity ();
14216 : 1373236 : gcc_checking_assert (ek < EK_DIRECT_HWM);
14217 : :
14218 : 1373236 : depset **slot = entity_slot (decl, true);
14219 : 1373236 : gcc_checking_assert (!*slot);
14220 : 1373236 : depset *dep = make_entity (decl, ek);
14221 : 1373236 : *slot = dep;
14222 : :
14223 : 1373236 : worklist.safe_push (dep);
14224 : :
14225 : : /* So we can locate the mergeable depset this depset refers to,
14226 : : mark the first dep. */
14227 : 1373236 : dep->set_special ();
14228 : 1373236 : dep->deps.safe_push (mergeable);
14229 : 1373236 : }
14230 : :
14231 : : /* Find the innermost-namespace scope of DECL, and that
14232 : : namespace-scope decl. */
14233 : :
14234 : : tree
14235 : 39255769 : find_pending_key (tree decl, tree *decl_p = nullptr)
14236 : : {
14237 : 39255769 : tree ns = decl;
14238 : 47545689 : do
14239 : : {
14240 : 47545689 : decl = ns;
14241 : 47545689 : ns = CP_DECL_CONTEXT (ns);
14242 : 47545689 : if (TYPE_P (ns))
14243 : 4822709 : ns = TYPE_NAME (ns);
14244 : : }
14245 : 47545689 : while (TREE_CODE (ns) != NAMESPACE_DECL);
14246 : :
14247 : 39255769 : if (decl_p)
14248 : 38618653 : *decl_p = decl;
14249 : :
14250 : 39255769 : return ns;
14251 : : }
14252 : :
14253 : : /* Creates bindings and dependencies for all deduction guides of
14254 : : the given class template DECL as needed. */
14255 : :
14256 : : void
14257 : 66013 : depset::hash::add_deduction_guides (tree decl)
14258 : : {
14259 : : /* Alias templates never have deduction guides. */
14260 : 66013 : if (DECL_ALIAS_TEMPLATE_P (decl))
14261 : 65084 : return;
14262 : :
14263 : : /* We don't need to do anything for class-scope deduction guides,
14264 : : as they will be added as members anyway. */
14265 : 66013 : if (!DECL_NAMESPACE_SCOPE_P (decl))
14266 : : return;
14267 : :
14268 : 52304 : tree ns = CP_DECL_CONTEXT (decl);
14269 : 52304 : tree name = dguide_name (decl);
14270 : :
14271 : : /* We always add all deduction guides with a given name at once,
14272 : : so if there's already a binding there's nothing to do. */
14273 : 52304 : if (find_binding (ns, name))
14274 : : return;
14275 : :
14276 : 52110 : tree guides = lookup_qualified_name (ns, name, LOOK_want::ANY_REACHABLE,
14277 : : /*complain=*/false);
14278 : 52110 : if (guides == error_mark_node)
14279 : : return;
14280 : :
14281 : : /* We have bindings to add. */
14282 : 929 : depset *binding = make_binding (ns, name);
14283 : 929 : add_namespace_context (binding, ns);
14284 : :
14285 : 929 : depset **slot = binding_slot (ns, name, /*insert=*/true);
14286 : 929 : *slot = binding;
14287 : :
14288 : 3132 : for (lkp_iterator it (guides); it; ++it)
14289 : : {
14290 : 2203 : gcc_checking_assert (!TREE_VISITED (*it));
14291 : 2203 : depset *dep = make_dependency (*it, EK_FOR_BINDING);
14292 : 2203 : binding->deps.safe_push (dep);
14293 : 2203 : dep->deps.safe_push (binding);
14294 : : }
14295 : : }
14296 : :
14297 : : /* Iteratively find dependencies. During the walk we may find more
14298 : : entries on the same binding that need walking. */
14299 : :
14300 : : void
14301 : 383462 : depset::hash::find_dependencies (module_state *module)
14302 : : {
14303 : 383462 : trees_out walker (NULL, module, *this);
14304 : 383462 : vec<depset *> unreached;
14305 : 766924 : unreached.create (worklist.length ());
14306 : :
14307 : 998 : for (;;)
14308 : : {
14309 : 384460 : reached_unreached = false;
14310 : 5117409 : while (worklist.length ())
14311 : : {
14312 : 4732949 : depset *item = worklist.pop ();
14313 : :
14314 : 4732949 : gcc_checking_assert (!item->is_binding ());
14315 : 4732949 : if (item->is_unreached ())
14316 : 1952205 : unreached.quick_push (item);
14317 : : else
14318 : : {
14319 : 2780744 : current = item;
14320 : 2780744 : tree decl = current->get_entity ();
14321 : 2780744 : dump (is_key_order () ? dumper::MERGE : dumper::DEPEND)
14322 : 2809434 : && dump ("Dependencies of %s %C:%N",
14323 : 28690 : is_key_order () ? "key-order"
14324 : 28690 : : current->entity_kind_name (), TREE_CODE (decl), decl);
14325 : 2780744 : dump.indent ();
14326 : 2780744 : walker.begin ();
14327 : 2780744 : if (current->get_entity_kind () == EK_USING)
14328 : 29179 : walker.tree_node (OVL_FUNCTION (decl));
14329 : 2751565 : else if (TREE_VISITED (decl))
14330 : : /* A global tree. */;
14331 : 2749621 : else if (item->get_entity_kind () == EK_NAMESPACE)
14332 : : {
14333 : 2657 : module->note_location (DECL_SOURCE_LOCATION (decl));
14334 : 2657 : add_namespace_context (current, CP_DECL_CONTEXT (decl));
14335 : : }
14336 : : else
14337 : : {
14338 : 2746964 : walker.mark_declaration (decl, current->has_defn ());
14339 : :
14340 : 2746964 : if (!is_key_order ()
14341 : 2746964 : && item->is_pending_entity ())
14342 : : {
14343 : 637116 : tree ns = find_pending_key (decl, nullptr);
14344 : 637116 : add_namespace_context (item, ns);
14345 : : }
14346 : :
14347 : 2746964 : walker.decl_value (decl, current);
14348 : 2746964 : if (current->has_defn ())
14349 : 501248 : walker.write_definition (decl, current->refs_tu_local ());
14350 : : }
14351 : 2780744 : walker.end ();
14352 : :
14353 : 2780744 : if (!is_key_order ()
14354 : 2780744 : && DECL_CLASS_TEMPLATE_P (decl))
14355 : 66013 : add_deduction_guides (decl);
14356 : :
14357 : 2780744 : if (!is_key_order ()
14358 : 1407508 : && TREE_CODE (decl) == TEMPLATE_DECL
14359 : 3275961 : && !DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
14360 : : {
14361 : : /* Mark all the explicit & partial specializations as
14362 : : reachable. We search both specialization lists as some
14363 : : constrained partial specializations for class types are
14364 : : only found in DECL_TEMPLATE_SPECIALIZATIONS. */
14365 : 1313933 : auto mark_reached = [this](tree spec)
14366 : : {
14367 : 825696 : if (TYPE_P (spec))
14368 : 250809 : spec = TYPE_NAME (spec);
14369 : 825696 : int use_tpl;
14370 : 825696 : node_template_info (spec, use_tpl);
14371 : 825696 : if (use_tpl & 2)
14372 : : {
14373 : 107834 : depset *spec_dep = find_dependency (spec);
14374 : 107834 : if (spec_dep->get_entity_kind () == EK_REDIRECT)
14375 : 24503 : spec_dep = spec_dep->deps[0];
14376 : 107834 : if (spec_dep->is_unreached ())
14377 : : {
14378 : 7941 : reached_unreached = true;
14379 : 7941 : spec_dep->clear_flag_bit<DB_UNREACHED_BIT> ();
14380 : 7941 : dump (dumper::DEPEND)
14381 : 2699 : && dump ("Reaching unreached specialization"
14382 : 2699 : " %C:%N", TREE_CODE (spec), spec);
14383 : : }
14384 : : }
14385 : 1313933 : };
14386 : :
14387 : 488237 : for (tree cons = DECL_TEMPLATE_INSTANTIATIONS (decl);
14388 : 1288662 : cons; cons = TREE_CHAIN (cons))
14389 : 800425 : mark_reached (TREE_VALUE (cons));
14390 : 488237 : for (tree cons = DECL_TEMPLATE_SPECIALIZATIONS (decl);
14391 : 513508 : cons; cons = TREE_CHAIN (cons))
14392 : 25271 : mark_reached (TREE_VALUE (cons));
14393 : : }
14394 : :
14395 : 2780744 : dump.outdent ();
14396 : 2780744 : current = NULL;
14397 : : }
14398 : : }
14399 : :
14400 : 384460 : if (!reached_unreached)
14401 : : break;
14402 : :
14403 : : /* It's possible the we reached the unreached before we
14404 : : processed it in the above loop, so we'll be doing this an
14405 : : extra time. However, to avoid that we have to do some
14406 : : bit shuffling that also involves a scan of the list.
14407 : : Swings & roundabouts I guess. */
14408 : 998 : std::swap (worklist, unreached);
14409 : : }
14410 : :
14411 : 383462 : unreached.release ();
14412 : 383462 : }
14413 : :
14414 : : /* Compare two entries of a single binding. TYPE_DECL before
14415 : : non-exported before exported. */
14416 : :
14417 : : static int
14418 : 772990 : binding_cmp (const void *a_, const void *b_)
14419 : : {
14420 : 772990 : depset *a = *(depset *const *)a_;
14421 : 772990 : depset *b = *(depset *const *)b_;
14422 : :
14423 : 772990 : tree a_ent = a->get_entity ();
14424 : 772990 : tree b_ent = b->get_entity ();
14425 : 772990 : gcc_checking_assert (a_ent != b_ent
14426 : : && !a->is_binding ()
14427 : : && !b->is_binding ());
14428 : :
14429 : : /* Implicit typedefs come first. */
14430 : 772990 : bool a_implicit = DECL_IMPLICIT_TYPEDEF_P (a_ent);
14431 : 772990 : bool b_implicit = DECL_IMPLICIT_TYPEDEF_P (b_ent);
14432 : 772840 : if (a_implicit || b_implicit)
14433 : : {
14434 : : /* A binding with two implicit type decls? That's unpossible! */
14435 : 300 : gcc_checking_assert (!(a_implicit && b_implicit));
14436 : 450 : return a_implicit ? -1 : +1; /* Implicit first. */
14437 : : }
14438 : :
14439 : : /* Hidden before non-hidden. */
14440 : 772690 : bool a_hidden = a->is_hidden ();
14441 : 772690 : bool b_hidden = b->is_hidden ();
14442 : 772690 : if (a_hidden != b_hidden)
14443 : 78212 : return a_hidden ? -1 : +1;
14444 : :
14445 : 721566 : bool a_using = a->get_entity_kind () == depset::EK_USING;
14446 : 721566 : bool a_export;
14447 : 721566 : if (a_using)
14448 : : {
14449 : 39598 : a_export = OVL_EXPORT_P (a_ent);
14450 : 39598 : a_ent = OVL_FUNCTION (a_ent);
14451 : : }
14452 : 681968 : else if (TREE_CODE (a_ent) == CONST_DECL
14453 : 0 : && DECL_LANG_SPECIFIC (a_ent)
14454 : 681968 : && DECL_MODULE_EXPORT_P (a_ent))
14455 : : a_export = true;
14456 : : else
14457 : 681968 : a_export = DECL_MODULE_EXPORT_P (TREE_CODE (a_ent) == CONST_DECL
14458 : : ? TYPE_NAME (TREE_TYPE (a_ent))
14459 : : : STRIP_TEMPLATE (a_ent));
14460 : :
14461 : 721566 : bool b_using = b->get_entity_kind () == depset::EK_USING;
14462 : 721566 : bool b_export;
14463 : 721566 : if (b_using)
14464 : : {
14465 : 32570 : b_export = OVL_EXPORT_P (b_ent);
14466 : 32570 : b_ent = OVL_FUNCTION (b_ent);
14467 : : }
14468 : 688996 : else if (TREE_CODE (b_ent) == CONST_DECL
14469 : 0 : && DECL_LANG_SPECIFIC (b_ent)
14470 : 688996 : && DECL_MODULE_EXPORT_P (b_ent))
14471 : : b_export = true;
14472 : : else
14473 : 688996 : b_export = DECL_MODULE_EXPORT_P (TREE_CODE (b_ent) == CONST_DECL
14474 : : ? TYPE_NAME (TREE_TYPE (b_ent))
14475 : : : STRIP_TEMPLATE (b_ent));
14476 : :
14477 : : /* Non-exports before exports. */
14478 : 721566 : if (a_export != b_export)
14479 : 72 : return a_export ? +1 : -1;
14480 : :
14481 : : /* At this point we don't care, but want a stable sort. */
14482 : :
14483 : 721521 : if (a_using != b_using)
14484 : : /* using first. */
14485 : 35807 : return a_using? -1 : +1;
14486 : :
14487 : 695307 : return DECL_UID (a_ent) < DECL_UID (b_ent) ? -1 : +1;
14488 : : }
14489 : :
14490 : : /* True iff TMPL has an explicit instantiation definition.
14491 : :
14492 : : This is local to module.cc because register_specialization skips adding most
14493 : : instantiations unless module_maybe_has_cmi_p. */
14494 : :
14495 : : static bool
14496 : 48 : template_has_explicit_inst (tree tmpl)
14497 : : {
14498 : 54 : for (tree t = DECL_TEMPLATE_INSTANTIATIONS (tmpl); t; t = TREE_CHAIN (t))
14499 : : {
14500 : 12 : tree spec = TREE_VALUE (t);
14501 : 12 : if (DECL_EXPLICIT_INSTANTIATION (spec)
14502 : 12 : && !DECL_REALLY_EXTERN (spec))
14503 : : return true;
14504 : : }
14505 : : return false;
14506 : : }
14507 : :
14508 : : /* Sort the bindings, issue errors about bad internal refs. */
14509 : :
14510 : : bool
14511 : 2170 : depset::hash::finalize_dependencies ()
14512 : : {
14513 : 2170 : bool ok = true;
14514 : 3761560 : for (depset *dep : *this)
14515 : : {
14516 : 1879695 : if (dep->is_binding ())
14517 : : {
14518 : : /* Keep the containing namespace dep first. */
14519 : 213619 : gcc_checking_assert (dep->deps.length () > 1
14520 : : && (dep->deps[0]->get_entity_kind ()
14521 : : == EK_NAMESPACE)
14522 : : && (dep->deps[0]->get_entity ()
14523 : : == dep->get_entity ()));
14524 : 213619 : if (dep->deps.length () > 2)
14525 : 16542 : gcc_qsort (&dep->deps[1], dep->deps.length () - 1,
14526 : : sizeof (dep->deps[1]), binding_cmp);
14527 : : }
14528 : 1666145 : else if (dep->is_exposure () && !dep->is_tu_local ())
14529 : : {
14530 : 69 : ok = false;
14531 : 69 : bool explained = false;
14532 : 69 : tree decl = dep->get_entity ();
14533 : :
14534 : 282 : for (depset *rdep : dep->deps)
14535 : 207 : if (!rdep->is_binding () && rdep->is_tu_local ())
14536 : : {
14537 : : // FIXME:QOI Better location information? We're
14538 : : // losing, so it doesn't matter about efficiency
14539 : 60 : tree exposed = rdep->get_entity ();
14540 : 60 : auto_diagnostic_group d;
14541 : 60 : error_at (DECL_SOURCE_LOCATION (decl),
14542 : : "%qD exposes TU-local entity %qD", decl, exposed);
14543 : 60 : bool informed = is_tu_local_entity (exposed, /*explain=*/true);
14544 : 60 : gcc_checking_assert (informed);
14545 : 60 : explained = true;
14546 : 60 : break;
14547 : 60 : }
14548 : :
14549 : 69 : if (!explained && VAR_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
14550 : : {
14551 : 9 : auto_diagnostic_group d;
14552 : 9 : error_at (DECL_SOURCE_LOCATION (decl),
14553 : : "%qD is declared %<constexpr%> and is initialized to "
14554 : : "a TU-local value", decl);
14555 : 9 : bool informed = is_tu_local_value (decl, DECL_INITIAL (decl),
14556 : : /*explain=*/true);
14557 : 9 : gcc_checking_assert (informed);
14558 : 9 : explained = true;
14559 : 9 : }
14560 : :
14561 : : /* We should have emitted an error above. */
14562 : 69 : gcc_checking_assert (explained);
14563 : : }
14564 : 1666007 : else if (warn_template_names_tu_local
14565 : 1860047 : && dep->refs_tu_local () && !dep->is_tu_local ())
14566 : : {
14567 : 57 : tree decl = dep->get_entity ();
14568 : :
14569 : : /* Friend decls in a class body are ignored, but this is harmless:
14570 : : it should not impact any consumers. */
14571 : 57 : if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
14572 : 9 : continue;
14573 : :
14574 : : /* We should now only be warning about templates. */
14575 : 48 : gcc_checking_assert
14576 : : (TREE_CODE (decl) == TEMPLATE_DECL
14577 : : && VAR_OR_FUNCTION_DECL_P (DECL_TEMPLATE_RESULT (decl)));
14578 : :
14579 : : /* Don't warn if we've seen any explicit instantiation definitions,
14580 : : the intent might be for importers to only use those. */
14581 : 48 : if (template_has_explicit_inst (decl))
14582 : 6 : continue;
14583 : :
14584 : 171 : for (depset *rdep : dep->deps)
14585 : 135 : if (!rdep->is_binding () && rdep->is_tu_local ())
14586 : : {
14587 : 42 : tree ref = rdep->get_entity ();
14588 : 42 : auto_diagnostic_group d;
14589 : 42 : if (warning_at (DECL_SOURCE_LOCATION (decl),
14590 : : OPT_Wtemplate_names_tu_local,
14591 : : "%qD refers to TU-local entity %qD and cannot "
14592 : : "be instantiated in other TUs", decl, ref))
14593 : 42 : is_tu_local_entity (ref, /*explain=*/true);
14594 : 42 : break;
14595 : 42 : }
14596 : : }
14597 : : }
14598 : :
14599 : 2170 : return ok;
14600 : : }
14601 : :
14602 : : /* Core of TARJAN's algorithm to find Strongly Connected Components
14603 : : within a graph. See https://en.wikipedia.org/wiki/
14604 : : Tarjan%27s_strongly_connected_components_algorithm for details.
14605 : :
14606 : : We use depset::section as lowlink. Completed nodes have
14607 : : depset::cluster containing the cluster number, with the top
14608 : : bit set.
14609 : :
14610 : : A useful property is that the output vector is a reverse
14611 : : topological sort of the resulting DAG. In our case that means
14612 : : dependent SCCs are found before their dependers. We make use of
14613 : : that property. */
14614 : :
14615 : : void
14616 : 2993666 : depset::tarjan::connect (depset *v)
14617 : : {
14618 : 2993666 : gcc_checking_assert (v->is_binding ()
14619 : : || !(v->is_tu_local ()
14620 : : || v->is_unreached ()
14621 : : || v->is_import ()));
14622 : :
14623 : 2993666 : v->cluster = v->section = ++index;
14624 : 2993666 : stack.safe_push (v);
14625 : :
14626 : : /* Walk all our dependencies, ignore a first marked slot */
14627 : 25524832 : for (unsigned ix = v->is_special (); ix != v->deps.length (); ix++)
14628 : : {
14629 : 9774310 : depset *dep = v->deps[ix];
14630 : :
14631 : 9774310 : if (dep->is_binding ()
14632 : 28785945 : || !(dep->is_import () || dep->is_tu_local ()))
14633 : : {
14634 : 9773486 : unsigned lwm = dep->cluster;
14635 : :
14636 : 9773486 : if (!dep->cluster)
14637 : : {
14638 : : /* A new node. Connect it. */
14639 : 1666021 : connect (dep);
14640 : 1666021 : lwm = dep->section;
14641 : : }
14642 : :
14643 : 9773486 : if (dep->section && v->section > lwm)
14644 : 1537393 : v->section = lwm;
14645 : : }
14646 : : }
14647 : :
14648 : 2993666 : if (v->section == v->cluster)
14649 : : {
14650 : : /* Root of a new SCC. Push all the members onto the result list. */
14651 : : unsigned num = v->cluster;
14652 : 2993666 : depset *p;
14653 : 2993666 : do
14654 : : {
14655 : 2993666 : p = stack.pop ();
14656 : 2993666 : p->cluster = num;
14657 : 2993666 : p->section = 0;
14658 : 2993666 : result.quick_push (p);
14659 : : }
14660 : 2993666 : while (p != v);
14661 : : }
14662 : 2993666 : }
14663 : :
14664 : : /* Compare two depsets. The specific ordering is unimportant, we're
14665 : : just trying to get consistency. */
14666 : :
14667 : : static int
14668 : 144129360 : depset_cmp (const void *a_, const void *b_)
14669 : : {
14670 : 144129360 : depset *a = *(depset *const *)a_;
14671 : 144129360 : depset *b = *(depset *const *)b_;
14672 : :
14673 : 144129360 : depset::entity_kind a_kind = a->get_entity_kind ();
14674 : 144129360 : depset::entity_kind b_kind = b->get_entity_kind ();
14675 : :
14676 : 144129360 : if (a_kind != b_kind)
14677 : : /* Different entity kinds, order by that. */
14678 : 6897795 : return a_kind < b_kind ? -1 : +1;
14679 : :
14680 : 139211603 : tree a_decl = a->get_entity ();
14681 : 139211603 : tree b_decl = b->get_entity ();
14682 : 139211603 : if (a_kind == depset::EK_USING)
14683 : : {
14684 : : /* If one is a using, the other must be too. */
14685 : 1667113 : a_decl = OVL_FUNCTION (a_decl);
14686 : 1667113 : b_decl = OVL_FUNCTION (b_decl);
14687 : : }
14688 : :
14689 : 139211603 : if (a_decl != b_decl)
14690 : : /* Different entities, order by their UID. */
14691 : 128244811 : return DECL_UID (a_decl) < DECL_UID (b_decl) ? -1 : +1;
14692 : :
14693 : 10966792 : if (a_kind == depset::EK_BINDING)
14694 : : {
14695 : : /* Both are bindings. Order by identifier hash. */
14696 : 10961292 : gcc_checking_assert (a->get_name () != b->get_name ());
14697 : 10961292 : hashval_t ah = IDENTIFIER_HASH_VALUE (a->get_name ());
14698 : 10961292 : hashval_t bh = IDENTIFIER_HASH_VALUE (b->get_name ());
14699 : 16333100 : return (ah == bh ? 0 : ah < bh ? -1 : +1);
14700 : : }
14701 : :
14702 : : /* They are the same decl. This can happen with two using decls
14703 : : pointing to the same target. The best we can aim for is
14704 : : consistently telling qsort how to order them. Hopefully we'll
14705 : : never have to debug a case that depends on this. Oh, who am I
14706 : : kidding? Good luck. */
14707 : 5500 : gcc_checking_assert (a_kind == depset::EK_USING);
14708 : :
14709 : : /* Order by depset address. Not the best, but it is something. */
14710 : 5500 : return a < b ? -1 : +1;
14711 : : }
14712 : :
14713 : : /* Sort the clusters in SCC such that those that depend on one another
14714 : : are placed later. */
14715 : :
14716 : : // FIXME: I am not convinced this is needed and, if needed,
14717 : : // sufficient. We emit the decls in this order but that emission
14718 : : // could walk into later decls (from the body of the decl, or default
14719 : : // arg-like things). Why doesn't that walk do the right thing? And
14720 : : // if it DTRT why do we need to sort here -- won't things naturally
14721 : : // work? I think part of the issue is that when we're going to refer
14722 : : // to an entity by name, and that entity is in the same cluster as us,
14723 : : // we need to actually walk that entity, if we've not already walked
14724 : : // it.
14725 : : static void
14726 : 381292 : sort_cluster (depset::hash *original, depset *scc[], unsigned size)
14727 : : {
14728 : 381292 : depset::hash table (size, original);
14729 : :
14730 : 381292 : dump.indent ();
14731 : :
14732 : : /* Place bindings last, usings before that. It's not strictly
14733 : : necessary, but it does make things neater. Says Mr OCD. */
14734 : : unsigned bind_lwm = size;
14735 : : unsigned use_lwm = size;
14736 : 1997178 : for (unsigned ix = 0; ix != use_lwm;)
14737 : : {
14738 : 1615886 : depset *dep = scc[ix];
14739 : 1615886 : switch (dep->get_entity_kind ())
14740 : : {
14741 : 213474 : case depset::EK_BINDING:
14742 : : /* Move to end. No increment. Notice this could be moving
14743 : : a using decl, which we'll then move again. */
14744 : 213474 : if (--bind_lwm != ix)
14745 : : {
14746 : 111661 : scc[ix] = scc[bind_lwm];
14747 : 111661 : scc[bind_lwm] = dep;
14748 : : }
14749 : 213474 : if (use_lwm > bind_lwm)
14750 : : {
14751 : 175636 : use_lwm--;
14752 : 175636 : break;
14753 : : }
14754 : : /* We must have copied a using, so move it too. */
14755 : 37838 : dep = scc[ix];
14756 : 37838 : gcc_checking_assert (dep->get_entity_kind () == depset::EK_USING);
14757 : : /* FALLTHROUGH */
14758 : :
14759 : 67014 : case depset::EK_USING:
14760 : 67014 : if (--use_lwm != ix)
14761 : : {
14762 : 49747 : scc[ix] = scc[use_lwm];
14763 : 49747 : scc[use_lwm] = dep;
14764 : : }
14765 : : break;
14766 : :
14767 : 1373236 : case depset::EK_DECL:
14768 : 1373236 : case depset::EK_SPECIALIZATION:
14769 : 1373236 : case depset::EK_PARTIAL:
14770 : 1373236 : table.add_mergeable (dep);
14771 : 1373236 : ix++;
14772 : 1373236 : break;
14773 : :
14774 : 0 : default:
14775 : 0 : gcc_unreachable ();
14776 : : }
14777 : : }
14778 : :
14779 : 381292 : gcc_checking_assert (use_lwm <= bind_lwm);
14780 : 381556 : dump (dumper::MERGE) && dump ("Ordering %u/%u depsets", use_lwm, size);
14781 : :
14782 : 381292 : table.find_dependencies (nullptr);
14783 : :
14784 : 762584 : auto_vec<depset *> order = table.connect ();
14785 : 762584 : gcc_checking_assert (order.length () == use_lwm);
14786 : :
14787 : : /* Now rewrite entries [0,lwm), in the dependency order we
14788 : : discovered. Usually each entity is in its own cluster. Rarely,
14789 : : we can get multi-entity clusters, in which case all but one must
14790 : : only be reached from within the cluster. This happens for
14791 : : something like:
14792 : :
14793 : : template<typename T>
14794 : : auto Foo (const T &arg) -> TPL<decltype (arg)>;
14795 : :
14796 : : The instantiation of TPL will be in the specialization table, and
14797 : : refer to Foo via arg. But we can only get to that specialization
14798 : : from Foo's declaration, so we only need to treat Foo as mergable
14799 : : (We'll do structural comparison of TPL<decltype (arg)>).
14800 : :
14801 : : We approximate finding the single cluster entry dep by checking for
14802 : : entities recursively depending on a dep first seen when streaming
14803 : : its own merge key; the first dep we see in such a cluster should be
14804 : : the first one streamed. */
14805 : : unsigned entry_pos = ~0u;
14806 : : unsigned cluster = ~0u;
14807 : 3509056 : for (unsigned ix = 0; ix != order.length (); ix++)
14808 : : {
14809 : 1373236 : gcc_checking_assert (order[ix]->is_special ());
14810 : 1373236 : bool tight = order[ix]->cluster == cluster;
14811 : 1373236 : depset *dep = order[ix]->deps[0];
14812 : 1373959 : dump (dumper::MERGE)
14813 : 1443 : && dump ("Mergeable %u is %N%s%s", ix, dep->get_entity (),
14814 : 723 : tight ? " (tight)" : "", dep->is_entry () ? " (entry)" : "");
14815 : 1373236 : scc[ix] = dep;
14816 : 1373236 : if (tight)
14817 : : {
14818 : 116 : gcc_checking_assert (dep->is_maybe_recursive ());
14819 : 116 : if (dep->is_entry ())
14820 : : {
14821 : : /* There should only be one entry dep in a cluster. */
14822 : 6 : gcc_checking_assert (!scc[entry_pos]->is_entry ());
14823 : 6 : gcc_checking_assert (scc[entry_pos]->is_maybe_recursive ());
14824 : 6 : scc[ix] = scc[entry_pos];
14825 : 6 : scc[entry_pos] = dep;
14826 : : }
14827 : : }
14828 : : else
14829 : : entry_pos = ix;
14830 : 1373236 : cluster = order[ix]->cluster;
14831 : : }
14832 : :
14833 : 381556 : dump (dumper::MERGE) && dump ("Ordered %u keys", order.length ());
14834 : 381292 : dump.outdent ();
14835 : 381292 : }
14836 : :
14837 : : /* Reduce graph to SCCS clusters. SCCS will be populated with the
14838 : : depsets in dependency order. Each depset's CLUSTER field contains
14839 : : its cluster number. Each SCC has a unique cluster number, and are
14840 : : contiguous in SCCS. Cluster numbers are otherwise arbitrary. */
14841 : :
14842 : : vec<depset *>
14843 : 383441 : depset::hash::connect ()
14844 : : {
14845 : 383441 : tarjan connector (size ());
14846 : 383441 : vec<depset *> deps;
14847 : 383441 : deps.create (size ());
14848 : 6888089 : for (depset *item : *this)
14849 : : {
14850 : 3252324 : entity_kind kind = item->get_entity_kind ();
14851 : 3038850 : if (kind == EK_BINDING
14852 : 3038850 : || !(kind == EK_REDIRECT
14853 : 3010755 : || item->is_tu_local ()
14854 : 3010647 : || item->is_unreached ()
14855 : 2780674 : || item->is_import ()))
14856 : 2993666 : deps.quick_push (item);
14857 : : }
14858 : :
14859 : : /* Iteration over the hash table is an unspecified ordering. While
14860 : : that has advantages, it causes 2 problems. Firstly repeatable
14861 : : builds are tricky. Secondly creating testcases that check
14862 : : dependencies are correct by making sure a bad ordering would
14863 : : happen if that was wrong. */
14864 : 2094527 : deps.qsort (depset_cmp);
14865 : :
14866 : 3377107 : while (deps.length ())
14867 : : {
14868 : 2993666 : depset *v = deps.pop ();
14869 : 2993666 : dump (dumper::CLUSTER) &&
14870 : 1599 : (v->is_binding ()
14871 : 195 : ? dump ("Connecting binding %P", v->get_entity (), v->get_name ())
14872 : 1404 : : dump ("Connecting %s %s %C:%N",
14873 : 1404 : is_key_order () ? "key-order"
14874 : 774 : : !v->has_defn () ? "declaration" : "definition",
14875 : 1404 : v->entity_kind_name (), TREE_CODE (v->get_entity ()),
14876 : : v->get_entity ()));
14877 : 2993666 : if (!v->cluster)
14878 : 1327645 : connector.connect (v);
14879 : : }
14880 : :
14881 : 383441 : deps.release ();
14882 : 766882 : return connector.result;
14883 : 383441 : }
14884 : :
14885 : : /* Initialize location spans. */
14886 : :
14887 : : void
14888 : 3881 : loc_spans::init (const line_maps *lmaps, const line_map_ordinary *map)
14889 : : {
14890 : 3881 : gcc_checking_assert (!init_p ());
14891 : 3881 : spans = new vec<span> ();
14892 : 3881 : spans->reserve (20);
14893 : :
14894 : 3881 : span interval;
14895 : 3881 : interval.ordinary.first = 0;
14896 : 3881 : interval.macro.second = MAX_LOCATION_T + 1;
14897 : 3881 : interval.ordinary_delta = interval.macro_delta = 0;
14898 : :
14899 : : /* A span for reserved fixed locs. */
14900 : 3881 : interval.ordinary.second
14901 : 3881 : = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0));
14902 : 3881 : interval.macro.first = interval.macro.second;
14903 : 3881 : dump (dumper::LOCATION)
14904 : 42 : && dump ("Fixed span %u ordinary:[%K,%K) macro:[%K,%K)", spans->length (),
14905 : : interval.ordinary.first, interval.ordinary.second,
14906 : : interval.macro.first, interval.macro.second);
14907 : 3881 : spans->quick_push (interval);
14908 : :
14909 : : /* A span for command line & forced headers. */
14910 : 3881 : interval.ordinary.first = interval.ordinary.second;
14911 : 3881 : interval.macro.second = interval.macro.first;
14912 : 3881 : if (map)
14913 : : {
14914 : 3875 : interval.ordinary.second = map->start_location;
14915 : 3875 : interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (lmaps);
14916 : : }
14917 : 3881 : dump (dumper::LOCATION)
14918 : 21 : && dump ("Pre span %u ordinary:[%K,%K) macro:[%K,%K)", spans->length (),
14919 : : interval.ordinary.first, interval.ordinary.second,
14920 : : interval.macro.first, interval.macro.second);
14921 : 3881 : spans->quick_push (interval);
14922 : :
14923 : : /* Start an interval for the main file. */
14924 : 3881 : interval.ordinary.first = interval.ordinary.second;
14925 : 3881 : interval.macro.second = interval.macro.first;
14926 : 3881 : dump (dumper::LOCATION)
14927 : 21 : && dump ("Main span %u ordinary:[%K,*) macro:[*,%K)", spans->length (),
14928 : : interval.ordinary.first, interval.macro.second);
14929 : 3881 : spans->quick_push (interval);
14930 : 3881 : }
14931 : :
14932 : : /* Reopen the span, if we want the about-to-be-inserted set of maps to
14933 : : be propagated in our own location table. I.e. we are the primary
14934 : : interface and we're importing a partition. */
14935 : :
14936 : : bool
14937 : 2428 : loc_spans::maybe_propagate (module_state *import, location_t hwm)
14938 : : {
14939 : 2428 : bool opened = (module_interface_p () && !module_partition_p ()
14940 : 2744 : && import->is_partition ());
14941 : 130 : if (opened)
14942 : 130 : open (hwm);
14943 : 2428 : return opened;
14944 : : }
14945 : :
14946 : : /* Open a new linemap interval. The just-created ordinary map is the
14947 : : first map of the interval. */
14948 : :
14949 : : void
14950 : 936 : loc_spans::open (location_t hwm)
14951 : : {
14952 : 936 : span interval;
14953 : 936 : interval.ordinary.first = interval.ordinary.second = hwm;
14954 : 1872 : interval.macro.first = interval.macro.second
14955 : 936 : = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
14956 : 936 : interval.ordinary_delta = interval.macro_delta = 0;
14957 : 936 : dump (dumper::LOCATION)
14958 : 0 : && dump ("Opening span %u ordinary:[%K,... macro:...,%K)",
14959 : 0 : spans->length (), interval.ordinary.first,
14960 : : interval.macro.second);
14961 : 936 : if (spans->length ())
14962 : : {
14963 : : /* No overlapping! */
14964 : 936 : auto &last = spans->last ();
14965 : 936 : gcc_checking_assert (interval.ordinary.first >= last.ordinary.second);
14966 : 936 : gcc_checking_assert (interval.macro.second <= last.macro.first);
14967 : : }
14968 : 936 : spans->safe_push (interval);
14969 : 936 : }
14970 : :
14971 : : /* Close out the current linemap interval. The last maps are within
14972 : : the interval. */
14973 : :
14974 : : void
14975 : 4814 : loc_spans::close ()
14976 : : {
14977 : 4814 : span &interval = spans->last ();
14978 : :
14979 : 4814 : interval.ordinary.second
14980 : 4814 : = ((line_table->highest_location
14981 : 4814 : + (loc_one << line_table->default_range_bits))
14982 : 4814 : & ~((loc_one << line_table->default_range_bits) - 1));
14983 : 4814 : interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
14984 : 4814 : dump (dumper::LOCATION)
14985 : 21 : && dump ("Closing span %u ordinary:[%K,%K) macro:[%K,%K)",
14986 : 21 : spans->length () - 1,
14987 : : interval.ordinary.first,interval.ordinary.second,
14988 : : interval.macro.first, interval.macro.second);
14989 : 4814 : }
14990 : :
14991 : : /* Given an ordinary location LOC, return the lmap_interval it resides
14992 : : in. NULL if it is not in an interval. */
14993 : :
14994 : : const loc_spans::span *
14995 : 43773105 : loc_spans::ordinary (location_t loc)
14996 : : {
14997 : 43773105 : unsigned len = spans->length ();
14998 : 87406968 : unsigned pos = 0;
14999 : 87412204 : while (len)
15000 : : {
15001 : 87406149 : unsigned half = len / 2;
15002 : 87406149 : const span &probe = (*spans)[pos + half];
15003 : 87406149 : if (loc < probe.ordinary.first)
15004 : : len = half;
15005 : 87400913 : else if (loc < probe.ordinary.second)
15006 : : return &probe;
15007 : : else
15008 : : {
15009 : 43633863 : pos += half + 1;
15010 : 43633863 : len = len - (half + 1);
15011 : : }
15012 : : }
15013 : : return NULL;
15014 : : }
15015 : :
15016 : : /* Likewise, given a macro location LOC, return the lmap interval it
15017 : : resides in. */
15018 : :
15019 : : const loc_spans::span *
15020 : 4833528 : loc_spans::macro (location_t loc)
15021 : : {
15022 : 4833528 : unsigned len = spans->length ();
15023 : 9661775 : unsigned pos = 0;
15024 : 9661775 : while (len)
15025 : : {
15026 : 9661763 : unsigned half = len / 2;
15027 : 9661763 : const span &probe = (*spans)[pos + half];
15028 : 9661763 : if (loc >= probe.macro.second)
15029 : : len = half;
15030 : 9661763 : else if (loc >= probe.macro.first)
15031 : : return &probe;
15032 : : else
15033 : : {
15034 : 4828247 : pos += half + 1;
15035 : 4828247 : len = len - (half + 1);
15036 : : }
15037 : : }
15038 : : return NULL;
15039 : : }
15040 : :
15041 : : /* Return the ordinary location closest to FROM. */
15042 : :
15043 : : static location_t
15044 : 5552 : ordinary_loc_of (line_maps *lmaps, location_t from)
15045 : : {
15046 : 11107 : while (!IS_ORDINARY_LOC (from))
15047 : : {
15048 : 3 : if (IS_ADHOC_LOC (from))
15049 : 3 : from = get_location_from_adhoc_loc (lmaps, from);
15050 : 3 : if (from >= LINEMAPS_MACRO_LOWEST_LOCATION (lmaps))
15051 : : {
15052 : : /* Find the ordinary location nearest FROM. */
15053 : 0 : const line_map *map = linemap_lookup (lmaps, from);
15054 : 0 : const line_map_macro *mac_map = linemap_check_macro (map);
15055 : 0 : from = mac_map->get_expansion_point_location ();
15056 : : }
15057 : : }
15058 : 5552 : return from;
15059 : : }
15060 : :
15061 : : static module_state **
15062 : 9722 : get_module_slot (tree name, module_state *parent, bool partition, bool insert)
15063 : : {
15064 : 9722 : module_state_hash::compare_type ct (name, uintptr_t (parent) | partition);
15065 : 9722 : hashval_t hv = module_state_hash::hash (ct);
15066 : :
15067 : 9722 : return modules_hash->find_slot_with_hash (ct, hv, insert ? INSERT : NO_INSERT);
15068 : : }
15069 : :
15070 : : static module_state *
15071 : 376 : get_primary (module_state *parent)
15072 : : {
15073 : 3469 : while (parent->is_partition ())
15074 : 334 : parent = parent->parent;
15075 : :
15076 : 3135 : if (!parent->name)
15077 : : // Implementation unit has null name
15078 : 126 : parent = parent->parent;
15079 : :
15080 : 357 : return parent;
15081 : : }
15082 : :
15083 : : /* Find or create module NAME & PARENT in the hash table. */
15084 : :
15085 : : module_state *
15086 : 9722 : get_module (tree name, module_state *parent, bool partition)
15087 : : {
15088 : : /* We might be given an empty NAME if preprocessing fails to handle
15089 : : a header-name token. */
15090 : 9722 : if (name && TREE_CODE (name) == STRING_CST
15091 : 12285 : && TREE_STRING_LENGTH (name) == 0)
15092 : : return nullptr;
15093 : :
15094 : 9722 : if (partition)
15095 : : {
15096 : 823 : if (!parent)
15097 : 169 : parent = get_primary ((*modules)[0]);
15098 : :
15099 : 823 : if (!parent->is_partition () && !parent->flatname)
15100 : 196 : parent->set_flatname ();
15101 : : }
15102 : :
15103 : 9722 : module_state **slot = get_module_slot (name, parent, partition, true);
15104 : 9722 : module_state *state = *slot;
15105 : 9722 : if (!state)
15106 : : {
15107 : 5327 : state = (new (ggc_alloc<module_state> ())
15108 : 5327 : module_state (name, parent, partition));
15109 : 5327 : *slot = state;
15110 : : }
15111 : : return state;
15112 : : }
15113 : :
15114 : : /* Process string name PTR into a module_state. */
15115 : :
15116 : : static module_state *
15117 : 341 : get_module (const char *ptr)
15118 : : {
15119 : : /* On DOS based file systems, there is an ambiguity with A:B which can be
15120 : : interpreted as a module Module:Partition or Drive:PATH. Interpret strings
15121 : : which clearly starts as pathnames as header-names and everything else is
15122 : : treated as a (possibly malformed) named moduled. */
15123 : 341 : if (IS_DIR_SEPARATOR (ptr[ptr[0] == '.']) // ./FOO or /FOO
15124 : : #if HAVE_DOS_BASED_FILE_SYSTEM
15125 : : || (HAS_DRIVE_SPEC (ptr) && IS_DIR_SEPARATOR (ptr[2])) // A:/FOO
15126 : : #endif
15127 : : || false)
15128 : : /* A header name. */
15129 : 103 : return get_module (build_string (strlen (ptr), ptr));
15130 : :
15131 : : bool partition = false;
15132 : : module_state *mod = NULL;
15133 : :
15134 : 1029 : for (const char *probe = ptr;; probe++)
15135 : 1267 : if (!*probe || *probe == '.' || *probe == ':')
15136 : : {
15137 : 307 : if (probe == ptr)
15138 : : return NULL;
15139 : :
15140 : 307 : mod = get_module (get_identifier_with_length (ptr, probe - ptr),
15141 : : mod, partition);
15142 : 307 : ptr = probe;
15143 : 307 : if (*ptr == ':')
15144 : : {
15145 : 69 : if (partition)
15146 : : return NULL;
15147 : : partition = true;
15148 : : }
15149 : :
15150 : 307 : if (!*ptr++)
15151 : : break;
15152 : : }
15153 : 960 : else if (!(ISALPHA (*probe) || *probe == '_'
15154 : 12 : || (probe != ptr && ISDIGIT (*probe))))
15155 : : return NULL;
15156 : :
15157 : : return mod;
15158 : : }
15159 : :
15160 : : /* Create a new mapper connecting to OPTION. */
15161 : :
15162 : : module_client *
15163 : 3881 : make_mapper (location_t loc, class mkdeps *deps)
15164 : : {
15165 : 3881 : timevar_start (TV_MODULE_MAPPER);
15166 : 3881 : const char *option = module_mapper_name;
15167 : 3881 : if (!option)
15168 : 3839 : option = getenv ("CXX_MODULE_MAPPER");
15169 : :
15170 : 7762 : mapper = module_client::open_module_client
15171 : 3881 : (loc, option, deps, &set_cmi_repo,
15172 : 3881 : (save_decoded_options[0].opt_index == OPT_SPECIAL_program_name)
15173 : 3881 : && save_decoded_options[0].arg != progname
15174 : : ? save_decoded_options[0].arg : nullptr);
15175 : :
15176 : 3881 : timevar_stop (TV_MODULE_MAPPER);
15177 : :
15178 : 3881 : return mapper;
15179 : : }
15180 : :
15181 : : static unsigned lazy_snum;
15182 : :
15183 : : static bool
15184 : 8314 : recursive_lazy (unsigned snum = ~0u)
15185 : : {
15186 : 8314 : if (lazy_snum)
15187 : : {
15188 : 0 : error_at (input_location, "recursive lazy load");
15189 : 0 : return true;
15190 : : }
15191 : :
15192 : 8314 : lazy_snum = snum;
15193 : 8314 : return false;
15194 : : }
15195 : :
15196 : : /* If THIS is the current purview, issue an import error and return false. */
15197 : :
15198 : : bool
15199 : 2281 : module_state::check_not_purview (location_t from)
15200 : : {
15201 : 2281 : module_state *imp = (*modules)[0];
15202 : 2281 : if (imp && !imp->name)
15203 : 1716 : imp = imp->parent;
15204 : 2281 : if (imp == this)
15205 : : {
15206 : : /* Cannot import the current module. */
15207 : 12 : auto_diagnostic_group d;
15208 : 12 : error_at (from, "cannot import module in its own purview");
15209 : 12 : inform (loc, "module %qs declared here", get_flatname ());
15210 : 12 : return false;
15211 : 12 : }
15212 : : return true;
15213 : : }
15214 : :
15215 : : /* Module name substitutions. */
15216 : : static vec<module_state *,va_heap> substs;
15217 : :
15218 : : void
15219 : 6527 : module_state::mangle (bool include_partition)
15220 : : {
15221 : 6527 : if (subst)
15222 : 176 : mangle_module_substitution (subst);
15223 : : else
15224 : : {
15225 : 6351 : if (parent)
15226 : 677 : parent->mangle (include_partition);
15227 : 6351 : if (include_partition || !is_partition ())
15228 : : {
15229 : : // Partitions are significant for global initializer
15230 : : // functions
15231 : 6272 : bool partition = is_partition () && !parent->is_partition ();
15232 : 6272 : subst = mangle_module_component (name, partition);
15233 : 6272 : substs.safe_push (this);
15234 : : }
15235 : : }
15236 : 6527 : }
15237 : :
15238 : : void
15239 : 5850 : mangle_module (int mod, bool include_partition)
15240 : : {
15241 : 5850 : module_state *imp = (*modules)[mod];
15242 : :
15243 : 5850 : gcc_checking_assert (!imp->is_header ());
15244 : :
15245 : 5850 : if (!imp->name)
15246 : : /* Set when importing the primary module interface. */
15247 : 210 : imp = imp->parent;
15248 : :
15249 : 5850 : imp->mangle (include_partition);
15250 : 5850 : }
15251 : :
15252 : : /* Clean up substitutions. */
15253 : : void
15254 : 5644 : mangle_module_fini ()
15255 : : {
15256 : 11916 : while (substs.length ())
15257 : 6272 : substs.pop ()->subst = 0;
15258 : 5644 : }
15259 : :
15260 : : /* Announce WHAT about the module. */
15261 : :
15262 : : void
15263 : 10053 : module_state::announce (const char *what) const
15264 : : {
15265 : 10053 : if (noisy_p ())
15266 : : {
15267 : 0 : fprintf (stderr, " %s:%s", what, get_flatname ());
15268 : 0 : fflush (stderr);
15269 : : }
15270 : 10053 : }
15271 : :
15272 : : /* A human-readable README section. The contents of this section to
15273 : : not contribute to the CRC, so the contents can change per
15274 : : compilation. That allows us to embed CWD, hostname, build time and
15275 : : what not. It is a STRTAB that may be extracted with:
15276 : : readelf -pgnu.c++.README $(module).gcm */
15277 : :
15278 : : void
15279 : 2149 : module_state::write_readme (elf_out *to, cpp_reader *reader, const char *dialect)
15280 : : {
15281 : 2149 : bytes_out readme (to);
15282 : :
15283 : 2149 : readme.begin (false);
15284 : :
15285 : 2149 : readme.printf ("GNU C++ %s",
15286 : 2149 : is_header () ? "header unit"
15287 : 1359 : : !is_partition () ? "primary interface"
15288 : 148 : : is_interface () ? "interface partition"
15289 : : : "internal partition");
15290 : :
15291 : : /* Compiler's version. */
15292 : 2149 : readme.printf ("compiler: %s", version_string);
15293 : :
15294 : : /* Module format version. */
15295 : 2149 : verstr_t string;
15296 : 2149 : version2string (MODULE_VERSION, string);
15297 : 2149 : readme.printf ("version: %s", string);
15298 : :
15299 : : /* Module information. */
15300 : 2149 : readme.printf ("module: %s", get_flatname ());
15301 : 2149 : readme.printf ("source: %s", main_input_filename);
15302 : 2149 : readme.printf ("dialect: %s", dialect);
15303 : 2149 : if (extensions)
15304 : 3 : readme.printf ("extensions: %s",
15305 : 3 : extensions & SE_OPENMP ? "-fopenmp" : "");
15306 : :
15307 : : /* The following fields could be expected to change between
15308 : : otherwise identical compilations. Consider a distributed build
15309 : : system. We should have a way of overriding that. */
15310 : 2149 : if (char *cwd = getcwd (NULL, 0))
15311 : : {
15312 : 2149 : readme.printf ("cwd: %s", cwd);
15313 : 2149 : free (cwd);
15314 : : }
15315 : 4298 : readme.printf ("repository: %s", cmi_repo ? cmi_repo : ".");
15316 : : #if NETWORKING
15317 : : {
15318 : : char hostname[64];
15319 : : if (!gethostname (hostname, sizeof (hostname)))
15320 : : readme.printf ("host: %s", hostname);
15321 : : }
15322 : : #endif
15323 : 2149 : {
15324 : : /* This of course will change! */
15325 : 2149 : time_t stampy;
15326 : 2149 : auto kind = cpp_get_date (reader, &stampy);
15327 : 2149 : if (kind != CPP_time_kind::UNKNOWN)
15328 : : {
15329 : 2149 : struct tm *time;
15330 : :
15331 : 2149 : time = gmtime (&stampy);
15332 : 2149 : readme.print_time ("build", time, "UTC");
15333 : :
15334 : 2149 : if (kind == CPP_time_kind::DYNAMIC)
15335 : : {
15336 : 2149 : time = localtime (&stampy);
15337 : 2149 : readme.print_time ("local", time,
15338 : : #if defined (__USE_MISC) || defined (__USE_BSD) /* Is there a better way? */
15339 : : time->tm_zone
15340 : : #else
15341 : : ""
15342 : : #endif
15343 : : );
15344 : : }
15345 : : }
15346 : : }
15347 : :
15348 : : /* Its direct imports. */
15349 : 2658 : for (unsigned ix = 1; ix < modules->length (); ix++)
15350 : : {
15351 : 509 : module_state *state = (*modules)[ix];
15352 : :
15353 : 509 : if (state->is_direct ())
15354 : 751 : readme.printf ("%s: %s %s", state->exported_p ? "export" : "import",
15355 : : state->get_flatname (), state->filename);
15356 : : }
15357 : :
15358 : 2149 : readme.end (to, to->name (MOD_SNAME_PFX ".README"), NULL);
15359 : 2149 : }
15360 : :
15361 : : /* Sort environment var names in reverse order. */
15362 : :
15363 : : static int
15364 : 0 : env_var_cmp (const void *a_, const void *b_)
15365 : : {
15366 : 0 : const unsigned char *a = *(const unsigned char *const *)a_;
15367 : 0 : const unsigned char *b = *(const unsigned char *const *)b_;
15368 : :
15369 : 0 : for (unsigned ix = 0; ; ix++)
15370 : : {
15371 : 0 : bool a_end = !a[ix] || a[ix] == '=';
15372 : 0 : if (a[ix] == b[ix])
15373 : : {
15374 : 0 : if (a_end)
15375 : : break;
15376 : : }
15377 : : else
15378 : : {
15379 : 0 : bool b_end = !b[ix] || b[ix] == '=';
15380 : :
15381 : 0 : if (!a_end && !b_end)
15382 : 0 : return a[ix] < b[ix] ? +1 : -1;
15383 : 0 : if (a_end && b_end)
15384 : : break;
15385 : 0 : return a_end ? +1 : -1;
15386 : : }
15387 : 0 : }
15388 : :
15389 : : return 0;
15390 : : }
15391 : :
15392 : : /* Write the environment. It is a STRTAB that may be extracted with:
15393 : : readelf -pgnu.c++.ENV $(module).gcm */
15394 : :
15395 : : void
15396 : 0 : module_state::write_env (elf_out *to)
15397 : : {
15398 : 0 : vec<const char *> vars;
15399 : 0 : vars.create (20);
15400 : :
15401 : 0 : extern char **environ;
15402 : 0 : while (const char *var = environ[vars.length ()])
15403 : 0 : vars.safe_push (var);
15404 : 0 : vars.qsort (env_var_cmp);
15405 : :
15406 : 0 : bytes_out env (to);
15407 : 0 : env.begin (false);
15408 : 0 : while (vars.length ())
15409 : 0 : env.printf ("%s", vars.pop ());
15410 : 0 : env.end (to, to->name (MOD_SNAME_PFX ".ENV"), NULL);
15411 : :
15412 : 0 : vars.release ();
15413 : 0 : }
15414 : :
15415 : : /* Write the direct or indirect imports.
15416 : : u:N
15417 : : {
15418 : : u:index
15419 : : s:name
15420 : : u32:crc
15421 : : s:filename (direct)
15422 : : u:exported (direct)
15423 : : } imports[N]
15424 : : */
15425 : :
15426 : : void
15427 : 694 : module_state::write_imports (bytes_out &sec, bool direct)
15428 : : {
15429 : 694 : unsigned count = 0;
15430 : :
15431 : 1458 : for (unsigned ix = 1; ix < modules->length (); ix++)
15432 : : {
15433 : 764 : module_state *imp = (*modules)[ix];
15434 : :
15435 : 764 : if (imp->remap && imp->is_direct () == direct)
15436 : 367 : count++;
15437 : : }
15438 : :
15439 : 694 : gcc_assert (!direct || count);
15440 : :
15441 : 694 : sec.u (count);
15442 : 1458 : for (unsigned ix = 1; ix < modules->length (); ix++)
15443 : : {
15444 : 764 : module_state *imp = (*modules)[ix];
15445 : :
15446 : 764 : if (imp->remap && imp->is_direct () == direct)
15447 : : {
15448 : 499 : dump () && dump ("Writing %simport:%u->%u %M (crc=%x)",
15449 : : !direct ? "indirect "
15450 : 66 : : imp->exported_p ? "exported " : "",
15451 : : ix, imp->remap, imp, imp->crc);
15452 : 367 : sec.u (imp->remap);
15453 : 367 : sec.str (imp->get_flatname ());
15454 : 367 : sec.u32 (imp->crc);
15455 : 367 : if (direct)
15456 : : {
15457 : 366 : write_location (sec, imp->imported_from ());
15458 : 366 : sec.str (imp->filename);
15459 : 366 : int exportedness = 0;
15460 : 366 : if (imp->exported_p)
15461 : : exportedness = +1;
15462 : 217 : else if (!imp->is_purview_direct ())
15463 : 12 : exportedness = -1;
15464 : 366 : sec.i (exportedness);
15465 : : }
15466 : : }
15467 : : }
15468 : 694 : }
15469 : :
15470 : : /* READER, LMAPS != NULL == direct imports,
15471 : : == NUL == indirect imports. */
15472 : :
15473 : : unsigned
15474 : 586 : module_state::read_imports (bytes_in &sec, cpp_reader *reader, line_maps *lmaps)
15475 : : {
15476 : 586 : unsigned count = sec.u ();
15477 : 586 : unsigned loaded = 0;
15478 : :
15479 : 1480 : while (count--)
15480 : : {
15481 : 308 : unsigned ix = sec.u ();
15482 : 308 : if (ix >= slurp->remap->length () || !ix || (*slurp->remap)[ix])
15483 : : {
15484 : 0 : sec.set_overrun ();
15485 : 0 : break;
15486 : : }
15487 : :
15488 : 308 : const char *name = sec.str (NULL);
15489 : 308 : module_state *imp = get_module (name);
15490 : 308 : unsigned crc = sec.u32 ();
15491 : 308 : int exportedness = 0;
15492 : :
15493 : : /* If the import is a partition, it must be the same primary
15494 : : module as this TU. */
15495 : 308 : if (imp && imp->is_partition () &&
15496 : : (!named_module_p ()
15497 : 126 : || (get_primary ((*modules)[0]) != get_primary (imp))))
15498 : : imp = NULL;
15499 : :
15500 : 308 : if (!imp)
15501 : 0 : sec.set_overrun ();
15502 : 308 : if (sec.get_overrun ())
15503 : : break;
15504 : :
15505 : 308 : if (lmaps)
15506 : : {
15507 : : /* A direct import, maybe load it. */
15508 : 308 : location_t floc = read_location (sec);
15509 : 308 : const char *fname = sec.str (NULL);
15510 : 308 : exportedness = sec.i ();
15511 : :
15512 : 308 : if (sec.get_overrun ())
15513 : : break;
15514 : :
15515 : 308 : if (!imp->check_not_purview (loc))
15516 : 3 : continue;
15517 : :
15518 : 305 : if (imp->loadedness == ML_NONE)
15519 : : {
15520 : 240 : imp->loc = floc;
15521 : 240 : imp->crc = crc;
15522 : 240 : if (!imp->get_flatname ())
15523 : 204 : imp->set_flatname ();
15524 : :
15525 : 240 : unsigned n = dump.push (imp);
15526 : :
15527 : 240 : if (!imp->filename && fname)
15528 : 201 : imp->filename = xstrdup (fname);
15529 : :
15530 : 240 : if (imp->is_partition ())
15531 : 30 : dump () && dump ("Importing elided partition %M", imp);
15532 : :
15533 : 240 : if (!imp->do_import (reader, false))
15534 : 3 : imp = NULL;
15535 : 240 : dump.pop (n);
15536 : 240 : if (!imp)
15537 : 3 : continue;
15538 : : }
15539 : :
15540 : 302 : if (is_partition ())
15541 : : {
15542 : 54 : if (!imp->is_direct ())
15543 : 27 : imp->directness = MD_PARTITION_DIRECT;
15544 : 54 : if (exportedness > 0)
15545 : 3 : imp->exported_p = true;
15546 : : }
15547 : : }
15548 : : else
15549 : : {
15550 : : /* An indirect import, find it, it should already be here. */
15551 : 0 : if (imp->loadedness == ML_NONE)
15552 : : {
15553 : 0 : error_at (loc, "indirect import %qs is not already loaded", name);
15554 : 0 : continue;
15555 : : }
15556 : : }
15557 : :
15558 : 302 : if (imp->crc != crc)
15559 : 0 : error_at (loc, "import %qs has CRC mismatch", imp->get_flatname ());
15560 : :
15561 : 302 : (*slurp->remap)[ix] = (imp->mod << 1) | (lmaps != NULL);
15562 : :
15563 : 302 : if (lmaps && exportedness >= 0)
15564 : 290 : set_import (imp, bool (exportedness));
15565 : 440 : dump () && dump ("Found %simport:%u %M->%u", !lmaps ? "indirect "
15566 : 69 : : exportedness > 0 ? "exported "
15567 : 36 : : exportedness < 0 ? "gmf" : "", ix, imp,
15568 : : imp->mod);
15569 : 302 : loaded++;
15570 : : }
15571 : :
15572 : 586 : return loaded;
15573 : : }
15574 : :
15575 : : /* Write the import table to MOD_SNAME_PFX.imp. */
15576 : :
15577 : : void
15578 : 347 : module_state::write_imports (elf_out *to, unsigned *crc_ptr)
15579 : : {
15580 : 410 : dump () && dump ("Writing imports");
15581 : 347 : dump.indent ();
15582 : :
15583 : 347 : bytes_out sec (to);
15584 : 347 : sec.begin ();
15585 : :
15586 : 347 : write_imports (sec, true);
15587 : 347 : write_imports (sec, false);
15588 : :
15589 : 347 : sec.end (to, to->name (MOD_SNAME_PFX ".imp"), crc_ptr);
15590 : 347 : dump.outdent ();
15591 : 347 : }
15592 : :
15593 : : bool
15594 : 293 : module_state::read_imports (cpp_reader *reader, line_maps *lmaps)
15595 : : {
15596 : 293 : bytes_in sec;
15597 : :
15598 : 293 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".imp"))
15599 : : return false;
15600 : :
15601 : 359 : dump () && dump ("Reading %u imports", slurp->remap->length () - 1);
15602 : 293 : dump.indent ();
15603 : :
15604 : : /* Read the imports. */
15605 : 293 : unsigned direct = read_imports (sec, reader, lmaps);
15606 : 293 : unsigned indirect = read_imports (sec, NULL, NULL);
15607 : 293 : if (direct + indirect + 1 != slurp->remap->length ())
15608 : 6 : from ()->set_error (elf::E_BAD_IMPORT);
15609 : :
15610 : 293 : dump.outdent ();
15611 : 293 : if (!sec.end (from ()))
15612 : : return false;
15613 : : return true;
15614 : 293 : }
15615 : :
15616 : : /* We're the primary module interface, but have partitions. Document
15617 : : them so that non-partition module implementation units know which
15618 : : have already been loaded. */
15619 : :
15620 : : void
15621 : 100 : module_state::write_partitions (elf_out *to, unsigned count, unsigned *crc_ptr)
15622 : : {
15623 : 118 : dump () && dump ("Writing %u elided partitions", count);
15624 : 100 : dump.indent ();
15625 : :
15626 : 100 : bytes_out sec (to);
15627 : 100 : sec.begin ();
15628 : :
15629 : 257 : for (unsigned ix = 1; ix != modules->length (); ix++)
15630 : : {
15631 : 157 : module_state *imp = (*modules)[ix];
15632 : 157 : if (imp->is_partition ())
15633 : : {
15634 : 172 : dump () && dump ("Writing elided partition %M (crc=%x)",
15635 : : imp, imp->crc);
15636 : 142 : sec.str (imp->get_flatname ());
15637 : 142 : sec.u32 (imp->crc);
15638 : 275 : write_location (sec, imp->is_direct ()
15639 : 133 : ? imp->imported_from () : UNKNOWN_LOCATION);
15640 : 142 : sec.str (imp->filename);
15641 : : }
15642 : : }
15643 : :
15644 : 100 : sec.end (to, to->name (MOD_SNAME_PFX ".prt"), crc_ptr);
15645 : 100 : dump.outdent ();
15646 : 100 : }
15647 : :
15648 : : bool
15649 : 15 : module_state::read_partitions (unsigned count)
15650 : : {
15651 : 15 : bytes_in sec;
15652 : 15 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".prt"))
15653 : : return false;
15654 : :
15655 : 18 : dump () && dump ("Reading %u elided partitions", count);
15656 : 15 : dump.indent ();
15657 : :
15658 : 42 : while (count--)
15659 : : {
15660 : 27 : const char *name = sec.str (NULL);
15661 : 27 : unsigned crc = sec.u32 ();
15662 : 27 : location_t floc = read_location (sec);
15663 : 27 : const char *fname = sec.str (NULL);
15664 : :
15665 : 27 : if (sec.get_overrun ())
15666 : : break;
15667 : :
15668 : 33 : dump () && dump ("Reading elided partition %s (crc=%x)", name, crc);
15669 : :
15670 : 27 : module_state *imp = get_module (name);
15671 : 27 : if (!imp /* Partition should be ... */
15672 : 27 : || !imp->is_partition () /* a partition ... */
15673 : 27 : || imp->loadedness != ML_NONE /* that is not yet loaded ... */
15674 : 54 : || get_primary (imp) != this) /* whose primary is this. */
15675 : : {
15676 : 0 : sec.set_overrun ();
15677 : 0 : break;
15678 : : }
15679 : :
15680 : 27 : if (!imp->has_location ())
15681 : 24 : imp->loc = floc;
15682 : 27 : imp->crc = crc;
15683 : 27 : if (!imp->filename && fname[0])
15684 : 24 : imp->filename = xstrdup (fname);
15685 : : }
15686 : :
15687 : 15 : dump.outdent ();
15688 : 15 : if (!sec.end (from ()))
15689 : : return false;
15690 : : return true;
15691 : 15 : }
15692 : :
15693 : : /* Data for config reading and writing. */
15694 : : struct module_state_config {
15695 : : const char *dialect_str = get_dialect ();
15696 : : line_map_uint_t ordinary_locs = 0;
15697 : : line_map_uint_t macro_locs = 0;
15698 : : unsigned num_imports = 0;
15699 : : unsigned num_partitions = 0;
15700 : : unsigned num_entities = 0;
15701 : : unsigned loc_range_bits = 0;
15702 : : unsigned active_init = 0;
15703 : :
15704 : 90549 : static void release ()
15705 : : {
15706 : 90549 : XDELETEVEC (dialect);
15707 : 90549 : dialect = NULL;
15708 : : }
15709 : :
15710 : : private:
15711 : : static const char *get_dialect ();
15712 : : static char *dialect;
15713 : : };
15714 : :
15715 : : char *module_state_config::dialect;
15716 : :
15717 : : /* Generate a string of the significant compilation options.
15718 : : Generally assume the user knows what they're doing, in the same way
15719 : : that object files can be mixed. */
15720 : :
15721 : : const char *
15722 : 4638 : module_state_config::get_dialect ()
15723 : : {
15724 : 4638 : if (!dialect)
15725 : 7432 : dialect = concat (get_cxx_dialect_name (cxx_dialect),
15726 : : /* C++ implies these, only show if disabled. */
15727 : 3716 : flag_exceptions ? "" : "/no-exceptions",
15728 : 3716 : flag_rtti ? "" : "/no-rtti",
15729 : 3716 : flag_new_inheriting_ctors ? "" : "/old-inheriting-ctors",
15730 : : /* C++ 20 implies concepts and coroutines. */
15731 : 1214 : cxx_dialect < cxx20 && flag_concepts ? "/concepts" : "",
15732 : 3716 : (cxx_dialect < cxx20 && flag_coroutines
15733 : : ? "/coroutines" : ""),
15734 : 3716 : flag_module_implicit_inline ? "/implicit-inline" : "",
15735 : 3716 : flag_contracts ? "/contracts" : "",
15736 : : NULL);
15737 : :
15738 : 4638 : return dialect;
15739 : : }
15740 : :
15741 : : /* Contents of a cluster. */
15742 : : enum cluster_tag {
15743 : : ct_decl, /* A decl. */
15744 : : ct_defn, /* A definition. */
15745 : : ct_bind, /* A binding. */
15746 : : ct_hwm
15747 : : };
15748 : :
15749 : : /* Binding modifiers. */
15750 : : enum ct_bind_flags
15751 : : {
15752 : : cbf_export = 0x1, /* An exported decl. */
15753 : : cbf_hidden = 0x2, /* A hidden (friend) decl. */
15754 : : cbf_using = 0x4, /* A using decl. */
15755 : : };
15756 : :
15757 : : /* DEP belongs to a different cluster, seed it to prevent
15758 : : unfortunately timed duplicate import. */
15759 : : // FIXME: QOI For inter-cluster references we could just only pick
15760 : : // one entity from an earlier cluster. Even better track
15761 : : // dependencies between earlier clusters
15762 : :
15763 : : void
15764 : 9341282 : module_state::intercluster_seed (trees_out &sec, unsigned index_hwm, depset *dep)
15765 : : {
15766 : 9341282 : if (dep->is_tu_local ())
15767 : : /* We only stream placeholders for TU-local entities anyway. */;
15768 : 9341135 : else if (dep->is_import () || dep->cluster < index_hwm)
15769 : : {
15770 : 3950848 : tree ent = dep->get_entity ();
15771 : 3950848 : if (!TREE_VISITED (ent))
15772 : : {
15773 : 1702046 : sec.tree_node (ent);
15774 : 1702436 : dump (dumper::CLUSTER)
15775 : 390 : && dump ("Seeded %s %N",
15776 : 390 : dep->is_import () ? "import" : "intercluster", ent);
15777 : : }
15778 : : }
15779 : 9341282 : }
15780 : :
15781 : : /* Write the cluster of depsets in SCC[0-SIZE).
15782 : : dep->section -> section number
15783 : : dep->cluster -> entity number
15784 : : */
15785 : :
15786 : : unsigned
15787 : 381292 : module_state::write_cluster (elf_out *to, depset *scc[], unsigned size,
15788 : : depset::hash &table, unsigned *counts,
15789 : : unsigned *crc_ptr)
15790 : : {
15791 : 388909 : dump () && dump ("Writing section:%u %u depsets", table.section, size);
15792 : 381292 : dump.indent ();
15793 : :
15794 : 381292 : trees_out sec (to, this, table, table.section);
15795 : 381292 : sec.begin ();
15796 : 381292 : unsigned index_lwm = counts[MSC_entities];
15797 : :
15798 : : /* Determine entity numbers, mark for writing. */
15799 : 381574 : dump (dumper::CLUSTER) && dump ("Cluster members:") && (dump.indent (), true);
15800 : 1997178 : for (unsigned ix = 0; ix != size; ix++)
15801 : : {
15802 : 1615886 : depset *b = scc[ix];
15803 : :
15804 : 1615886 : switch (b->get_entity_kind ())
15805 : : {
15806 : 0 : default:
15807 : 0 : gcc_unreachable ();
15808 : :
15809 : 213474 : case depset::EK_BINDING:
15810 : 213474 : {
15811 : 213474 : dump (dumper::CLUSTER)
15812 : 195 : && dump ("[%u]=%s %P", ix, b->entity_kind_name (),
15813 : : b->get_entity (), b->get_name ());
15814 : 213474 : depset *ns_dep = b->deps[0];
15815 : 213474 : gcc_checking_assert (ns_dep->get_entity_kind ()
15816 : : == depset::EK_NAMESPACE
15817 : : && ns_dep->get_entity () == b->get_entity ());
15818 : 481628 : for (unsigned jx = b->deps.length (); --jx;)
15819 : : {
15820 : 268154 : depset *dep = b->deps[jx];
15821 : : // We could be declaring something that is also a
15822 : : // (merged) import
15823 : 297330 : gcc_checking_assert (dep->is_import ()
15824 : : || TREE_VISITED (dep->get_entity ())
15825 : : || (dep->get_entity_kind ()
15826 : : == depset::EK_USING));
15827 : : }
15828 : : }
15829 : : break;
15830 : :
15831 : 1373236 : case depset::EK_DECL:
15832 : 1373236 : case depset::EK_SPECIALIZATION:
15833 : 1373236 : case depset::EK_PARTIAL:
15834 : 1373236 : b->cluster = counts[MSC_entities]++;
15835 : 1373236 : sec.mark_declaration (b->get_entity (), b->has_defn ());
15836 : : /* FALLTHROUGH */
15837 : :
15838 : 1402412 : case depset::EK_USING:
15839 : 2804824 : gcc_checking_assert (!b->is_import ()
15840 : : && !b->is_unreached ());
15841 : 1645689 : dump (dumper::CLUSTER)
15842 : 1014 : && dump ("[%u]=%s %s %N", ix, b->entity_kind_name (),
15843 : 639 : b->has_defn () ? "definition" : "declaration",
15844 : : b->get_entity ());
15845 : : break;
15846 : : }
15847 : : }
15848 : 381574 : dump (dumper::CLUSTER) && (dump.outdent (), true);
15849 : :
15850 : : /* Ensure every out-of-cluster decl is referenced before we start
15851 : : streaming. We must do both imports *and* earlier clusters,
15852 : : because the latter could reach into the former and cause a
15853 : : duplicate loop. */
15854 : 381292 : sec.set_importing (+1);
15855 : 1997178 : for (unsigned ix = 0; ix != size; ix++)
15856 : : {
15857 : 1615886 : depset *b = scc[ix];
15858 : 19512591 : for (unsigned jx = b->is_special (); jx != b->deps.length (); jx++)
15859 : : {
15860 : 8145008 : depset *dep = b->deps[jx];
15861 : :
15862 : 8145008 : if (dep->is_binding ())
15863 : : {
15864 : 1732582 : for (unsigned ix = dep->deps.length (); --ix;)
15865 : : {
15866 : 1196274 : depset *bind = dep->deps[ix];
15867 : 1196274 : if (bind->get_entity_kind () == depset::EK_USING)
15868 : 62354 : bind = bind->deps[1];
15869 : :
15870 : 1196274 : intercluster_seed (sec, index_lwm, bind);
15871 : : }
15872 : : /* Also check the namespace itself. */
15873 : 268154 : dep = dep->deps[0];
15874 : : }
15875 : :
15876 : 8145008 : intercluster_seed (sec, index_lwm, dep);
15877 : : }
15878 : : }
15879 : 381292 : sec.tree_node (NULL_TREE);
15880 : : /* We're done importing now. */
15881 : 381292 : sec.set_importing (-1);
15882 : :
15883 : : /* Write non-definitions. */
15884 : 1997178 : for (unsigned ix = 0; ix != size; ix++)
15885 : : {
15886 : 1615886 : depset *b = scc[ix];
15887 : 1615886 : tree decl = b->get_entity ();
15888 : 1615886 : switch (b->get_entity_kind ())
15889 : : {
15890 : 0 : default:
15891 : 0 : gcc_unreachable ();
15892 : 213474 : break;
15893 : :
15894 : 213474 : case depset::EK_BINDING:
15895 : 213474 : {
15896 : 213474 : gcc_assert (TREE_CODE (decl) == NAMESPACE_DECL);
15897 : 214519 : dump () && dump ("Depset:%u binding %C:%P", ix, TREE_CODE (decl),
15898 : : decl, b->get_name ());
15899 : 213474 : sec.u (ct_bind);
15900 : 213474 : sec.tree_node (decl);
15901 : 213474 : sec.tree_node (b->get_name ());
15902 : :
15903 : : /* Write in reverse order, so reading will see the exports
15904 : : first, thus building the overload chain will be
15905 : : optimized. */
15906 : 695102 : for (unsigned jx = b->deps.length (); --jx;)
15907 : : {
15908 : 268154 : depset *dep = b->deps[jx];
15909 : 268154 : tree bound = dep->get_entity ();
15910 : 268154 : unsigned flags = 0;
15911 : 268154 : if (dep->get_entity_kind () == depset::EK_USING)
15912 : : {
15913 : 29176 : tree ovl = bound;
15914 : 29176 : bound = OVL_FUNCTION (bound);
15915 : 29176 : if (!(TREE_CODE (bound) == CONST_DECL
15916 : 11114 : && UNSCOPED_ENUM_P (TREE_TYPE (bound))
15917 : 11102 : && decl == TYPE_NAME (TREE_TYPE (bound))))
15918 : : /* An unscoped enumerator in its enumeration's
15919 : : scope is not a using. */
15920 : : flags |= cbf_using;
15921 : 29176 : if (OVL_EXPORT_P (ovl))
15922 : 26169 : flags |= cbf_export;
15923 : : }
15924 : : else
15925 : : {
15926 : : /* An implicit typedef must be at one. */
15927 : 238978 : gcc_assert (!DECL_IMPLICIT_TYPEDEF_P (bound) || jx == 1);
15928 : 238978 : if (dep->is_hidden ())
15929 : : flags |= cbf_hidden;
15930 : 232847 : else if (DECL_MODULE_EXPORT_P (STRIP_TEMPLATE (bound)))
15931 : 206172 : flags |= cbf_export;
15932 : : }
15933 : :
15934 : 268154 : gcc_checking_assert (DECL_P (bound));
15935 : :
15936 : 268154 : sec.i (flags);
15937 : 268154 : sec.tree_node (bound);
15938 : : }
15939 : :
15940 : : /* Terminate the list. */
15941 : 213474 : sec.i (-1);
15942 : : }
15943 : 213474 : break;
15944 : :
15945 : 29176 : case depset::EK_USING:
15946 : 29200 : dump () && dump ("Depset:%u %s %C:%N", ix, b->entity_kind_name (),
15947 : 24 : TREE_CODE (decl), decl);
15948 : : break;
15949 : :
15950 : 1373236 : case depset::EK_SPECIALIZATION:
15951 : 1373236 : case depset::EK_PARTIAL:
15952 : 1373236 : case depset::EK_DECL:
15953 : 1403015 : dump () && dump ("Depset:%u %s entity:%u %C:%N", ix,
15954 : : b->entity_kind_name (), b->cluster,
15955 : 29779 : TREE_CODE (decl), decl);
15956 : :
15957 : 1373236 : sec.u (ct_decl);
15958 : 1373236 : sec.tree_node (decl);
15959 : :
15960 : 1645665 : dump () && dump ("Wrote declaration entity:%u %C:%N",
15961 : 29779 : b->cluster, TREE_CODE (decl), decl);
15962 : : break;
15963 : : }
15964 : : }
15965 : :
15966 : : depset *namer = NULL;
15967 : :
15968 : : /* Write out definitions */
15969 : 1997178 : for (unsigned ix = 0; ix != size; ix++)
15970 : : {
15971 : 1615886 : depset *b = scc[ix];
15972 : 1615886 : tree decl = b->get_entity ();
15973 : 1615886 : switch (b->get_entity_kind ())
15974 : : {
15975 : : default:
15976 : : break;
15977 : :
15978 : 1373236 : case depset::EK_SPECIALIZATION:
15979 : 1373236 : case depset::EK_PARTIAL:
15980 : 1373236 : case depset::EK_DECL:
15981 : 1373236 : if (!namer)
15982 : 366896 : namer = b;
15983 : :
15984 : 1373236 : if (b->has_defn ())
15985 : : {
15986 : 501132 : sec.u (ct_defn);
15987 : 501132 : sec.tree_node (decl);
15988 : 512311 : dump () && dump ("Writing definition %N", decl);
15989 : 501132 : sec.write_definition (decl, b->refs_tu_local ());
15990 : :
15991 : 501132 : if (!namer->has_defn ())
15992 : 1615886 : namer = b;
15993 : : }
15994 : : break;
15995 : : }
15996 : : }
15997 : :
15998 : : /* We don't find the section by name. Use depset's decl's name for
15999 : : human friendliness. */
16000 : 381292 : unsigned name = 0;
16001 : 381292 : tree naming_decl = NULL_TREE;
16002 : 381292 : if (namer)
16003 : : {
16004 : 366896 : naming_decl = namer->get_entity ();
16005 : 366896 : if (namer->get_entity_kind () == depset::EK_USING)
16006 : : /* This unfortunately names the section from the target of the
16007 : : using decl. But the name is only a guide, so Do Not Care. */
16008 : 0 : naming_decl = OVL_FUNCTION (naming_decl);
16009 : 366896 : if (DECL_IMPLICIT_TYPEDEF_P (naming_decl))
16010 : : /* Lose any anonymousness. */
16011 : 122432 : naming_decl = TYPE_NAME (TREE_TYPE (naming_decl));
16012 : 366896 : name = to->qualified_name (naming_decl, namer->has_defn ());
16013 : : }
16014 : :
16015 : 381292 : unsigned bytes = sec.pos;
16016 : 381292 : unsigned snum = sec.end (to, name, crc_ptr);
16017 : :
16018 : 1997178 : for (unsigned ix = size; ix--;)
16019 : 1615886 : gcc_checking_assert (scc[ix]->section == snum);
16020 : :
16021 : 381292 : dump.outdent ();
16022 : 388909 : dump () && dump ("Wrote section:%u named-by:%N", table.section, naming_decl);
16023 : :
16024 : 381292 : return bytes;
16025 : 381292 : }
16026 : :
16027 : : /* Read a cluster from section SNUM. */
16028 : :
16029 : : bool
16030 : 357237 : module_state::read_cluster (unsigned snum)
16031 : : {
16032 : 357237 : trees_in sec (this);
16033 : :
16034 : 357237 : if (!sec.begin (loc, from (), snum))
16035 : : return false;
16036 : :
16037 : 358310 : dump () && dump ("Reading section:%u", snum);
16038 : 357237 : dump.indent ();
16039 : :
16040 : : /* We care about structural equality. */
16041 : 357237 : comparing_dependent_aliases++;
16042 : :
16043 : : /* First seed the imports. */
16044 : 1950825 : while (tree import = sec.tree_node ())
16045 : 3544578 : dump (dumper::CLUSTER) && dump ("Seeded import %N", import);
16046 : :
16047 : 2372064 : while (!sec.get_overrun () && sec.more_p ())
16048 : : {
16049 : 2014827 : unsigned ct = sec.u ();
16050 : 2014827 : switch (ct)
16051 : : {
16052 : 0 : default:
16053 : 0 : sec.set_overrun ();
16054 : 0 : break;
16055 : :
16056 : 207987 : case ct_bind:
16057 : : /* A set of namespace bindings. */
16058 : 207987 : {
16059 : 207987 : tree ns = sec.tree_node ();
16060 : 207987 : tree name = sec.tree_node ();
16061 : 207987 : tree decls = NULL_TREE;
16062 : 207987 : tree visible = NULL_TREE;
16063 : 207987 : tree type = NULL_TREE;
16064 : 207987 : bool dedup = false;
16065 : 207987 : bool global_p = is_header ();
16066 : :
16067 : : /* We rely on the bindings being in the reverse order of
16068 : : the resulting overload set. */
16069 : 470300 : for (;;)
16070 : : {
16071 : 470300 : int flags = sec.i ();
16072 : 470300 : if (flags < 0)
16073 : : break;
16074 : :
16075 : 262313 : if ((flags & cbf_hidden)
16076 : 6098 : && (flags & (cbf_using | cbf_export)))
16077 : 0 : sec.set_overrun ();
16078 : :
16079 : 262313 : tree decl = sec.tree_node ();
16080 : 262313 : if (sec.get_overrun ())
16081 : : break;
16082 : :
16083 : 262313 : if (!global_p)
16084 : : {
16085 : : /* Check if the decl could require GM merging. */
16086 : 2359 : tree orig = get_originating_module_decl (decl);
16087 : 2359 : tree inner = STRIP_TEMPLATE (orig);
16088 : 2359 : if (!DECL_LANG_SPECIFIC (inner)
16089 : 4718 : || !DECL_MODULE_ATTACH_P (inner))
16090 : : global_p = true;
16091 : : }
16092 : :
16093 : 262313 : if (decls && TREE_CODE (decl) == TYPE_DECL)
16094 : : {
16095 : : /* Stat hack. */
16096 : 78 : if (type || !DECL_IMPLICIT_TYPEDEF_P (decl))
16097 : 0 : sec.set_overrun ();
16098 : :
16099 : 78 : if (flags & cbf_using)
16100 : : {
16101 : 3 : type = build_lang_decl_loc (UNKNOWN_LOCATION,
16102 : : USING_DECL,
16103 : 3 : DECL_NAME (decl),
16104 : : NULL_TREE);
16105 : 3 : USING_DECL_DECLS (type) = decl;
16106 : 3 : USING_DECL_SCOPE (type) = CP_DECL_CONTEXT (decl);
16107 : 3 : DECL_CONTEXT (type) = ns;
16108 : :
16109 : 3 : DECL_MODULE_PURVIEW_P (type) = true;
16110 : 3 : if (flags & cbf_export)
16111 : 3 : DECL_MODULE_EXPORT_P (type) = true;
16112 : : }
16113 : : else
16114 : : type = decl;
16115 : : }
16116 : : else
16117 : : {
16118 : 262235 : if ((flags & cbf_using) &&
16119 : 28698 : !DECL_DECLARES_FUNCTION_P (decl))
16120 : : {
16121 : : /* We should only see a single non-function using-decl
16122 : : for a binding; more than that would clash. */
16123 : 13709 : if (decls)
16124 : 0 : sec.set_overrun ();
16125 : :
16126 : : /* FIXME: Propagate the location of the using-decl
16127 : : for use in diagnostics. */
16128 : 13709 : decls = build_lang_decl_loc (UNKNOWN_LOCATION,
16129 : : USING_DECL,
16130 : 13709 : DECL_NAME (decl),
16131 : : NULL_TREE);
16132 : 13709 : USING_DECL_DECLS (decls) = decl;
16133 : : /* We don't currently record the actual scope of the
16134 : : using-declaration, but this approximation should
16135 : : generally be good enough. */
16136 : 13709 : USING_DECL_SCOPE (decls) = CP_DECL_CONTEXT (decl);
16137 : 13709 : DECL_CONTEXT (decls) = ns;
16138 : :
16139 : 13709 : DECL_MODULE_PURVIEW_P (decls) = true;
16140 : 13709 : if (flags & cbf_export)
16141 : 13703 : DECL_MODULE_EXPORT_P (decls) = true;
16142 : : }
16143 : 248526 : else if (decls
16144 : 194278 : || (flags & (cbf_hidden | cbf_using))
16145 : 430567 : || DECL_FUNCTION_TEMPLATE_P (decl))
16146 : : {
16147 : 92701 : decls = ovl_make (decl, decls);
16148 : 92701 : if (flags & cbf_using)
16149 : : {
16150 : 14989 : dedup = true;
16151 : 14989 : OVL_USING_P (decls) = true;
16152 : 14989 : OVL_PURVIEW_P (decls) = true;
16153 : 14989 : if (flags & cbf_export)
16154 : 14974 : OVL_EXPORT_P (decls) = true;
16155 : : }
16156 : :
16157 : 92701 : if (flags & cbf_hidden)
16158 : 6098 : OVL_HIDDEN_P (decls) = true;
16159 : 86603 : else if (dedup)
16160 : 14989 : OVL_DEDUP_P (decls) = true;
16161 : : }
16162 : : else
16163 : : decls = decl;
16164 : :
16165 : 262229 : if (flags & cbf_export
16166 : 262235 : || (!(flags & cbf_hidden)
16167 : 640 : && (is_module () || is_partition ())))
16168 : : visible = decls;
16169 : : }
16170 : : }
16171 : :
16172 : 207987 : if (!decls)
16173 : 0 : sec.set_overrun ();
16174 : :
16175 : 207987 : if (sec.get_overrun ())
16176 : : break; /* Bail. */
16177 : :
16178 : 208783 : dump () && dump ("Binding of %P", ns, name);
16179 : 207987 : if (!set_module_binding (ns, name, mod, global_p,
16180 : 207987 : is_module () || is_partition (),
16181 : : decls, type, visible))
16182 : 0 : sec.set_overrun ();
16183 : : }
16184 : : break;
16185 : :
16186 : 1323145 : case ct_decl:
16187 : : /* A decl. */
16188 : 1323145 : {
16189 : 1323145 : tree decl = sec.tree_node ();
16190 : 3697939 : dump () && dump ("Read declaration of %N", decl);
16191 : : }
16192 : : break;
16193 : :
16194 : 483695 : case ct_defn:
16195 : 483695 : {
16196 : 483695 : tree decl = sec.tree_node ();
16197 : 484683 : dump () && dump ("Reading definition of %N", decl);
16198 : 483695 : sec.read_definition (decl);
16199 : : }
16200 : 483695 : break;
16201 : : }
16202 : : }
16203 : :
16204 : : /* When lazy loading is in effect, we can be in the middle of
16205 : : parsing or instantiating a function. Save it away.
16206 : : push_function_context does too much work. */
16207 : 357237 : tree old_cfd = current_function_decl;
16208 : 357237 : struct function *old_cfun = cfun;
16209 : 552542 : for (const post_process_data& pdata : sec.post_process ())
16210 : : {
16211 : 137893 : tree decl = pdata.decl;
16212 : :
16213 : 137893 : bool abstract = false;
16214 : 137893 : if (TREE_CODE (decl) == TEMPLATE_DECL)
16215 : : {
16216 : 75010 : abstract = true;
16217 : 75010 : decl = DECL_TEMPLATE_RESULT (decl);
16218 : : }
16219 : :
16220 : 137893 : current_function_decl = decl;
16221 : 137893 : allocate_struct_function (decl, abstract);
16222 : 137893 : cfun->language = ggc_cleared_alloc<language_function> ();
16223 : 137893 : cfun->language->base.x_stmt_tree.stmts_are_full_exprs_p = 1;
16224 : 137893 : cfun->function_start_locus = pdata.start_locus;
16225 : 137893 : cfun->function_end_locus = pdata.end_locus;
16226 : :
16227 : 137893 : if (abstract)
16228 : : ;
16229 : 62883 : else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
16230 : 13516 : vec_safe_push (post_load_decls, decl);
16231 : : else
16232 : : {
16233 : 49367 : bool aggr = aggregate_value_p (DECL_RESULT (decl), decl);
16234 : : #ifdef PCC_STATIC_STRUCT_RETURN
16235 : : cfun->returns_pcc_struct = aggr;
16236 : : #endif
16237 : 49367 : cfun->returns_struct = aggr;
16238 : :
16239 : 49367 : if (DECL_COMDAT (decl))
16240 : : // FIXME: Comdat grouping?
16241 : 49208 : comdat_linkage (decl);
16242 : 49367 : note_vague_linkage_fn (decl);
16243 : 49367 : cgraph_node::finalize_function (decl, true);
16244 : : }
16245 : :
16246 : : }
16247 : : /* Look, function.cc's interface to cfun does too much for us, we
16248 : : just need to restore the old value. I do not want to go
16249 : : redesigning that API right now. */
16250 : : #undef cfun
16251 : 357237 : cfun = old_cfun;
16252 : 357237 : current_function_decl = old_cfd;
16253 : 357237 : comparing_dependent_aliases--;
16254 : :
16255 : 357237 : dump.outdent ();
16256 : 358310 : dump () && dump ("Read section:%u", snum);
16257 : :
16258 : 357237 : loaded_clusters++;
16259 : :
16260 : 357237 : if (!sec.end (from ()))
16261 : : return false;
16262 : :
16263 : : return true;
16264 : 357237 : }
16265 : :
16266 : : void
16267 : 216095 : module_state::write_namespace (bytes_out &sec, depset *dep)
16268 : : {
16269 : 216095 : unsigned ns_num = dep->cluster;
16270 : 216095 : unsigned ns_import = 0;
16271 : :
16272 : 216095 : if (dep->is_import ())
16273 : 0 : ns_import = dep->section;
16274 : 216095 : else if (dep->get_entity () != global_namespace)
16275 : 126361 : ns_num++;
16276 : :
16277 : 216095 : sec.u (ns_import);
16278 : 216095 : sec.u (ns_num);
16279 : 216095 : }
16280 : :
16281 : : tree
16282 : 272426 : module_state::read_namespace (bytes_in &sec)
16283 : : {
16284 : 272426 : unsigned ns_import = sec.u ();
16285 : 272426 : unsigned ns_num = sec.u ();
16286 : 272426 : tree ns = NULL_TREE;
16287 : :
16288 : 272426 : if (ns_import || ns_num)
16289 : : {
16290 : 156826 : if (!ns_import)
16291 : 156826 : ns_num--;
16292 : :
16293 : 156826 : if (unsigned origin = slurp->remap_module (ns_import))
16294 : : {
16295 : 156826 : module_state *from = (*modules)[origin];
16296 : 156826 : if (ns_num < from->entity_num)
16297 : : {
16298 : 156826 : binding_slot &slot = (*entity_ary)[from->entity_lwm + ns_num];
16299 : :
16300 : 156826 : if (!slot.is_lazy ())
16301 : 156826 : ns = slot;
16302 : : }
16303 : : }
16304 : : else
16305 : 0 : sec.set_overrun ();
16306 : : }
16307 : : else
16308 : 115600 : ns = global_namespace;
16309 : :
16310 : 272426 : return ns;
16311 : : }
16312 : :
16313 : : /* SPACES is a sorted vector of namespaces. Write out the namespaces
16314 : : to MOD_SNAME_PFX.nms section. */
16315 : :
16316 : : void
16317 : 414 : module_state::write_namespaces (elf_out *to, vec<depset *> spaces,
16318 : : unsigned num, unsigned *crc_p)
16319 : : {
16320 : 453 : dump () && dump ("Writing namespaces");
16321 : 414 : dump.indent ();
16322 : :
16323 : 414 : bytes_out sec (to);
16324 : 414 : sec.begin ();
16325 : :
16326 : 3035 : for (unsigned ix = 0; ix != num; ix++)
16327 : : {
16328 : 2621 : depset *b = spaces[ix];
16329 : 2621 : tree ns = b->get_entity ();
16330 : :
16331 : 2621 : gcc_checking_assert (TREE_CODE (ns) == NAMESPACE_DECL);
16332 : 2621 : gcc_checking_assert (TREE_PUBLIC (ns) || header_module_p ());
16333 : :
16334 : 2621 : unsigned flags = 0;
16335 : 2621 : if (TREE_PUBLIC (ns))
16336 : 2612 : flags |= 1;
16337 : 2621 : if (DECL_NAMESPACE_INLINE_P (ns))
16338 : 527 : flags |= 2;
16339 : 2621 : if (DECL_MODULE_PURVIEW_P (ns))
16340 : 2254 : flags |= 4;
16341 : 2621 : if (DECL_MODULE_EXPORT_P (ns))
16342 : 2015 : flags |= 8;
16343 : :
16344 : 2744 : dump () && dump ("Writing namespace:%u %N%s%s%s%s",
16345 : : b->cluster, ns,
16346 : 123 : flags & 1 ? ", public" : "",
16347 : 123 : flags & 2 ? ", inline" : "",
16348 : 123 : flags & 4 ? ", purview" : "",
16349 : 123 : flags & 8 ? ", export" : "");
16350 : 2621 : sec.u (b->cluster);
16351 : 2621 : sec.u (to->name (DECL_NAME (ns)));
16352 : 2621 : write_namespace (sec, b->deps[0]);
16353 : :
16354 : 2621 : sec.u (flags);
16355 : 2621 : write_location (sec, DECL_SOURCE_LOCATION (ns));
16356 : :
16357 : 2621 : if (DECL_NAMESPACE_INLINE_P (ns))
16358 : : {
16359 : 527 : if (tree attr = lookup_attribute ("abi_tag", DECL_ATTRIBUTES (ns)))
16360 : : {
16361 : 146 : tree tags = TREE_VALUE (attr);
16362 : 146 : sec.u (list_length (tags));
16363 : 295 : for (tree tag = tags; tag; tag = TREE_CHAIN (tag))
16364 : 149 : sec.str (TREE_STRING_POINTER (TREE_VALUE (tag)));
16365 : : }
16366 : : else
16367 : 381 : sec.u (0);
16368 : : }
16369 : : }
16370 : :
16371 : 414 : sec.end (to, to->name (MOD_SNAME_PFX ".nms"), crc_p);
16372 : 414 : dump.outdent ();
16373 : 414 : }
16374 : :
16375 : : /* Read the namespace hierarchy from MOD_SNAME_PFX.namespace. Fill in
16376 : : SPACES from that data. */
16377 : :
16378 : : bool
16379 : 416 : module_state::read_namespaces (unsigned num)
16380 : : {
16381 : 416 : bytes_in sec;
16382 : :
16383 : 416 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".nms"))
16384 : : return false;
16385 : :
16386 : 464 : dump () && dump ("Reading namespaces");
16387 : 416 : dump.indent ();
16388 : :
16389 : 3552 : for (unsigned ix = 0; ix != num; ix++)
16390 : : {
16391 : 3136 : unsigned entity_index = sec.u ();
16392 : 3136 : unsigned name = sec.u ();
16393 : :
16394 : 3136 : tree parent = read_namespace (sec);
16395 : :
16396 : : /* See comment in write_namespace about why not bits. */
16397 : 3136 : unsigned flags = sec.u ();
16398 : 3136 : location_t src_loc = read_location (sec);
16399 : 3136 : unsigned tags_count = (flags & 2) ? sec.u () : 0;
16400 : :
16401 : 3136 : if (entity_index >= entity_num
16402 : 3136 : || !parent
16403 : 3136 : || (flags & 0xc) == 0x8)
16404 : 0 : sec.set_overrun ();
16405 : :
16406 : : tree tags = NULL_TREE;
16407 : 3311 : while (tags_count--)
16408 : : {
16409 : 175 : size_t len;
16410 : 175 : const char *str = sec.str (&len);
16411 : 175 : tags = tree_cons (NULL_TREE, build_string (len + 1, str), tags);
16412 : 175 : tags = nreverse (tags);
16413 : : }
16414 : :
16415 : 3136 : if (sec.get_overrun ())
16416 : : break;
16417 : :
16418 : 6266 : tree id = name ? get_identifier (from ()->name (name)) : NULL_TREE;
16419 : :
16420 : 3256 : dump () && dump ("Read namespace:%u %P%s%s%s%s",
16421 : : entity_index, parent, id,
16422 : 60 : flags & 1 ? ", public" : "",
16423 : : flags & 2 ? ", inline" : "",
16424 : 60 : flags & 4 ? ", purview" : "",
16425 : 60 : flags & 8 ? ", export" : "");
16426 : 3136 : bool visible_p = ((flags & 8)
16427 : 3136 : || ((flags & 1)
16428 : 495 : && (flags & 4)
16429 : 47 : && (is_partition () || is_module ())));
16430 : 3136 : tree inner = add_imported_namespace (parent, id, src_loc, mod,
16431 : : bool (flags & 2), visible_p);
16432 : 3136 : if (!inner)
16433 : : {
16434 : 0 : sec.set_overrun ();
16435 : 0 : break;
16436 : : }
16437 : :
16438 : 3136 : if (is_partition ())
16439 : : {
16440 : 28 : if (flags & 4)
16441 : 23 : DECL_MODULE_PURVIEW_P (inner) = true;
16442 : 28 : if (flags & 8)
16443 : 23 : DECL_MODULE_EXPORT_P (inner) = true;
16444 : : }
16445 : :
16446 : 3136 : if (tags)
16447 : 172 : DECL_ATTRIBUTES (inner)
16448 : 344 : = tree_cons (get_identifier ("abi_tag"), tags, DECL_ATTRIBUTES (inner));
16449 : :
16450 : : /* Install the namespace. */
16451 : 3136 : (*entity_ary)[entity_lwm + entity_index] = inner;
16452 : 3136 : if (DECL_MODULE_IMPORT_P (inner))
16453 : : {
16454 : 0 : bool existed;
16455 : 0 : unsigned *slot = &entity_map->get_or_insert
16456 : 0 : (DECL_UID (inner), &existed);
16457 : 0 : if (existed)
16458 : : /* If it existed, it should match. */
16459 : 0 : gcc_checking_assert (inner == (*entity_ary)[*slot]);
16460 : : else
16461 : 0 : *slot = entity_lwm + entity_index;
16462 : : }
16463 : : }
16464 : 416 : dump.outdent ();
16465 : 416 : if (!sec.end (from ()))
16466 : : return false;
16467 : : return true;
16468 : 416 : }
16469 : :
16470 : : /* Write the binding TABLE to MOD_SNAME_PFX.bnd */
16471 : :
16472 : : unsigned
16473 : 2149 : module_state::write_bindings (elf_out *to, vec<depset *> sccs, unsigned *crc_p)
16474 : : {
16475 : 2390 : dump () && dump ("Writing binding table");
16476 : 2149 : dump.indent ();
16477 : :
16478 : 2149 : unsigned num = 0;
16479 : 2149 : bytes_out sec (to);
16480 : 2149 : sec.begin ();
16481 : :
16482 : 3245158 : for (unsigned ix = 0; ix != sccs.length (); ix++)
16483 : : {
16484 : 1620430 : depset *b = sccs[ix];
16485 : 1620430 : if (b->is_binding ())
16486 : : {
16487 : 213474 : tree ns = b->get_entity ();
16488 : 214519 : dump () && dump ("Bindings %P section:%u", ns, b->get_name (),
16489 : : b->section);
16490 : 213474 : sec.u (to->name (b->get_name ()));
16491 : 213474 : write_namespace (sec, b->deps[0]);
16492 : 213474 : sec.u (b->section);
16493 : 213474 : num++;
16494 : : }
16495 : : }
16496 : :
16497 : 2149 : sec.end (to, to->name (MOD_SNAME_PFX ".bnd"), crc_p);
16498 : 2149 : dump.outdent ();
16499 : :
16500 : 2149 : return num;
16501 : 2149 : }
16502 : :
16503 : : /* Read the binding table from MOD_SNAME_PFX.bind. */
16504 : :
16505 : : bool
16506 : 2301 : module_state::read_bindings (unsigned num, unsigned lwm, unsigned hwm)
16507 : : {
16508 : 2301 : bytes_in sec;
16509 : :
16510 : 2301 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".bnd"))
16511 : : return false;
16512 : :
16513 : 2756 : dump () && dump ("Reading binding table");
16514 : 2301 : dump.indent ();
16515 : 271591 : for (; !sec.get_overrun () && num--;)
16516 : : {
16517 : 269290 : const char *name = from ()->name (sec.u ());
16518 : 269290 : tree ns = read_namespace (sec);
16519 : 269290 : unsigned snum = sec.u ();
16520 : :
16521 : 269290 : if (!ns || !name || (snum - lwm) >= (hwm - lwm))
16522 : 0 : sec.set_overrun ();
16523 : 269290 : if (!sec.get_overrun ())
16524 : : {
16525 : 269290 : tree id = get_identifier (name);
16526 : 270689 : dump () && dump ("Bindings %P section:%u", ns, id, snum);
16527 : 269290 : if (mod && !import_module_binding (ns, id, mod, snum))
16528 : : break;
16529 : : }
16530 : : }
16531 : :
16532 : 2301 : dump.outdent ();
16533 : 2301 : if (!sec.end (from ()))
16534 : : return false;
16535 : : return true;
16536 : 2301 : }
16537 : :
16538 : : /* Write the entity table to MOD_SNAME_PFX.ent
16539 : :
16540 : : Each entry is a section number. */
16541 : :
16542 : : void
16543 : 1920 : module_state::write_entities (elf_out *to, vec<depset *> depsets,
16544 : : unsigned count, unsigned *crc_p)
16545 : : {
16546 : 2121 : dump () && dump ("Writing entities");
16547 : 1920 : dump.indent ();
16548 : :
16549 : 1920 : bytes_out sec (to);
16550 : 1920 : sec.begin ();
16551 : :
16552 : 1920 : unsigned current = 0;
16553 : 1622335 : for (unsigned ix = 0; ix < depsets.length (); ix++)
16554 : : {
16555 : 1620415 : depset *d = depsets[ix];
16556 : :
16557 : 2998192 : switch (d->get_entity_kind ())
16558 : : {
16559 : : default:
16560 : : break;
16561 : :
16562 : 4541 : case depset::EK_NAMESPACE:
16563 : 4541 : if (!d->is_import () && d->get_entity () != global_namespace)
16564 : : {
16565 : 2621 : gcc_checking_assert (d->cluster == current);
16566 : 2621 : current++;
16567 : 2621 : sec.u (0);
16568 : : }
16569 : : break;
16570 : :
16571 : 1373236 : case depset::EK_DECL:
16572 : 1373236 : case depset::EK_SPECIALIZATION:
16573 : 1373236 : case depset::EK_PARTIAL:
16574 : 2746472 : gcc_checking_assert (!d->is_unreached ()
16575 : : && !d->is_import ()
16576 : : && d->cluster == current
16577 : : && d->section);
16578 : 1373236 : current++;
16579 : 1373236 : sec.u (d->section);
16580 : 1373236 : break;
16581 : : }
16582 : : }
16583 : 1920 : gcc_assert (count == current);
16584 : 1920 : sec.end (to, to->name (MOD_SNAME_PFX ".ent"), crc_p);
16585 : 1920 : dump.outdent ();
16586 : 1920 : }
16587 : :
16588 : : bool
16589 : 2100 : module_state::read_entities (unsigned count, unsigned lwm, unsigned hwm)
16590 : : {
16591 : 2100 : trees_in sec (this);
16592 : :
16593 : 2100 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".ent"))
16594 : : return false;
16595 : :
16596 : 2507 : dump () && dump ("Reading entities");
16597 : 2100 : dump.indent ();
16598 : :
16599 : 1681708 : for (binding_slot *slot = entity_ary->begin () + entity_lwm; count--; slot++)
16600 : : {
16601 : 1679608 : unsigned snum = sec.u ();
16602 : 1679608 : if (snum && (snum - lwm) >= (hwm - lwm))
16603 : 0 : sec.set_overrun ();
16604 : 1679608 : if (sec.get_overrun ())
16605 : : break;
16606 : :
16607 : 1679608 : if (snum)
16608 : 1676472 : slot->set_lazy (snum << 2);
16609 : : }
16610 : :
16611 : 2100 : dump.outdent ();
16612 : 2100 : if (!sec.end (from ()))
16613 : : return false;
16614 : : return true;
16615 : 2100 : }
16616 : :
16617 : : /* Write the pending table to MOD_SNAME_PFX.pnd
16618 : :
16619 : : The pending table holds information about clusters that need to be
16620 : : loaded because they contain information about something that is not
16621 : : found by namespace-scope lookup.
16622 : :
16623 : : The three cases are:
16624 : :
16625 : : (a) Template (maybe-partial) specializations that we have
16626 : : instantiated or defined. When an importer needs to instantiate
16627 : : that template, they /must have/ the partial, explicit & extern
16628 : : specializations available. If they have the other specializations
16629 : : available, they'll have less work to do. Thus, when we're about to
16630 : : instantiate FOO, we have to be able to ask 'are there any
16631 : : specialization of FOO in our imports?'.
16632 : :
16633 : : (b) (Maybe-implicit) member functions definitions. A class could
16634 : : be defined in one header, and an inline member defined in a
16635 : : different header (this occurs in the STL). Similarly, like the
16636 : : specialization case, an implicit member function could have been
16637 : : 'instantiated' in one module, and it'd be nice to not have to
16638 : : reinstantiate it in another.
16639 : :
16640 : : (c) Classes completed elsewhere. A class could be declared in one
16641 : : header and defined in another. We need to know to load the class
16642 : : definition before looking in it. It does highlight an issue --
16643 : : there could be an intermediate import between the outermost containing
16644 : : namespace-scope class and the innermost being-defined class. This is
16645 : : actually possible with all of these cases, so be aware -- we're not
16646 : : just talking of one level of import to get to the innermost namespace.
16647 : :
16648 : : This gets complicated fast, it took me multiple attempts to even
16649 : : get something remotely working. Partially because I focussed on
16650 : : optimizing what I think turns out to be a smaller problem, given
16651 : : the known need to do the more general case *anyway*. I document
16652 : : the smaller problem, because it does appear to be the natural way
16653 : : to do it. It's trap!
16654 : :
16655 : : **** THE TRAP
16656 : :
16657 : : Let's refer to the primary template or the containing class as the
16658 : : KEY. And the specialization or member as the PENDING-ENTITY. (To
16659 : : avoid having to say those mouthfuls all the time.)
16660 : :
16661 : : In either case, we have an entity and we need some way of mapping
16662 : : that to a set of entities that need to be loaded before we can
16663 : : proceed with whatever processing of the entity we were going to do.
16664 : :
16665 : : We need to link the key to the pending-entity in some way. Given a
16666 : : key, tell me the pending-entities I need to have loaded. However
16667 : : we tie the key to the pending-entity must not rely on the key being
16668 : : loaded -- that'd defeat the lazy loading scheme.
16669 : :
16670 : : As the key will be an import in we know its entity number (either
16671 : : because we imported it, or we're writing it out too). Thus we can
16672 : : generate a map of key-indices to pending-entities. The
16673 : : pending-entity indices will be into our span of the entity table,
16674 : : and thus allow them to be lazily loaded. The key index will be
16675 : : into another slot of the entity table. Notice that this checking
16676 : : could be expensive, we don't want to iterate over a bunch of
16677 : : pending-entity indices (across multiple imports), every time we're
16678 : : about do to the thing with the key. We need to quickly determine
16679 : : 'definitely nothing needed'.
16680 : :
16681 : : That's almost good enough, except that key indices are not unique
16682 : : in a couple of cases :( Specifically the Global Module or a module
16683 : : partition can result in multiple modules assigning an entity index
16684 : : for the key. The decl-merging on loading will detect that so we
16685 : : only have one Key loaded, and in the entity hash it'll indicate the
16686 : : entity index of first load. Which might be different to how we
16687 : : know it. Notice this is restricted to GM entities or this-module
16688 : : entities. Foreign imports cannot have this.
16689 : :
16690 : : We can simply resolve this in the direction of how this module
16691 : : referred to the key to how the importer knows it. Look in the
16692 : : entity table slot that we nominate, maybe lazy load it, and then
16693 : : lookup the resultant entity in the entity hash to learn how the
16694 : : importer knows it.
16695 : :
16696 : : But we need to go in the other direction :( Given the key, find all
16697 : : the index-aliases of that key. We can partially solve that by
16698 : : adding an alias hash table. Whenever we load a merged decl, add or
16699 : : augment a mapping from the entity (or its entity-index) to the
16700 : : newly-discovered index. Then when we look for pending entities of
16701 : : a key, we also iterate over this aliases this mapping provides.
16702 : :
16703 : : But that requires the alias to be loaded. And that's not
16704 : : necessarily true.
16705 : :
16706 : : *** THE SIMPLER WAY
16707 : :
16708 : : The remaining fixed thing we have is the innermost namespace
16709 : : containing the ultimate namespace-scope container of the key and
16710 : : the name of that container (which might be the key itself). I.e. a
16711 : : namespace-decl/identifier/module tuple. Let's call this the
16712 : : top-key. We'll discover that the module is not important here,
16713 : : because of cross-module possibilities mentioned in case #c above.
16714 : : We can't markup namespace-binding slots. The best we can do is
16715 : : mark the binding vector with 'there's something here', and have
16716 : : another map from namespace/identifier pairs to a vector of pending
16717 : : entity indices.
16718 : :
16719 : : Maintain a pending-entity map. This is keyed by top-key, and
16720 : : maps to a vector of pending-entity indices. On the binding vector
16721 : : have flags saying whether the pending-name-entity map has contents.
16722 : : (We might want to further extend the key to be GM-vs-Partition and
16723 : : specialization-vs-member, but let's not get ahead of ourselves.)
16724 : :
16725 : : For every key-like entity, find the outermost namespace-scope
16726 : : name. Use that to lookup in the pending-entity map and then make
16727 : : sure the specified entities are loaded.
16728 : :
16729 : : An optimization might be to have a flag in each key-entity saying
16730 : : that its top key might be in the entity table. It's not clear to
16731 : : me how to set that flag cheaply -- cheaper than just looking.
16732 : :
16733 : : FIXME: It'd be nice to have a bit in decls to tell us whether to
16734 : : even try this. We can have a 'already done' flag, that we set when
16735 : : we've done KLASS's lazy pendings. When we import a module that
16736 : : registers pendings on the same top-key as KLASS we need to clear
16737 : : the flag. A recursive walk of the top-key clearing the bit will
16738 : : suffice. Plus we only need to recurse on classes that have the bit
16739 : : set. (That means we need to set the bit on parents of KLASS here,
16740 : : don't forget.) However, first: correctness, second: efficiency. */
16741 : :
16742 : : unsigned
16743 : 2149 : module_state::write_pendings (elf_out *to, vec<depset *> depsets,
16744 : : depset::hash &table, unsigned *crc_p)
16745 : : {
16746 : 2390 : dump () && dump ("Writing pending-entities");
16747 : 2149 : dump.indent ();
16748 : :
16749 : 2149 : trees_out sec (to, this, table);
16750 : 2149 : sec.begin ();
16751 : :
16752 : 2149 : unsigned count = 0;
16753 : 2149 : tree cache_ns = NULL_TREE;
16754 : 2149 : tree cache_id = NULL_TREE;
16755 : 2149 : unsigned cache_section = ~0;
16756 : 1622579 : for (unsigned ix = 0; ix < depsets.length (); ix++)
16757 : : {
16758 : 1620430 : depset *d = depsets[ix];
16759 : :
16760 : 1620430 : if (d->is_binding ())
16761 : 983374 : continue;
16762 : :
16763 : 1406956 : if (d->is_import ())
16764 : 0 : continue;
16765 : :
16766 : 1406956 : if (!d->is_pending_entity ())
16767 : 769900 : continue;
16768 : :
16769 : 637056 : tree key_decl = nullptr;
16770 : 637056 : tree key_ns = find_pending_key (d->get_entity (), &key_decl);
16771 : 637056 : tree key_name = DECL_NAME (key_decl);
16772 : :
16773 : 637056 : if (IDENTIFIER_ANON_P (key_name))
16774 : : {
16775 : 6 : gcc_checking_assert (IDENTIFIER_LAMBDA_P (key_name));
16776 : 6 : if (tree attached = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (key_decl)))
16777 : 6 : key_name = DECL_NAME (attached);
16778 : : else
16779 : : {
16780 : : /* There's nothing to attach it to. Must
16781 : : always reinstantiate. */
16782 : 0 : dump ()
16783 : 0 : && dump ("Unattached lambda %N[%u] section:%u",
16784 : 0 : d->get_entity_kind () == depset::EK_DECL
16785 : : ? "Member" : "Specialization", d->get_entity (),
16786 : : d->cluster, d->section);
16787 : 0 : continue;
16788 : : }
16789 : : }
16790 : :
16791 : 637056 : char const *also = "";
16792 : 637056 : if (d->section == cache_section
16793 : 423821 : && key_ns == cache_ns
16794 : 423821 : && key_name == cache_id)
16795 : : /* Same section & key as previous, no need to repeat ourselves. */
16796 : : also = "also ";
16797 : : else
16798 : : {
16799 : 290632 : cache_ns = key_ns;
16800 : 290632 : cache_id = key_name;
16801 : 290632 : cache_section = d->section;
16802 : 290632 : gcc_checking_assert (table.find_dependency (cache_ns));
16803 : 290632 : sec.tree_node (cache_ns);
16804 : 290632 : sec.tree_node (cache_id);
16805 : 290632 : sec.u (d->cluster);
16806 : 290632 : count++;
16807 : : }
16808 : 664790 : dump () && dump ("Pending %s %N entity:%u section:%u %skeyed to %P",
16809 : 13867 : d->get_entity_kind () == depset::EK_DECL
16810 : : ? "member" : "specialization", d->get_entity (),
16811 : : d->cluster, cache_section, also, cache_ns, cache_id);
16812 : : }
16813 : 2149 : sec.end (to, to->name (MOD_SNAME_PFX ".pnd"), crc_p);
16814 : 2149 : dump.outdent ();
16815 : :
16816 : 2149 : return count;
16817 : 2149 : }
16818 : :
16819 : : bool
16820 : 1203 : module_state::read_pendings (unsigned count)
16821 : : {
16822 : 1203 : trees_in sec (this);
16823 : :
16824 : 1203 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".pnd"))
16825 : : return false;
16826 : :
16827 : 1478 : dump () && dump ("Reading %u pendings", count);
16828 : 1203 : dump.indent ();
16829 : :
16830 : 354586 : for (unsigned ix = 0; ix != count; ix++)
16831 : : {
16832 : 353383 : pending_key key;
16833 : 353383 : unsigned index;
16834 : :
16835 : 353383 : key.ns = sec.tree_node ();
16836 : 353383 : key.id = sec.tree_node ();
16837 : 353383 : index = sec.u ();
16838 : :
16839 : 353383 : if (!key.ns || !key.id
16840 : 353383 : || !(TREE_CODE (key.ns) == NAMESPACE_DECL
16841 : 353383 : && !DECL_NAMESPACE_ALIAS (key.ns))
16842 : 353383 : || !identifier_p (key.id)
16843 : 706766 : || index >= entity_num)
16844 : 0 : sec.set_overrun ();
16845 : :
16846 : 353383 : if (sec.get_overrun ())
16847 : : break;
16848 : :
16849 : 354049 : dump () && dump ("Pending:%u keyed to %P", index, key.ns, key.id);
16850 : :
16851 : 353383 : index += entity_lwm;
16852 : 353383 : auto &vec = pending_table->get_or_insert (key);
16853 : 353383 : vec.safe_push (index);
16854 : : }
16855 : :
16856 : 1203 : dump.outdent ();
16857 : 1203 : if (!sec.end (from ()))
16858 : : return false;
16859 : : return true;
16860 : 1203 : }
16861 : :
16862 : : /* Read & write locations. */
16863 : : enum loc_kind {
16864 : : LK_ORDINARY,
16865 : : LK_MACRO,
16866 : : LK_IMPORT_ORDINARY,
16867 : : LK_IMPORT_MACRO,
16868 : : LK_ADHOC,
16869 : : LK_RESERVED,
16870 : : };
16871 : :
16872 : : static const module_state *
16873 : 3027 : module_for_ordinary_loc (location_t loc)
16874 : : {
16875 : 3027 : unsigned pos = 0;
16876 : 6054 : unsigned len = ool->length () - pos;
16877 : :
16878 : 3030 : while (len)
16879 : : {
16880 : 3030 : unsigned half = len / 2;
16881 : 3030 : module_state *probe = (*ool)[pos + half];
16882 : 3030 : if (loc < probe->ordinary_locs.first)
16883 : : len = half;
16884 : 3027 : else if (loc < probe->ordinary_locs.first + probe->ordinary_locs.second)
16885 : : return probe;
16886 : : else
16887 : : {
16888 : 0 : pos += half + 1;
16889 : 0 : len = len - (half + 1);
16890 : : }
16891 : : }
16892 : :
16893 : : return nullptr;
16894 : : }
16895 : :
16896 : : static const module_state *
16897 : 6 : module_for_macro_loc (location_t loc)
16898 : : {
16899 : 6 : unsigned pos = 1;
16900 : 6 : unsigned len = modules->length () - pos;
16901 : :
16902 : 6 : while (len)
16903 : : {
16904 : 6 : unsigned half = len / 2;
16905 : 6 : module_state *probe = (*modules)[pos + half];
16906 : 6 : if (loc < probe->macro_locs.first)
16907 : : {
16908 : 0 : pos += half + 1;
16909 : 0 : len = len - (half + 1);
16910 : : }
16911 : 6 : else if (loc >= probe->macro_locs.first + probe->macro_locs.second)
16912 : : len = half;
16913 : : else
16914 : : return probe;
16915 : : }
16916 : :
16917 : : return NULL;
16918 : : }
16919 : :
16920 : : location_t
16921 : 1001 : module_state::imported_from () const
16922 : : {
16923 : 1001 : location_t from = loc;
16924 : 1001 : line_map_ordinary const *fmap
16925 : 1001 : = linemap_check_ordinary (linemap_lookup (line_table, from));
16926 : :
16927 : 1001 : if (MAP_MODULE_P (fmap))
16928 : 1001 : from = linemap_included_from (fmap);
16929 : :
16930 : 1001 : return from;
16931 : : }
16932 : :
16933 : : /* Note that LOC will need writing. This allows us to prune locations
16934 : : that are not needed. */
16935 : :
16936 : : bool
16937 : 30399131 : module_state::note_location (location_t loc)
16938 : : {
16939 : 30399131 : bool added = false;
16940 : 30399131 : if (!macro_loc_table && !ord_loc_table)
16941 : : ;
16942 : 30399131 : else if (loc < RESERVED_LOCATION_COUNT)
16943 : : ;
16944 : 27825482 : else if (IS_ADHOC_LOC (loc))
16945 : : {
16946 : 3157357 : location_t locus = get_location_from_adhoc_loc (line_table, loc);
16947 : 3157357 : note_location (locus);
16948 : 3157357 : source_range range = get_range_from_loc (line_table, loc);
16949 : 3157357 : if (range.m_start != locus)
16950 : 3049604 : note_location (range.m_start);
16951 : 3157357 : note_location (range.m_finish);
16952 : : }
16953 : 24668125 : else if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (line_table))
16954 : : {
16955 : 2424070 : if (spans.macro (loc))
16956 : : {
16957 : 2424064 : const line_map *map = linemap_lookup (line_table, loc);
16958 : 2424064 : const line_map_macro *mac_map = linemap_check_macro (map);
16959 : 2424064 : hashval_t hv = macro_loc_traits::hash (mac_map);
16960 : 2424064 : macro_loc_info *slot
16961 : 2424064 : = macro_loc_table->find_slot_with_hash (mac_map, hv, INSERT);
16962 : 2424064 : if (!slot->src)
16963 : : {
16964 : 284066 : slot->src = mac_map;
16965 : 284066 : slot->remap = 0;
16966 : : // Expansion locations could themselves be from a
16967 : : // macro, we need to note them all.
16968 : 284066 : note_location (mac_map->m_expansion);
16969 : 284066 : gcc_checking_assert (mac_map->n_tokens);
16970 : 284066 : location_t tloc = UNKNOWN_LOCATION;
16971 : 10444908 : for (unsigned ix = mac_map->n_tokens * 2; ix--;)
16972 : 10160842 : if (mac_map->macro_locations[ix] != tloc)
16973 : : {
16974 : 5394765 : tloc = mac_map->macro_locations[ix];
16975 : 5394765 : note_location (tloc);
16976 : : }
16977 : : added = true;
16978 : : }
16979 : : }
16980 : : }
16981 : 22244055 : else if (IS_ORDINARY_LOC (loc))
16982 : : {
16983 : 22244055 : if (spans.ordinary (loc))
16984 : : {
16985 : 22241027 : const line_map *map = linemap_lookup (line_table, loc);
16986 : 22241027 : const line_map_ordinary *ord_map = linemap_check_ordinary (map);
16987 : 22241027 : ord_loc_info lkup;
16988 : 22241027 : lkup.src = ord_map;
16989 : 22241027 : lkup.span = loc_one << ord_map->m_column_and_range_bits;
16990 : 22241027 : lkup.offset = (loc - MAP_START_LOCATION (ord_map)) & ~(lkup.span - 1);
16991 : 22241027 : lkup.remap = 0;
16992 : 22241027 : ord_loc_info *slot = (ord_loc_table->find_slot_with_hash
16993 : 22241027 : (lkup, ord_loc_traits::hash (lkup), INSERT));
16994 : 22241027 : if (!slot->src)
16995 : : {
16996 : 2602894 : *slot = lkup;
16997 : 2602894 : added = true;
16998 : : }
16999 : : }
17000 : : }
17001 : : else
17002 : 0 : gcc_unreachable ();
17003 : 30399131 : return added;
17004 : : }
17005 : :
17006 : : /* If we're not streaming, record that we need location LOC.
17007 : : Otherwise stream it. */
17008 : :
17009 : : void
17010 : 44723134 : module_state::write_location (bytes_out &sec, location_t loc)
17011 : : {
17012 : 44723134 : if (!sec.streaming_p ())
17013 : : {
17014 : 14956712 : note_location (loc);
17015 : 14956712 : return;
17016 : : }
17017 : :
17018 : 29766422 : if (loc < RESERVED_LOCATION_COUNT)
17019 : : {
17020 : 2652396 : dump (dumper::LOCATION) && dump ("Reserved location %K", loc);
17021 : 2652378 : sec.loc (LK_RESERVED + loc);
17022 : : }
17023 : 27114044 : else if (IS_ADHOC_LOC (loc))
17024 : : {
17025 : 3175539 : dump (dumper::LOCATION) && dump ("Adhoc location");
17026 : 3175536 : sec.u (LK_ADHOC);
17027 : 3175536 : location_t locus = get_location_from_adhoc_loc (line_table, loc);
17028 : 3175536 : write_location (sec, locus);
17029 : 3175536 : source_range range = get_range_from_loc (line_table, loc);
17030 : 3175536 : if (range.m_start == locus)
17031 : : /* Compress. */
17032 : 102107 : range.m_start = UNKNOWN_LOCATION;
17033 : 3175536 : write_location (sec, range.m_start);
17034 : 3175536 : write_location (sec, range.m_finish);
17035 : 3175536 : unsigned discriminator = get_discriminator_from_adhoc_loc (line_table, loc);
17036 : 3175536 : sec.u (discriminator);
17037 : : }
17038 : 23938508 : else if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (line_table))
17039 : : {
17040 : 2409458 : const macro_loc_info *info = nullptr;
17041 : 2409458 : line_map_uint_t offset = 0;
17042 : 2409458 : if (unsigned hwm = macro_loc_remap->length ())
17043 : : {
17044 : 2409452 : info = macro_loc_remap->begin ();
17045 : 36628697 : while (hwm != 1)
17046 : : {
17047 : 31809793 : unsigned mid = hwm / 2;
17048 : 31809793 : if (MAP_START_LOCATION (info[mid].src) <= loc)
17049 : : {
17050 : 16139517 : info += mid;
17051 : 16139517 : hwm -= mid;
17052 : : }
17053 : : else
17054 : : hwm = mid;
17055 : : }
17056 : 2409452 : offset = loc - MAP_START_LOCATION (info->src);
17057 : 2409452 : if (offset > info->src->n_tokens)
17058 : 0 : info = nullptr;
17059 : : }
17060 : :
17061 : 2409458 : gcc_checking_assert (bool (info) == bool (spans.macro (loc)));
17062 : :
17063 : 2409458 : if (info)
17064 : : {
17065 : 2409452 : offset += info->remap;
17066 : 2409452 : sec.u (LK_MACRO);
17067 : 2409452 : sec.loc (offset);
17068 : 2409452 : dump (dumper::LOCATION)
17069 : 9 : && dump ("Macro location %K output %K", loc, offset);
17070 : : }
17071 : 6 : else if (const module_state *import = module_for_macro_loc (loc))
17072 : : {
17073 : 6 : auto off = loc - import->macro_locs.first;
17074 : 6 : sec.u (LK_IMPORT_MACRO);
17075 : 6 : sec.u (import->remap);
17076 : 6 : sec.loc (off);
17077 : 6 : dump (dumper::LOCATION)
17078 : 0 : && dump ("Imported macro location %K output %u:%K",
17079 : 0 : loc, import->remap, off);
17080 : : }
17081 : : else
17082 : 0 : gcc_unreachable ();
17083 : : }
17084 : 21529050 : else if (IS_ORDINARY_LOC (loc))
17085 : : {
17086 : : /* If we ran out of locations for imported decls, this location could
17087 : : be a module unit's location. In that case, remap the location
17088 : : to be where we imported the module from. */
17089 : 21529050 : if (spans.locations_exhausted_p () || CHECKING_P)
17090 : : {
17091 : 21529050 : const line_map_ordinary *map
17092 : 21529050 : = linemap_check_ordinary (linemap_lookup (line_table, loc));
17093 : 21529050 : if (MAP_MODULE_P (map) && loc == MAP_START_LOCATION (map))
17094 : : {
17095 : 0 : gcc_checking_assert (spans.locations_exhausted_p ());
17096 : 0 : write_location (sec, linemap_included_from (map));
17097 : 0 : return;
17098 : : }
17099 : : }
17100 : :
17101 : 21529050 : const ord_loc_info *info = nullptr;
17102 : 21529050 : line_map_uint_t offset = 0;
17103 : 21529050 : if (line_map_uint_t hwm = ord_loc_remap->length ())
17104 : : {
17105 : 21529050 : info = ord_loc_remap->begin ();
17106 : 316515237 : while (hwm != 1)
17107 : : {
17108 : 273457137 : auto mid = hwm / 2;
17109 : 273457137 : if (MAP_START_LOCATION (info[mid].src) + info[mid].offset <= loc)
17110 : : {
17111 : 143261276 : info += mid;
17112 : 143261276 : hwm -= mid;
17113 : : }
17114 : : else
17115 : : hwm = mid;
17116 : : }
17117 : 21529050 : offset = loc - MAP_START_LOCATION (info->src) - info->offset;
17118 : 21529050 : if (offset > info->span)
17119 : 3027 : info = nullptr;
17120 : : }
17121 : :
17122 : 21529050 : gcc_checking_assert (bool (info) == bool (spans.ordinary (loc)));
17123 : :
17124 : 21529050 : if (info)
17125 : : {
17126 : 21526023 : offset += info->remap;
17127 : 21526023 : sec.u (LK_ORDINARY);
17128 : 21526023 : sec.loc (offset);
17129 : :
17130 : 21526023 : dump (dumper::LOCATION)
17131 : 78 : && dump ("Ordinary location %K output %K", loc, offset);
17132 : : }
17133 : 3027 : else if (const module_state *import = module_for_ordinary_loc (loc))
17134 : : {
17135 : 3027 : auto off = loc - import->ordinary_locs.first;
17136 : 3027 : sec.u (LK_IMPORT_ORDINARY);
17137 : 3027 : sec.u (import->remap);
17138 : 3027 : sec.loc (off);
17139 : 3027 : dump (dumper::LOCATION)
17140 : 0 : && dump ("Imported ordinary location %K output %u:%K",
17141 : 0 : loc, import->remap, off);
17142 : : }
17143 : : else
17144 : 0 : gcc_unreachable ();
17145 : : }
17146 : : else
17147 : 0 : gcc_unreachable ();
17148 : : }
17149 : :
17150 : : location_t
17151 : 30376685 : module_state::read_location (bytes_in &sec) const
17152 : : {
17153 : 30376685 : location_t locus = UNKNOWN_LOCATION;
17154 : 30376685 : unsigned kind = sec.u ();
17155 : 30376685 : switch (kind)
17156 : : {
17157 : 2626891 : default:
17158 : 2626891 : {
17159 : 2626891 : if (kind < LK_RESERVED + RESERVED_LOCATION_COUNT)
17160 : 2626891 : locus = location_t (kind - LK_RESERVED);
17161 : : else
17162 : 0 : sec.set_overrun ();
17163 : 2626891 : dump (dumper::LOCATION)
17164 : 0 : && dump ("Reserved location %K", locus);
17165 : : }
17166 : : break;
17167 : :
17168 : 3120170 : case LK_ADHOC:
17169 : 3120170 : {
17170 : 3120170 : dump (dumper::LOCATION) && dump ("Adhoc location");
17171 : 3120170 : locus = read_location (sec);
17172 : 3120170 : source_range range;
17173 : 3120170 : range.m_start = read_location (sec);
17174 : 3120170 : if (range.m_start == UNKNOWN_LOCATION)
17175 : 94799 : range.m_start = locus;
17176 : 3120170 : range.m_finish = read_location (sec);
17177 : 3120170 : unsigned discriminator = sec.u ();
17178 : 3120170 : if (locus != loc && range.m_start != loc && range.m_finish != loc)
17179 : 3120170 : locus = line_table->get_or_create_combined_loc (locus, range,
17180 : : nullptr, discriminator);
17181 : : }
17182 : : break;
17183 : :
17184 : 2813186 : case LK_MACRO:
17185 : 2813186 : {
17186 : 2813186 : auto off = sec.loc ();
17187 : :
17188 : 2813186 : if (macro_locs.second)
17189 : : {
17190 : 2813186 : if (off < macro_locs.second)
17191 : 2813186 : locus = off + macro_locs.first;
17192 : : else
17193 : 0 : sec.set_overrun ();
17194 : : }
17195 : : else
17196 : 0 : locus = loc;
17197 : 2813186 : dump (dumper::LOCATION)
17198 : 0 : && dump ("Macro %K becoming %K", off, locus);
17199 : : }
17200 : : break;
17201 : :
17202 : 21815456 : case LK_ORDINARY:
17203 : 21815456 : {
17204 : 21815456 : auto off = sec.loc ();
17205 : 21815456 : if (ordinary_locs.second)
17206 : : {
17207 : 21815456 : if (off < ordinary_locs.second)
17208 : 21815456 : locus = off + ordinary_locs.first;
17209 : : else
17210 : 0 : sec.set_overrun ();
17211 : : }
17212 : : else
17213 : 0 : locus = loc;
17214 : :
17215 : 21815456 : dump (dumper::LOCATION)
17216 : 0 : && dump ("Ordinary location %K becoming %K", off, locus);
17217 : : }
17218 : : break;
17219 : :
17220 : 982 : case LK_IMPORT_MACRO:
17221 : 982 : case LK_IMPORT_ORDINARY:
17222 : 982 : {
17223 : 982 : unsigned mod = sec.u ();
17224 : 982 : location_t off = sec.loc ();
17225 : 982 : const module_state *import = NULL;
17226 : :
17227 : 982 : if (!mod && !slurp->remap)
17228 : : /* This is an early read of a partition location during the
17229 : : read of our ordinary location map. */
17230 : : import = this;
17231 : : else
17232 : : {
17233 : 982 : mod = slurp->remap_module (mod);
17234 : 982 : if (!mod)
17235 : 0 : sec.set_overrun ();
17236 : : else
17237 : 982 : import = (*modules)[mod];
17238 : : }
17239 : :
17240 : 982 : if (import)
17241 : : {
17242 : 982 : if (kind == LK_IMPORT_MACRO)
17243 : : {
17244 : 6 : if (!import->macro_locs.second)
17245 : 0 : locus = import->loc;
17246 : 6 : else if (off < import->macro_locs.second)
17247 : 6 : locus = off + import->macro_locs.first;
17248 : : else
17249 : 0 : sec.set_overrun ();
17250 : : }
17251 : : else
17252 : : {
17253 : 976 : if (!import->ordinary_locs.second)
17254 : 0 : locus = import->loc;
17255 : 976 : else if (off < import->ordinary_locs.second)
17256 : 976 : locus = import->ordinary_locs.first + off;
17257 : : else
17258 : 0 : sec.set_overrun ();
17259 : : }
17260 : : }
17261 : : }
17262 : : break;
17263 : : }
17264 : :
17265 : 30376685 : return locus;
17266 : : }
17267 : :
17268 : : /* Allocate hash tables to record needed locations. */
17269 : :
17270 : : void
17271 : 2170 : module_state::write_init_maps ()
17272 : : {
17273 : 2170 : macro_loc_table = new hash_table<macro_loc_traits> (EXPERIMENT (1, 400));
17274 : 2170 : ord_loc_table = new hash_table<ord_loc_traits> (EXPERIMENT (1, 400));
17275 : 2170 : }
17276 : :
17277 : : /* Prepare the span adjustments. We prune unneeded locations -- at
17278 : : this point every needed location must have been seen by
17279 : : note_location. */
17280 : :
17281 : : range_t
17282 : 2149 : module_state::write_prepare_maps (module_state_config *cfg, bool has_partitions)
17283 : : {
17284 : 2390 : dump () && dump ("Preparing locations");
17285 : 2149 : dump.indent ();
17286 : :
17287 : 2390 : dump () && dump ("Reserved locations [%K,%K) macro [%K,%K)",
17288 : 241 : spans[loc_spans::SPAN_RESERVED].ordinary.first,
17289 : 241 : spans[loc_spans::SPAN_RESERVED].ordinary.second,
17290 : 241 : spans[loc_spans::SPAN_RESERVED].macro.first,
17291 : 241 : spans[loc_spans::SPAN_RESERVED].macro.second);
17292 : :
17293 : 2149 : range_t info {0, 0};
17294 : :
17295 : : // Sort the noted lines.
17296 : 2149 : vec_alloc (ord_loc_remap, ord_loc_table->size ());
17297 : 2149 : for (auto iter = ord_loc_table->begin (), end = ord_loc_table->end ();
17298 : 5175455 : iter != end; ++iter)
17299 : 2586653 : ord_loc_remap->quick_push (*iter);
17300 : 2149 : ord_loc_remap->qsort (&ord_loc_info::compare);
17301 : :
17302 : : // Note included-from maps.
17303 : 2149 : bool added = false;
17304 : 2149 : const line_map_ordinary *current = nullptr;
17305 : 2593100 : for (auto iter = ord_loc_remap->begin (), end = ord_loc_remap->end ();
17306 : 2588802 : iter != end; ++iter)
17307 : 2586653 : if (iter->src != current)
17308 : : {
17309 : 39558 : current = iter->src;
17310 : 31796 : for (auto probe = current;
17311 : 39558 : auto from = linemap_included_from (probe);
17312 : 15898 : probe = linemap_check_ordinary (linemap_lookup (line_table, from)))
17313 : : {
17314 : 37183 : if (has_partitions)
17315 : : {
17316 : : // Partition locations need to elide their module map
17317 : : // entry.
17318 : 136 : probe
17319 : 136 : = linemap_check_ordinary (linemap_lookup (line_table, from));
17320 : 136 : if (MAP_MODULE_P (probe))
17321 : 121 : from = linemap_included_from (probe);
17322 : : }
17323 : :
17324 : 37183 : if (!note_location (from))
17325 : : break;
17326 : 15898 : added = true;
17327 : 15898 : }
17328 : : }
17329 : 2149 : if (added)
17330 : : {
17331 : : // Reconstruct the line array as we added items to the hash table.
17332 : 406 : vec_free (ord_loc_remap);
17333 : 406 : vec_alloc (ord_loc_remap, ord_loc_table->size ());
17334 : 406 : for (auto iter = ord_loc_table->begin (), end = ord_loc_table->end ();
17335 : 5189734 : iter != end; ++iter)
17336 : 2594664 : ord_loc_remap->quick_push (*iter);
17337 : 406 : ord_loc_remap->qsort (&ord_loc_info::compare);
17338 : : }
17339 : 2149 : delete ord_loc_table;
17340 : 2149 : ord_loc_table = nullptr;
17341 : :
17342 : : // Merge (sufficiently) adjacent spans, and calculate remapping.
17343 : 2149 : constexpr line_map_uint_t adjacency = 2; // Allow 2 missing lines.
17344 : 4298 : auto begin = ord_loc_remap->begin (), end = ord_loc_remap->end ();
17345 : 2149 : auto dst = begin;
17346 : 2149 : line_map_uint_t offset = 0;
17347 : 2149 : unsigned range_bits = 0;
17348 : 2149 : ord_loc_info *base = nullptr;
17349 : 2604700 : for (auto iter = begin; iter != end; ++iter)
17350 : : {
17351 : 2602551 : if (base && iter->src == base->src)
17352 : : {
17353 : 4854260 : if (base->offset + base->span +
17354 : 2569556 : ((adjacency << base->src->m_column_and_range_bits)
17355 : : // If there are few c&r bits, allow further separation.
17356 : 2569556 : | (adjacency << 4))
17357 : 2569556 : >= iter->offset)
17358 : : {
17359 : : // Merge.
17360 : 2284704 : offset -= base->span;
17361 : 2284704 : base->span = iter->offset + iter->span - base->offset;
17362 : 2284704 : offset += base->span;
17363 : 2284704 : continue;
17364 : : }
17365 : : }
17366 : 32995 : else if (range_bits < iter->src->m_range_bits)
17367 : 2058 : range_bits = iter->src->m_range_bits;
17368 : :
17369 : 317847 : offset += ((loc_one << iter->src->m_range_bits) - 1);
17370 : 317847 : offset &= ~((loc_one << iter->src->m_range_bits) - 1);
17371 : 317847 : iter->remap = offset;
17372 : 317847 : offset += iter->span;
17373 : 317847 : base = dst;
17374 : 317847 : *dst++ = *iter;
17375 : : }
17376 : 2149 : ord_loc_remap->truncate (dst - begin);
17377 : :
17378 : 2149 : info.first = ord_loc_remap->length ();
17379 : 2149 : cfg->ordinary_locs = offset;
17380 : 2149 : cfg->loc_range_bits = range_bits;
17381 : 2390 : dump () && dump ("Ordinary maps:%K locs:%K range_bits:%u",
17382 : : info.first,
17383 : : cfg->ordinary_locs,
17384 : : cfg->loc_range_bits);
17385 : :
17386 : : // Remap the macro locations.
17387 : 2149 : vec_alloc (macro_loc_remap, macro_loc_table->size ());
17388 : 2149 : for (auto iter = macro_loc_table->begin (), end = macro_loc_table->end ();
17389 : 570281 : iter != end; ++iter)
17390 : 284066 : macro_loc_remap->quick_push (*iter);
17391 : 2149 : delete macro_loc_table;
17392 : 2149 : macro_loc_table = nullptr;
17393 : :
17394 : 2149 : macro_loc_remap->qsort (¯o_loc_info::compare);
17395 : 2149 : offset = 0;
17396 : 6447 : for (auto iter = macro_loc_remap->begin (), end = macro_loc_remap->end ();
17397 : 286215 : iter != end; ++iter)
17398 : : {
17399 : 284066 : auto mac = iter->src;
17400 : 284066 : iter->remap = offset;
17401 : 284066 : offset += mac->n_tokens;
17402 : : }
17403 : 2149 : info.second = macro_loc_remap->length ();
17404 : 2149 : cfg->macro_locs = offset;
17405 : :
17406 : 2390 : dump () && dump ("Macro maps:%K locs:%K", info.second, cfg->macro_locs);
17407 : :
17408 : 2149 : dump.outdent ();
17409 : :
17410 : : // If we have no ordinary locs, we must also have no macro locs.
17411 : 2149 : gcc_checking_assert (cfg->ordinary_locs || !cfg->macro_locs);
17412 : :
17413 : 2149 : return info;
17414 : : }
17415 : :
17416 : : bool
17417 : 2352 : module_state::read_prepare_maps (const module_state_config *cfg)
17418 : : {
17419 : 2352 : location_t ordinary = line_table->highest_location + 1;
17420 : 2352 : ordinary += cfg->ordinary_locs;
17421 : :
17422 : 2352 : location_t macro = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
17423 : 2352 : macro -= cfg->macro_locs;
17424 : :
17425 : 2352 : if (ordinary < LINE_MAP_MAX_LOCATION_WITH_COLS
17426 : 2352 : && macro >= LINE_MAP_MAX_LOCATION)
17427 : : /* OK, we have enough locations. */
17428 : : return true;
17429 : :
17430 : 0 : ordinary_locs.first = ordinary_locs.second = 0;
17431 : 0 : macro_locs.first = macro_locs.second = 0;
17432 : :
17433 : 0 : spans.report_location_exhaustion (loc);
17434 : :
17435 : : return false;
17436 : : }
17437 : :
17438 : : /* Write & read the location maps. Not called if there are no
17439 : : locations. */
17440 : :
17441 : : void
17442 : 2058 : module_state::write_ordinary_maps (elf_out *to, range_t &info,
17443 : : bool has_partitions, unsigned *crc_p)
17444 : : {
17445 : 2283 : dump () && dump ("Writing ordinary location maps");
17446 : 2058 : dump.indent ();
17447 : :
17448 : 2058 : vec<const char *> filenames;
17449 : 2058 : filenames.create (20);
17450 : :
17451 : : /* Determine the unique filenames. */
17452 : 2058 : const line_map_ordinary *current = nullptr;
17453 : 324021 : for (auto iter = ord_loc_remap->begin (), end = ord_loc_remap->end ();
17454 : 319905 : iter != end; ++iter)
17455 : 317847 : if (iter->src != current)
17456 : : {
17457 : 32995 : current = iter->src;
17458 : 32995 : const char *fname = ORDINARY_MAP_FILE_NAME (iter->src);
17459 : :
17460 : : /* We should never find a module linemap in an interval. */
17461 : 32995 : gcc_checking_assert (!MAP_MODULE_P (iter->src));
17462 : :
17463 : : /* We expect very few filenames, so just an array.
17464 : : (Not true when headers are still in play :() */
17465 : 2428729 : for (unsigned jx = filenames.length (); jx--;)
17466 : : {
17467 : 2379123 : const char *name = filenames[jx];
17468 : 2379123 : if (0 == strcmp (name, fname))
17469 : : {
17470 : : /* Reset the linemap's name, because for things like
17471 : : preprocessed input we could have multiple instances
17472 : : of the same name, and we'd rather not percolate
17473 : : that. */
17474 : 16384 : const_cast<line_map_ordinary *> (iter->src)->to_file = name;
17475 : 16384 : fname = NULL;
17476 : 16384 : break;
17477 : : }
17478 : : }
17479 : 32995 : if (fname)
17480 : 16611 : filenames.safe_push (fname);
17481 : : }
17482 : :
17483 : 2058 : bytes_out sec (to);
17484 : 2058 : sec.begin ();
17485 : :
17486 : : /* Write the filenames. */
17487 : 2058 : unsigned len = filenames.length ();
17488 : 2058 : sec.u (len);
17489 : 2283 : dump () && dump ("%u source file names", len);
17490 : 18669 : for (unsigned ix = 0; ix != len; ix++)
17491 : : {
17492 : 16611 : const char *fname = filenames[ix];
17493 : 16626 : dump (dumper::LOCATION) && dump ("Source file[%u]=%s", ix, fname);
17494 : 16611 : sec.str (fname);
17495 : : }
17496 : :
17497 : 2058 : sec.loc (info.first); /* Num maps. */
17498 : 2058 : const ord_loc_info *base = nullptr;
17499 : 324021 : for (auto iter = ord_loc_remap->begin (), end = ord_loc_remap->end ();
17500 : 319905 : iter != end; ++iter)
17501 : : {
17502 : 317847 : dump (dumper::LOCATION)
17503 : 36 : && dump ("Span:%K ordinary [%K+%K,+%K)->[%K,+%K)",
17504 : 36 : (location_t) (iter - ord_loc_remap->begin ()),
17505 : 18 : MAP_START_LOCATION (iter->src),
17506 : : iter->offset, iter->span, iter->remap,
17507 : : iter->span);
17508 : :
17509 : 317847 : if (!base || iter->src != base->src)
17510 : 32995 : base = iter;
17511 : 317847 : sec.loc (iter->offset - base->offset);
17512 : 317847 : if (base == iter)
17513 : : {
17514 : 32995 : sec.u (iter->src->sysp);
17515 : 32995 : sec.u (iter->src->m_range_bits);
17516 : 32995 : sec.u (iter->src->m_column_and_range_bits - iter->src->m_range_bits);
17517 : :
17518 : 32995 : const char *fname = ORDINARY_MAP_FILE_NAME (iter->src);
17519 : 7608848 : for (unsigned ix = 0; ix != filenames.length (); ix++)
17520 : 3804424 : if (filenames[ix] == fname)
17521 : : {
17522 : 32995 : sec.u (ix);
17523 : 32995 : break;
17524 : : }
17525 : 32995 : unsigned line = ORDINARY_MAP_STARTING_LINE_NUMBER (iter->src);
17526 : 32995 : line += iter->offset >> iter->src->m_column_and_range_bits;
17527 : 32995 : sec.u (line);
17528 : : }
17529 : 317847 : sec.loc (iter->remap);
17530 : 317847 : if (base == iter)
17531 : : {
17532 : : /* Write the included from location, which means reading it
17533 : : while reading in the ordinary maps. So we'd better not
17534 : : be getting ahead of ourselves. */
17535 : 32995 : location_t from = linemap_included_from (iter->src);
17536 : 32995 : gcc_checking_assert (from < MAP_START_LOCATION (iter->src));
17537 : 32995 : if (from != UNKNOWN_LOCATION && has_partitions)
17538 : : {
17539 : : /* A partition's span will have a from pointing at a
17540 : : MODULE_INC. Find that map's from. */
17541 : 130 : line_map_ordinary const *fmap
17542 : 130 : = linemap_check_ordinary (linemap_lookup (line_table, from));
17543 : 130 : if (MAP_MODULE_P (fmap))
17544 : 115 : from = linemap_included_from (fmap);
17545 : : }
17546 : 32995 : write_location (sec, from);
17547 : : }
17548 : : }
17549 : :
17550 : 2058 : filenames.release ();
17551 : :
17552 : 2058 : sec.end (to, to->name (MOD_SNAME_PFX ".olm"), crc_p);
17553 : 2058 : dump.outdent ();
17554 : 2058 : }
17555 : :
17556 : : void
17557 : 120 : module_state::write_macro_maps (elf_out *to, range_t &info, unsigned *crc_p)
17558 : : {
17559 : 135 : dump () && dump ("Writing macro location maps");
17560 : 120 : dump.indent ();
17561 : :
17562 : 120 : bytes_out sec (to);
17563 : 120 : sec.begin ();
17564 : :
17565 : 135 : dump () && dump ("Macro maps:%K", info.second);
17566 : 120 : sec.loc (info.second);
17567 : :
17568 : 120 : line_map_uint_t macro_num = 0;
17569 : 240 : for (auto iter = macro_loc_remap->end (), begin = macro_loc_remap->begin ();
17570 : 284186 : iter-- != begin;)
17571 : : {
17572 : 284066 : auto mac = iter->src;
17573 : 284066 : sec.loc (iter->remap);
17574 : 284066 : sec.u (mac->n_tokens);
17575 : 284066 : sec.cpp_node (mac->macro);
17576 : 284066 : write_location (sec, mac->m_expansion);
17577 : 284066 : const location_t *locs = mac->macro_locations;
17578 : : /* There are lots of identical runs. */
17579 : 284066 : location_t prev = UNKNOWN_LOCATION;
17580 : 284066 : unsigned count = 0;
17581 : 284066 : unsigned runs = 0;
17582 : 10444908 : for (unsigned jx = mac->n_tokens * 2; jx--;)
17583 : : {
17584 : 10160842 : location_t tok_loc = locs[jx];
17585 : 10160842 : if (tok_loc == prev)
17586 : : {
17587 : 4766077 : count++;
17588 : 4766077 : continue;
17589 : : }
17590 : 5394765 : runs++;
17591 : 5394765 : sec.u (count);
17592 : 5394765 : count = 1;
17593 : 5394765 : prev = tok_loc;
17594 : 5394765 : write_location (sec, tok_loc);
17595 : : }
17596 : 284066 : sec.u (count);
17597 : 284066 : dump (dumper::LOCATION)
17598 : 9 : && dump ("Macro:%K %I %u/%u*2 locations [%K,%K)->%K",
17599 : 9 : macro_num, identifier (mac->macro),
17600 : : runs, mac->n_tokens,
17601 : : MAP_START_LOCATION (mac),
17602 : 9 : MAP_START_LOCATION (mac) + mac->n_tokens,
17603 : : iter->remap);
17604 : 284066 : macro_num++;
17605 : : }
17606 : 120 : gcc_assert (macro_num == info.second);
17607 : :
17608 : 120 : sec.end (to, to->name (MOD_SNAME_PFX ".mlm"), crc_p);
17609 : 120 : dump.outdent ();
17610 : 120 : }
17611 : :
17612 : : bool
17613 : 2289 : module_state::read_ordinary_maps (line_map_uint_t num_ord_locs,
17614 : : unsigned range_bits)
17615 : : {
17616 : 2289 : bytes_in sec;
17617 : :
17618 : 2289 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".olm"))
17619 : : return false;
17620 : 2732 : dump () && dump ("Reading ordinary location maps");
17621 : 2289 : dump.indent ();
17622 : :
17623 : : /* Read the filename table. */
17624 : 2289 : unsigned len = sec.u ();
17625 : 2732 : dump () && dump ("%u source file names", len);
17626 : 2289 : vec<const char *> filenames;
17627 : 2289 : filenames.create (len);
17628 : 22967 : for (unsigned ix = 0; ix != len; ix++)
17629 : : {
17630 : 20678 : size_t l;
17631 : 20678 : const char *buf = sec.str (&l);
17632 : 20678 : char *fname = XNEWVEC (char, l + 1);
17633 : 20678 : memcpy (fname, buf, l + 1);
17634 : 20678 : dump (dumper::LOCATION) && dump ("Source file[%u]=%s", ix, fname);
17635 : : /* We leak these names into the line-map table. But it
17636 : : doesn't own them. */
17637 : 20678 : filenames.quick_push (fname);
17638 : : }
17639 : :
17640 : 2289 : line_map_uint_t num_ordinary = sec.loc ();
17641 : 2732 : dump () && dump ("Ordinary maps:%K, range_bits:%u",
17642 : : num_ordinary, range_bits);
17643 : :
17644 : 2289 : location_t offset = line_table->highest_location + 1;
17645 : 2289 : offset += ((loc_one << range_bits) - 1);
17646 : 2289 : offset &= ~((loc_one << range_bits) - 1);
17647 : 2289 : ordinary_locs.first = offset;
17648 : :
17649 : 2289 : bool propagated = spans.maybe_propagate (this, offset);
17650 : 2289 : line_map_ordinary *maps = static_cast<line_map_ordinary *>
17651 : 2289 : (line_map_new_raw (line_table, false, num_ordinary));
17652 : :
17653 : 2289 : const line_map_ordinary *base = nullptr;
17654 : 403623 : for (line_map_uint_t ix = 0; ix != num_ordinary && !sec.get_overrun (); ix++)
17655 : : {
17656 : 401334 : line_map_ordinary *map = &maps[ix];
17657 : :
17658 : 401334 : location_t offset = sec.loc ();
17659 : 401334 : if (!offset)
17660 : : {
17661 : 41738 : map->reason = LC_RENAME;
17662 : 41738 : map->sysp = sec.u ();
17663 : 41738 : map->m_range_bits = sec.u ();
17664 : 41738 : map->m_column_and_range_bits = sec.u () + map->m_range_bits;
17665 : 41738 : unsigned fnum = sec.u ();
17666 : 83476 : map->to_file = (fnum < filenames.length () ? filenames[fnum] : "");
17667 : 41738 : map->to_line = sec.u ();
17668 : 41738 : base = map;
17669 : : }
17670 : : else
17671 : : {
17672 : 359596 : *map = *base;
17673 : 359596 : map->to_line += offset >> map->m_column_and_range_bits;
17674 : : }
17675 : 401334 : location_t remap = sec.loc ();
17676 : 401334 : map->start_location = remap + ordinary_locs.first;
17677 : 401334 : if (base == map)
17678 : : {
17679 : : /* Root the outermost map at our location. */
17680 : 41738 : ordinary_locs.second = remap;
17681 : 41738 : location_t from = read_location (sec);
17682 : 41738 : map->included_from = from != UNKNOWN_LOCATION ? from : loc;
17683 : : }
17684 : : }
17685 : :
17686 : 2289 : ordinary_locs.second = num_ord_locs;
17687 : : /* highest_location is the one handed out, not the next one to
17688 : : hand out. */
17689 : 2289 : line_table->highest_location = ordinary_locs.first + ordinary_locs.second - 1;
17690 : :
17691 : 2289 : if (line_table->highest_location >= LINE_MAP_MAX_LOCATION_WITH_COLS)
17692 : : /* We shouldn't run out of locations, as we checked before
17693 : : starting. */
17694 : 0 : sec.set_overrun ();
17695 : 2732 : dump () && dump ("Ordinary location [%K,+%K)",
17696 : : ordinary_locs.first, ordinary_locs.second);
17697 : :
17698 : 2289 : if (propagated)
17699 : 127 : spans.close ();
17700 : :
17701 : 2289 : filenames.release ();
17702 : :
17703 : 2289 : dump.outdent ();
17704 : 2289 : if (!sec.end (from ()))
17705 : : return false;
17706 : :
17707 : : return true;
17708 : 2289 : }
17709 : :
17710 : : bool
17711 : 139 : module_state::read_macro_maps (line_map_uint_t num_macro_locs)
17712 : : {
17713 : 139 : bytes_in sec;
17714 : :
17715 : 139 : if (!sec.begin (loc, from (), MOD_SNAME_PFX ".mlm"))
17716 : : return false;
17717 : 145 : dump () && dump ("Reading macro location maps");
17718 : 139 : dump.indent ();
17719 : :
17720 : 139 : line_map_uint_t num_macros = sec.loc ();
17721 : 145 : dump () && dump ("Macro maps:%K locs:%K",
17722 : : num_macros, num_macro_locs);
17723 : :
17724 : 278 : bool propagated = spans.maybe_propagate (this,
17725 : 139 : line_table->highest_location + 1);
17726 : :
17727 : 139 : location_t offset = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
17728 : 139 : macro_locs.second = num_macro_locs;
17729 : 139 : macro_locs.first = offset - num_macro_locs;
17730 : :
17731 : 145 : dump () && dump ("Macro loc delta %K", offset);
17732 : 145 : dump () && dump ("Macro locations [%K,%K)",
17733 : : macro_locs.first, macro_locs.second);
17734 : :
17735 : 360939 : for (line_map_uint_t ix = 0; ix != num_macros && !sec.get_overrun (); ix++)
17736 : : {
17737 : 360800 : location_t offset = sec.loc ();
17738 : 360800 : unsigned n_tokens = sec.u ();
17739 : 360800 : cpp_hashnode *node = sec.cpp_node ();
17740 : 360800 : location_t exp_loc = read_location (sec);
17741 : :
17742 : 360800 : const line_map_macro *macro
17743 : 360800 : = linemap_enter_macro (line_table, node, exp_loc, n_tokens);
17744 : 360800 : if (!macro)
17745 : : /* We shouldn't run out of locations, as we checked that we
17746 : : had enough before starting. */
17747 : : break;
17748 : 360800 : gcc_checking_assert (MAP_START_LOCATION (macro)
17749 : : == offset + macro_locs.first);
17750 : :
17751 : 360800 : location_t *locs = macro->macro_locations;
17752 : 360800 : location_t tok_loc = UNKNOWN_LOCATION;
17753 : 360800 : unsigned count = sec.u ();
17754 : 360800 : unsigned runs = 0;
17755 : 13048274 : for (unsigned jx = macro->n_tokens * 2; jx-- && !sec.get_overrun ();)
17756 : : {
17757 : 19432605 : while (!count-- && !sec.get_overrun ())
17758 : : {
17759 : 6745131 : runs++;
17760 : 6745131 : tok_loc = read_location (sec);
17761 : 6745131 : count = sec.u ();
17762 : : }
17763 : 12687474 : locs[jx] = tok_loc;
17764 : : }
17765 : 360800 : if (count)
17766 : 0 : sec.set_overrun ();
17767 : 360827 : dump (dumper::LOCATION)
17768 : 0 : && dump ("Macro:%K %I %u/%u*2 locations [%K,%K)",
17769 : : ix, identifier (node), runs, n_tokens,
17770 : : MAP_START_LOCATION (macro),
17771 : 0 : MAP_START_LOCATION (macro) + n_tokens);
17772 : : }
17773 : :
17774 : 145 : dump () && dump ("Macro location lwm:%K", macro_locs.first);
17775 : 139 : if (propagated)
17776 : 3 : spans.close ();
17777 : :
17778 : 139 : dump.outdent ();
17779 : 139 : if (!sec.end (from ()))
17780 : : return false;
17781 : :
17782 : : return true;
17783 : 139 : }
17784 : :
17785 : : /* Serialize the definition of MACRO. */
17786 : :
17787 : : void
17788 : 113401 : module_state::write_define (bytes_out &sec, const cpp_macro *macro)
17789 : : {
17790 : 113401 : sec.u (macro->count);
17791 : :
17792 : 113401 : bytes_out::bits_out bits = sec.stream_bits ();
17793 : 113401 : bits.b (macro->fun_like);
17794 : 113401 : bits.b (macro->variadic);
17795 : 113401 : bits.b (macro->syshdr);
17796 : 113401 : bits.bflush ();
17797 : :
17798 : 113401 : write_location (sec, macro->line);
17799 : 113401 : if (macro->fun_like)
17800 : : {
17801 : 12767 : sec.u (macro->paramc);
17802 : 12767 : const cpp_hashnode *const *parms = macro->parm.params;
17803 : 32537 : for (unsigned ix = 0; ix != macro->paramc; ix++)
17804 : 19770 : sec.cpp_node (parms[ix]);
17805 : : }
17806 : :
17807 : : unsigned len = 0;
17808 : 358535 : for (unsigned ix = 0; ix != macro->count; ix++)
17809 : : {
17810 : 245134 : const cpp_token *token = ¯o->exp.tokens[ix];
17811 : 245134 : write_location (sec, token->src_loc);
17812 : 245134 : sec.u (token->type);
17813 : 245134 : sec.u (token->flags);
17814 : 245134 : switch (cpp_token_val_index (token))
17815 : : {
17816 : 0 : default:
17817 : 0 : gcc_unreachable ();
17818 : :
17819 : 17493 : case CPP_TOKEN_FLD_ARG_NO:
17820 : : /* An argument reference. */
17821 : 17493 : sec.u (token->val.macro_arg.arg_no);
17822 : 17493 : sec.cpp_node (token->val.macro_arg.spelling);
17823 : 17493 : break;
17824 : :
17825 : 53986 : case CPP_TOKEN_FLD_NODE:
17826 : : /* An identifier. */
17827 : 53986 : sec.cpp_node (token->val.node.node);
17828 : 53986 : if (token->val.node.spelling == token->val.node.node)
17829 : : /* The spelling will usually be the same. so optimize
17830 : : that. */
17831 : 53986 : sec.str (NULL, 0);
17832 : : else
17833 : 0 : sec.cpp_node (token->val.node.spelling);
17834 : : break;
17835 : :
17836 : : case CPP_TOKEN_FLD_NONE:
17837 : : break;
17838 : :
17839 : 76020 : case CPP_TOKEN_FLD_STR:
17840 : : /* A string, number or comment. Not always NUL terminated,
17841 : : we stream out in a single contatenation with embedded
17842 : : NULs as that's a safe default. */
17843 : 76020 : len += token->val.str.len + 1;
17844 : 76020 : sec.u (token->val.str.len);
17845 : 76020 : break;
17846 : :
17847 : 0 : case CPP_TOKEN_FLD_SOURCE:
17848 : 0 : case CPP_TOKEN_FLD_TOKEN_NO:
17849 : 0 : case CPP_TOKEN_FLD_PRAGMA:
17850 : : /* These do not occur inside a macro itself. */
17851 : 0 : gcc_unreachable ();
17852 : : }
17853 : : }
17854 : :
17855 : 113401 : if (len)
17856 : : {
17857 : 70424 : char *ptr = reinterpret_cast<char *> (sec.buf (len));
17858 : 70424 : len = 0;
17859 : 218015 : for (unsigned ix = 0; ix != macro->count; ix++)
17860 : : {
17861 : 147591 : const cpp_token *token = ¯o->exp.tokens[ix];
17862 : 147591 : if (cpp_token_val_index (token) == CPP_TOKEN_FLD_STR)
17863 : : {
17864 : 76020 : memcpy (ptr + len, token->val.str.text,
17865 : 76020 : token->val.str.len);
17866 : 76020 : len += token->val.str.len;
17867 : 76020 : ptr[len++] = 0;
17868 : : }
17869 : : }
17870 : : }
17871 : 113401 : }
17872 : :
17873 : : /* Read a macro definition. */
17874 : :
17875 : : cpp_macro *
17876 : 304 : module_state::read_define (bytes_in &sec, cpp_reader *reader) const
17877 : : {
17878 : 304 : unsigned count = sec.u ();
17879 : : /* We rely on knowing cpp_reader's hash table is ident_hash, and
17880 : : its subobject allocator is stringpool_ggc_alloc and that is just
17881 : : a wrapper for ggc_alloc_atomic. */
17882 : 304 : cpp_macro *macro
17883 : 608 : = (cpp_macro *)ggc_alloc_atomic (sizeof (cpp_macro)
17884 : 304 : + sizeof (cpp_token) * (count - !!count));
17885 : 304 : memset (macro, 0, sizeof (cpp_macro) + sizeof (cpp_token) * (count - !!count));
17886 : :
17887 : 304 : macro->count = count;
17888 : 304 : macro->kind = cmk_macro;
17889 : 304 : macro->imported_p = true;
17890 : :
17891 : 304 : bytes_in::bits_in bits = sec.stream_bits ();
17892 : 304 : macro->fun_like = bits.b ();
17893 : 304 : macro->variadic = bits.b ();
17894 : 304 : macro->syshdr = bits.b ();
17895 : 304 : bits.bflush ();
17896 : :
17897 : 304 : macro->line = read_location (sec);
17898 : :
17899 : 304 : if (macro->fun_like)
17900 : : {
17901 : 53 : unsigned paramc = sec.u ();
17902 : 53 : cpp_hashnode **params
17903 : 53 : = (cpp_hashnode **)ggc_alloc_atomic (sizeof (cpp_hashnode *) * paramc);
17904 : 53 : macro->paramc = paramc;
17905 : 53 : macro->parm.params = params;
17906 : 115 : for (unsigned ix = 0; ix != paramc; ix++)
17907 : 62 : params[ix] = sec.cpp_node ();
17908 : : }
17909 : :
17910 : : unsigned len = 0;
17911 : 872 : for (unsigned ix = 0; ix != count && !sec.get_overrun (); ix++)
17912 : : {
17913 : 568 : cpp_token *token = ¯o->exp.tokens[ix];
17914 : 568 : token->src_loc = read_location (sec);
17915 : 568 : token->type = cpp_ttype (sec.u ());
17916 : 568 : token->flags = sec.u ();
17917 : 568 : switch (cpp_token_val_index (token))
17918 : : {
17919 : 0 : default:
17920 : 0 : sec.set_overrun ();
17921 : 0 : break;
17922 : :
17923 : 48 : case CPP_TOKEN_FLD_ARG_NO:
17924 : : /* An argument reference. */
17925 : 48 : {
17926 : 48 : unsigned arg_no = sec.u ();
17927 : 48 : if (arg_no - 1 >= macro->paramc)
17928 : 0 : sec.set_overrun ();
17929 : 48 : token->val.macro_arg.arg_no = arg_no;
17930 : 48 : token->val.macro_arg.spelling = sec.cpp_node ();
17931 : : }
17932 : 48 : break;
17933 : :
17934 : 157 : case CPP_TOKEN_FLD_NODE:
17935 : : /* An identifier. */
17936 : 157 : token->val.node.node = sec.cpp_node ();
17937 : 157 : token->val.node.spelling = sec.cpp_node ();
17938 : 157 : if (!token->val.node.spelling)
17939 : 157 : token->val.node.spelling = token->val.node.node;
17940 : : break;
17941 : :
17942 : : case CPP_TOKEN_FLD_NONE:
17943 : : break;
17944 : :
17945 : 165 : case CPP_TOKEN_FLD_STR:
17946 : : /* A string, number or comment. */
17947 : 165 : token->val.str.len = sec.u ();
17948 : 165 : len += token->val.str.len + 1;
17949 : 165 : break;
17950 : : }
17951 : : }
17952 : :
17953 : 304 : if (len)
17954 : 164 : if (const char *ptr = reinterpret_cast<const char *> (sec.buf (len)))
17955 : : {
17956 : : /* There should be a final NUL. */
17957 : 164 : if (ptr[len-1])
17958 : 0 : sec.set_overrun ();
17959 : : /* cpp_alloc_token_string will add a final NUL. */
17960 : 164 : const unsigned char *buf
17961 : 164 : = cpp_alloc_token_string (reader, (const unsigned char *)ptr, len - 1);
17962 : 164 : len = 0;
17963 : 427 : for (unsigned ix = 0; ix != count && !sec.get_overrun (); ix++)
17964 : : {
17965 : 263 : cpp_token *token = ¯o->exp.tokens[ix];
17966 : 263 : if (cpp_token_val_index (token) == CPP_TOKEN_FLD_STR)
17967 : : {
17968 : 165 : token->val.str.text = buf + len;
17969 : 165 : len += token->val.str.len;
17970 : 165 : if (buf[len++])
17971 : 0 : sec.set_overrun ();
17972 : : }
17973 : : }
17974 : : }
17975 : :
17976 : 304 : if (sec.get_overrun ())
17977 : 0 : return NULL;
17978 : : return macro;
17979 : 304 : }
17980 : :
17981 : : /* Exported macro data. */
17982 : : struct GTY(()) macro_export {
17983 : : cpp_macro *def;
17984 : : location_t undef_loc;
17985 : :
17986 : 193353 : macro_export ()
17987 : 193353 : :def (NULL), undef_loc (UNKNOWN_LOCATION)
17988 : : {
17989 : : }
17990 : : };
17991 : :
17992 : : /* Imported macro data. */
17993 : : class macro_import {
17994 : : public:
17995 : : struct slot {
17996 : : #if defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8
17997 : : int offset;
17998 : : #endif
17999 : : /* We need to ensure we don't use the LSB for representation, as
18000 : : that's the union discriminator below. */
18001 : : unsigned bits;
18002 : :
18003 : : #if !(defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8)
18004 : : int offset;
18005 : : #endif
18006 : :
18007 : : public:
18008 : : enum Layout {
18009 : : L_DEF = 1,
18010 : : L_UNDEF = 2,
18011 : : L_BOTH = 3,
18012 : : L_MODULE_SHIFT = 2
18013 : : };
18014 : :
18015 : : public:
18016 : : /* Not a regular ctor, because we put it in a union, and that's
18017 : : not allowed in C++ 98. */
18018 : 339574 : static slot ctor (unsigned module, unsigned defness)
18019 : : {
18020 : 339574 : gcc_checking_assert (defness);
18021 : 339574 : slot s;
18022 : 339574 : s.bits = defness | (module << L_MODULE_SHIFT);
18023 : 339574 : s.offset = -1;
18024 : 339574 : return s;
18025 : : }
18026 : :
18027 : : public:
18028 : 228273 : unsigned get_defness () const
18029 : : {
18030 : 228273 : return bits & L_BOTH;
18031 : : }
18032 : 195064 : unsigned get_module () const
18033 : : {
18034 : 195064 : return bits >> L_MODULE_SHIFT;
18035 : : }
18036 : 12 : void become_undef ()
18037 : : {
18038 : 12 : bits &= ~unsigned (L_DEF);
18039 : 12 : bits |= unsigned (L_UNDEF);
18040 : : }
18041 : : };
18042 : :
18043 : : private:
18044 : : typedef vec<slot, va_heap, vl_embed> ary_t;
18045 : : union either {
18046 : : /* Discriminated by bits 0|1 != 0. The expected case is that
18047 : : there will be exactly one slot per macro, hence the effort of
18048 : : packing that. */
18049 : : ary_t *ary;
18050 : : slot single;
18051 : : } u;
18052 : :
18053 : : public:
18054 : 255260 : macro_import ()
18055 : 255260 : {
18056 : 255260 : u.ary = NULL;
18057 : : }
18058 : :
18059 : : private:
18060 : 12889747 : bool single_p () const
18061 : : {
18062 : 12889747 : return u.single.bits & slot::L_BOTH;
18063 : : }
18064 : 13145013 : bool occupied_p () const
18065 : : {
18066 : 13145013 : return u.ary != NULL;
18067 : : }
18068 : :
18069 : : public:
18070 : 870 : unsigned length () const
18071 : : {
18072 : 870 : gcc_checking_assert (occupied_p ());
18073 : 870 : return single_p () ? 1 : u.ary->length ();
18074 : : }
18075 : 12611520 : slot &operator[] (unsigned ix)
18076 : : {
18077 : 12611520 : gcc_checking_assert (occupied_p ());
18078 : 12611520 : if (single_p ())
18079 : : {
18080 : 12475396 : gcc_checking_assert (!ix);
18081 : 12475396 : return u.single;
18082 : : }
18083 : : else
18084 : 136124 : return (*u.ary)[ix];
18085 : : }
18086 : :
18087 : : public:
18088 : : slot &exported ();
18089 : : slot &append (unsigned module, unsigned defness);
18090 : : };
18091 : :
18092 : : /* O is a new import to append to the list for. If we're an empty
18093 : : set, initialize us. */
18094 : :
18095 : : macro_import::slot &
18096 : 339574 : macro_import::append (unsigned module, unsigned defness)
18097 : : {
18098 : 339574 : if (!occupied_p ())
18099 : : {
18100 : 255260 : u.single = slot::ctor (module, defness);
18101 : 255260 : return u.single;
18102 : : }
18103 : : else
18104 : : {
18105 : 84314 : bool single = single_p ();
18106 : 84314 : ary_t *m = single ? NULL : u.ary;
18107 : 84314 : vec_safe_reserve (m, 1 + single);
18108 : 84314 : if (single)
18109 : 84311 : m->quick_push (u.single);
18110 : 84314 : u.ary = m;
18111 : 84314 : return *u.ary->quick_push (slot::ctor (module, defness));
18112 : : }
18113 : : }
18114 : :
18115 : : /* We're going to export something. Make sure the first import slot
18116 : : is us. */
18117 : :
18118 : : macro_import::slot &
18119 : 193049 : macro_import::exported ()
18120 : : {
18121 : 193049 : if (occupied_p () && !(*this)[0].get_module ())
18122 : : {
18123 : 6 : slot &res = (*this)[0];
18124 : 6 : res.bits |= slot::L_DEF;
18125 : 6 : return res;
18126 : : }
18127 : :
18128 : 193043 : slot *a = &append (0, slot::L_DEF);
18129 : 193043 : if (!single_p ())
18130 : : {
18131 : 80187 : slot &f = (*this)[0];
18132 : 80187 : std::swap (f, *a);
18133 : 80187 : a = &f;
18134 : : }
18135 : : return *a;
18136 : : }
18137 : :
18138 : : /* The import (&exported) macros. cpp_hasnode's deferred field
18139 : : indexes this array (offset by 1, so zero means 'not present'. */
18140 : :
18141 : : static vec<macro_import, va_heap, vl_embed> *macro_imports;
18142 : :
18143 : : /* The exported macros. A macro_import slot's zeroth element's offset
18144 : : indexes this array. If the zeroth slot is not for module zero,
18145 : : there is no export. */
18146 : :
18147 : : static GTY(()) vec<macro_export, va_gc> *macro_exports;
18148 : :
18149 : : /* The reachable set of header imports from this TU. */
18150 : :
18151 : : static GTY(()) bitmap headers;
18152 : :
18153 : : /* Get the (possibly empty) macro imports for NODE. */
18154 : :
18155 : : static macro_import &
18156 : 259393 : get_macro_imports (cpp_hashnode *node)
18157 : : {
18158 : 259393 : if (node->deferred)
18159 : 4133 : return (*macro_imports)[node->deferred - 1];
18160 : :
18161 : 255260 : vec_safe_reserve (macro_imports, 1);
18162 : 255260 : node->deferred = macro_imports->length () + 1;
18163 : 255260 : return *vec_safe_push (macro_imports, macro_import ());
18164 : : }
18165 : :
18166 : : /* Get the macro export for export EXP of NODE. */
18167 : :
18168 : : static macro_export &
18169 : 193049 : get_macro_export (macro_import::slot &slot)
18170 : : {
18171 : 193049 : if (slot.offset >= 0)
18172 : 6 : return (*macro_exports)[slot.offset];
18173 : :
18174 : 193043 : vec_safe_reserve (macro_exports, 1);
18175 : 193043 : slot.offset = macro_exports->length ();
18176 : 193043 : return *macro_exports->quick_push (macro_export ());
18177 : : }
18178 : :
18179 : : /* If NODE is an exportable macro, add it to the export set. */
18180 : :
18181 : : static int
18182 : 3565500 : maybe_add_macro (cpp_reader *, cpp_hashnode *node, void *data_)
18183 : : {
18184 : 3565500 : bool exporting = false;
18185 : :
18186 : 3565500 : if (cpp_user_macro_p (node))
18187 : 488323 : if (cpp_macro *macro = node->value.macro)
18188 : : /* Ignore imported, builtins, command line and forced header macros. */
18189 : 487885 : if (!macro->imported_p
18190 : 487885 : && !macro->lazy && macro->line >= spans.main_start ())
18191 : : {
18192 : 112862 : gcc_checking_assert (macro->kind == cmk_macro);
18193 : : /* I don't want to deal with this corner case, that I suspect is
18194 : : a devil's advocate reading of the standard. */
18195 : 112862 : gcc_checking_assert (!macro->extra_tokens);
18196 : :
18197 : 112862 : macro_import::slot &slot = get_macro_imports (node).exported ();
18198 : 112862 : macro_export &exp = get_macro_export (slot);
18199 : 112862 : exp.def = macro;
18200 : 112862 : exporting = true;
18201 : : }
18202 : :
18203 : 3452638 : if (!exporting && node->deferred)
18204 : : {
18205 : 577 : macro_import &imports = (*macro_imports)[node->deferred - 1];
18206 : 577 : macro_import::slot &slot = imports[0];
18207 : 577 : if (!slot.get_module ())
18208 : : {
18209 : 546 : gcc_checking_assert (slot.get_defness ());
18210 : : exporting = true;
18211 : : }
18212 : : }
18213 : :
18214 : 112862 : if (exporting)
18215 : 113408 : static_cast<vec<cpp_hashnode *> *> (data_)->safe_push (node);
18216 : :
18217 : 3565500 : return 1; /* Don't stop. */
18218 : : }
18219 : :
18220 : : /* Order cpp_hashnodes A_ and B_ by their exported macro locations. */
18221 : :
18222 : : static int
18223 : 6054587 : macro_loc_cmp (const void *a_, const void *b_)
18224 : : {
18225 : 6054587 : const cpp_hashnode *node_a = *(const cpp_hashnode *const *)a_;
18226 : 6054587 : macro_import &import_a = (*macro_imports)[node_a->deferred - 1];
18227 : 6054587 : const macro_export &export_a = (*macro_exports)[import_a[0].offset];
18228 : 6054587 : location_t loc_a = export_a.def ? export_a.def->line : export_a.undef_loc;
18229 : :
18230 : 6054587 : const cpp_hashnode *node_b = *(const cpp_hashnode *const *)b_;
18231 : 6054587 : macro_import &import_b = (*macro_imports)[node_b->deferred - 1];
18232 : 6054587 : const macro_export &export_b = (*macro_exports)[import_b[0].offset];
18233 : 6054587 : location_t loc_b = export_b.def ? export_b.def->line : export_b.undef_loc;
18234 : :
18235 : 6054587 : if (loc_a < loc_b)
18236 : : return +1;
18237 : 3109106 : else if (loc_a > loc_b)
18238 : : return -1;
18239 : : else
18240 : 0 : return 0;
18241 : : }
18242 : :
18243 : : /* Gather the macro definitions and undefinitions that we will need to
18244 : : write out. */
18245 : :
18246 : : vec<cpp_hashnode *> *
18247 : 790 : module_state::prepare_macros (cpp_reader *reader)
18248 : : {
18249 : 790 : vec<cpp_hashnode *> *macros;
18250 : 790 : vec_alloc (macros, 100);
18251 : :
18252 : 790 : cpp_forall_identifiers (reader, maybe_add_macro, macros);
18253 : :
18254 : 814 : dump (dumper::MACRO) && dump ("No more than %u macros", macros->length ());
18255 : :
18256 : 790 : macros->qsort (macro_loc_cmp);
18257 : :
18258 : : // Note the locations.
18259 : 114988 : for (unsigned ix = macros->length (); ix--;)
18260 : : {
18261 : 113408 : cpp_hashnode *node = (*macros)[ix];
18262 : 113408 : macro_import::slot &slot = (*macro_imports)[node->deferred - 1][0];
18263 : 113408 : macro_export &mac = (*macro_exports)[slot.offset];
18264 : :
18265 : 113408 : if (IDENTIFIER_KEYWORD_P (identifier (node)))
18266 : 1 : continue;
18267 : :
18268 : 113407 : if (mac.undef_loc != UNKNOWN_LOCATION)
18269 : 12 : note_location (mac.undef_loc);
18270 : 113407 : if (mac.def)
18271 : : {
18272 : 113401 : note_location (mac.def->line);
18273 : 358535 : for (unsigned ix = 0; ix != mac.def->count; ix++)
18274 : 245134 : note_location (mac.def->exp.tokens[ix].src_loc);
18275 : : }
18276 : : }
18277 : :
18278 : 790 : return macros;
18279 : : }
18280 : :
18281 : : /* Write out the exported defines. This is two sections, one
18282 : : containing the definitions, the other a table of node names. */
18283 : :
18284 : : unsigned
18285 : 790 : module_state::write_macros (elf_out *to, vec<cpp_hashnode *> *macros,
18286 : : unsigned *crc_p)
18287 : : {
18288 : 856 : dump () && dump ("Writing macros");
18289 : 790 : dump.indent ();
18290 : :
18291 : : /* Write the defs */
18292 : 790 : bytes_out sec (to);
18293 : 790 : sec.begin ();
18294 : :
18295 : 790 : unsigned count = 0;
18296 : 114988 : for (unsigned ix = macros->length (); ix--;)
18297 : : {
18298 : 113408 : cpp_hashnode *node = (*macros)[ix];
18299 : 113408 : macro_import::slot &slot = (*macro_imports)[node->deferred - 1][0];
18300 : 113408 : gcc_assert (!slot.get_module () && slot.get_defness ());
18301 : :
18302 : 113408 : macro_export &mac = (*macro_exports)[slot.offset];
18303 : 113408 : gcc_assert (!!(slot.get_defness () & macro_import::slot::L_UNDEF)
18304 : : == (mac.undef_loc != UNKNOWN_LOCATION)
18305 : : && !!(slot.get_defness () & macro_import::slot::L_DEF)
18306 : : == (mac.def != NULL));
18307 : :
18308 : 113408 : if (IDENTIFIER_KEYWORD_P (identifier (node)))
18309 : : {
18310 : 1 : warning_at (mac.def->line, 0,
18311 : : "not exporting %<#define %E%> as it is a keyword",
18312 : : identifier (node));
18313 : 1 : slot.offset = 0;
18314 : 1 : continue;
18315 : : }
18316 : :
18317 : 113407 : count++;
18318 : 113407 : slot.offset = sec.pos;
18319 : 113407 : dump (dumper::MACRO)
18320 : 24 : && dump ("Writing macro %s%s%s %I at %u",
18321 : 24 : slot.get_defness () & macro_import::slot::L_UNDEF
18322 : : ? "#undef" : "",
18323 : 24 : slot.get_defness () == macro_import::slot::L_BOTH
18324 : : ? " & " : "",
18325 : 24 : slot.get_defness () & macro_import::slot::L_DEF
18326 : : ? "#define" : "",
18327 : : identifier (node), slot.offset);
18328 : 113407 : if (mac.undef_loc != UNKNOWN_LOCATION)
18329 : 12 : write_location (sec, mac.undef_loc);
18330 : 113407 : if (mac.def)
18331 : 113401 : write_define (sec, mac.def);
18332 : : }
18333 : 790 : if (count)
18334 : : // We may have ended on a tokenless macro with a very short
18335 : : // location, that will cause problems reading its bit flags.
18336 : 142 : sec.u (0);
18337 : 790 : sec.end (to, to->name (MOD_SNAME_PFX ".def"), crc_p);
18338 : :
18339 : 790 : if (count)
18340 : : {
18341 : : /* Write the table. */
18342 : 142 : bytes_out sec (to);
18343 : 142 : sec.begin ();
18344 : 142 : sec.u (count);
18345 : :
18346 : 113691 : for (unsigned ix = macros->length (); ix--;)
18347 : : {
18348 : 113407 : const cpp_hashnode *node = (*macros)[ix];
18349 : 113407 : macro_import::slot &slot = (*macro_imports)[node->deferred - 1][0];
18350 : :
18351 : 113407 : if (slot.offset)
18352 : : {
18353 : 113407 : sec.cpp_node (node);
18354 : 113407 : sec.u (slot.get_defness ());
18355 : 113407 : sec.u (slot.offset);
18356 : : }
18357 : : }
18358 : 142 : sec.end (to, to->name (MOD_SNAME_PFX ".mac"), crc_p);
18359 : 142 : }
18360 : :
18361 : 790 : dump.outdent ();
18362 : 790 : return count;
18363 : 790 : }
18364 : :
18365 : : bool
18366 : 835 : module_state::read_macros ()
18367 : : {
18368 : : /* Get the def section. */
18369 : 835 : if (!slurp->macro_defs.begin (loc, from (), MOD_SNAME_PFX ".def"))
18370 : : return false;
18371 : :
18372 : : /* Get the tbl section, if there are defs. */
18373 : 835 : if (slurp->macro_defs.more_p ()
18374 : 835 : && !slurp->macro_tbl.begin (loc, from (), MOD_SNAME_PFX ".mac"))
18375 : : return false;
18376 : :
18377 : : return true;
18378 : : }
18379 : :
18380 : : /* Install the macro name table. */
18381 : :
18382 : : void
18383 : 841 : module_state::install_macros ()
18384 : : {
18385 : 841 : bytes_in &sec = slurp->macro_tbl;
18386 : 841 : if (!sec.size)
18387 : : return;
18388 : :
18389 : 209 : dump () && dump ("Reading macro table %M", this);
18390 : 188 : dump.indent ();
18391 : :
18392 : 188 : unsigned count = sec.u ();
18393 : 209 : dump () && dump ("%u macros", count);
18394 : 146719 : while (count--)
18395 : : {
18396 : 146531 : cpp_hashnode *node = sec.cpp_node ();
18397 : 146531 : macro_import &imp = get_macro_imports (node);
18398 : 146531 : unsigned flags = sec.u () & macro_import::slot::L_BOTH;
18399 : 146531 : if (!flags)
18400 : 0 : sec.set_overrun ();
18401 : :
18402 : 146531 : if (sec.get_overrun ())
18403 : : break;
18404 : :
18405 : 146531 : macro_import::slot &slot = imp.append (mod, flags);
18406 : 146531 : slot.offset = sec.u ();
18407 : :
18408 : 146531 : dump (dumper::MACRO)
18409 : 84 : && dump ("Read %s macro %s%s%s %I at %u",
18410 : 30 : imp.length () > 1 ? "add" : "new",
18411 : 27 : flags & macro_import::slot::L_UNDEF ? "#undef" : "",
18412 : : flags == macro_import::slot::L_BOTH ? " & " : "",
18413 : 30 : flags & macro_import::slot::L_DEF ? "#define" : "",
18414 : : identifier (node), slot.offset);
18415 : :
18416 : : /* We'll leak an imported definition's TOKEN_FLD_STR's data
18417 : : here. But that only happens when we've had to resolve the
18418 : : deferred macro before this import -- why are you doing
18419 : : that? */
18420 : 146531 : if (cpp_macro *cur = cpp_set_deferred_macro (node))
18421 : 80175 : if (!cur->imported_p)
18422 : : {
18423 : 80175 : macro_import::slot &slot = imp.exported ();
18424 : 80175 : macro_export &exp = get_macro_export (slot);
18425 : 80175 : exp.def = cur;
18426 : 226894 : dump (dumper::MACRO)
18427 : 0 : && dump ("Saving current #define %I", identifier (node));
18428 : : }
18429 : : }
18430 : :
18431 : : /* We're now done with the table. */
18432 : 188 : elf_in::release (slurp->from, sec);
18433 : :
18434 : 188 : dump.outdent ();
18435 : : }
18436 : :
18437 : : /* Import the transitive macros. */
18438 : :
18439 : : void
18440 : 803 : module_state::import_macros ()
18441 : : {
18442 : 803 : bitmap_ior_into (headers, slurp->headers);
18443 : :
18444 : 803 : bitmap_iterator bititer;
18445 : 803 : unsigned bitnum;
18446 : 1644 : EXECUTE_IF_SET_IN_BITMAP (slurp->headers, 0, bitnum, bititer)
18447 : 841 : (*modules)[bitnum]->install_macros ();
18448 : 803 : }
18449 : :
18450 : : /* NODE is being undefined at LOC. Record it in the export table, if
18451 : : necessary. */
18452 : :
18453 : : void
18454 : 304356 : module_state::undef_macro (cpp_reader *, location_t loc, cpp_hashnode *node)
18455 : : {
18456 : 304356 : if (!node->deferred)
18457 : : /* The macro is not imported, so our undef is irrelevant. */
18458 : : return;
18459 : :
18460 : 12 : unsigned n = dump.push (NULL);
18461 : :
18462 : 12 : macro_import::slot &slot = (*macro_imports)[node->deferred - 1].exported ();
18463 : 12 : macro_export &exp = get_macro_export (slot);
18464 : :
18465 : 12 : exp.undef_loc = loc;
18466 : 12 : slot.become_undef ();
18467 : 12 : exp.def = NULL;
18468 : :
18469 : 18 : dump (dumper::MACRO) && dump ("Recording macro #undef %I", identifier (node));
18470 : :
18471 : 12 : dump.pop (n);
18472 : : }
18473 : :
18474 : : /* NODE is a deferred macro node. Determine the definition and return
18475 : : it, with NULL if undefined. May issue diagnostics.
18476 : :
18477 : : This can leak memory, when merging declarations -- the string
18478 : : contents (TOKEN_FLD_STR) of each definition are allocated in
18479 : : unreclaimable cpp objstack. Only one will win. However, I do not
18480 : : expect this to be common -- mostly macros have a single point of
18481 : : definition. Perhaps we could restore the objstack to its position
18482 : : after the first imported definition (if that wins)? The macros
18483 : : themselves are GC'd. */
18484 : :
18485 : : cpp_macro *
18486 : 280 : module_state::deferred_macro (cpp_reader *reader, location_t loc,
18487 : : cpp_hashnode *node)
18488 : : {
18489 : 280 : macro_import &imports = (*macro_imports)[node->deferred - 1];
18490 : :
18491 : 280 : unsigned n = dump.push (NULL);
18492 : 286 : dump (dumper::MACRO) && dump ("Deferred macro %I", identifier (node));
18493 : :
18494 : 280 : bitmap visible (BITMAP_GGC_ALLOC ());
18495 : :
18496 : 280 : if (!((imports[0].get_defness () & macro_import::slot::L_UNDEF)
18497 : 0 : && !imports[0].get_module ()))
18498 : : {
18499 : : /* Calculate the set of visible header imports. */
18500 : 280 : bitmap_copy (visible, headers);
18501 : 723 : for (unsigned ix = imports.length (); ix--;)
18502 : : {
18503 : 443 : const macro_import::slot &slot = imports[ix];
18504 : 443 : unsigned mod = slot.get_module ();
18505 : 443 : if ((slot.get_defness () & macro_import::slot::L_UNDEF)
18506 : 443 : && bitmap_bit_p (visible, mod))
18507 : : {
18508 : 12 : bitmap arg = mod ? (*modules)[mod]->slurp->headers : headers;
18509 : 12 : bitmap_and_compl_into (visible, arg);
18510 : 12 : bitmap_set_bit (visible, mod);
18511 : : }
18512 : : }
18513 : : }
18514 : 280 : bitmap_set_bit (visible, 0);
18515 : :
18516 : : /* Now find the macros that are still visible. */
18517 : 280 : bool failed = false;
18518 : 280 : cpp_macro *def = NULL;
18519 : 280 : vec<macro_export> defs;
18520 : 280 : defs.create (imports.length ());
18521 : 723 : for (unsigned ix = imports.length (); ix--;)
18522 : : {
18523 : 443 : const macro_import::slot &slot = imports[ix];
18524 : 443 : unsigned mod = slot.get_module ();
18525 : 443 : if (bitmap_bit_p (visible, mod))
18526 : : {
18527 : 431 : macro_export *pushed = NULL;
18528 : 431 : if (mod)
18529 : : {
18530 : 310 : const module_state *imp = (*modules)[mod];
18531 : 310 : bytes_in &sec = imp->slurp->macro_defs;
18532 : 310 : if (!sec.get_overrun ())
18533 : : {
18534 : 310 : dump (dumper::MACRO)
18535 : 6 : && dump ("Reading macro %s%s%s %I module %M at %u",
18536 : 6 : slot.get_defness () & macro_import::slot::L_UNDEF
18537 : : ? "#undef" : "",
18538 : 6 : slot.get_defness () == macro_import::slot::L_BOTH
18539 : : ? " & " : "",
18540 : 6 : slot.get_defness () & macro_import::slot::L_DEF
18541 : : ? "#define" : "",
18542 : 6 : identifier (node), imp, slot.offset);
18543 : 310 : sec.random_access (slot.offset);
18544 : :
18545 : 310 : macro_export exp;
18546 : 310 : if (slot.get_defness () & macro_import::slot::L_UNDEF)
18547 : 12 : exp.undef_loc = imp->read_location (sec);
18548 : 310 : if (slot.get_defness () & macro_import::slot::L_DEF)
18549 : 304 : exp.def = imp->read_define (sec, reader);
18550 : 310 : if (sec.get_overrun ())
18551 : 0 : error_at (loc, "macro definitions of %qE corrupted",
18552 : 0 : imp->name);
18553 : : else
18554 : 310 : pushed = defs.quick_push (exp);
18555 : : }
18556 : : }
18557 : : else
18558 : 121 : pushed = defs.quick_push ((*macro_exports)[slot.offset]);
18559 : 431 : if (pushed && pushed->def)
18560 : : {
18561 : 425 : if (!def)
18562 : : def = pushed->def;
18563 : 148 : else if (cpp_compare_macros (def, pushed->def))
18564 : 443 : failed = true;
18565 : : }
18566 : : }
18567 : : }
18568 : :
18569 : 280 : if (failed)
18570 : : {
18571 : : /* If LOC is the first loc, this is the end of file check, which
18572 : : is a warning. */
18573 : 15 : auto_diagnostic_group d;
18574 : 15 : if (loc == MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0)))
18575 : 9 : warning_at (loc, OPT_Winvalid_imported_macros,
18576 : : "inconsistent imported macro definition %qE",
18577 : : identifier (node));
18578 : : else
18579 : 6 : error_at (loc, "inconsistent imported macro definition %qE",
18580 : : identifier (node));
18581 : 60 : for (unsigned ix = defs.length (); ix--;)
18582 : : {
18583 : 30 : macro_export &exp = defs[ix];
18584 : 30 : if (exp.undef_loc)
18585 : 0 : inform (exp.undef_loc, "%<#undef %E%>", identifier (node));
18586 : 30 : if (exp.def)
18587 : 30 : inform (exp.def->line, "%<#define %s%>",
18588 : : cpp_macro_definition (reader, node, exp.def));
18589 : : }
18590 : 15 : def = NULL;
18591 : 15 : }
18592 : :
18593 : 280 : defs.release ();
18594 : :
18595 : 280 : dump.pop (n);
18596 : :
18597 : 280 : return def;
18598 : : }
18599 : :
18600 : : /* Stream the static aggregates. Sadly some headers (ahem:
18601 : : iostream) contain static vars, and rely on them to run global
18602 : : ctors. */
18603 : : unsigned
18604 : 790 : module_state::write_inits (elf_out *to, depset::hash &table, unsigned *crc_ptr)
18605 : : {
18606 : 790 : if (!static_aggregates && !tls_aggregates)
18607 : : return 0;
18608 : :
18609 : 26 : dump () && dump ("Writing initializers");
18610 : 26 : dump.indent ();
18611 : :
18612 : 26 : static_aggregates = nreverse (static_aggregates);
18613 : 26 : tls_aggregates = nreverse (tls_aggregates);
18614 : :
18615 : 26 : unsigned count = 0;
18616 : 26 : trees_out sec (to, this, table, ~0u);
18617 : 26 : sec.begin ();
18618 : :
18619 : 26 : tree list = static_aggregates;
18620 : 78 : for (int passes = 0; passes != 2; passes++)
18621 : : {
18622 : 78 : for (tree init = list; init; init = TREE_CHAIN (init))
18623 : 26 : if (TREE_LANG_FLAG_0 (init))
18624 : : {
18625 : 26 : tree decl = TREE_VALUE (init);
18626 : :
18627 : 26 : dump ("Initializer:%u for %N", count, decl);
18628 : 26 : sec.tree_node (decl);
18629 : 26 : ++count;
18630 : : }
18631 : :
18632 : 52 : list = tls_aggregates;
18633 : : }
18634 : :
18635 : 26 : sec.end (to, to->name (MOD_SNAME_PFX ".ini"), crc_ptr);
18636 : 26 : dump.outdent ();
18637 : :
18638 : 26 : return count;
18639 : 26 : }
18640 : :
18641 : : /* We have to defer some post-load processing until we've completed
18642 : : reading, because they can cause more reading. */
18643 : :
18644 : : static void
18645 : 8790 : post_load_processing ()
18646 : : {
18647 : : /* We mustn't cause a GC, our caller should have arranged for that
18648 : : not to happen. */
18649 : 8790 : gcc_checking_assert (function_depth);
18650 : :
18651 : 8790 : if (!post_load_decls)
18652 : : return;
18653 : :
18654 : 5360 : tree old_cfd = current_function_decl;
18655 : 5360 : struct function *old_cfun = cfun;
18656 : 24236 : while (post_load_decls->length ())
18657 : : {
18658 : 13516 : tree decl = post_load_decls->pop ();
18659 : :
18660 : 13566 : dump () && dump ("Post-load processing of %N", decl);
18661 : :
18662 : 13516 : gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl));
18663 : :
18664 : 13516 : if (DECL_COMDAT (decl))
18665 : 13501 : comdat_linkage (decl);
18666 : 13516 : if (!TREE_ASM_WRITTEN (decl))
18667 : : {
18668 : : /* Cloning can cause loading -- specifically operator delete for
18669 : : the deleting dtor. */
18670 : 10707 : if (maybe_clone_body (decl))
18671 : 10704 : TREE_ASM_WRITTEN (decl) = 1;
18672 : : else
18673 : : {
18674 : : /* We didn't clone the cdtor, make sure we emit it. */
18675 : 3 : note_vague_linkage_fn (decl);
18676 : 3 : cgraph_node::finalize_function (decl, true);
18677 : : }
18678 : : }
18679 : : }
18680 : :
18681 : 5360 : cfun = old_cfun;
18682 : 5360 : current_function_decl = old_cfd;
18683 : : }
18684 : :
18685 : : bool
18686 : 26 : module_state::read_inits (unsigned count)
18687 : : {
18688 : 26 : trees_in sec (this);
18689 : 26 : if (!sec.begin (loc, from (), from ()->find (MOD_SNAME_PFX ".ini")))
18690 : : return false;
18691 : 37 : dump () && dump ("Reading %u initializers", count);
18692 : 26 : dump.indent ();
18693 : :
18694 : 26 : lazy_snum = ~0u;
18695 : 52 : for (unsigned ix = 0; ix != count; ix++)
18696 : : {
18697 : : /* Merely referencing the decl causes its initializer to be read
18698 : : and added to the correct list. */
18699 : 26 : tree decl = sec.tree_node ();
18700 : :
18701 : 26 : if (sec.get_overrun ())
18702 : : break;
18703 : 26 : if (decl)
18704 : 26 : dump ("Initializer:%u for %N", count, decl);
18705 : : }
18706 : 26 : lazy_snum = 0;
18707 : 26 : post_load_processing ();
18708 : 26 : dump.outdent ();
18709 : 26 : if (!sec.end (from ()))
18710 : : return false;
18711 : : return true;
18712 : 26 : }
18713 : :
18714 : : void
18715 : 2149 : module_state::write_counts (elf_out *to, unsigned counts[MSC_HWM],
18716 : : unsigned *crc_ptr)
18717 : : {
18718 : 2149 : bytes_out cfg (to);
18719 : :
18720 : 2149 : cfg.begin ();
18721 : :
18722 : 19341 : for (unsigned ix = MSC_HWM; ix--;)
18723 : 17192 : cfg.u (counts[ix]);
18724 : :
18725 : 2149 : if (dump ())
18726 : : {
18727 : 241 : dump ("Cluster sections are [%u,%u)",
18728 : : counts[MSC_sec_lwm], counts[MSC_sec_hwm]);
18729 : 241 : dump ("Bindings %u", counts[MSC_bindings]);
18730 : 241 : dump ("Pendings %u", counts[MSC_pendings]);
18731 : 241 : dump ("Entities %u", counts[MSC_entities]);
18732 : 241 : dump ("Namespaces %u", counts[MSC_namespaces]);
18733 : 241 : dump ("Macros %u", counts[MSC_macros]);
18734 : 241 : dump ("Initializers %u", counts[MSC_inits]);
18735 : : }
18736 : :
18737 : 2149 : cfg.end (to, to->name (MOD_SNAME_PFX ".cnt"), crc_ptr);
18738 : 2149 : }
18739 : :
18740 : : bool
18741 : 2301 : module_state::read_counts (unsigned counts[MSC_HWM])
18742 : : {
18743 : 2301 : bytes_in cfg;
18744 : :
18745 : 2301 : if (!cfg.begin (loc, from (), MOD_SNAME_PFX ".cnt"))
18746 : : return false;
18747 : :
18748 : 20709 : for (unsigned ix = MSC_HWM; ix--;)
18749 : 18408 : counts[ix] = cfg.u ();
18750 : :
18751 : 2301 : if (dump ())
18752 : : {
18753 : 455 : dump ("Declaration sections are [%u,%u)",
18754 : : counts[MSC_sec_lwm], counts[MSC_sec_hwm]);
18755 : 455 : dump ("Bindings %u", counts[MSC_bindings]);
18756 : 455 : dump ("Pendings %u", counts[MSC_pendings]);
18757 : 455 : dump ("Entities %u", counts[MSC_entities]);
18758 : 455 : dump ("Namespaces %u", counts[MSC_namespaces]);
18759 : 455 : dump ("Macros %u", counts[MSC_macros]);
18760 : 455 : dump ("Initializers %u", counts[MSC_inits]);
18761 : : }
18762 : :
18763 : 2301 : return cfg.end (from ());
18764 : 2301 : }
18765 : :
18766 : : /* Tool configuration: MOD_SNAME_PFX .config
18767 : :
18768 : : This is data that confirms current state (or fails). */
18769 : :
18770 : : void
18771 : 2149 : module_state::write_config (elf_out *to, module_state_config &config,
18772 : : unsigned inner_crc)
18773 : : {
18774 : 2149 : bytes_out cfg (to);
18775 : :
18776 : 2149 : cfg.begin ();
18777 : :
18778 : : /* Write version and inner crc as u32 values, for easier
18779 : : debug inspection. */
18780 : 2390 : dump () && dump ("Writing version=%V, inner_crc=%x",
18781 : : MODULE_VERSION, inner_crc);
18782 : 2149 : cfg.u32 (unsigned (MODULE_VERSION));
18783 : 2149 : cfg.u32 (inner_crc);
18784 : :
18785 : 2149 : cfg.u (to->name (is_header () ? "" : get_flatname ()));
18786 : :
18787 : : /* Configuration. */
18788 : 2390 : dump () && dump ("Writing target='%s', host='%s'",
18789 : : TARGET_MACHINE, HOST_MACHINE);
18790 : 2149 : unsigned target = to->name (TARGET_MACHINE);
18791 : 2149 : unsigned host = (!strcmp (TARGET_MACHINE, HOST_MACHINE)
18792 : : ? target : to->name (HOST_MACHINE));
18793 : 2149 : cfg.u (target);
18794 : 2149 : cfg.u (host);
18795 : :
18796 : 2149 : cfg.str (config.dialect_str);
18797 : 2149 : cfg.u (extensions);
18798 : :
18799 : : /* Global tree information. We write the globals crc separately,
18800 : : rather than mix it directly into the overall crc, as it is used
18801 : : to ensure data match between instances of the compiler, not
18802 : : integrity of the file. */
18803 : 2390 : dump () && dump ("Writing globals=%u, crc=%x",
18804 : : fixed_trees->length (), global_crc);
18805 : 2149 : cfg.u (fixed_trees->length ());
18806 : 2149 : cfg.u32 (global_crc);
18807 : :
18808 : 2149 : if (is_partition ())
18809 : 148 : cfg.u (is_interface ());
18810 : :
18811 : 2149 : cfg.u (config.num_imports);
18812 : 2149 : cfg.u (config.num_partitions);
18813 : 2149 : cfg.u (config.num_entities);
18814 : :
18815 : 2149 : cfg.loc (config.ordinary_locs);
18816 : 2149 : cfg.loc (config.macro_locs);
18817 : 2149 : cfg.u (config.loc_range_bits);
18818 : :
18819 : 2149 : cfg.u (config.active_init);
18820 : :
18821 : : /* Now generate CRC, we'll have incorporated the inner CRC because
18822 : : of its serialization above. */
18823 : 2149 : cfg.end (to, to->name (MOD_SNAME_PFX ".cfg"), &crc);
18824 : 2390 : dump () && dump ("Writing CRC=%x", crc);
18825 : 2149 : }
18826 : :
18827 : : void
18828 : 31 : module_state::note_cmi_name ()
18829 : : {
18830 : 31 : if (!cmi_noted_p && filename)
18831 : : {
18832 : 31 : cmi_noted_p = true;
18833 : 31 : inform (loc, "compiled module file is %qs",
18834 : : maybe_add_cmi_prefix (filename));
18835 : : }
18836 : 31 : }
18837 : :
18838 : : bool
18839 : 2359 : module_state::read_config (module_state_config &config)
18840 : : {
18841 : 2359 : bytes_in cfg;
18842 : :
18843 : 2359 : if (!cfg.begin (loc, from (), MOD_SNAME_PFX ".cfg"))
18844 : : return false;
18845 : :
18846 : : /* Check version. */
18847 : 2359 : unsigned my_ver = MODULE_VERSION;
18848 : 2359 : unsigned their_ver = cfg.u32 ();
18849 : 2814 : dump () && dump (my_ver == their_ver ? "Version %V"
18850 : : : "Expecting %V found %V", my_ver, their_ver);
18851 : 2359 : if (their_ver != my_ver)
18852 : : {
18853 : : /* The compiler versions differ. Close enough? */
18854 : 0 : verstr_t my_string, their_string;
18855 : :
18856 : 0 : version2string (my_ver, my_string);
18857 : 0 : version2string (their_ver, their_string);
18858 : :
18859 : : /* Reject when either is non-experimental or when experimental
18860 : : major versions differ. */
18861 : 0 : auto_diagnostic_group d;
18862 : 0 : bool reject_p = ((!IS_EXPERIMENTAL (my_ver)
18863 : : || !IS_EXPERIMENTAL (their_ver)
18864 : 0 : || MODULE_MAJOR (my_ver) != MODULE_MAJOR (their_ver))
18865 : : /* The 'I know what I'm doing' switch. */
18866 : 0 : && !flag_module_version_ignore);
18867 : 0 : bool inform_p = true;
18868 : 0 : if (reject_p)
18869 : : {
18870 : 0 : cfg.set_overrun ();
18871 : 0 : error_at (loc, "compiled module is %sversion %s",
18872 : : IS_EXPERIMENTAL (their_ver) ? "experimental " : "",
18873 : : their_string);
18874 : : }
18875 : : else
18876 : 0 : inform_p = warning_at (loc, 0, "compiled module is %sversion %s",
18877 : : IS_EXPERIMENTAL (their_ver) ? "experimental " : "",
18878 : : their_string);
18879 : :
18880 : 0 : if (inform_p)
18881 : : {
18882 : 0 : inform (loc, "compiler is %sversion %s%s%s",
18883 : : IS_EXPERIMENTAL (my_ver) ? "experimental " : "",
18884 : : my_string,
18885 : 0 : reject_p ? "" : flag_module_version_ignore
18886 : 0 : ? ", be it on your own head!" : ", close enough?",
18887 : : reject_p ? "" : " \xc2\xaf\\_(\xe3\x83\x84)_/\xc2\xaf");
18888 : 0 : note_cmi_name ();
18889 : : }
18890 : :
18891 : 0 : if (reject_p)
18892 : 0 : goto done;
18893 : 0 : }
18894 : :
18895 : : /* We wrote the inner crc merely to merge it, so simply read it
18896 : : back and forget it. */
18897 : 2359 : cfg.u32 ();
18898 : :
18899 : : /* Check module name. */
18900 : 2359 : {
18901 : 2359 : const char *their_name = from ()->name (cfg.u ());
18902 : 2359 : const char *our_name = "";
18903 : :
18904 : 2359 : if (!is_header ())
18905 : 1470 : our_name = get_flatname ();
18906 : :
18907 : : /* Header units can be aliased, so name checking is
18908 : : inappropriate. */
18909 : 2359 : if (0 != strcmp (their_name, our_name))
18910 : : {
18911 : 0 : error_at (loc,
18912 : 0 : their_name[0] && our_name[0] ? G_("module %qs found")
18913 : : : their_name[0]
18914 : : ? G_("header module expected, module %qs found")
18915 : : : G_("module %qs expected, header module found"),
18916 : 0 : their_name[0] ? their_name : our_name);
18917 : 0 : cfg.set_overrun ();
18918 : 0 : goto done;
18919 : : }
18920 : : }
18921 : :
18922 : : /* Check the CRC after the above sanity checks, so that the user is
18923 : : clued in. */
18924 : 2359 : {
18925 : 2359 : unsigned e_crc = crc;
18926 : 2359 : crc = cfg.get_crc ();
18927 : 2814 : dump () && dump ("Reading CRC=%x", crc);
18928 : 2359 : if (!is_direct () && crc != e_crc)
18929 : : {
18930 : 3 : error_at (loc, "module %qs CRC mismatch", get_flatname ());
18931 : 3 : cfg.set_overrun ();
18932 : 3 : goto done;
18933 : : }
18934 : : }
18935 : :
18936 : : /* Check target & host. */
18937 : 2356 : {
18938 : 2356 : const char *their_target = from ()->name (cfg.u ());
18939 : 2356 : const char *their_host = from ()->name (cfg.u ());
18940 : 2811 : dump () && dump ("Read target='%s', host='%s'", their_target, their_host);
18941 : 2356 : if (strcmp (their_target, TARGET_MACHINE)
18942 : 2356 : || strcmp (their_host, HOST_MACHINE))
18943 : : {
18944 : 0 : error_at (loc, "target & host is %qs:%qs, expected %qs:%qs",
18945 : : their_target, TARGET_MACHINE, their_host, HOST_MACHINE);
18946 : 0 : cfg.set_overrun ();
18947 : 0 : goto done;
18948 : : }
18949 : : }
18950 : :
18951 : : /* Check compilation dialect. This must match. */
18952 : 2356 : {
18953 : 2356 : const char *their_dialect = cfg.str ();
18954 : 2356 : if (strcmp (their_dialect, config.dialect_str))
18955 : : {
18956 : 1 : error_at (loc, "language dialect differs %qs, expected %qs",
18957 : : their_dialect, config.dialect_str);
18958 : 1 : cfg.set_overrun ();
18959 : 1 : goto done;
18960 : : }
18961 : : }
18962 : :
18963 : : /* Check for extensions. If they set any, we must have them set
18964 : : too. */
18965 : 2355 : {
18966 : 2355 : unsigned ext = cfg.u ();
18967 : 2355 : unsigned allowed = (flag_openmp ? SE_OPENMP : 0);
18968 : :
18969 : 2355 : if (unsigned bad = ext & ~allowed)
18970 : : {
18971 : 3 : if (bad & SE_OPENMP)
18972 : 3 : error_at (loc, "module contains OpenMP, use %<-fopenmp%> to enable");
18973 : 3 : cfg.set_overrun ();
18974 : 3 : goto done;
18975 : : }
18976 : 2352 : extensions = ext;
18977 : : }
18978 : :
18979 : : /* Check global trees. */
18980 : 2352 : {
18981 : 2352 : unsigned their_fixed_length = cfg.u ();
18982 : 2352 : unsigned their_fixed_crc = cfg.u32 ();
18983 : 2807 : dump () && dump ("Read globals=%u, crc=%x",
18984 : : their_fixed_length, their_fixed_crc);
18985 : 2352 : if (!flag_preprocess_only
18986 : 2352 : && (their_fixed_length != fixed_trees->length ()
18987 : 2313 : || their_fixed_crc != global_crc))
18988 : : {
18989 : 0 : error_at (loc, "fixed tree mismatch");
18990 : 0 : cfg.set_overrun ();
18991 : 0 : goto done;
18992 : : }
18993 : : }
18994 : :
18995 : : /* All non-partitions are interfaces. */
18996 : 2352 : interface_p = !is_partition () || cfg.u ();
18997 : :
18998 : 2352 : config.num_imports = cfg.u ();
18999 : 2352 : config.num_partitions = cfg.u ();
19000 : 2352 : config.num_entities = cfg.u ();
19001 : :
19002 : 2352 : config.ordinary_locs = cfg.loc ();
19003 : 2352 : config.macro_locs = cfg.loc ();
19004 : 2352 : config.loc_range_bits = cfg.u ();
19005 : :
19006 : 2352 : config.active_init = cfg.u ();
19007 : :
19008 : 2359 : done:
19009 : 2359 : return cfg.end (from ());
19010 : 2359 : }
19011 : :
19012 : : /* Comparator for ordering the Ordered Ordinary Location array. */
19013 : :
19014 : : static int
19015 : 80 : ool_cmp (const void *a_, const void *b_)
19016 : : {
19017 : 80 : auto *a = *static_cast<const module_state *const *> (a_);
19018 : 80 : auto *b = *static_cast<const module_state *const *> (b_);
19019 : 80 : if (a == b)
19020 : : return 0;
19021 : 80 : else if (a->ordinary_locs.first < b->ordinary_locs.first)
19022 : : return -1;
19023 : : else
19024 : 30 : return +1;
19025 : : }
19026 : :
19027 : : /* Use ELROND format to record the following sections:
19028 : : qualified-names : binding value(s)
19029 : : MOD_SNAME_PFX.README : human readable, strings
19030 : : MOD_SNAME_PFX.ENV : environment strings, strings
19031 : : MOD_SNAME_PFX.nms : namespace hierarchy
19032 : : MOD_SNAME_PFX.bnd : binding table
19033 : : MOD_SNAME_PFX.spc : specialization table
19034 : : MOD_SNAME_PFX.imp : import table
19035 : : MOD_SNAME_PFX.ent : entity table
19036 : : MOD_SNAME_PFX.prt : partitions table
19037 : : MOD_SNAME_PFX.olm : ordinary line maps
19038 : : MOD_SNAME_PFX.mlm : macro line maps
19039 : : MOD_SNAME_PFX.def : macro definitions
19040 : : MOD_SNAME_PFX.mac : macro index
19041 : : MOD_SNAME_PFX.ini : inits
19042 : : MOD_SNAME_PFX.cnt : counts
19043 : : MOD_SNAME_PFX.cfg : config data
19044 : : */
19045 : :
19046 : : bool
19047 : 2170 : module_state::write_begin (elf_out *to, cpp_reader *reader,
19048 : : module_state_config &config, unsigned &crc)
19049 : : {
19050 : : /* Figure out remapped module numbers, which might elide
19051 : : partitions. */
19052 : 2170 : bitmap partitions = NULL;
19053 : 2170 : if (!is_header () && !is_partition ())
19054 : 1232 : partitions = BITMAP_GGC_ALLOC ();
19055 : 2170 : write_init_maps ();
19056 : :
19057 : 2170 : unsigned mod_hwm = 1;
19058 : 2682 : for (unsigned ix = 1; ix != modules->length (); ix++)
19059 : : {
19060 : 512 : module_state *imp = (*modules)[ix];
19061 : :
19062 : : /* Promote any non-partition direct import from a partition, unless
19063 : : we're a partition. */
19064 : 470 : if (!is_partition () && !imp->is_partition ()
19065 : 840 : && imp->is_partition_direct ())
19066 : 9 : imp->directness = MD_PURVIEW_DIRECT;
19067 : :
19068 : : /* Write any import that is not a partition, unless we're a
19069 : : partition. */
19070 : 512 : if (!partitions || !imp->is_partition ())
19071 : 370 : imp->remap = mod_hwm++;
19072 : : else
19073 : : {
19074 : 172 : dump () && dump ("Partition %M %u", imp, ix);
19075 : 142 : bitmap_set_bit (partitions, ix);
19076 : 142 : imp->remap = 0;
19077 : : /* All interface partitions must be exported. */
19078 : 142 : if (imp->is_interface () && !bitmap_bit_p (exports, imp->mod))
19079 : : {
19080 : 3 : error_at (imp->loc, "interface partition is not exported");
19081 : 3 : bitmap_set_bit (exports, imp->mod);
19082 : : }
19083 : :
19084 : : /* All the partition entities should have been loaded when
19085 : : loading the partition. */
19086 : : if (CHECKING_P)
19087 : 758 : for (unsigned jx = 0; jx != imp->entity_num; jx++)
19088 : : {
19089 : 616 : binding_slot *slot = &(*entity_ary)[imp->entity_lwm + jx];
19090 : 616 : gcc_checking_assert (!slot->is_lazy ());
19091 : : }
19092 : : }
19093 : :
19094 : 512 : if (imp->is_direct () && (imp->remap || imp->is_partition ()))
19095 : 502 : note_location (imp->imported_from ());
19096 : : }
19097 : :
19098 : 2170 : if (partitions && bitmap_empty_p (partitions))
19099 : : /* No partitions present. */
19100 : : partitions = nullptr;
19101 : :
19102 : : /* Find the set of decls we must write out. */
19103 : 2170 : depset::hash table (DECL_NAMESPACE_BINDINGS (global_namespace)->size () * 8);
19104 : : /* Add the specializations before the writables, so that we can
19105 : : detect injected friend specializations. */
19106 : 2170 : table.add_specializations (true);
19107 : 2170 : table.add_specializations (false);
19108 : 2170 : if (partial_specializations)
19109 : : {
19110 : 176 : table.add_partial_entities (partial_specializations);
19111 : 176 : partial_specializations = NULL;
19112 : : }
19113 : 2170 : table.add_namespace_entities (global_namespace, partitions);
19114 : 2170 : if (class_members)
19115 : : {
19116 : 12 : table.add_class_entities (class_members);
19117 : 12 : class_members = NULL;
19118 : : }
19119 : :
19120 : : /* Now join everything up. */
19121 : 2170 : table.find_dependencies (this);
19122 : :
19123 : 2170 : if (!table.finalize_dependencies ())
19124 : : return false;
19125 : :
19126 : : #if CHECKING_P
19127 : : /* We're done verifying at-most once reading, reset to verify
19128 : : at-most once writing. */
19129 : 2149 : note_defs = note_defs_table_t::create_ggc (1000);
19130 : : #endif
19131 : :
19132 : : /* Determine Strongly Connected Components. This will also strip any
19133 : : unnecessary dependencies on imported or TU-local entities. */
19134 : 2149 : vec<depset *> sccs = table.connect ();
19135 : :
19136 : 2149 : vec_alloc (ool, modules->length ());
19137 : 2658 : for (unsigned ix = modules->length (); --ix;)
19138 : : {
19139 : 509 : auto *import = (*modules)[ix];
19140 : 509 : if (import->loadedness > ML_NONE
19141 : 509 : && !(partitions && bitmap_bit_p (partitions, import->mod)))
19142 : 367 : ool->quick_push (import);
19143 : : }
19144 : 2149 : ool->qsort (ool_cmp);
19145 : :
19146 : 2149 : vec<cpp_hashnode *> *macros = nullptr;
19147 : 2149 : if (is_header ())
19148 : 790 : macros = prepare_macros (reader);
19149 : :
19150 : 2149 : config.num_imports = mod_hwm;
19151 : 2149 : config.num_partitions = modules->length () - mod_hwm;
19152 : 2149 : auto map_info = write_prepare_maps (&config, bool (config.num_partitions));
19153 : 2149 : unsigned counts[MSC_HWM];
19154 : 2149 : memset (counts, 0, sizeof (counts));
19155 : :
19156 : : /* depset::cluster is the cluster number,
19157 : : depset::section is unspecified scratch value.
19158 : :
19159 : : The following loops make use of the tarjan property that
19160 : : dependencies will be earlier in the SCCS array. */
19161 : :
19162 : : /* This first loop determines the number of depsets in each SCC, and
19163 : : also the number of namespaces we're dealing with. During the
19164 : : loop, the meaning of a couple of depset fields now change:
19165 : :
19166 : : depset::cluster -> size_of cluster, if first of cluster & !namespace
19167 : : depset::section -> section number of cluster (if !namespace). */
19168 : :
19169 : 2149 : unsigned n_spaces = 0;
19170 : 2149 : counts[MSC_sec_lwm] = counts[MSC_sec_hwm] = to->get_section_limit ();
19171 : 387985 : for (unsigned size, ix = 0; ix < sccs.length (); ix += size)
19172 : : {
19173 : 385836 : depset **base = &sccs[ix];
19174 : :
19175 : 729011 : if (base[0]->get_entity_kind () == depset::EK_NAMESPACE)
19176 : : {
19177 : 4544 : n_spaces++;
19178 : 4544 : size = 1;
19179 : : }
19180 : : else
19181 : : {
19182 : : /* Count the members in this cluster. */
19183 : 1615886 : for (size = 1; ix + size < sccs.length (); size++)
19184 : 1614003 : if (base[size]->cluster != base[0]->cluster)
19185 : : break;
19186 : :
19187 : 1997178 : for (unsigned jx = 0; jx != size; jx++)
19188 : : {
19189 : : /* Set the section number. */
19190 : 1615886 : base[jx]->cluster = ~(~0u >> 1); /* A bad value. */
19191 : 1615886 : base[jx]->section = counts[MSC_sec_hwm];
19192 : : }
19193 : :
19194 : : /* Save the size in the first member's cluster slot. */
19195 : 381292 : base[0]->cluster = size;
19196 : :
19197 : 381292 : counts[MSC_sec_hwm]++;
19198 : : }
19199 : : }
19200 : :
19201 : : /* Write the clusters. Namespace decls are put in the spaces array.
19202 : : The meaning of depset::cluster changes to provide the
19203 : : unnamed-decl count of the depset's decl (and remains zero for
19204 : : non-decls and non-unnamed). */
19205 : 2149 : unsigned bytes = 0;
19206 : 2149 : vec<depset *> spaces;
19207 : 2149 : spaces.create (n_spaces);
19208 : :
19209 : 387985 : for (unsigned size, ix = 0; ix < sccs.length (); ix += size)
19210 : : {
19211 : 385836 : depset **base = &sccs[ix];
19212 : :
19213 : 385836 : if (base[0]->get_entity_kind () == depset::EK_NAMESPACE)
19214 : : {
19215 : 4544 : tree decl = base[0]->get_entity ();
19216 : 4544 : if (decl == global_namespace)
19217 : 1923 : base[0]->cluster = 0;
19218 : 2621 : else if (!base[0]->is_import ())
19219 : : {
19220 : 2621 : base[0]->cluster = counts[MSC_entities]++;
19221 : 2621 : spaces.quick_push (base[0]);
19222 : 2621 : counts[MSC_namespaces]++;
19223 : 2621 : if (CHECKING_P)
19224 : : {
19225 : : /* Add it to the entity map, such that we can tell it is
19226 : : part of us. */
19227 : 2621 : bool existed;
19228 : 2621 : unsigned *slot = &entity_map->get_or_insert
19229 : 2621 : (DECL_UID (decl), &existed);
19230 : 2621 : if (existed)
19231 : : /* It must have come from a partition. */
19232 : 0 : gcc_checking_assert
19233 : : (import_entity_module (*slot)->is_partition ());
19234 : 2621 : *slot = ~base[0]->cluster;
19235 : : }
19236 : 388487 : dump (dumper::CLUSTER) && dump ("Cluster namespace %N", decl);
19237 : : }
19238 : : size = 1;
19239 : : }
19240 : : else
19241 : : {
19242 : 381292 : size = base[0]->cluster;
19243 : :
19244 : : /* Cluster is now used to number entities. */
19245 : 381292 : base[0]->cluster = ~(~0u >> 1); /* A bad value. */
19246 : :
19247 : 381292 : sort_cluster (&table, base, size);
19248 : :
19249 : : /* Record the section for consistency checking during stream
19250 : : out -- we don't want to start writing decls in different
19251 : : sections. */
19252 : 381292 : table.section = base[0]->section;
19253 : 381292 : bytes += write_cluster (to, base, size, table, counts, &crc);
19254 : 381292 : table.section = 0;
19255 : : }
19256 : : }
19257 : :
19258 : : /* depset::cluster - entity number (on entities)
19259 : : depset::section - cluster number */
19260 : : /* We'd better have written as many sections and found as many
19261 : : namespaces as we predicted. */
19262 : 4298 : gcc_assert (counts[MSC_sec_hwm] == to->get_section_limit ()
19263 : : && spaces.length () == counts[MSC_namespaces]);
19264 : :
19265 : : /* Write the entitites. None happens if we contain namespaces or
19266 : : nothing. */
19267 : 2149 : config.num_entities = counts[MSC_entities];
19268 : 2149 : if (counts[MSC_entities])
19269 : 1920 : write_entities (to, sccs, counts[MSC_entities], &crc);
19270 : :
19271 : : /* Write the namespaces. */
19272 : 2149 : if (counts[MSC_namespaces])
19273 : 414 : write_namespaces (to, spaces, counts[MSC_namespaces], &crc);
19274 : :
19275 : : /* Write the bindings themselves. */
19276 : 2149 : counts[MSC_bindings] = write_bindings (to, sccs, &crc);
19277 : :
19278 : : /* Write the unnamed. */
19279 : 2149 : counts[MSC_pendings] = write_pendings (to, sccs, table, &crc);
19280 : :
19281 : : /* Write the import table. */
19282 : 2149 : if (config.num_imports > 1)
19283 : 347 : write_imports (to, &crc);
19284 : :
19285 : : /* Write elided partition table. */
19286 : 2149 : if (config.num_partitions)
19287 : 100 : write_partitions (to, config.num_partitions, &crc);
19288 : :
19289 : : /* Write the line maps. */
19290 : 2149 : if (config.ordinary_locs)
19291 : 2058 : write_ordinary_maps (to, map_info, bool (config.num_partitions), &crc);
19292 : 2149 : if (config.macro_locs)
19293 : 120 : write_macro_maps (to, map_info, &crc);
19294 : :
19295 : 2149 : if (is_header ())
19296 : : {
19297 : 790 : counts[MSC_macros] = write_macros (to, macros, &crc);
19298 : 790 : counts[MSC_inits] = write_inits (to, table, &crc);
19299 : 790 : vec_free (macros);
19300 : : }
19301 : :
19302 : 2149 : unsigned clusters = counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
19303 : 2149 : dump () && dump ("Wrote %u clusters, average %u bytes/cluster",
19304 : 241 : clusters, (bytes + clusters / 2) / (clusters + !clusters));
19305 : 2149 : trees_out::instrument ();
19306 : :
19307 : 2149 : write_counts (to, counts, &crc);
19308 : :
19309 : 2149 : spaces.release ();
19310 : 2149 : sccs.release ();
19311 : :
19312 : 2149 : vec_free (macro_loc_remap);
19313 : 2149 : vec_free (ord_loc_remap);
19314 : 2149 : vec_free (ool);
19315 : :
19316 : : // FIXME:QOI: Have a command line switch to control more detailed
19317 : : // information (which might leak data you do not want to leak).
19318 : : // Perhaps (some of) the write_readme contents should also be
19319 : : // so-controlled.
19320 : 2149 : if (false)
19321 : : write_env (to);
19322 : :
19323 : 2149 : return true;
19324 : 2170 : }
19325 : :
19326 : : // Finish module writing after we've emitted all dynamic initializers.
19327 : :
19328 : : void
19329 : 2149 : module_state::write_end (elf_out *to, cpp_reader *reader,
19330 : : module_state_config &config, unsigned &crc)
19331 : : {
19332 : : /* And finish up. */
19333 : 2149 : write_config (to, config, crc);
19334 : :
19335 : : /* Human-readable info. */
19336 : 2149 : write_readme (to, reader, config.dialect_str);
19337 : :
19338 : 2390 : dump () && dump ("Wrote %u sections", to->get_section_limit ());
19339 : 2149 : }
19340 : :
19341 : : /* Initial read of a CMI. Checks config, loads up imports and line
19342 : : maps. */
19343 : :
19344 : : bool
19345 : 2359 : module_state::read_initial (cpp_reader *reader)
19346 : : {
19347 : 2359 : module_state_config config;
19348 : 2359 : bool ok = true;
19349 : :
19350 : 2359 : if (ok && !from ()->begin (loc))
19351 : : ok = false;
19352 : :
19353 : 2359 : if (ok && !read_config (config))
19354 : : ok = false;
19355 : :
19356 : 2352 : bool have_locs = ok && read_prepare_maps (&config);
19357 : :
19358 : : /* Ordinary maps before the imports. */
19359 : 2352 : if (!(have_locs && config.ordinary_locs))
19360 : 70 : ordinary_locs.first = line_table->highest_location + 1;
19361 : 2289 : else if (!read_ordinary_maps (config.ordinary_locs, config.loc_range_bits))
19362 : : ok = false;
19363 : :
19364 : : /* Allocate the REMAP vector. */
19365 : 2359 : slurp->alloc_remap (config.num_imports);
19366 : :
19367 : 2359 : if (ok)
19368 : : {
19369 : : /* Read the import table. Decrement current to stop this CMI
19370 : : from being evicted during the import. */
19371 : 2352 : slurp->current--;
19372 : 2352 : if (config.num_imports > 1 && !read_imports (reader, line_table))
19373 : : ok = false;
19374 : 2352 : slurp->current++;
19375 : : }
19376 : :
19377 : : /* Read the elided partition table, if we're the primary partition. */
19378 : 2352 : if (ok && config.num_partitions && is_module ()
19379 : 2367 : && !read_partitions (config.num_partitions))
19380 : : ok = false;
19381 : :
19382 : : /* Determine the module's number. */
19383 : 2359 : gcc_checking_assert (mod == MODULE_UNKNOWN);
19384 : 2359 : gcc_checking_assert (this != (*modules)[0]);
19385 : :
19386 : 2359 : {
19387 : : /* Allocate space in the entities array now -- that array must be
19388 : : monotonically in step with the modules array. */
19389 : 2359 : entity_lwm = vec_safe_length (entity_ary);
19390 : 2359 : entity_num = config.num_entities;
19391 : 2359 : gcc_checking_assert (modules->length () == 1
19392 : : || modules->last ()->entity_lwm <= entity_lwm);
19393 : 2359 : vec_safe_reserve (entity_ary, config.num_entities);
19394 : :
19395 : 2359 : binding_slot slot;
19396 : 2359 : slot.u.binding = NULL_TREE;
19397 : 1681988 : for (unsigned count = config.num_entities; count--;)
19398 : 1679629 : entity_ary->quick_push (slot);
19399 : : }
19400 : :
19401 : : /* We'll run out of other resources before we run out of module
19402 : : indices. */
19403 : 2359 : mod = modules->length ();
19404 : 2359 : vec_safe_push (modules, this);
19405 : :
19406 : : /* We always import and export ourselves. */
19407 : 2359 : bitmap_set_bit (imports, mod);
19408 : 2359 : bitmap_set_bit (exports, mod);
19409 : :
19410 : 2359 : if (ok)
19411 : 2352 : (*slurp->remap)[0] = mod << 1;
19412 : 2814 : dump () && dump ("Assigning %M module number %u", this, mod);
19413 : :
19414 : : /* We should not have been frozen during the importing done by
19415 : : read_config. */
19416 : 2359 : gcc_assert (!from ()->is_frozen ());
19417 : :
19418 : : /* Macro maps after the imports. */
19419 : 2359 : if (!(ok && have_locs && config.macro_locs))
19420 : 2220 : macro_locs.first = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
19421 : 139 : else if (!read_macro_maps (config.macro_locs))
19422 : : ok = false;
19423 : :
19424 : : /* Note whether there's an active initializer. */
19425 : 2359 : active_init_p = !is_header () && bool (config.active_init);
19426 : :
19427 : 2359 : gcc_assert (slurp->current == ~0u);
19428 : 2359 : return ok;
19429 : : }
19430 : :
19431 : : /* Read a preprocessor state. */
19432 : :
19433 : : bool
19434 : 841 : module_state::read_preprocessor (bool outermost)
19435 : : {
19436 : 841 : gcc_checking_assert (is_header () && slurp
19437 : : && slurp->remap_module (0) == mod);
19438 : :
19439 : 841 : if (loadedness == ML_PREPROCESSOR)
19440 : 6 : return !(from () && from ()->get_error ());
19441 : :
19442 : 835 : bool ok = true;
19443 : :
19444 : : /* Read direct header imports. */
19445 : 835 : unsigned len = slurp->remap->length ();
19446 : 873 : for (unsigned ix = 1; ok && ix != len; ix++)
19447 : : {
19448 : 38 : unsigned map = (*slurp->remap)[ix];
19449 : 38 : if (map & 1)
19450 : : {
19451 : 38 : module_state *import = (*modules)[map >> 1];
19452 : 38 : if (import->is_header ())
19453 : : {
19454 : 38 : ok = import->read_preprocessor (false);
19455 : 38 : bitmap_ior_into (slurp->headers, import->slurp->headers);
19456 : : }
19457 : : }
19458 : : }
19459 : :
19460 : : /* Record as a direct header. */
19461 : 835 : if (ok)
19462 : 835 : bitmap_set_bit (slurp->headers, mod);
19463 : :
19464 : 835 : if (ok && !read_macros ())
19465 : : ok = false;
19466 : :
19467 : 835 : loadedness = ML_PREPROCESSOR;
19468 : 835 : announce ("macros");
19469 : :
19470 : 835 : if (flag_preprocess_only)
19471 : : /* We're done with the string table. */
19472 : 39 : from ()->release ();
19473 : :
19474 : 835 : return check_read (outermost, ok);
19475 : : }
19476 : :
19477 : : /* Read language state. */
19478 : :
19479 : : bool
19480 : 2366 : module_state::read_language (bool outermost)
19481 : : {
19482 : 2366 : gcc_checking_assert (!lazy_snum);
19483 : :
19484 : 2366 : if (loadedness == ML_LANGUAGE)
19485 : 65 : return !(slurp && from () && from ()->get_error ());
19486 : :
19487 : 2301 : gcc_checking_assert (slurp && slurp->current == ~0u
19488 : : && slurp->remap_module (0) == mod);
19489 : :
19490 : 2301 : bool ok = true;
19491 : :
19492 : : /* Read direct imports. */
19493 : 2301 : unsigned len = slurp->remap->length ();
19494 : 2603 : for (unsigned ix = 1; ok && ix != len; ix++)
19495 : : {
19496 : 302 : unsigned map = (*slurp->remap)[ix];
19497 : 302 : if (map & 1)
19498 : : {
19499 : 302 : module_state *import = (*modules)[map >> 1];
19500 : 302 : if (!import->read_language (false))
19501 : 302 : ok = false;
19502 : : }
19503 : : }
19504 : :
19505 : 2301 : unsigned counts[MSC_HWM];
19506 : :
19507 : 2301 : if (ok && !read_counts (counts))
19508 : : ok = false;
19509 : :
19510 : 2301 : function_depth++; /* Prevent unexpected GCs. */
19511 : :
19512 : 2301 : if (ok && counts[MSC_entities] != entity_num)
19513 : : ok = false;
19514 : 2301 : if (ok && counts[MSC_entities]
19515 : 2100 : && !read_entities (counts[MSC_entities],
19516 : : counts[MSC_sec_lwm], counts[MSC_sec_hwm]))
19517 : : ok = false;
19518 : :
19519 : : /* Read the namespace hierarchy. */
19520 : 2301 : if (ok && counts[MSC_namespaces]
19521 : 2717 : && !read_namespaces (counts[MSC_namespaces]))
19522 : : ok = false;
19523 : :
19524 : 2301 : if (ok && !read_bindings (counts[MSC_bindings],
19525 : : counts[MSC_sec_lwm], counts[MSC_sec_hwm]))
19526 : : ok = false;
19527 : :
19528 : : /* And unnamed. */
19529 : 2301 : if (ok && counts[MSC_pendings] && !read_pendings (counts[MSC_pendings]))
19530 : : ok = false;
19531 : :
19532 : 2301 : if (ok)
19533 : : {
19534 : 2301 : slurp->remaining = counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
19535 : 2301 : available_clusters += counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
19536 : : }
19537 : :
19538 : 2301 : if (!flag_module_lazy
19539 : 2301 : || (is_partition ()
19540 : 181 : && module_interface_p ()
19541 : 166 : && !module_partition_p ()))
19542 : : {
19543 : : /* Read the sections in forward order, so that dependencies are read
19544 : : first. See note about tarjan_connect. */
19545 : 450 : ggc_collect ();
19546 : :
19547 : 450 : lazy_snum = ~0u;
19548 : :
19549 : 450 : unsigned hwm = counts[MSC_sec_hwm];
19550 : 320938 : for (unsigned ix = counts[MSC_sec_lwm]; ok && ix != hwm; ix++)
19551 : 320488 : if (!load_section (ix, NULL))
19552 : : {
19553 : : ok = false;
19554 : : break;
19555 : : }
19556 : 450 : lazy_snum = 0;
19557 : 450 : post_load_processing ();
19558 : :
19559 : 450 : ggc_collect ();
19560 : :
19561 : 450 : if (ok && CHECKING_P)
19562 : 1128873 : for (unsigned ix = 0; ix != entity_num; ix++)
19563 : 1128423 : gcc_assert (!(*entity_ary)[ix + entity_lwm].is_lazy ());
19564 : : }
19565 : :
19566 : : // If the import is a header-unit, we need to register initializers
19567 : : // of any static objects it contains (looking at you _Ioinit).
19568 : : // Notice, the ordering of these initializers will be that of a
19569 : : // dynamic initializer at this point in the current TU. (Other
19570 : : // instances of these objects in other TUs will be initialized as
19571 : : // part of that TU's global initializers.)
19572 : 2301 : if (ok && counts[MSC_inits] && !read_inits (counts[MSC_inits]))
19573 : : ok = false;
19574 : :
19575 : 2301 : function_depth--;
19576 : :
19577 : 2609 : announce (flag_module_lazy ? "lazy" : "imported");
19578 : 2301 : loadedness = ML_LANGUAGE;
19579 : :
19580 : 2301 : gcc_assert (slurp->current == ~0u);
19581 : :
19582 : : /* We're done with the string table. */
19583 : 2301 : from ()->release ();
19584 : :
19585 : 2301 : return check_read (outermost, ok);
19586 : : }
19587 : :
19588 : : bool
19589 : 357237 : module_state::maybe_defrost ()
19590 : : {
19591 : 357237 : bool ok = true;
19592 : 357237 : if (from ()->is_frozen ())
19593 : : {
19594 : 9 : if (lazy_open >= lazy_limit)
19595 : 3 : freeze_an_elf ();
19596 : 18 : dump () && dump ("Defrosting '%s'", filename);
19597 : 9 : ok = from ()->defrost (maybe_add_cmi_prefix (filename));
19598 : 9 : lazy_open++;
19599 : : }
19600 : :
19601 : 357237 : return ok;
19602 : : }
19603 : :
19604 : : /* Load section SNUM, dealing with laziness. It doesn't matter if we
19605 : : have multiple concurrent loads, because we do not use TREE_VISITED
19606 : : when reading back in. */
19607 : :
19608 : : bool
19609 : 357237 : module_state::load_section (unsigned snum, binding_slot *mslot)
19610 : : {
19611 : 357237 : if (from ()->get_error ())
19612 : : return false;
19613 : :
19614 : 357237 : if (snum >= slurp->current)
19615 : 0 : from ()->set_error (elf::E_BAD_LAZY);
19616 : 357237 : else if (maybe_defrost ())
19617 : : {
19618 : 357237 : unsigned old_current = slurp->current;
19619 : 357237 : slurp->current = snum;
19620 : 357237 : slurp->lru = 0; /* Do not swap out. */
19621 : 357237 : slurp->remaining--;
19622 : 357237 : read_cluster (snum);
19623 : 357237 : slurp->lru = ++lazy_lru;
19624 : 357237 : slurp->current = old_current;
19625 : : }
19626 : :
19627 : 357237 : if (mslot && mslot->is_lazy ())
19628 : : {
19629 : : /* Oops, the section didn't set this slot. */
19630 : 0 : from ()->set_error (elf::E_BAD_DATA);
19631 : 0 : *mslot = NULL_TREE;
19632 : : }
19633 : :
19634 : 357237 : bool ok = !from ()->get_error ();
19635 : 357237 : if (!ok)
19636 : : {
19637 : 0 : error_at (loc, "failed to read compiled module cluster %u: %s",
19638 : 0 : snum, from ()->get_error (filename));
19639 : 0 : note_cmi_name ();
19640 : : }
19641 : :
19642 : 357237 : maybe_completed_reading ();
19643 : :
19644 : 357237 : return ok;
19645 : : }
19646 : :
19647 : : void
19648 : 362722 : module_state::maybe_completed_reading ()
19649 : : {
19650 : 362722 : if (loadedness == ML_LANGUAGE && slurp->current == ~0u && !slurp->remaining)
19651 : : {
19652 : 1938 : lazy_open--;
19653 : : /* We no longer need the macros, all tokenizing has been done. */
19654 : 1938 : slurp->release_macros ();
19655 : :
19656 : 1938 : from ()->end ();
19657 : 1938 : slurp->close ();
19658 : 1938 : slurped ();
19659 : : }
19660 : 362722 : }
19661 : :
19662 : : /* After a reading operation, make sure things are still ok. If not,
19663 : : emit an error and clean up. */
19664 : :
19665 : : bool
19666 : 5513 : module_state::check_read (bool outermost, bool ok)
19667 : : {
19668 : 5513 : gcc_checking_assert (!outermost || slurp->current == ~0u);
19669 : :
19670 : 5513 : if (!ok)
19671 : 7 : from ()->set_error ();
19672 : :
19673 : 5513 : if (int e = from ()->get_error ())
19674 : : {
19675 : 31 : auto_diagnostic_group d;
19676 : 31 : error_at (loc, "failed to read compiled module: %s",
19677 : 31 : from ()->get_error (filename));
19678 : 31 : note_cmi_name ();
19679 : :
19680 : 31 : if (e == EMFILE
19681 : 31 : || e == ENFILE
19682 : : #if MAPPED_READING
19683 : 31 : || e == ENOMEM
19684 : : #endif
19685 : : || false)
19686 : 0 : inform (loc, "consider using %<-fno-module-lazy%>,"
19687 : : " increasing %<-param-lazy-modules=%u%> value,"
19688 : : " or increasing the per-process file descriptor limit",
19689 : : param_lazy_modules);
19690 : 31 : else if (e == ENOENT)
19691 : 18 : inform (loc, "imports must be built before being imported");
19692 : :
19693 : 31 : if (outermost)
19694 : 28 : fatal_error (loc, "returning to the gate for a mechanical issue");
19695 : :
19696 : 3 : ok = false;
19697 : 3 : }
19698 : :
19699 : 5485 : maybe_completed_reading ();
19700 : :
19701 : 5485 : return ok;
19702 : : }
19703 : :
19704 : : /* Return the IDENTIFIER_NODE naming module IX. This is the name
19705 : : including dots. */
19706 : :
19707 : : char const *
19708 : 496 : module_name (unsigned ix, bool header_ok)
19709 : : {
19710 : 496 : if (modules)
19711 : : {
19712 : 496 : module_state *imp = (*modules)[ix];
19713 : :
19714 : 496 : if (ix && !imp->name)
19715 : 0 : imp = imp->parent;
19716 : :
19717 : 496 : if (header_ok || !imp->is_header ())
19718 : 288 : return imp->get_flatname ();
19719 : : }
19720 : :
19721 : : return NULL;
19722 : : }
19723 : :
19724 : : /* Return the bitmap describing what modules are imported. Remember,
19725 : : we always import ourselves. */
19726 : :
19727 : : bitmap
19728 : 93529 : get_import_bitmap ()
19729 : : {
19730 : 93529 : return (*modules)[0]->imports;
19731 : : }
19732 : :
19733 : : /* Return the visible imports and path of instantiation for an
19734 : : instantiation at TINST. If TINST is nullptr, we're not in an
19735 : : instantiation, and thus will return the visible imports of the
19736 : : current TU (and NULL *PATH_MAP_P). We cache the information on
19737 : : the tinst level itself. */
19738 : :
19739 : : static bitmap
19740 : 120839 : path_of_instantiation (tinst_level *tinst, bitmap *path_map_p)
19741 : : {
19742 : 120839 : gcc_checking_assert (modules_p ());
19743 : :
19744 : 120839 : if (!tinst)
19745 : : {
19746 : : /* Not inside an instantiation, just the regular case. */
19747 : 70074 : *path_map_p = nullptr;
19748 : 70074 : return get_import_bitmap ();
19749 : : }
19750 : :
19751 : 50765 : if (!tinst->path)
19752 : : {
19753 : : /* Calculate. */
19754 : 15180 : bitmap visible = path_of_instantiation (tinst->next, path_map_p);
19755 : 15180 : bitmap path_map = *path_map_p;
19756 : :
19757 : 15180 : if (!path_map)
19758 : : {
19759 : 3217 : path_map = BITMAP_GGC_ALLOC ();
19760 : 3217 : bitmap_set_bit (path_map, 0);
19761 : : }
19762 : :
19763 : 15180 : tree decl = tinst->tldcl;
19764 : 15180 : if (TREE_CODE (decl) == TREE_LIST)
19765 : 0 : decl = TREE_PURPOSE (decl);
19766 : 15180 : if (TYPE_P (decl))
19767 : 1390 : decl = TYPE_NAME (decl);
19768 : :
19769 : 15180 : if (unsigned mod = get_originating_module (decl))
19770 : 1409 : if (!bitmap_bit_p (path_map, mod))
19771 : : {
19772 : : /* This is brand new information! */
19773 : 83 : bitmap new_path = BITMAP_GGC_ALLOC ();
19774 : 83 : bitmap_copy (new_path, path_map);
19775 : 83 : bitmap_set_bit (new_path, mod);
19776 : 83 : path_map = new_path;
19777 : :
19778 : 83 : bitmap imports = (*modules)[mod]->imports;
19779 : 83 : if (bitmap_intersect_compl_p (imports, visible))
19780 : : {
19781 : : /* IMPORTS contains additional modules to VISIBLE. */
19782 : 6 : bitmap new_visible = BITMAP_GGC_ALLOC ();
19783 : :
19784 : 6 : bitmap_ior (new_visible, visible, imports);
19785 : 6 : visible = new_visible;
19786 : : }
19787 : : }
19788 : :
19789 : 15180 : tinst->path = path_map;
19790 : 15180 : tinst->visible = visible;
19791 : : }
19792 : :
19793 : 50765 : *path_map_p = tinst->path;
19794 : 50765 : return tinst->visible;
19795 : : }
19796 : :
19797 : : /* Return the bitmap describing what modules are visible along the
19798 : : path of instantiation. If we're not an instantiation, this will be
19799 : : the visible imports of the TU. *PATH_MAP_P is filled in with the
19800 : : modules owning the instantiation path -- we see the module-linkage
19801 : : entities of those modules. */
19802 : :
19803 : : bitmap
19804 : 17937551 : visible_instantiation_path (bitmap *path_map_p)
19805 : : {
19806 : 17937551 : if (!modules_p ())
19807 : : return NULL;
19808 : :
19809 : 105659 : return path_of_instantiation (current_instantiation (), path_map_p);
19810 : : }
19811 : :
19812 : : /* We've just directly imported IMPORT. Update our import/export
19813 : : bitmaps. IS_EXPORT is true if we're reexporting the OTHER. */
19814 : :
19815 : : void
19816 : 2427 : module_state::set_import (module_state const *import, bool is_export)
19817 : : {
19818 : 2427 : gcc_checking_assert (this != import);
19819 : :
19820 : : /* We see IMPORT's exports (which includes IMPORT). If IMPORT is
19821 : : the primary interface or a partition we'll see its imports. */
19822 : 2427 : bitmap_ior_into (imports, import->is_module () || import->is_partition ()
19823 : : ? import->imports : import->exports);
19824 : :
19825 : 2427 : if (is_export)
19826 : : /* We'll export OTHER's exports. */
19827 : 369 : bitmap_ior_into (exports, import->exports);
19828 : 2427 : }
19829 : :
19830 : : /* Return the declaring entity of DECL. That is the decl determining
19831 : : how to decorate DECL with module information. Returns NULL_TREE if
19832 : : it's the global module. */
19833 : :
19834 : : tree
19835 : 153613236 : get_originating_module_decl (tree decl)
19836 : : {
19837 : : /* An enumeration constant. */
19838 : 153613236 : if (TREE_CODE (decl) == CONST_DECL
19839 : 12628 : && DECL_CONTEXT (decl)
19840 : 153625864 : && (TREE_CODE (DECL_CONTEXT (decl)) == ENUMERAL_TYPE))
19841 : 12626 : decl = TYPE_NAME (DECL_CONTEXT (decl));
19842 : 153600610 : else if (TREE_CODE (decl) == FIELD_DECL
19843 : 153582745 : || TREE_CODE (decl) == USING_DECL
19844 : 307171131 : || CONST_DECL_USING_P (decl))
19845 : : {
19846 : 30091 : decl = DECL_CONTEXT (decl);
19847 : 30091 : if (TREE_CODE (decl) != FUNCTION_DECL)
19848 : 30091 : decl = TYPE_NAME (decl);
19849 : : }
19850 : :
19851 : 153613236 : gcc_checking_assert (TREE_CODE (decl) == TEMPLATE_DECL
19852 : : || TREE_CODE (decl) == FUNCTION_DECL
19853 : : || TREE_CODE (decl) == TYPE_DECL
19854 : : || TREE_CODE (decl) == VAR_DECL
19855 : : || TREE_CODE (decl) == CONCEPT_DECL
19856 : : || TREE_CODE (decl) == NAMESPACE_DECL);
19857 : :
19858 : 155062366 : for (;;)
19859 : : {
19860 : : /* Uninstantiated template friends are owned by the befriending
19861 : : class -- not their context. */
19862 : 154337801 : if (TREE_CODE (decl) == TEMPLATE_DECL
19863 : 154337801 : && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
19864 : 8052 : decl = TYPE_NAME (DECL_CHAIN (decl));
19865 : :
19866 : : /* An imported temploid friend is attached to the same module the
19867 : : befriending class was. */
19868 : 154337801 : if (imported_temploid_friends)
19869 : 2995157 : if (tree *slot = imported_temploid_friends->get (decl))
19870 : 199 : decl = *slot;
19871 : :
19872 : 154337801 : int use;
19873 : 154337801 : if (tree ti = node_template_info (decl, use))
19874 : : {
19875 : 575972 : decl = TI_TEMPLATE (ti);
19876 : 575972 : if (TREE_CODE (decl) != TEMPLATE_DECL)
19877 : : {
19878 : : /* A friend template specialization. */
19879 : 12 : gcc_checking_assert (OVL_P (decl));
19880 : 12 : return global_namespace;
19881 : : }
19882 : : }
19883 : : else
19884 : : {
19885 : 153761829 : tree ctx = CP_DECL_CONTEXT (decl);
19886 : 153761829 : if (TREE_CODE (ctx) == NAMESPACE_DECL)
19887 : : break;
19888 : :
19889 : 148605 : if (TYPE_P (ctx))
19890 : : {
19891 : 135559 : ctx = TYPE_NAME (ctx);
19892 : 135559 : if (!ctx)
19893 : : {
19894 : : /* Some kind of internal type. */
19895 : 0 : gcc_checking_assert (DECL_ARTIFICIAL (decl));
19896 : 0 : return global_namespace;
19897 : : }
19898 : : }
19899 : 148605 : decl = ctx;
19900 : : }
19901 : 724565 : }
19902 : :
19903 : 153613224 : return decl;
19904 : : }
19905 : :
19906 : : int
19907 : 1045079 : get_originating_module (tree decl, bool for_mangle)
19908 : : {
19909 : 1045079 : tree owner = get_originating_module_decl (decl);
19910 : 1045079 : tree not_tmpl = STRIP_TEMPLATE (owner);
19911 : :
19912 : 1045079 : if (!DECL_LANG_SPECIFIC (not_tmpl))
19913 : 197749 : return for_mangle ? -1 : 0;
19914 : :
19915 : 1620678 : if (for_mangle && !DECL_MODULE_ATTACH_P (not_tmpl))
19916 : : return -1;
19917 : :
19918 : 181542 : int mod = !DECL_MODULE_IMPORT_P (not_tmpl) ? 0 : get_importing_module (owner);
19919 : 181542 : gcc_checking_assert (!for_mangle || !(*modules)[mod]->is_header ());
19920 : : return mod;
19921 : : }
19922 : :
19923 : : unsigned
19924 : 11809 : get_importing_module (tree decl, bool flexible)
19925 : : {
19926 : 11809 : unsigned index = import_entity_index (decl, flexible);
19927 : 11809 : if (index == ~(~0u >> 1))
19928 : : return -1;
19929 : 11809 : module_state *module = import_entity_module (index);
19930 : :
19931 : 11809 : return module->mod;
19932 : : }
19933 : :
19934 : : /* Is it permissible to redeclare OLDDECL with NEWDECL.
19935 : :
19936 : : If NEWDECL is NULL, assumes that OLDDECL will be redeclared using
19937 : : the current scope's module and attachment. */
19938 : :
19939 : : bool
19940 : 218783 : module_may_redeclare (tree olddecl, tree newdecl)
19941 : : {
19942 : 218783 : tree decl = olddecl;
19943 : 243005 : for (;;)
19944 : : {
19945 : 230894 : tree ctx = CP_DECL_CONTEXT (decl);
19946 : 230894 : if (TREE_CODE (ctx) == NAMESPACE_DECL)
19947 : : // Found the namespace-scope decl.
19948 : : break;
19949 : 23630 : if (!CLASS_TYPE_P (ctx))
19950 : : // We've met a non-class scope. Such a thing is not
19951 : : // reopenable, so we must be ok.
19952 : : return true;
19953 : 12111 : decl = TYPE_NAME (ctx);
19954 : 12111 : }
19955 : :
19956 : 207264 : int use_tpl = 0;
19957 : 207264 : if (node_template_info (STRIP_TEMPLATE (decl), use_tpl) && use_tpl)
19958 : : // Specializations of any kind can be redeclared anywhere.
19959 : : // FIXME: Should we be checking this in more places on the scope chain?
19960 : : return true;
19961 : :
19962 : 140932 : module_state *old_mod = (*modules)[0];
19963 : 140932 : module_state *new_mod = old_mod;
19964 : :
19965 : 140932 : tree old_origin = get_originating_module_decl (decl);
19966 : 140932 : tree old_inner = STRIP_TEMPLATE (old_origin);
19967 : 140932 : bool olddecl_attached_p = (DECL_LANG_SPECIFIC (old_inner)
19968 : 232679 : && DECL_MODULE_ATTACH_P (old_inner));
19969 : 232679 : if (DECL_LANG_SPECIFIC (old_inner) && DECL_MODULE_IMPORT_P (old_inner))
19970 : : {
19971 : 317 : unsigned index = import_entity_index (old_origin);
19972 : 317 : old_mod = import_entity_module (index);
19973 : : }
19974 : :
19975 : 140932 : bool newdecl_attached_p = module_attach_p ();
19976 : 140932 : if (newdecl)
19977 : : {
19978 : 43956 : tree new_origin = get_originating_module_decl (newdecl);
19979 : 43956 : tree new_inner = STRIP_TEMPLATE (new_origin);
19980 : 43956 : newdecl_attached_p = (DECL_LANG_SPECIFIC (new_inner)
19981 : 86315 : && DECL_MODULE_ATTACH_P (new_inner));
19982 : 86315 : if (DECL_LANG_SPECIFIC (new_inner) && DECL_MODULE_IMPORT_P (new_inner))
19983 : : {
19984 : 93 : unsigned index = import_entity_index (new_origin);
19985 : 93 : new_mod = import_entity_module (index);
19986 : : }
19987 : : }
19988 : :
19989 : : /* Module attachment needs to match. */
19990 : 140932 : if (olddecl_attached_p == newdecl_attached_p)
19991 : : {
19992 : 140890 : if (!olddecl_attached_p)
19993 : : /* Both are GM entities, OK. */
19994 : : return true;
19995 : :
19996 : 1009 : if (new_mod == old_mod
19997 : 1255 : || (new_mod && get_primary (new_mod) == get_primary (old_mod)))
19998 : : /* Both attached to same named module, OK. */
19999 : : return true;
20000 : : }
20001 : :
20002 : : /* Attached to different modules, error. */
20003 : 45 : decl = newdecl ? newdecl : olddecl;
20004 : 45 : location_t loc = newdecl ? DECL_SOURCE_LOCATION (newdecl) : input_location;
20005 : 45 : if (DECL_IS_UNDECLARED_BUILTIN (olddecl))
20006 : : {
20007 : 3 : if (newdecl_attached_p)
20008 : 3 : error_at (loc, "declaring %qD in module %qs conflicts with builtin "
20009 : : "in global module", decl, new_mod->get_flatname ());
20010 : : else
20011 : 0 : error_at (loc, "declaration %qD conflicts with builtin", decl);
20012 : : }
20013 : 81 : else if (DECL_LANG_SPECIFIC (old_inner) && DECL_MODULE_IMPORT_P (old_inner))
20014 : : {
20015 : 27 : auto_diagnostic_group d;
20016 : 27 : if (newdecl_attached_p)
20017 : 3 : error_at (loc, "redeclaring %qD in module %qs conflicts with import",
20018 : : decl, new_mod->get_flatname ());
20019 : : else
20020 : 24 : error_at (loc, "redeclaring %qD in global module conflicts with import",
20021 : : decl);
20022 : :
20023 : 27 : if (olddecl_attached_p)
20024 : 27 : inform (DECL_SOURCE_LOCATION (olddecl),
20025 : : "import declared attached to module %qs",
20026 : : old_mod->get_flatname ());
20027 : : else
20028 : 0 : inform (DECL_SOURCE_LOCATION (olddecl),
20029 : : "import declared in global module");
20030 : 27 : }
20031 : : else
20032 : : {
20033 : 15 : auto_diagnostic_group d;
20034 : 15 : if (newdecl_attached_p)
20035 : 15 : error_at (loc, "conflicting declaration of %qD in module %qs",
20036 : : decl, new_mod->get_flatname ());
20037 : : else
20038 : 0 : error_at (loc, "conflicting declaration of %qD in global module",
20039 : : decl);
20040 : :
20041 : 15 : if (olddecl_attached_p)
20042 : 0 : inform (DECL_SOURCE_LOCATION (olddecl),
20043 : : "previously declared in module %qs",
20044 : : old_mod->get_flatname ());
20045 : : else
20046 : 15 : inform (DECL_SOURCE_LOCATION (olddecl),
20047 : : "previously declared in global module");
20048 : 15 : }
20049 : : return false;
20050 : : }
20051 : :
20052 : : /* DECL is being created by this TU. Record it came from here. We
20053 : : record module purview, so we can see if partial or explicit
20054 : : specialization needs to be written out, even though its purviewness
20055 : : comes from the most general template. */
20056 : :
20057 : : void
20058 : 710110798 : set_instantiating_module (tree decl)
20059 : : {
20060 : 710110798 : gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
20061 : : || VAR_P (decl)
20062 : : || TREE_CODE (decl) == TYPE_DECL
20063 : : || TREE_CODE (decl) == CONCEPT_DECL
20064 : : || TREE_CODE (decl) == TEMPLATE_DECL
20065 : : || TREE_CODE (decl) == CONST_DECL
20066 : : || (TREE_CODE (decl) == NAMESPACE_DECL
20067 : : && DECL_NAMESPACE_ALIAS (decl)));
20068 : :
20069 : 710110798 : if (!modules_p ())
20070 : : return;
20071 : :
20072 : 3678899 : decl = STRIP_TEMPLATE (decl);
20073 : :
20074 : 3678899 : if (!DECL_LANG_SPECIFIC (decl) && module_purview_p ())
20075 : 548462 : retrofit_lang_decl (decl);
20076 : :
20077 : 3678899 : if (DECL_LANG_SPECIFIC (decl))
20078 : : {
20079 : 3014551 : DECL_MODULE_PURVIEW_P (decl) = module_purview_p ();
20080 : : /* If this was imported, we'll still be in the entity_hash. */
20081 : 3014551 : DECL_MODULE_IMPORT_P (decl) = false;
20082 : : }
20083 : : }
20084 : :
20085 : : /* If DECL is a class member, whose class is not defined in this TU
20086 : : (it was imported), remember this decl. */
20087 : :
20088 : : void
20089 : 188434 : set_defining_module (tree decl)
20090 : : {
20091 : 188434 : gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
20092 : : || !DECL_MODULE_IMPORT_P (decl));
20093 : :
20094 : 188434 : if (module_maybe_has_cmi_p ())
20095 : : {
20096 : : /* We need to track all declarations within a module, not just those
20097 : : in the module purview, because we don't necessarily know yet if
20098 : : this module will require a CMI while in the global fragment. */
20099 : 116024 : tree ctx = DECL_CONTEXT (decl);
20100 : 116024 : if (ctx
20101 : 116024 : && (TREE_CODE (ctx) == RECORD_TYPE || TREE_CODE (ctx) == UNION_TYPE)
20102 : 23260 : && DECL_LANG_SPECIFIC (TYPE_NAME (ctx))
20103 : 137066 : && DECL_MODULE_IMPORT_P (TYPE_NAME (ctx)))
20104 : : {
20105 : : /* This entity's context is from an import. We may need to
20106 : : record this entity to make sure we emit it in the CMI.
20107 : : Template specializations are in the template hash tables,
20108 : : so we don't need to record them here as well. */
20109 : 12 : int use_tpl = -1;
20110 : 12 : tree ti = node_template_info (decl, use_tpl);
20111 : 12 : if (use_tpl <= 0)
20112 : : {
20113 : 12 : if (ti)
20114 : : {
20115 : 3 : gcc_checking_assert (!use_tpl);
20116 : : /* Get to the TEMPLATE_DECL. */
20117 : 3 : decl = TI_TEMPLATE (ti);
20118 : : }
20119 : :
20120 : : /* Record it on the class_members list. */
20121 : 12 : vec_safe_push (class_members, decl);
20122 : : }
20123 : : }
20124 : : }
20125 : 188434 : }
20126 : :
20127 : : /* Also remember DECL if it's a newly declared class template partial
20128 : : specialization, because these are not necessarily added to the
20129 : : instantiation tables. */
20130 : :
20131 : : void
20132 : 6832930 : set_defining_module_for_partial_spec (tree decl)
20133 : : {
20134 : 6832930 : if (module_maybe_has_cmi_p ()
20135 : 28098 : && DECL_IMPLICIT_TYPEDEF_P (decl)
20136 : 6857860 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
20137 : 24930 : vec_safe_push (partial_specializations, decl);
20138 : 6832930 : }
20139 : :
20140 : : void
20141 : 254276237 : set_originating_module (tree decl, bool friend_p ATTRIBUTE_UNUSED)
20142 : : {
20143 : 254276237 : set_instantiating_module (decl);
20144 : :
20145 : 254276237 : if (!DECL_NAMESPACE_SCOPE_P (decl))
20146 : : return;
20147 : :
20148 : 155716660 : gcc_checking_assert (friend_p || decl == get_originating_module_decl (decl));
20149 : :
20150 : 155716660 : if (module_attach_p ())
20151 : : {
20152 : 3378 : retrofit_lang_decl (decl);
20153 : 3378 : DECL_MODULE_ATTACH_P (decl) = true;
20154 : : }
20155 : :
20156 : : /* It is ill-formed to export a declaration with internal linkage. However,
20157 : : at the point this function is called we don't yet always know whether this
20158 : : declaration has internal linkage; instead we defer this check for callers
20159 : : to do once visibility has been determined. */
20160 : 155716660 : if (module_exporting_p ())
20161 : 353782 : DECL_MODULE_EXPORT_P (decl) = true;
20162 : : }
20163 : :
20164 : : /* Checks whether DECL within a module unit has valid linkage for its kind.
20165 : : Must be called after visibility for DECL has been finalised. */
20166 : :
20167 : : void
20168 : 312198285 : check_module_decl_linkage (tree decl)
20169 : : {
20170 : 312198285 : if (!module_has_cmi_p ())
20171 : : return;
20172 : :
20173 : : /* A header unit shall not contain a definition of a non-inline function
20174 : : or variable (not template) whose name has external linkage. */
20175 : 815907 : if (header_module_p ()
20176 : 705388 : && !processing_template_decl
20177 : 216615 : && ((TREE_CODE (decl) == FUNCTION_DECL
20178 : 139005 : && !DECL_DECLARED_INLINE_P (decl))
20179 : 151755 : || (TREE_CODE (decl) == VAR_DECL
20180 : 40372 : && !DECL_INLINE_VAR_P (decl)))
20181 : 77884 : && decl_defined_p (decl)
20182 : 5486 : && !(DECL_LANG_SPECIFIC (decl)
20183 : 5486 : && DECL_TEMPLATE_INSTANTIATION (decl))
20184 : 821393 : && decl_linkage (decl) == lk_external)
20185 : 57 : error_at (DECL_SOURCE_LOCATION (decl),
20186 : : "external linkage definition of %qD in header module must "
20187 : : "be declared %<inline%>", decl);
20188 : :
20189 : : /* An internal-linkage declaration cannot be generally be exported.
20190 : : But it's OK to export any declaration from a header unit, including
20191 : : internal linkage declarations. */
20192 : 815907 : if (!header_module_p ()
20193 : 110519 : && DECL_MODULE_EXPORT_P (decl)
20194 : 817521 : && decl_linkage (decl) == lk_internal)
20195 : : {
20196 : 50 : error_at (DECL_SOURCE_LOCATION (decl),
20197 : : "exporting declaration %qD with internal linkage", decl);
20198 : 50 : DECL_MODULE_EXPORT_P (decl) = false;
20199 : : }
20200 : : }
20201 : :
20202 : : /* DECL is keyed to CTX for odr purposes. */
20203 : :
20204 : : void
20205 : 750829 : maybe_key_decl (tree ctx, tree decl)
20206 : : {
20207 : 750829 : if (!modules_p ())
20208 : : return;
20209 : :
20210 : : /* We only need to deal with lambdas attached to var, field,
20211 : : parm, or type decls. */
20212 : 10223 : if (TREE_CODE (ctx) != VAR_DECL
20213 : 10223 : && TREE_CODE (ctx) != FIELD_DECL
20214 : 10153 : && TREE_CODE (ctx) != PARM_DECL
20215 : 10141 : && TREE_CODE (ctx) != TYPE_DECL)
20216 : : return;
20217 : :
20218 : : /* For fields, key it to the containing type to handle deduplication
20219 : : correctly. */
20220 : 94 : if (TREE_CODE (ctx) == FIELD_DECL)
20221 : 6 : ctx = TYPE_NAME (DECL_CONTEXT (ctx));
20222 : :
20223 : 94 : if (!keyed_table)
20224 : 46 : keyed_table = new keyed_map_t (EXPERIMENT (1, 400));
20225 : :
20226 : 94 : auto &vec = keyed_table->get_or_insert (ctx);
20227 : 94 : if (!vec.length ())
20228 : : {
20229 : 94 : retrofit_lang_decl (ctx);
20230 : 94 : DECL_MODULE_KEYED_DECLS_P (ctx) = true;
20231 : : }
20232 : 94 : vec.safe_push (decl);
20233 : : }
20234 : :
20235 : : /* DECL is an instantiated friend that should be attached to the same
20236 : : module that ORIG is. */
20237 : :
20238 : : void
20239 : 1681876 : propagate_defining_module (tree decl, tree orig)
20240 : : {
20241 : 1681876 : if (!modules_p ())
20242 : : return;
20243 : :
20244 : 5796 : tree not_tmpl = STRIP_TEMPLATE (orig);
20245 : 11578 : if (DECL_LANG_SPECIFIC (not_tmpl) && DECL_MODULE_ATTACH_P (not_tmpl))
20246 : : {
20247 : 96 : tree inner = STRIP_TEMPLATE (decl);
20248 : 96 : retrofit_lang_decl (inner);
20249 : 96 : DECL_MODULE_ATTACH_P (inner) = true;
20250 : : }
20251 : :
20252 : 11578 : if (DECL_LANG_SPECIFIC (not_tmpl) && DECL_MODULE_IMPORT_P (not_tmpl))
20253 : : {
20254 : 119 : bool exists = imported_temploid_friends->put (decl, orig);
20255 : :
20256 : : /* We should only be called if lookup for an existing decl
20257 : : failed, in which case there shouldn't already be an entry
20258 : : in the map. */
20259 : 119 : gcc_assert (!exists);
20260 : : }
20261 : : }
20262 : :
20263 : : /* DECL is being freed, clear data we don't need anymore. */
20264 : :
20265 : : void
20266 : 53986 : remove_defining_module (tree decl)
20267 : : {
20268 : 53986 : if (!modules_p ())
20269 : : return;
20270 : :
20271 : 53986 : if (imported_temploid_friends)
20272 : 53986 : imported_temploid_friends->remove (decl);
20273 : : }
20274 : :
20275 : : /* Create the flat name string. It is simplest to have it handy. */
20276 : :
20277 : : void
20278 : 5038 : module_state::set_flatname ()
20279 : : {
20280 : 5038 : gcc_checking_assert (!flatname);
20281 : 5038 : if (parent)
20282 : : {
20283 : 541 : auto_vec<tree,5> ids;
20284 : 541 : size_t len = 0;
20285 : 541 : char const *primary = NULL;
20286 : 541 : size_t pfx_len = 0;
20287 : :
20288 : 541 : for (module_state *probe = this;
20289 : 1360 : probe;
20290 : 819 : probe = probe->parent)
20291 : 1214 : if (is_partition () && !probe->is_partition ())
20292 : : {
20293 : 395 : primary = probe->get_flatname ();
20294 : 395 : pfx_len = strlen (primary);
20295 : 395 : break;
20296 : : }
20297 : : else
20298 : : {
20299 : 819 : ids.safe_push (probe->name);
20300 : 819 : len += IDENTIFIER_LENGTH (probe->name) + 1;
20301 : : }
20302 : :
20303 : 541 : char *flat = XNEWVEC (char, pfx_len + len + is_partition ());
20304 : 541 : flatname = flat;
20305 : :
20306 : 541 : if (primary)
20307 : : {
20308 : 395 : memcpy (flat, primary, pfx_len);
20309 : 395 : flat += pfx_len;
20310 : 395 : *flat++ = ':';
20311 : : }
20312 : :
20313 : 1360 : for (unsigned len = 0; ids.length ();)
20314 : : {
20315 : 819 : if (len)
20316 : 278 : flat[len++] = '.';
20317 : 819 : tree elt = ids.pop ();
20318 : 819 : unsigned l = IDENTIFIER_LENGTH (elt);
20319 : 819 : memcpy (flat + len, IDENTIFIER_POINTER (elt), l + 1);
20320 : 819 : len += l;
20321 : : }
20322 : 541 : }
20323 : 4497 : else if (is_header ())
20324 : 1703 : flatname = TREE_STRING_POINTER (name);
20325 : : else
20326 : 2794 : flatname = IDENTIFIER_POINTER (name);
20327 : 5038 : }
20328 : :
20329 : : /* Read the CMI file for a module. */
20330 : :
20331 : : bool
20332 : 2377 : module_state::do_import (cpp_reader *reader, bool outermost)
20333 : : {
20334 : 2377 : gcc_assert (global_namespace == current_scope () && loadedness == ML_NONE);
20335 : :
20336 : 2377 : loc = linemap_module_loc (line_table, loc, get_flatname ());
20337 : :
20338 : 2377 : if (lazy_open >= lazy_limit)
20339 : 9 : freeze_an_elf ();
20340 : :
20341 : 2377 : int fd = -1;
20342 : 2377 : int e = ENOENT;
20343 : 2377 : if (filename)
20344 : : {
20345 : 2377 : const char *file = maybe_add_cmi_prefix (filename);
20346 : 2832 : dump () && dump ("CMI is %s", file);
20347 : 2377 : if (note_module_cmi_yes || inform_cmi_p)
20348 : 12 : inform (loc, "reading CMI %qs", file);
20349 : : /* Add the CMI file to the dependency tracking. */
20350 : 2377 : if (cpp_get_deps (reader))
20351 : 12 : deps_add_dep (cpp_get_deps (reader), file);
20352 : 2377 : fd = open (file, O_RDONLY | O_CLOEXEC | O_BINARY);
20353 : 2377 : e = errno;
20354 : : }
20355 : :
20356 : 2377 : gcc_checking_assert (!slurp);
20357 : 4736 : slurp = new slurping (new elf_in (fd, e));
20358 : :
20359 : 2377 : bool ok = true;
20360 : 2377 : if (!from ()->get_error ())
20361 : : {
20362 : 2359 : announce ("importing");
20363 : 2359 : loadedness = ML_CONFIG;
20364 : 2359 : lazy_open++;
20365 : 2359 : ok = read_initial (reader);
20366 : 2359 : slurp->lru = ++lazy_lru;
20367 : : }
20368 : :
20369 : 2377 : gcc_assert (slurp->current == ~0u);
20370 : :
20371 : 2377 : return check_read (outermost, ok);
20372 : : }
20373 : :
20374 : : /* Attempt to increase the file descriptor limit. */
20375 : :
20376 : : static bool
20377 : 3887 : try_increase_lazy (unsigned want)
20378 : : {
20379 : 3887 : gcc_checking_assert (lazy_open >= lazy_limit);
20380 : :
20381 : : /* If we're increasing, saturate at hard limit. */
20382 : 3887 : if (want > lazy_hard_limit && lazy_limit < lazy_hard_limit)
20383 : 3887 : want = lazy_hard_limit;
20384 : :
20385 : : #if HAVE_SETRLIMIT
20386 : 3887 : if ((!lazy_limit || !param_lazy_modules)
20387 : 3875 : && lazy_hard_limit
20388 : 3875 : && want <= lazy_hard_limit)
20389 : : {
20390 : 3875 : struct rlimit rlimit;
20391 : 3875 : rlimit.rlim_cur = want + LAZY_HEADROOM;
20392 : 3875 : rlimit.rlim_max = lazy_hard_limit + LAZY_HEADROOM;
20393 : 3875 : if (!setrlimit (RLIMIT_NOFILE, &rlimit))
20394 : 3875 : lazy_limit = want;
20395 : : }
20396 : : #endif
20397 : :
20398 : 3887 : return lazy_open < lazy_limit;
20399 : : }
20400 : :
20401 : : /* Pick a victim module to freeze its reader. */
20402 : :
20403 : : void
20404 : 12 : module_state::freeze_an_elf ()
20405 : : {
20406 : 12 : if (try_increase_lazy (lazy_open * 2))
20407 : : return;
20408 : :
20409 : 12 : module_state *victim = NULL;
20410 : 12 : for (unsigned ix = modules->length (); ix--;)
20411 : : {
20412 : 30 : module_state *candidate = (*modules)[ix];
20413 : 30 : if (candidate && candidate->slurp && candidate->slurp->lru
20414 : 60 : && candidate->from ()->is_freezable ()
20415 : 39 : && (!victim || victim->slurp->lru > candidate->slurp->lru))
20416 : : victim = candidate;
20417 : : }
20418 : :
20419 : 12 : if (victim)
20420 : : {
20421 : 18 : dump () && dump ("Freezing '%s'", victim->filename);
20422 : 9 : if (victim->slurp->macro_defs.size)
20423 : : /* Save the macro definitions to a buffer. */
20424 : 0 : victim->from ()->preserve (victim->slurp->macro_defs);
20425 : 9 : if (victim->slurp->macro_tbl.size)
20426 : : /* Save the macro definitions to a buffer. */
20427 : 0 : victim->from ()->preserve (victim->slurp->macro_tbl);
20428 : 9 : victim->from ()->freeze ();
20429 : 9 : lazy_open--;
20430 : : }
20431 : : else
20432 : 3 : dump () && dump ("No module available for freezing");
20433 : : }
20434 : :
20435 : : /* Load the lazy slot *MSLOT, INDEX'th slot of the module. */
20436 : :
20437 : : bool
20438 : 34488 : module_state::lazy_load (unsigned index, binding_slot *mslot)
20439 : : {
20440 : 34488 : unsigned n = dump.push (this);
20441 : :
20442 : 34488 : gcc_checking_assert (function_depth);
20443 : :
20444 : 34488 : unsigned cookie = mslot->get_lazy ();
20445 : 34488 : unsigned snum = cookie >> 2;
20446 : 34779 : dump () && dump ("Loading entity %M[%u] section:%u", this, index, snum);
20447 : :
20448 : 34488 : bool ok = load_section (snum, mslot);
20449 : :
20450 : 34488 : dump.pop (n);
20451 : :
20452 : 34488 : return ok;
20453 : : }
20454 : :
20455 : : /* Load MOD's binding for NS::ID into *MSLOT. *MSLOT contains the
20456 : : lazy cookie. OUTER is true if this is the outermost lazy, (used
20457 : : for diagnostics). */
20458 : :
20459 : : void
20460 : 2261 : lazy_load_binding (unsigned mod, tree ns, tree id, binding_slot *mslot)
20461 : : {
20462 : 2261 : int count = errorcount + warningcount;
20463 : :
20464 : 2261 : bool timer_running = timevar_cond_start (TV_MODULE_IMPORT);
20465 : :
20466 : : /* Make sure lazy loading from a template context behaves as if
20467 : : from a non-template context. */
20468 : 2261 : processing_template_decl_sentinel ptds;
20469 : :
20470 : : /* Stop GC happening, even in outermost loads (because our caller
20471 : : could well be building up a lookup set). */
20472 : 2261 : function_depth++;
20473 : :
20474 : 2261 : gcc_checking_assert (mod);
20475 : 2261 : module_state *module = (*modules)[mod];
20476 : 2261 : unsigned n = dump.push (module);
20477 : :
20478 : 2261 : unsigned snum = mslot->get_lazy ();
20479 : 2555 : dump () && dump ("Lazily binding %P@%N section:%u", ns, id,
20480 : : module->name, snum);
20481 : :
20482 : 2261 : bool ok = !recursive_lazy (snum);
20483 : 2261 : if (ok)
20484 : : {
20485 : 2261 : ok = module->load_section (snum, mslot);
20486 : 2261 : lazy_snum = 0;
20487 : 2261 : post_load_processing ();
20488 : : }
20489 : :
20490 : 2261 : dump.pop (n);
20491 : :
20492 : 2261 : function_depth--;
20493 : :
20494 : 2261 : timevar_cond_stop (TV_MODULE_IMPORT, timer_running);
20495 : :
20496 : 2261 : if (!ok)
20497 : 0 : fatal_error (input_location,
20498 : 0 : module->is_header ()
20499 : : ? G_("failed to load binding %<%E%s%E%>")
20500 : : : G_("failed to load binding %<%E%s%E@%s%>"),
20501 : 0 : ns, &"::"[ns == global_namespace ? 2 : 0], id,
20502 : : module->get_flatname ());
20503 : :
20504 : 2261 : if (count != errorcount + warningcount)
20505 : 21 : inform (input_location,
20506 : 21 : module->is_header ()
20507 : : ? G_("during load of binding %<%E%s%E%>")
20508 : : : G_("during load of binding %<%E%s%E@%s%>"),
20509 : 21 : ns, &"::"[ns == global_namespace ? 2 : 0], id,
20510 : : module->get_flatname ());
20511 : 2261 : }
20512 : :
20513 : : /* Load any pending entities keyed to the top-key of DECL. */
20514 : :
20515 : : void
20516 : 37981597 : lazy_load_pendings (tree decl)
20517 : : {
20518 : : /* Make sure lazy loading from a template context behaves as if
20519 : : from a non-template context. */
20520 : 37981597 : processing_template_decl_sentinel ptds;
20521 : :
20522 : 37981597 : tree key_decl;
20523 : 37981597 : pending_key key;
20524 : 37981597 : key.ns = find_pending_key (decl, &key_decl);
20525 : 37981597 : key.id = DECL_NAME (key_decl);
20526 : :
20527 : 37981597 : auto *pending_vec = pending_table ? pending_table->get (key) : nullptr;
20528 : 37981597 : if (!pending_vec)
20529 : 37975544 : return;
20530 : :
20531 : 6053 : int count = errorcount + warningcount;
20532 : :
20533 : 6053 : bool timer_running = timevar_cond_start (TV_MODULE_IMPORT);
20534 : 6053 : bool ok = !recursive_lazy ();
20535 : 6053 : if (ok)
20536 : : {
20537 : 6053 : function_depth++; /* Prevent GC */
20538 : 6053 : unsigned n = dump.push (NULL);
20539 : 6463 : dump () && dump ("Reading %u pending entities keyed to %P",
20540 : : pending_vec->length (), key.ns, key.id);
20541 : 6053 : for (unsigned ix = pending_vec->length (); ix--;)
20542 : : {
20543 : 74411 : unsigned index = (*pending_vec)[ix];
20544 : 74411 : binding_slot *slot = &(*entity_ary)[index];
20545 : :
20546 : 74411 : if (slot->is_lazy ())
20547 : : {
20548 : 3664 : module_state *import = import_entity_module (index);
20549 : 3664 : if (!import->lazy_load (index - import->entity_lwm, slot))
20550 : 74411 : ok = false;
20551 : : }
20552 : 70747 : else if (dump ())
20553 : : {
20554 : 301 : module_state *import = import_entity_module (index);
20555 : 80765 : dump () && dump ("Entity %M[%u] already loaded",
20556 : 301 : import, index - import->entity_lwm);
20557 : : }
20558 : : }
20559 : :
20560 : 6053 : pending_table->remove (key);
20561 : 6053 : dump.pop (n);
20562 : 6053 : lazy_snum = 0;
20563 : 6053 : post_load_processing ();
20564 : 6053 : function_depth--;
20565 : : }
20566 : :
20567 : 6053 : timevar_cond_stop (TV_MODULE_IMPORT, timer_running);
20568 : :
20569 : 6053 : if (!ok)
20570 : 0 : fatal_error (input_location, "failed to load pendings for %<%E%s%E%>",
20571 : 0 : key.ns, &"::"[key.ns == global_namespace ? 2 : 0], key.id);
20572 : :
20573 : 6053 : if (count != errorcount + warningcount)
20574 : 0 : inform (input_location, "during load of pendings for %<%E%s%E%>",
20575 : 0 : key.ns, &"::"[key.ns == global_namespace ? 2 : 0], key.id);
20576 : 37981597 : }
20577 : :
20578 : : static void
20579 : 2165 : direct_import (module_state *import, cpp_reader *reader)
20580 : : {
20581 : 2165 : timevar_start (TV_MODULE_IMPORT);
20582 : 2165 : unsigned n = dump.push (import);
20583 : :
20584 : 2165 : gcc_checking_assert (import->is_direct () && import->has_location ());
20585 : 2165 : if (import->loadedness == ML_NONE)
20586 : 1325 : if (!import->do_import (reader, true))
20587 : 0 : gcc_unreachable ();
20588 : :
20589 : 2137 : if (import->loadedness < ML_LANGUAGE)
20590 : : {
20591 : 2064 : if (!keyed_table)
20592 : 1818 : keyed_table = new keyed_map_t (EXPERIMENT (1, 400));
20593 : 2064 : import->read_language (true);
20594 : : }
20595 : :
20596 : 2137 : (*modules)[0]->set_import (import, import->exported_p);
20597 : :
20598 : 2137 : dump.pop (n);
20599 : 2137 : timevar_stop (TV_MODULE_IMPORT);
20600 : 2137 : }
20601 : :
20602 : : /* Import module IMPORT. */
20603 : :
20604 : : void
20605 : 1973 : import_module (module_state *import, location_t from_loc, bool exporting_p,
20606 : : tree, cpp_reader *reader)
20607 : : {
20608 : 1973 : if (!import->check_not_purview (from_loc))
20609 : : return;
20610 : :
20611 : 1964 : if (!import->is_header () && current_lang_depth ())
20612 : : /* Only header units should appear inside language
20613 : : specifications. The std doesn't specify this, but I think
20614 : : that's an error in resolving US 033, because language linkage
20615 : : is also our escape clause to getting things into the global
20616 : : module, so we don't want to confuse things by having to think
20617 : : about whether 'extern "C++" { import foo; }' puts foo's
20618 : : contents into the global module all of a sudden. */
20619 : 6 : warning (0, "import of named module %qs inside language-linkage block",
20620 : : import->get_flatname ());
20621 : :
20622 : 1964 : if (exporting_p || module_exporting_p ())
20623 : 256 : import->exported_p = true;
20624 : :
20625 : 1964 : if (import->loadedness != ML_NONE)
20626 : : {
20627 : 837 : from_loc = ordinary_loc_of (line_table, from_loc);
20628 : 837 : linemap_module_reparent (line_table, import->loc, from_loc);
20629 : : }
20630 : 1964 : gcc_checking_assert (!import->module_p);
20631 : 1964 : gcc_checking_assert (import->is_direct () && import->has_location ());
20632 : :
20633 : 1964 : direct_import (import, reader);
20634 : : }
20635 : :
20636 : : /* Declare the name of the current module to be NAME. EXPORTING_p is
20637 : : true if this TU is the exporting module unit. */
20638 : :
20639 : : void
20640 : 2492 : declare_module (module_state *module, location_t from_loc, bool exporting_p,
20641 : : tree, cpp_reader *reader)
20642 : : {
20643 : 2492 : gcc_assert (global_namespace == current_scope ());
20644 : :
20645 : 2492 : module_state *current = (*modules)[0];
20646 : 2492 : if (module_purview_p () || module->loadedness > ML_CONFIG)
20647 : : {
20648 : 6 : auto_diagnostic_group d;
20649 : 12 : error_at (from_loc, module_purview_p ()
20650 : : ? G_("module already declared")
20651 : : : G_("module already imported"));
20652 : 6 : if (module_purview_p ())
20653 : 0 : module = current;
20654 : 12 : inform (module->loc, module_purview_p ()
20655 : : ? G_("module %qs declared here")
20656 : : : G_("module %qs imported here"),
20657 : : module->get_flatname ());
20658 : 6 : return;
20659 : 6 : }
20660 : :
20661 : 2486 : gcc_checking_assert (module->module_p);
20662 : 2486 : gcc_checking_assert (module->is_direct () && module->has_location ());
20663 : :
20664 : : /* Yer a module, 'arry. */
20665 : 2486 : module_kind = module->is_header () ? MK_HEADER : MK_NAMED | MK_ATTACH;
20666 : :
20667 : : // Even in header units, we consider the decls to be purview
20668 : 2486 : module_kind |= MK_PURVIEW;
20669 : :
20670 : 2486 : if (module->is_partition ())
20671 : 154 : module_kind |= MK_PARTITION;
20672 : 2486 : if (exporting_p)
20673 : : {
20674 : 2244 : module->interface_p = true;
20675 : 2244 : module_kind |= MK_INTERFACE;
20676 : : }
20677 : :
20678 : 2486 : if (module_has_cmi_p ())
20679 : : {
20680 : : /* Copy the importing information we may have already done. We
20681 : : do not need to separate out the imports that only happen in
20682 : : the GMF, inspite of what the literal wording of the std
20683 : : might imply. See p2191, the core list had a discussion
20684 : : where the module implementors agreed that the GMF of a named
20685 : : module is invisible to importers. */
20686 : 2285 : module->imports = current->imports;
20687 : :
20688 : 2285 : module->mod = 0;
20689 : 2285 : (*modules)[0] = module;
20690 : : }
20691 : : else
20692 : : {
20693 : 201 : module->interface_p = true;
20694 : 201 : current->parent = module; /* So mangler knows module identity. */
20695 : 201 : direct_import (module, reader);
20696 : : }
20697 : : }
20698 : :
20699 : : /* Return true IFF we must emit a module global initializer function
20700 : : (which will be called by importers' init code). */
20701 : :
20702 : : bool
20703 : 97005 : module_global_init_needed ()
20704 : : {
20705 : 97005 : return module_has_cmi_p () && !header_module_p ();
20706 : : }
20707 : :
20708 : : /* Calculate which, if any, import initializers need calling. */
20709 : :
20710 : : bool
20711 : 90549 : module_determine_import_inits ()
20712 : : {
20713 : 90549 : if (!modules || header_module_p ())
20714 : : return false;
20715 : :
20716 : : /* Prune active_init_p. We need the same bitmap allocation
20717 : : scheme as for the imports member. */
20718 : 2937 : function_depth++; /* Disable GC. */
20719 : 2937 : bitmap covered_imports (BITMAP_GGC_ALLOC ());
20720 : :
20721 : 2937 : bool any = false;
20722 : :
20723 : : /* Because indirect imports are before their direct import, and
20724 : : we're scanning the array backwards, we only need one pass! */
20725 : 5151 : for (unsigned ix = modules->length (); --ix;)
20726 : : {
20727 : 2214 : module_state *import = (*modules)[ix];
20728 : :
20729 : 2214 : if (!import->active_init_p)
20730 : : ;
20731 : 37 : else if (bitmap_bit_p (covered_imports, ix))
20732 : 6 : import->active_init_p = false;
20733 : : else
20734 : : {
20735 : : /* Everything this imports is therefore handled by its
20736 : : initializer, so doesn't need initializing by us. */
20737 : 31 : bitmap_ior_into (covered_imports, import->imports);
20738 : 31 : any = true;
20739 : : }
20740 : : }
20741 : 2937 : function_depth--;
20742 : :
20743 : 2937 : return any;
20744 : : }
20745 : :
20746 : : /* Emit calls to each direct import's global initializer. Including
20747 : : direct imports of directly imported header units. The initializers
20748 : : of (static) entities in header units will be called by their
20749 : : importing modules (for the instance contained within that), or by
20750 : : the current TU (for the instances we've brought in). Of course
20751 : : such header unit behaviour is evil, but iostream went through that
20752 : : door some time ago. */
20753 : :
20754 : : void
20755 : 31 : module_add_import_initializers ()
20756 : : {
20757 : 31 : if (!modules || header_module_p ())
20758 : 0 : return;
20759 : :
20760 : 31 : tree fntype = build_function_type (void_type_node, void_list_node);
20761 : 31 : releasing_vec args; // There are no args
20762 : :
20763 : 71 : for (unsigned ix = modules->length (); --ix;)
20764 : : {
20765 : 40 : module_state *import = (*modules)[ix];
20766 : 40 : if (import->active_init_p)
20767 : : {
20768 : 31 : tree name = mangle_module_global_init (ix);
20769 : 31 : tree fndecl = build_lang_decl (FUNCTION_DECL, name, fntype);
20770 : :
20771 : 31 : DECL_CONTEXT (fndecl) = FROB_CONTEXT (global_namespace);
20772 : 31 : SET_DECL_ASSEMBLER_NAME (fndecl, name);
20773 : 31 : TREE_PUBLIC (fndecl) = true;
20774 : 31 : determine_visibility (fndecl);
20775 : :
20776 : 31 : tree call = cp_build_function_call_vec (fndecl, &args,
20777 : : tf_warning_or_error);
20778 : 31 : finish_expr_stmt (call);
20779 : : }
20780 : : }
20781 : 31 : }
20782 : :
20783 : : /* NAME & LEN are a preprocessed header name, possibly including the
20784 : : surrounding "" or <> characters. Return the raw string name of the
20785 : : module to which it refers. This will be an absolute path, or begin
20786 : : with ./, so it is immediately distinguishable from a (non-header
20787 : : unit) module name. If READER is non-null, ask the preprocessor to
20788 : : locate the header to which it refers using the appropriate include
20789 : : path. Note that we do never do \ processing of the string, as that
20790 : : matches the preprocessor's behaviour. */
20791 : :
20792 : : static const char *
20793 : 31963 : canonicalize_header_name (cpp_reader *reader, location_t loc, bool unquoted,
20794 : : const char *str, size_t &len_r)
20795 : : {
20796 : 31963 : size_t len = len_r;
20797 : 31963 : static char *buf = 0;
20798 : 31963 : static size_t alloc = 0;
20799 : :
20800 : 31963 : if (!unquoted)
20801 : : {
20802 : 4 : gcc_checking_assert (len >= 2
20803 : : && ((reader && str[0] == '<' && str[len-1] == '>')
20804 : : || (str[0] == '"' && str[len-1] == '"')));
20805 : 4 : str += 1;
20806 : 4 : len -= 2;
20807 : : }
20808 : :
20809 : 31963 : if (reader)
20810 : : {
20811 : 4 : gcc_assert (!unquoted);
20812 : :
20813 : 4 : if (len >= alloc)
20814 : : {
20815 : 4 : alloc = len + 1;
20816 : 4 : buf = XRESIZEVEC (char, buf, alloc);
20817 : : }
20818 : 4 : memcpy (buf, str, len);
20819 : 4 : buf[len] = 0;
20820 : :
20821 : 8 : if (const char *hdr
20822 : 4 : = cpp_probe_header_unit (reader, buf, str[-1] == '<', loc))
20823 : : {
20824 : 4 : len = strlen (hdr);
20825 : 4 : str = hdr;
20826 : : }
20827 : : else
20828 : 0 : str = buf;
20829 : : }
20830 : :
20831 : 31963 : if (!(str[0] == '.' ? IS_DIR_SEPARATOR (str[1]) : IS_ABSOLUTE_PATH (str)))
20832 : : {
20833 : : /* Prepend './' */
20834 : 9 : if (len + 3 > alloc)
20835 : : {
20836 : 9 : alloc = len + 3;
20837 : 9 : buf = XRESIZEVEC (char, buf, alloc);
20838 : : }
20839 : :
20840 : 9 : buf[0] = '.';
20841 : 9 : buf[1] = DIR_SEPARATOR;
20842 : 9 : memmove (buf + 2, str, len);
20843 : 9 : len += 2;
20844 : 9 : buf[len] = 0;
20845 : 9 : str = buf;
20846 : : }
20847 : :
20848 : 31963 : len_r = len;
20849 : 31963 : return str;
20850 : : }
20851 : :
20852 : : /* Set the CMI name from a cody packet. Issue an error if
20853 : : ill-formed. */
20854 : :
20855 : 4575 : void module_state::set_filename (const Cody::Packet &packet)
20856 : : {
20857 : 4575 : if (packet.GetCode () == Cody::Client::PC_PATHNAME)
20858 : : {
20859 : : /* If we've seen this import before we better have the same CMI. */
20860 : 4572 : const std::string &path = packet.GetString ();
20861 : 4572 : if (!filename)
20862 : 4569 : filename = xstrdup (packet.GetString ().c_str ());
20863 : 3 : else if (filename != path)
20864 : 0 : error_at (loc, "mismatching compiled module interface: "
20865 : : "had %qs, got %qs", filename, path.c_str ());
20866 : : }
20867 : : else
20868 : : {
20869 : 3 : gcc_checking_assert (packet.GetCode () == Cody::Client::PC_ERROR);
20870 : 3 : fatal_error (loc, "unknown compiled module interface: %s",
20871 : 3 : packet.GetString ().c_str ());
20872 : : }
20873 : 4572 : }
20874 : :
20875 : : /* Figure out whether to treat HEADER as an include or an import. */
20876 : :
20877 : : static char *
20878 : 31145 : maybe_translate_include (cpp_reader *reader, line_maps *lmaps, location_t loc,
20879 : : const char *path)
20880 : : {
20881 : 31145 : if (!modules_p ())
20882 : : {
20883 : : /* Turn off. */
20884 : 0 : cpp_get_callbacks (reader)->translate_include = NULL;
20885 : 0 : return nullptr;
20886 : : }
20887 : :
20888 : 31145 : dump.push (NULL);
20889 : :
20890 : 32503 : dump () && dump ("Checking include translation '%s'", path);
20891 : 31145 : auto *mapper = get_mapper (cpp_main_loc (reader), cpp_get_deps (reader));
20892 : :
20893 : 31145 : size_t len = strlen (path);
20894 : 31145 : path = canonicalize_header_name (NULL, loc, true, path, len);
20895 : 31145 : auto packet = mapper->IncludeTranslate (path, Cody::Flags::None, len);
20896 : :
20897 : 31145 : enum class xlate_kind {
20898 : : unknown, text, import,
20899 : 31145 : } translate = xlate_kind::unknown;
20900 : :
20901 : 31145 : if (packet.GetCode () == Cody::Client::PC_BOOL)
20902 : 31101 : translate = packet.GetInteger () ? xlate_kind::text : xlate_kind::unknown;
20903 : 44 : else if (packet.GetCode () == Cody::Client::PC_PATHNAME)
20904 : : {
20905 : : /* Record the CMI name for when we do the import.
20906 : : We may already know about this import, but libcpp doesn't yet. */
20907 : 44 : module_state *import = get_module (build_string (len, path));
20908 : 44 : import->set_filename (packet);
20909 : 44 : translate = xlate_kind::import;
20910 : : }
20911 : : else
20912 : : {
20913 : 0 : gcc_checking_assert (packet.GetCode () == Cody::Client::PC_ERROR);
20914 : 0 : error_at (loc, "cannot determine %<#include%> translation of %s: %s",
20915 : 0 : path, packet.GetString ().c_str ());
20916 : : }
20917 : :
20918 : 31145 : bool note = false;
20919 : 31145 : if (note_include_translate_yes && translate == xlate_kind::import)
20920 : : note = true;
20921 : 31142 : else if (note_include_translate_no && translate == xlate_kind::unknown)
20922 : : note = true;
20923 : 31136 : else if (note_includes)
20924 : : /* We do not expect the note_includes vector to be large, so O(N)
20925 : : iteration. */
20926 : 384 : for (unsigned ix = note_includes->length (); !note && ix--;)
20927 : 192 : if (!strcmp ((*note_includes)[ix], path))
20928 : 1 : note = true;
20929 : :
20930 : 192 : if (note)
20931 : 16 : inform (loc, translate == xlate_kind::import
20932 : : ? G_("include %qs translated to import")
20933 : : : G_("include %qs processed textually"), path);
20934 : :
20935 : 33858 : dump () && dump (translate == xlate_kind::import
20936 : : ? "Translating include to import"
20937 : : : "Keeping include as include");
20938 : 31145 : dump.pop (0);
20939 : :
20940 : 31145 : if (translate != xlate_kind::import)
20941 : : return nullptr;
20942 : :
20943 : : /* Create the translation text. */
20944 : 44 : loc = ordinary_loc_of (lmaps, loc);
20945 : 44 : const line_map_ordinary *map
20946 : 44 : = linemap_check_ordinary (linemap_lookup (lmaps, loc));
20947 : 44 : unsigned col = SOURCE_COLUMN (map, loc);
20948 : 44 : col -= (col != 0); /* Columns are 1-based. */
20949 : :
20950 : 44 : unsigned alloc = len + col + 60;
20951 : 44 : char *res = XNEWVEC (char, alloc);
20952 : :
20953 : 44 : strcpy (res, "__import");
20954 : 44 : unsigned actual = 8;
20955 : 44 : if (col > actual)
20956 : : {
20957 : : /* Pad out so the filename appears at the same position. */
20958 : 41 : memset (res + actual, ' ', col - actual);
20959 : 41 : actual = col;
20960 : : }
20961 : : /* No need to encode characters, that's not how header names are
20962 : : handled. */
20963 : 44 : actual += snprintf (res + actual, alloc - actual,
20964 : : "\"%s\" [[__translated]];\n", path);
20965 : 44 : gcc_checking_assert (actual < alloc);
20966 : :
20967 : : /* cpplib will delete the buffer. */
20968 : : return res;
20969 : 31145 : }
20970 : :
20971 : : static void
20972 : 814 : begin_header_unit (cpp_reader *reader)
20973 : : {
20974 : : /* Set the module header name from the main_input_filename. */
20975 : 814 : const char *main = main_input_filename;
20976 : 814 : size_t len = strlen (main);
20977 : 814 : main = canonicalize_header_name (NULL, 0, true, main, len);
20978 : 814 : module_state *module = get_module (build_string (len, main));
20979 : :
20980 : 814 : preprocess_module (module, cpp_main_loc (reader), false, false, true, reader);
20981 : 814 : }
20982 : :
20983 : : /* We've just properly entered the main source file. I.e. after the
20984 : : command line, builtins and forced headers. Record the line map and
20985 : : location of this map. Note we may be called more than once. The
20986 : : first call sticks. */
20987 : :
20988 : : void
20989 : 92300 : module_begin_main_file (cpp_reader *reader, line_maps *lmaps,
20990 : : const line_map_ordinary *map)
20991 : : {
20992 : 92300 : gcc_checking_assert (lmaps == line_table);
20993 : 92300 : if (modules_p () && !spans.init_p ())
20994 : : {
20995 : 3875 : unsigned n = dump.push (NULL);
20996 : 3875 : spans.init (lmaps, map);
20997 : 3875 : dump.pop (n);
20998 : 3875 : if (flag_header_unit && !cpp_get_options (reader)->preprocessed)
20999 : : {
21000 : : /* Tell the preprocessor this is an include file. */
21001 : 805 : cpp_retrofit_as_include (reader);
21002 : 805 : begin_header_unit (reader);
21003 : : }
21004 : : }
21005 : 92300 : }
21006 : :
21007 : : /* Process the pending_import queue, making sure we know the
21008 : : filenames. */
21009 : :
21010 : : static void
21011 : 4687 : name_pending_imports (cpp_reader *reader)
21012 : : {
21013 : 4687 : auto *mapper = get_mapper (cpp_main_loc (reader), cpp_get_deps (reader));
21014 : :
21015 : 4687 : if (!vec_safe_length (pending_imports))
21016 : : /* Not doing anything. */
21017 : : return;
21018 : :
21019 : 3965 : timevar_start (TV_MODULE_MAPPER);
21020 : :
21021 : 3965 : auto n = dump.push (NULL);
21022 : 4499 : dump () && dump ("Resolving direct import names");
21023 : 3965 : bool want_deps = (bool (mapper->get_flags () & Cody::Flags::NameOnly)
21024 : 3965 : || cpp_get_deps (reader));
21025 : 3965 : bool any = false;
21026 : :
21027 : 8660 : for (unsigned ix = 0; ix != pending_imports->length (); ix++)
21028 : : {
21029 : 4695 : module_state *module = (*pending_imports)[ix];
21030 : 4695 : gcc_checking_assert (module->is_direct ());
21031 : 4695 : if (!module->filename && !module->visited_p)
21032 : : {
21033 : 4597 : bool export_p = (module->module_p
21034 : 4597 : && (module->is_partition () || module->exported_p));
21035 : :
21036 : 4597 : Cody::Flags flags = Cody::Flags::None;
21037 : 4597 : if (flag_preprocess_only
21038 : 4597 : && !(module->is_header () && !export_p))
21039 : : {
21040 : 129 : if (!want_deps)
21041 : 66 : continue;
21042 : : flags = Cody::Flags::NameOnly;
21043 : : }
21044 : :
21045 : 4531 : if (!any)
21046 : : {
21047 : 3898 : any = true;
21048 : 3898 : mapper->Cork ();
21049 : : }
21050 : 4531 : if (export_p)
21051 : 2330 : mapper->ModuleExport (module->get_flatname (), flags);
21052 : : else
21053 : 2201 : mapper->ModuleImport (module->get_flatname (), flags);
21054 : 4531 : module->visited_p = true;
21055 : : }
21056 : : }
21057 : :
21058 : 3965 : if (any)
21059 : : {
21060 : 3898 : auto response = mapper->Uncork ();
21061 : 3898 : auto r_iter = response.begin ();
21062 : 8511 : for (unsigned ix = 0; ix != pending_imports->length (); ix++)
21063 : : {
21064 : 4616 : module_state *module = (*pending_imports)[ix];
21065 : 4616 : if (module->visited_p)
21066 : : {
21067 : 4531 : module->visited_p = false;
21068 : 4531 : gcc_checking_assert (!module->filename);
21069 : :
21070 : 4531 : module->set_filename (*r_iter);
21071 : 4528 : ++r_iter;
21072 : : }
21073 : : }
21074 : 3895 : }
21075 : :
21076 : 3962 : dump.pop (n);
21077 : :
21078 : 3962 : timevar_stop (TV_MODULE_MAPPER);
21079 : : }
21080 : :
21081 : : /* We've just lexed a module-specific control line for MODULE. Mark
21082 : : the module as a direct import, and possibly load up its macro
21083 : : state. Returns the primary module, if this is a module
21084 : : declaration. */
21085 : : /* Perhaps we should offer a preprocessing mode where we read the
21086 : : directives from the header unit, rather than require the header's
21087 : : CMI. */
21088 : :
21089 : : module_state *
21090 : 4714 : preprocess_module (module_state *module, location_t from_loc,
21091 : : bool in_purview, bool is_import, bool is_export,
21092 : : cpp_reader *reader)
21093 : : {
21094 : 4714 : if (!is_import)
21095 : : {
21096 : 2630 : if (module->loc)
21097 : : /* It's already been mentioned, so ignore its module-ness. */
21098 : : is_import = true;
21099 : : else
21100 : : {
21101 : : /* Record it is the module. */
21102 : 2609 : module->module_p = true;
21103 : 2609 : if (is_export)
21104 : : {
21105 : 2334 : module->exported_p = true;
21106 : 2334 : module->interface_p = true;
21107 : : }
21108 : : }
21109 : : }
21110 : :
21111 : 4714 : if (module->directness < MD_DIRECT + in_purview)
21112 : : {
21113 : : /* Mark as a direct import. */
21114 : 4671 : module->directness = module_directness (MD_DIRECT + in_purview);
21115 : :
21116 : : /* Set the location to be most informative for users. */
21117 : 4671 : from_loc = ordinary_loc_of (line_table, from_loc);
21118 : 4671 : if (module->loadedness != ML_NONE)
21119 : 6 : linemap_module_reparent (line_table, module->loc, from_loc);
21120 : : else
21121 : : {
21122 : 4665 : module->loc = from_loc;
21123 : 4665 : if (!module->flatname)
21124 : 4638 : module->set_flatname ();
21125 : : }
21126 : : }
21127 : :
21128 : 4714 : auto desired = ML_CONFIG;
21129 : 4714 : if (is_import
21130 : 2105 : && module->is_header ()
21131 : 5539 : && (!cpp_get_options (reader)->preprocessed
21132 : 3 : || cpp_get_options (reader)->directives_only))
21133 : : /* We need preprocessor state now. */
21134 : : desired = ML_PREPROCESSOR;
21135 : :
21136 : 4714 : if (!is_import || module->loadedness < desired)
21137 : : {
21138 : 4695 : vec_safe_push (pending_imports, module);
21139 : :
21140 : 4695 : if (desired == ML_PREPROCESSOR)
21141 : : {
21142 : 806 : unsigned n = dump.push (NULL);
21143 : :
21144 : 1003 : dump () && dump ("Reading %M preprocessor state", module);
21145 : 806 : name_pending_imports (reader);
21146 : :
21147 : : /* Preserve the state of the line-map. */
21148 : 806 : auto pre_hwm = LINEMAPS_ORDINARY_USED (line_table);
21149 : :
21150 : : /* We only need to close the span, if we're going to emit a
21151 : : CMI. But that's a little tricky -- our token scanner
21152 : : needs to be smarter -- and this isn't much state.
21153 : : Remember, we've not parsed anything at this point, so
21154 : : our module state flags are inadequate. */
21155 : 806 : spans.maybe_init ();
21156 : 806 : spans.close ();
21157 : :
21158 : 806 : timevar_start (TV_MODULE_IMPORT);
21159 : :
21160 : : /* Load the config of each pending import -- we must assign
21161 : : module numbers monotonically. */
21162 : 1788 : for (unsigned ix = 0; ix != pending_imports->length (); ix++)
21163 : : {
21164 : 982 : auto *import = (*pending_imports)[ix];
21165 : 1149 : if (!(import->module_p
21166 : 167 : && (import->is_partition () || import->exported_p))
21167 : 821 : && import->loadedness == ML_NONE
21168 : 1803 : && (import->is_header () || !flag_preprocess_only))
21169 : : {
21170 : 812 : unsigned n = dump.push (import);
21171 : 812 : import->do_import (reader, true);
21172 : 812 : dump.pop (n);
21173 : : }
21174 : : }
21175 : 806 : vec_free (pending_imports);
21176 : :
21177 : : /* Restore the line-map state. */
21178 : 806 : spans.open (linemap_module_restore (line_table, pre_hwm));
21179 : :
21180 : : /* Now read the preprocessor state of this particular
21181 : : import. */
21182 : 806 : if (module->loadedness == ML_CONFIG
21183 : 806 : && module->read_preprocessor (true))
21184 : 803 : module->import_macros ();
21185 : :
21186 : 806 : timevar_stop (TV_MODULE_IMPORT);
21187 : :
21188 : 806 : dump.pop (n);
21189 : : }
21190 : : }
21191 : :
21192 : 4714 : return is_import ? NULL : get_primary (module);
21193 : : }
21194 : :
21195 : : /* We've completed phase-4 translation. Emit any dependency
21196 : : information for the not-yet-loaded direct imports, and fill in
21197 : : their file names. We'll have already loaded up the direct header
21198 : : unit wavefront. */
21199 : :
21200 : : void
21201 : 3881 : preprocessed_module (cpp_reader *reader)
21202 : : {
21203 : 3881 : unsigned n = dump.push (NULL);
21204 : :
21205 : 4379 : dump () && dump ("Completed phase-4 (tokenization) processing");
21206 : :
21207 : 3881 : name_pending_imports (reader);
21208 : 3878 : vec_free (pending_imports);
21209 : :
21210 : 3878 : spans.maybe_init ();
21211 : 3878 : spans.close ();
21212 : :
21213 : 3878 : using iterator = hash_table<module_state_hash>::iterator;
21214 : 3878 : if (mkdeps *deps = cpp_get_deps (reader))
21215 : : {
21216 : : /* Walk the module hash, informing the dependency machinery. */
21217 : 51 : iterator end = modules_hash->end ();
21218 : 294 : for (iterator iter = modules_hash->begin (); iter != end; ++iter)
21219 : : {
21220 : 96 : module_state *module = *iter;
21221 : :
21222 : 96 : if (module->is_direct ())
21223 : : {
21224 : 81 : if (module->is_module ()
21225 : 81 : && (module->is_interface () || module->is_partition ()))
21226 : 33 : deps_add_module_target (deps, module->get_flatname (),
21227 : 33 : maybe_add_cmi_prefix (module->filename),
21228 : 33 : module->is_header (),
21229 : 33 : module->is_exported ());
21230 : : else
21231 : 48 : deps_add_module_dep (deps, module->get_flatname ());
21232 : : }
21233 : : }
21234 : : }
21235 : :
21236 : 3878 : if (flag_header_unit && !flag_preprocess_only)
21237 : : {
21238 : : /* Find the main module -- remember, it's not yet in the module
21239 : : array. */
21240 : 802 : iterator end = modules_hash->end ();
21241 : 1706 : for (iterator iter = modules_hash->begin (); iter != end; ++iter)
21242 : : {
21243 : 853 : module_state *module = *iter;
21244 : 853 : if (module->is_module ())
21245 : : {
21246 : 802 : declare_module (module, cpp_main_loc (reader), true, NULL, reader);
21247 : 802 : module_kind |= MK_EXPORTING;
21248 : 802 : break;
21249 : : }
21250 : : }
21251 : : }
21252 : :
21253 : 3878 : dump.pop (n);
21254 : 3878 : }
21255 : :
21256 : : /* VAL is a global tree, add it to the global vec if it is
21257 : : interesting. Add some of its targets, if they too are
21258 : : interesting. We do not add identifiers, as they can be re-found
21259 : : via the identifier hash table. There is a cost to the number of
21260 : : global trees. */
21261 : :
21262 : : static int
21263 : 2401070 : maybe_add_global (tree val, unsigned &crc)
21264 : : {
21265 : 2401070 : int v = 0;
21266 : :
21267 : 2401070 : if (val && !(identifier_p (val) || TREE_VISITED (val)))
21268 : : {
21269 : 740002 : TREE_VISITED (val) = true;
21270 : 740002 : crc = crc32_unsigned (crc, fixed_trees->length ());
21271 : 740002 : vec_safe_push (fixed_trees, val);
21272 : 740002 : v++;
21273 : :
21274 : 740002 : if (CODE_CONTAINS_STRUCT (TREE_CODE (val), TS_TYPED))
21275 : 740002 : v += maybe_add_global (TREE_TYPE (val), crc);
21276 : 740002 : if (CODE_CONTAINS_STRUCT (TREE_CODE (val), TS_TYPE_COMMON))
21277 : 485125 : v += maybe_add_global (TYPE_NAME (val), crc);
21278 : : }
21279 : :
21280 : 2401070 : return v;
21281 : : }
21282 : :
21283 : : /* Initialize module state. Create the hash table, determine the
21284 : : global trees. Create the module for current TU. */
21285 : :
21286 : : void
21287 : 3881 : init_modules (cpp_reader *reader)
21288 : : {
21289 : : /* PCH should not be reachable because of lang-specs, but the
21290 : : user could have overriden that. */
21291 : 3881 : if (pch_file)
21292 : 0 : fatal_error (input_location,
21293 : : "C++ modules are incompatible with precompiled headers");
21294 : :
21295 : 3881 : if (cpp_get_options (reader)->traditional)
21296 : 0 : fatal_error (input_location,
21297 : : "C++ modules are incompatible with traditional preprocessing");
21298 : :
21299 : : /* :: is always exported. */
21300 : 3881 : DECL_MODULE_EXPORT_P (global_namespace) = true;
21301 : :
21302 : 3881 : modules_hash = hash_table<module_state_hash>::create_ggc (31);
21303 : 3881 : vec_safe_reserve (modules, 20);
21304 : :
21305 : : /* Create module for current TU. */
21306 : 3881 : module_state *current
21307 : 3881 : = new (ggc_alloc<module_state> ()) module_state (NULL_TREE, NULL, false);
21308 : 3881 : current->mod = 0;
21309 : 3881 : bitmap_set_bit (current->imports, 0);
21310 : 3881 : modules->quick_push (current);
21311 : :
21312 : 3881 : gcc_checking_assert (!fixed_trees);
21313 : :
21314 : 3881 : headers = BITMAP_GGC_ALLOC ();
21315 : :
21316 : 3881 : if (note_includes)
21317 : : /* Canonicalize header names. */
21318 : 2 : for (unsigned ix = 0; ix != note_includes->length (); ix++)
21319 : : {
21320 : 1 : const char *hdr = (*note_includes)[ix];
21321 : 1 : size_t len = strlen (hdr);
21322 : :
21323 : 1 : bool system = hdr[0] == '<';
21324 : 1 : bool user = hdr[0] == '"';
21325 : 1 : bool delimed = system || user;
21326 : :
21327 : 1 : if (len <= (delimed ? 2 : 0)
21328 : 1 : || (delimed && hdr[len-1] != (system ? '>' : '"')))
21329 : 0 : error ("invalid header name %qs", hdr);
21330 : :
21331 : 1 : hdr = canonicalize_header_name (delimed ? reader : NULL,
21332 : : 0, !delimed, hdr, len);
21333 : 1 : char *path = XNEWVEC (char, len + 1);
21334 : 1 : memcpy (path, hdr, len);
21335 : 1 : path[len] = 0;
21336 : :
21337 : 1 : (*note_includes)[ix] = path;
21338 : : }
21339 : :
21340 : 3881 : if (note_cmis)
21341 : : /* Canonicalize & mark module names. */
21342 : 12 : for (unsigned ix = 0; ix != note_cmis->length (); ix++)
21343 : : {
21344 : 6 : const char *name = (*note_cmis)[ix];
21345 : 6 : size_t len = strlen (name);
21346 : :
21347 : 6 : bool is_system = name[0] == '<';
21348 : 6 : bool is_user = name[0] == '"';
21349 : 6 : bool is_pathname = false;
21350 : 6 : if (!(is_system || is_user))
21351 : 12 : for (unsigned ix = len; !is_pathname && ix--;)
21352 : 9 : is_pathname = IS_DIR_SEPARATOR (name[ix]);
21353 : 6 : if (is_system || is_user || is_pathname)
21354 : : {
21355 : 3 : if (len <= (is_pathname ? 0 : 2)
21356 : 3 : || (!is_pathname && name[len-1] != (is_system ? '>' : '"')))
21357 : : {
21358 : 0 : error ("invalid header name %qs", name);
21359 : 0 : continue;
21360 : : }
21361 : : else
21362 : 3 : name = canonicalize_header_name (is_pathname ? nullptr : reader,
21363 : : 0, is_pathname, name, len);
21364 : : }
21365 : 6 : if (auto module = get_module (name))
21366 : 6 : module->inform_cmi_p = 1;
21367 : : else
21368 : 0 : error ("invalid module name %qs", name);
21369 : : }
21370 : :
21371 : 3881 : dump.push (NULL);
21372 : :
21373 : : /* Determine lazy handle bound. */
21374 : 3881 : {
21375 : 3881 : unsigned limit = 1000;
21376 : : #if HAVE_GETRLIMIT
21377 : 3881 : struct rlimit rlimit;
21378 : 3881 : if (!getrlimit (RLIMIT_NOFILE, &rlimit))
21379 : : {
21380 : 3881 : lazy_hard_limit = (rlimit.rlim_max < 1000000
21381 : 3881 : ? unsigned (rlimit.rlim_max) : 1000000);
21382 : 3881 : lazy_hard_limit = (lazy_hard_limit > LAZY_HEADROOM
21383 : 3881 : ? lazy_hard_limit - LAZY_HEADROOM : 0);
21384 : 3881 : if (rlimit.rlim_cur < limit)
21385 : 0 : limit = unsigned (rlimit.rlim_cur);
21386 : : }
21387 : : #endif
21388 : 3881 : limit = limit > LAZY_HEADROOM ? limit - LAZY_HEADROOM : 1;
21389 : :
21390 : 3881 : if (unsigned parm = param_lazy_modules)
21391 : : {
21392 : 3881 : if (parm <= limit || !lazy_hard_limit || !try_increase_lazy (parm))
21393 : 6 : lazy_limit = parm;
21394 : : }
21395 : : else
21396 : 0 : lazy_limit = limit;
21397 : : }
21398 : :
21399 : 3881 : if (dump ())
21400 : : {
21401 : 498 : verstr_t ver;
21402 : 498 : version2string (MODULE_VERSION, ver);
21403 : 498 : dump ("Source: %s", main_input_filename);
21404 : 498 : dump ("Compiler: %s", version_string);
21405 : 498 : dump ("Modules: %s", ver);
21406 : 498 : dump ("Checking: %s",
21407 : : #if CHECKING_P
21408 : : "checking"
21409 : : #elif ENABLE_ASSERT_CHECKING
21410 : : "asserting"
21411 : : #else
21412 : : "release"
21413 : : #endif
21414 : : );
21415 : 498 : dump ("Compiled by: "
21416 : : #ifdef __GNUC__
21417 : : "GCC %d.%d, %s", __GNUC__, __GNUC_MINOR__,
21418 : : #ifdef __OPTIMIZE__
21419 : : "optimizing"
21420 : : #else
21421 : : "not optimizing"
21422 : : #endif
21423 : : #else
21424 : : "not GCC"
21425 : : #endif
21426 : : );
21427 : 498 : dump ("Reading: %s", MAPPED_READING ? "mmap" : "fileio");
21428 : 498 : dump ("Writing: %s", MAPPED_WRITING ? "mmap" : "fileio");
21429 : 498 : dump ("Lazy limit: %u", lazy_limit);
21430 : 498 : dump ("Lazy hard limit: %u", lazy_hard_limit);
21431 : 498 : dump ("");
21432 : : }
21433 : :
21434 : : /* Construct the global tree array. This is an array of unique
21435 : : global trees (& types). Do this now, rather than lazily, as
21436 : : some global trees are lazily created and we don't want that to
21437 : : mess with our syndrome of fixed trees. */
21438 : 3881 : unsigned crc = 0;
21439 : 3881 : vec_alloc (fixed_trees, 250);
21440 : :
21441 : 4379 : dump () && dump ("+Creating globals");
21442 : : /* Insert the TRANSLATION_UNIT_DECL. */
21443 : 3881 : TREE_VISITED (DECL_CONTEXT (global_namespace)) = true;
21444 : 3881 : fixed_trees->quick_push (DECL_CONTEXT (global_namespace));
21445 : 23286 : for (unsigned jx = 0; global_tree_arys[jx].first; jx++)
21446 : : {
21447 : 19405 : const tree *ptr = global_tree_arys[jx].first;
21448 : 19405 : unsigned limit = global_tree_arys[jx].second;
21449 : :
21450 : 1183705 : for (unsigned ix = 0; ix != limit; ix++, ptr++)
21451 : : {
21452 : 1164300 : !(ix & 31) && dump ("") && dump ("+\t%u:%u:", jx, ix);
21453 : 1164300 : unsigned v = maybe_add_global (*ptr, crc);
21454 : 1313700 : dump () && dump ("+%u", v);
21455 : : }
21456 : : }
21457 : : /* OS- and machine-specific types are dynamically registered at
21458 : : runtime, so cannot be part of global_tree_arys. */
21459 : 3881 : registered_builtin_types && dump ("") && dump ("+\tB:");
21460 : 15524 : for (tree t = registered_builtin_types; t; t = TREE_CHAIN (t))
21461 : : {
21462 : 11643 : unsigned v = maybe_add_global (TREE_VALUE (t), crc);
21463 : 13137 : dump () && dump ("+%u", v);
21464 : : }
21465 : 3881 : global_crc = crc32_unsigned (crc, fixed_trees->length ());
21466 : 3881 : dump ("") && dump ("Created %u unique globals, crc=%x",
21467 : : fixed_trees->length (), global_crc);
21468 : 747764 : for (unsigned ix = fixed_trees->length (); ix--;)
21469 : 743883 : TREE_VISITED ((*fixed_trees)[ix]) = false;
21470 : :
21471 : 3881 : dump.pop (0);
21472 : :
21473 : 3881 : if (!flag_module_lazy)
21474 : : /* Get the mapper now, if we're not being lazy. */
21475 : 272 : get_mapper (cpp_main_loc (reader), cpp_get_deps (reader));
21476 : :
21477 : 3881 : if (!flag_preprocess_only)
21478 : : {
21479 : 3770 : pending_table = new pending_map_t (EXPERIMENT (1, 400));
21480 : 3770 : entity_map = new entity_map_t (EXPERIMENT (1, 400));
21481 : 3770 : vec_safe_reserve (entity_ary, EXPERIMENT (1, 400));
21482 : 3770 : imported_temploid_friends
21483 : 3770 : = decl_tree_cache_map::create_ggc (EXPERIMENT (1, 400));
21484 : : }
21485 : :
21486 : : #if CHECKING_P
21487 : 3881 : note_defs = note_defs_table_t::create_ggc (1000);
21488 : : #endif
21489 : :
21490 : 3881 : if (flag_header_unit && cpp_get_options (reader)->preprocessed)
21491 : 9 : begin_header_unit (reader);
21492 : :
21493 : : /* Collect here to make sure things are tagged correctly (when
21494 : : aggressively GC'd). */
21495 : 3881 : ggc_collect ();
21496 : 3881 : }
21497 : :
21498 : : /* If NODE is a deferred macro, load it. */
21499 : :
21500 : : static int
21501 : 79684 : load_macros (cpp_reader *reader, cpp_hashnode *node, void *)
21502 : : {
21503 : 79684 : location_t main_loc
21504 : 79684 : = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0));
21505 : :
21506 : 79684 : if (cpp_user_macro_p (node)
21507 : 79684 : && !node->value.macro)
21508 : : {
21509 : 72 : cpp_macro *macro = cpp_get_deferred_macro (reader, node, main_loc);
21510 : 72 : dump () && dump ("Loaded macro #%s %I",
21511 : : macro ? "define" : "undef", identifier (node));
21512 : : }
21513 : :
21514 : 79684 : return 1;
21515 : : }
21516 : :
21517 : : /* At the end of tokenizing, we no longer need the macro tables of
21518 : : imports. But the user might have requested some checking. */
21519 : :
21520 : : void
21521 : 90743 : maybe_check_all_macros (cpp_reader *reader)
21522 : : {
21523 : 90743 : if (!warn_imported_macros)
21524 : : return;
21525 : :
21526 : : /* Force loading of any remaining deferred macros. This will
21527 : : produce diagnostics if they are ill-formed. */
21528 : 21 : unsigned n = dump.push (NULL);
21529 : 21 : cpp_forall_identifiers (reader, load_macros, NULL);
21530 : 21 : dump.pop (n);
21531 : : }
21532 : :
21533 : : // State propagated from finish_module_processing to fini_modules
21534 : :
21535 : : struct module_processing_cookie
21536 : : {
21537 : : elf_out out;
21538 : : module_state_config config;
21539 : : char *cmi_name;
21540 : : char *tmp_name;
21541 : : unsigned crc;
21542 : : bool began;
21543 : :
21544 : 2279 : module_processing_cookie (char *cmi, char *tmp, int fd, int e)
21545 : 2279 : : out (fd, e), cmi_name (cmi), tmp_name (tmp), crc (0), began (false)
21546 : : {
21547 : : }
21548 : 2279 : ~module_processing_cookie ()
21549 : : {
21550 : 2279 : XDELETEVEC (tmp_name);
21551 : 2279 : XDELETEVEC (cmi_name);
21552 : 2279 : }
21553 : : };
21554 : :
21555 : : /* Write the CMI, if we're a module interface. */
21556 : :
21557 : : void *
21558 : 90549 : finish_module_processing (cpp_reader *reader)
21559 : : {
21560 : 90549 : module_processing_cookie *cookie = nullptr;
21561 : :
21562 : 90549 : if (header_module_p ())
21563 : 802 : module_kind &= ~MK_EXPORTING;
21564 : :
21565 : 90549 : if (!modules || !(*modules)[0]->name)
21566 : : {
21567 : 88267 : if (flag_module_only)
21568 : 6 : warning (0, "%<-fmodule-only%> used for non-interface");
21569 : : }
21570 : 2282 : else if (!flag_syntax_only)
21571 : : {
21572 : 2279 : int fd = -1;
21573 : 2279 : int e = -1;
21574 : :
21575 : 2279 : timevar_start (TV_MODULE_EXPORT);
21576 : :
21577 : : /* Force a valid but empty line map at the end. This simplifies
21578 : : the line table preparation and writing logic. */
21579 : 2279 : linemap_add (line_table, LC_ENTER, false, "", 0);
21580 : :
21581 : : /* We write to a tmpname, and then atomically rename. */
21582 : 2279 : char *cmi_name = NULL;
21583 : 2279 : char *tmp_name = NULL;
21584 : 2279 : module_state *state = (*modules)[0];
21585 : :
21586 : 2279 : unsigned n = dump.push (state);
21587 : 2279 : state->announce ("creating");
21588 : 2279 : if (state->filename)
21589 : : {
21590 : 2279 : size_t len = 0;
21591 : 2279 : cmi_name = xstrdup (maybe_add_cmi_prefix (state->filename, &len));
21592 : 2279 : tmp_name = XNEWVEC (char, len + 3);
21593 : 2279 : memcpy (tmp_name, cmi_name, len);
21594 : 2279 : strcpy (&tmp_name[len], "~");
21595 : :
21596 : 2279 : if (!errorcount)
21597 : 40 : for (unsigned again = 2; ; again--)
21598 : : {
21599 : 2216 : fd = open (tmp_name,
21600 : : O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY,
21601 : : S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
21602 : 2216 : e = errno;
21603 : 2216 : if (fd >= 0 || !again || e != ENOENT)
21604 : : break;
21605 : 40 : create_dirs (tmp_name);
21606 : : }
21607 : 2279 : if (note_module_cmi_yes || state->inform_cmi_p)
21608 : 3 : inform (state->loc, "writing CMI %qs", cmi_name);
21609 : 2520 : dump () && dump ("CMI is %s", cmi_name);
21610 : : }
21611 : :
21612 : 2279 : cookie = new module_processing_cookie (cmi_name, tmp_name, fd, e);
21613 : :
21614 : 2279 : if (errorcount)
21615 : : /* Don't write the module if we have reported errors. */;
21616 : 2176 : else if (erroneous_templates
21617 : 2176 : && !erroneous_templates->is_empty ())
21618 : : {
21619 : : /* Don't write the module if it contains an erroneous template.
21620 : : Also emit notes about where errors occurred in case
21621 : : -Wno-template-body was passed. */
21622 : 6 : auto_diagnostic_group d;
21623 : 6 : error_at (state->loc, "not writing module %qs due to errors "
21624 : : "in template bodies", state->get_flatname ());
21625 : 6 : if (!warn_template_body)
21626 : 3 : inform (state->loc, "enable %<-Wtemplate-body%> for more details");
21627 : 12 : for (auto e : *erroneous_templates)
21628 : 6 : inform (e.second, "first error in %qD appeared here", e.first);
21629 : 6 : }
21630 : 2170 : else if (cookie->out.begin ())
21631 : : {
21632 : : /* So crashes finger-point the module decl. */
21633 : 2170 : iloc_sentinel ils = state->loc;
21634 : 2170 : if (state->write_begin (&cookie->out, reader, cookie->config,
21635 : 2170 : cookie->crc))
21636 : 2149 : cookie->began = true;
21637 : 2170 : }
21638 : :
21639 : 2279 : dump.pop (n);
21640 : 2279 : timevar_stop (TV_MODULE_EXPORT);
21641 : :
21642 : 2279 : ggc_collect ();
21643 : : }
21644 : :
21645 : 90549 : if (modules)
21646 : : {
21647 : 3739 : unsigned n = dump.push (NULL);
21648 : 4237 : dump () && dump ("Imported %u modules", modules->length () - 1);
21649 : 4237 : dump () && dump ("Containing %u clusters", available_clusters);
21650 : 3739 : dump () && dump ("Loaded %u clusters (%u%%)", loaded_clusters,
21651 : 498 : (loaded_clusters * 100 + available_clusters / 2) /
21652 : 498 : (available_clusters + !available_clusters));
21653 : 3739 : dump.pop (n);
21654 : : }
21655 : :
21656 : 90549 : return cookie;
21657 : : }
21658 : :
21659 : : // Do the final emission of a module. At this point we know whether
21660 : : // the module static initializer is a NOP or not.
21661 : :
21662 : : static void
21663 : 2279 : late_finish_module (cpp_reader *reader, module_processing_cookie *cookie,
21664 : : bool init_fn_non_empty)
21665 : : {
21666 : 2279 : timevar_start (TV_MODULE_EXPORT);
21667 : :
21668 : 2279 : module_state *state = (*modules)[0];
21669 : 2279 : unsigned n = dump.push (state);
21670 : 2279 : state->announce ("finishing");
21671 : :
21672 : 2279 : cookie->config.active_init = init_fn_non_empty;
21673 : 2279 : if (cookie->began)
21674 : 2149 : state->write_end (&cookie->out, reader, cookie->config, cookie->crc);
21675 : :
21676 : 2279 : if (cookie->out.end () && cookie->cmi_name)
21677 : : {
21678 : : /* Some OS's do not replace NEWNAME if it already exists.
21679 : : This'll have a race condition in erroneous concurrent
21680 : : builds. */
21681 : 2176 : unlink (cookie->cmi_name);
21682 : 2176 : if (rename (cookie->tmp_name, cookie->cmi_name))
21683 : : {
21684 : 0 : dump () && dump ("Rename ('%s','%s') errno=%u",
21685 : 0 : cookie->tmp_name, cookie->cmi_name, errno);
21686 : 0 : cookie->out.set_error (errno);
21687 : : }
21688 : : }
21689 : :
21690 : 2279 : if (cookie->out.get_error () && cookie->began)
21691 : : {
21692 : 0 : error_at (state->loc, "failed to write compiled module: %s",
21693 : 0 : cookie->out.get_error (state->filename));
21694 : 0 : state->note_cmi_name ();
21695 : : }
21696 : :
21697 : 2279 : if (!errorcount)
21698 : : {
21699 : 2146 : auto *mapper = get_mapper (cpp_main_loc (reader), cpp_get_deps (reader));
21700 : 2146 : mapper->ModuleCompiled (state->get_flatname ());
21701 : : }
21702 : 133 : else if (cookie->cmi_name)
21703 : : {
21704 : : /* We failed, attempt to erase all evidence we even tried. */
21705 : 133 : unlink (cookie->tmp_name);
21706 : 133 : unlink (cookie->cmi_name);
21707 : : }
21708 : :
21709 : 2279 : delete cookie;
21710 : 2279 : dump.pop (n);
21711 : 2279 : timevar_stop (TV_MODULE_EXPORT);
21712 : 2279 : }
21713 : :
21714 : : void
21715 : 90549 : fini_modules (cpp_reader *reader, void *cookie, bool has_inits)
21716 : : {
21717 : 90549 : if (cookie)
21718 : 2279 : late_finish_module (reader,
21719 : : static_cast<module_processing_cookie *> (cookie),
21720 : : has_inits);
21721 : :
21722 : : /* We're done with the macro tables now. */
21723 : 90549 : vec_free (macro_exports);
21724 : 90549 : vec_free (macro_imports);
21725 : 90549 : headers = NULL;
21726 : :
21727 : : /* We're now done with everything but the module names. */
21728 : 90549 : set_cmi_repo (NULL);
21729 : 90549 : if (mapper)
21730 : : {
21731 : 3739 : timevar_start (TV_MODULE_MAPPER);
21732 : 3739 : module_client::close_module_client (0, mapper);
21733 : 3739 : mapper = nullptr;
21734 : 3739 : timevar_stop (TV_MODULE_MAPPER);
21735 : : }
21736 : 90549 : module_state_config::release ();
21737 : :
21738 : : #if CHECKING_P
21739 : 90549 : note_defs = NULL;
21740 : : #endif
21741 : :
21742 : 90549 : if (modules)
21743 : 6046 : for (unsigned ix = modules->length (); --ix;)
21744 : 2307 : if (module_state *state = (*modules)[ix])
21745 : 2307 : state->release ();
21746 : :
21747 : : /* No need to lookup modules anymore. */
21748 : 90549 : modules_hash = NULL;
21749 : :
21750 : : /* Or entity array. We still need the entity map to find import numbers. */
21751 : 90549 : vec_free (entity_ary);
21752 : 90549 : entity_ary = NULL;
21753 : :
21754 : : /* Or remember any pending entities. */
21755 : 94288 : delete pending_table;
21756 : 90549 : pending_table = NULL;
21757 : :
21758 : : /* Or any keys -- Let it go! */
21759 : 92413 : delete keyed_table;
21760 : 90549 : keyed_table = NULL;
21761 : :
21762 : : /* Allow a GC, we've possibly made much data unreachable. */
21763 : 90549 : ggc_collect ();
21764 : 90549 : }
21765 : :
21766 : : /* If CODE is a module option, handle it & return true. Otherwise
21767 : : return false. For unknown reasons I cannot get the option
21768 : : generation machinery to set fmodule-mapper or -fmodule-header to
21769 : : make a string type option variable. */
21770 : :
21771 : : bool
21772 : 1786655 : handle_module_option (unsigned code, const char *str, int)
21773 : : {
21774 : 1786655 : auto hdr = CMS_header;
21775 : :
21776 : 1786655 : switch (opt_code (code))
21777 : : {
21778 : 42 : case OPT_fmodule_mapper_:
21779 : 42 : module_mapper_name = str;
21780 : 42 : return true;
21781 : :
21782 : 11 : case OPT_fmodule_header_:
21783 : 11 : {
21784 : 11 : if (!strcmp (str, "user"))
21785 : : hdr = CMS_user;
21786 : 11 : else if (!strcmp (str, "system"))
21787 : : hdr = CMS_system;
21788 : : else
21789 : 0 : error ("unknown header kind %qs", str);
21790 : : }
21791 : : /* Fallthrough. */
21792 : :
21793 : 817 : case OPT_fmodule_header:
21794 : 817 : flag_header_unit = hdr;
21795 : 817 : flag_modules = 1;
21796 : 817 : return true;
21797 : :
21798 : 1 : case OPT_flang_info_include_translate_:
21799 : 1 : vec_safe_push (note_includes, str);
21800 : 1 : return true;
21801 : :
21802 : 6 : case OPT_flang_info_module_cmi_:
21803 : 6 : vec_safe_push (note_cmis, str);
21804 : 6 : return true;
21805 : :
21806 : : default:
21807 : : return false;
21808 : : }
21809 : : }
21810 : :
21811 : : /* Set preprocessor callbacks and options for modules. */
21812 : :
21813 : : void
21814 : 92106 : module_preprocess_options (cpp_reader *reader)
21815 : : {
21816 : 92106 : gcc_checking_assert (!lang_hooks.preprocess_undef);
21817 : 92106 : if (modules_p ())
21818 : : {
21819 : 3881 : auto *cb = cpp_get_callbacks (reader);
21820 : :
21821 : 3881 : cb->translate_include = maybe_translate_include;
21822 : 3881 : cb->user_deferred_macro = module_state::deferred_macro;
21823 : 3881 : if (flag_header_unit)
21824 : : {
21825 : : /* If the preprocessor hook is already in use, that
21826 : : implementation will call the undef langhook. */
21827 : 814 : if (cb->undef)
21828 : 0 : lang_hooks.preprocess_undef = module_state::undef_macro;
21829 : : else
21830 : 814 : cb->undef = module_state::undef_macro;
21831 : : }
21832 : 3881 : auto *opt = cpp_get_options (reader);
21833 : 3881 : opt->module_directives = true;
21834 : 3881 : if (flag_no_output)
21835 : 12 : opt->directives_only = true;
21836 : 3881 : if (opt->main_search == CMS_none)
21837 : 3881 : opt->main_search = cpp_main_search (flag_header_unit);
21838 : : }
21839 : 92106 : }
21840 : :
21841 : : #include "gt-cp-module.h"
|
