1 /* C++ modules. Experimental!
2 Copyright (C) 2017-2023 Free Software Foundation, Inc.
3 Written by Nathan Sidwell <nathan@acm.org> while at FaceBook
5 This file is part of GCC.
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)
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.
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/>. */
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
27 /* (Incomplete) Design Notes
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).
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
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
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.
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.
68 Header units are module-like.
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
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.
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.
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
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.
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.
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
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).
156 bytes - data streamer
157 bytes_in : bytes - scalar reader
158 bytes_out : bytes - scalar writer
161 elf_in : elf - ELROND reader
162 elf_out : elf - ELROND writer
164 trees_in : bytes_in - tree reader
165 trees_out : bytes_out - tree writer
167 depset - dependency set
168 depset::hash - hash table of depsets
169 depset::tarjan - SCC determinator
171 uidset<T> - set T's related to a UID
172 uidset<T>::hash hash table of uidset<T>
174 loc_spans - location map data
176 module_state - module object
178 slurping - data needed during loading
180 macro_import - imported macro data
181 macro_export - exported macro data
183 The ELROND objects use mmap, for both reading and writing. If mmap
184 is unavailable, fileno IO is used to read and write blocks of data.
186 The mapper object uses fileno IO to communicate with the server or
189 /* In expermental (trunk) sources, MODULE_VERSION is a #define passed
190 in from the Makefile. It records the modification date of the
191 source directory -- that's the only way to stay sane. In release
192 sources, we (plan to) use the compiler's major.minor versioning.
193 While the format might not change between at minor versions, it
194 seems simplest to tie the two together. There's no concept of
195 inter-version compatibility. */
196 #define IS_EXPERIMENTAL(V) ((V) >= (1U << 20))
197 #define MODULE_MAJOR(V) ((V) / 10000)
198 #define MODULE_MINOR(V) ((V) % 10000)
199 #define EXPERIMENT(A,B) (IS_EXPERIMENTAL (MODULE_VERSION) ? (A) : (B))
200 #ifndef MODULE_VERSION
201 #include "bversion.h"
202 #define MODULE_VERSION (BUILDING_GCC_MAJOR * 10000U + BUILDING_GCC_MINOR)
203 #elif !IS_EXPERIMENTAL (MODULE_VERSION)
204 #error "This is not the version I was looking for."
207 #define _DEFAULT_SOURCE 1 /* To get TZ field of struct tm, if available. */
209 #define INCLUDE_MEMORY
210 #define INCLUDE_STRING
211 #define INCLUDE_VECTOR
213 #include "coretypes.h"
216 #include "stringpool.h"
217 #include "dumpfile.h"
220 #include "tree-iterator.h"
224 #include "libiberty.h"
225 #include "stor-layout.h"
227 #include "tree-diagnostic.h"
232 #include "langhooks.h"
233 /* This TU doesn't need or want to see the networking. */
234 #define CODY_NETWORKING 0
235 #include "mapper-client.h"
237 #if 0 // 1 for testing no mmap
238 #define MAPPED_READING 0
239 #define MAPPED_WRITING 0
241 #if HAVE_MMAP_FILE && _POSIX_MAPPED_FILES > 0
243 #define MAPPED_READING 1
244 #if HAVE_SYSCONF && defined (_SC_PAGE_SIZE)
245 /* msync, sysconf (_SC_PAGE_SIZE), ftruncate */
246 /* posix_fallocate used if available. */
247 #define MAPPED_WRITING 1
249 #define MAPPED_WRITING 0
252 #define MAPPED_READING 0
253 #define MAPPED_WRITING 0
257 /* Some open(2) flag differences, what a colourful world it is! */
258 #if defined (O_CLOEXEC)
260 #elif defined (_O_NOINHERIT)
261 /* Windows' _O_NOINHERIT matches O_CLOEXEC flag */
262 #define O_CLOEXEC _O_NOINHERIT
266 #if defined (O_BINARY)
268 #elif defined (_O_BINARY)
269 /* Windows' open(2) call defaults to text! */
270 #define O_BINARY _O_BINARY
275 static inline cpp_hashnode
*cpp_node (tree id
)
277 return CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (id
));
280 static inline tree
identifier (const cpp_hashnode
*node
)
282 /* HT_NODE() expands to node->ident that HT_IDENT_TO_GCC_IDENT()
283 then subtracts a nonzero constant, deriving a pointer to
284 a different member than ident. That's strictly undefined
285 and detected by -Warray-bounds. Suppress it. See PR 101372. */
286 #pragma GCC diagnostic push
287 #pragma GCC diagnostic ignored "-Warray-bounds"
288 return HT_IDENT_TO_GCC_IDENT (HT_NODE (const_cast<cpp_hashnode
*> (node
)));
289 #pragma GCC diagnostic pop
292 /* Id for dumping module information. */
295 /* We have a special module owner. */
296 #define MODULE_UNKNOWN (~0U) /* Not yet known. */
298 /* Prefix for section names. */
299 #define MOD_SNAME_PFX ".gnu.c++"
301 /* Format a version for user consumption. */
303 typedef char verstr_t
[32];
305 version2string (unsigned version
, verstr_t
&out
)
307 unsigned major
= MODULE_MAJOR (version
);
308 unsigned minor
= MODULE_MINOR (version
);
310 if (IS_EXPERIMENTAL (version
))
311 sprintf (out
, "%04u/%02u/%02u-%02u:%02u%s",
312 2000 + major
/ 10000, (major
/ 100) % 100, (major
% 100),
313 minor
/ 100, minor
% 100,
314 EXPERIMENT ("", " (experimental)"));
316 sprintf (out
, "%u.%u", major
, minor
);
319 /* Include files to note translation for. */
320 static vec
<const char *, va_heap
, vl_embed
> *note_includes
;
322 /* Modules to note CMI pathames. */
323 static vec
<const char *, va_heap
, vl_embed
> *note_cmis
;
325 /* Traits to hash an arbitrary pointer. Entries are not deletable,
326 and removal is a noop (removal needed upon destruction). */
327 template <typename T
>
328 struct nodel_ptr_hash
: pointer_hash
<T
>, typed_noop_remove
<T
*> {
329 /* Nothing is deletable. Everything is insertable. */
330 static bool is_deleted (T
*) { return false; }
331 static void mark_deleted (T
*) { gcc_unreachable (); }
334 /* Map from pointer to signed integer. */
335 typedef simple_hashmap_traits
<nodel_ptr_hash
<void>, int> ptr_int_traits
;
336 typedef hash_map
<void *,signed,ptr_int_traits
> ptr_int_hash_map
;
338 /********************************************************************/
339 /* Basic streaming & ELF. Serialization is usually via mmap. For
340 writing we slide a buffer over the output file, syncing it
341 approproiately. For reading we simply map the whole file (as a
342 file-backed read-only map -- it's just address space, leaving the
343 OS pager to deal with getting the data to us). Some buffers need
344 to be more conventional malloc'd contents. */
346 /* Variable length buffer. */
352 /* Tools tend to moan if the dtor's not virtual. */
353 virtual ~allocator () {}
356 void grow (data
&obj
, unsigned needed
, bool exact
);
357 void shrink (data
&obj
);
360 virtual char *grow (char *ptr
, unsigned needed
);
361 virtual void shrink (char *ptr
);
365 char *buffer
; /* Buffer being transferred. */
366 /* Although size_t would be the usual size, we know we never get
367 more than 4GB of buffer -- because that's the limit of the
368 encapsulation format. And if you need bigger imports, you're
370 unsigned size
; /* Allocated size of buffer. */
371 unsigned pos
; /* Position in buffer. */
375 :buffer (NULL
), size (0), pos (0)
380 /* Make sure the derived and/or using class know what they're
382 gcc_checking_assert (!buffer
);
386 char *use (unsigned count
)
388 if (size
< pos
+ count
)
390 char *res
= &buffer
[pos
];
396 void unuse (unsigned count
)
402 static allocator simple_memory
;
405 /* The simple data allocator. */
406 data::allocator
data::simple_memory
;
408 /* Grow buffer to at least size NEEDED. */
411 data::allocator::grow (data
&obj
, unsigned needed
, bool exact
)
413 gcc_checking_assert (needed
? needed
> obj
.size
: !obj
.size
);
415 /* Pick a default size. */
416 needed
= EXPERIMENT (100, 1000);
420 obj
.buffer
= grow (obj
.buffer
, needed
);
424 obj
.pos
= obj
.size
= 0;
430 data::allocator::shrink (data
&obj
)
438 data::allocator::grow (char *ptr
, unsigned needed
)
440 return XRESIZEVAR (char, ptr
, needed
);
444 data::allocator::shrink (char *ptr
)
449 /* Byte streamer base. Buffer with read/write position and smarts
452 class bytes
: public data
{
457 uint32_t bit_val
; /* Bit buffer. */
458 unsigned bit_pos
; /* Next bit in bit buffer. */
462 :parent (), bit_val (0), bit_pos (0)
469 unsigned calc_crc (unsigned) const;
472 /* Finish bit packet. Rewind the bytes not used. */
473 unsigned bit_flush ()
475 gcc_assert (bit_pos
);
476 unsigned bytes
= (bit_pos
+ 7) / 8;
484 /* Calculate the crc32 of the buffer. Note the CRC is stored in the
485 first 4 bytes, so don't include them. */
488 bytes::calc_crc (unsigned l
) const
491 for (size_t ix
= 4; ix
< l
; ix
++)
492 crc
= crc32_byte (crc
, buffer
[ix
]);
498 /* Byte stream reader. */
500 class bytes_in
: public bytes
{
501 typedef bytes parent
;
504 bool overrun
; /* Sticky read-too-much flag. */
508 : parent (), overrun (false)
516 /* Begin reading a named section. */
517 bool begin (location_t loc
, elf_in
*src
, const char *name
);
518 /* Begin reading a numbered section with optional name. */
519 bool begin (location_t loc
, elf_in
*src
, unsigned, const char * = NULL
);
520 /* Complete reading a buffer. Propagate errors and return true on
522 bool end (elf_in
*src
);
523 /* Return true if there is unread data. */
530 /* Start reading at OFFSET. */
531 void random_access (unsigned offset
)
536 bit_pos
= bit_val
= 0;
540 void align (unsigned boundary
)
542 if (unsigned pad
= pos
& (boundary
- 1))
543 read (boundary
- pad
);
547 const char *read (unsigned count
)
549 char *ptr
= use (count
);
556 bool check_crc () const;
557 /* We store the CRC in the first 4 bytes, using host endianness. */
558 unsigned get_crc () const
560 return *(const unsigned *)&buffer
[0];
564 /* Manipulate the overrun flag. */
565 bool get_overrun () const
575 unsigned u32 (); /* Read uncompressed integer. */
578 bool b (); /* Read a bool. */
579 void bflush (); /* Completed a block of bools. */
582 void bfill (); /* Get the next block of bools. */
585 int c (); /* Read a char. */
586 int i (); /* Read a signed int. */
587 unsigned u (); /* Read an unsigned int. */
588 size_t z (); /* Read a size_t. */
589 HOST_WIDE_INT
wi (); /* Read a HOST_WIDE_INT. */
590 unsigned HOST_WIDE_INT
wu (); /* Read an unsigned HOST_WIDE_INT. */
591 const char *str (size_t * = NULL
); /* Read a string. */
592 const void *buf (size_t); /* Read a fixed-length buffer. */
593 cpp_hashnode
*cpp_node (); /* Read a cpp node. */
596 /* Verify the buffer's CRC is correct. */
599 bytes_in::check_crc () const
604 unsigned c_crc
= calc_crc (size
);
605 if (c_crc
!= get_crc ())
613 /* Byte stream writer. */
615 class bytes_out
: public bytes
{
616 typedef bytes parent
;
619 allocator
*memory
; /* Obtainer of memory. */
622 bytes_out (allocator
*memory
)
623 : parent (), memory (memory
)
631 bool streaming_p () const
633 return memory
!= NULL
;
637 void set_crc (unsigned *crc_ptr
);
640 /* Begin writing, maybe reserve space for CRC. */
641 void begin (bool need_crc
= true);
642 /* Finish writing. Spill to section by number. */
643 unsigned end (elf_out
*, unsigned, unsigned *crc_ptr
= NULL
);
646 void align (unsigned boundary
)
648 if (unsigned pad
= pos
& (boundary
- 1))
649 write (boundary
- pad
);
653 char *write (unsigned count
, bool exact
= false)
655 if (size
< pos
+ count
)
656 memory
->grow (*this, pos
+ count
, exact
);
661 void u32 (unsigned); /* Write uncompressed integer. */
664 void b (bool); /* Write bool. */
665 void bflush (); /* Finish block of bools. */
668 void c (unsigned char); /* Write unsigned char. */
669 void i (int); /* Write signed int. */
670 void u (unsigned); /* Write unsigned int. */
671 void z (size_t s
); /* Write size_t. */
672 void wi (HOST_WIDE_INT
); /* Write HOST_WIDE_INT. */
673 void wu (unsigned HOST_WIDE_INT
); /* Write unsigned HOST_WIDE_INT. */
674 void str (const char *ptr
)
676 str (ptr
, strlen (ptr
));
678 void cpp_node (const cpp_hashnode
*node
)
680 str ((const char *)NODE_NAME (node
), NODE_LEN (node
));
682 void str (const char *, size_t); /* Write string of known length. */
683 void buf (const void *, size_t); /* Write fixed length buffer. */
684 void *buf (size_t); /* Create a writable buffer */
687 /* Format a NUL-terminated raw string. */
688 void printf (const char *, ...) ATTRIBUTE_PRINTF_2
;
689 void print_time (const char *, const tm
*, const char *);
692 /* Dump instrumentation. */
693 static void instrument ();
696 /* Instrumentation. */
697 static unsigned spans
[4];
698 static unsigned lengths
[4];
702 /* Instrumentation. */
703 unsigned bytes_out::spans
[4];
704 unsigned bytes_out::lengths
[4];
705 int bytes_out::is_set
= -1;
707 /* If CRC_PTR non-null, set the CRC of the buffer. Mix the CRC into
708 that pointed to by CRC_PTR. */
711 bytes_out::set_crc (unsigned *crc_ptr
)
715 gcc_checking_assert (pos
>= 4);
717 unsigned crc
= calc_crc (pos
);
718 unsigned accum
= *crc_ptr
;
719 /* Only mix the existing *CRC_PTR if it is non-zero. */
720 accum
= accum
? crc32_unsigned (accum
, crc
) : crc
;
723 /* Buffer will be sufficiently aligned. */
724 *(unsigned *)buffer
= crc
;
728 /* Finish a set of bools. */
736 lengths
[2] += bit_flush ();
749 /* When reading, we don't know how many bools we'll read in. So read
750 4 bytes-worth, and then rewind when flushing if we didn't need them
751 all. You can't have a block of bools closer than 4 bytes to the
752 end of the buffer. */
760 /* Bools are packed into bytes. You cannot mix bools and non-bools.
761 You must call bflush before emitting another type. So batch your
764 It may be worth optimizing for most bools being zero. Some kind of
765 run-length encoding? */
768 bytes_out::b (bool x
)
776 bit_val
|= unsigned (x
) << bit_pos
++;
780 lengths
[2] += bit_flush ();
789 bool v
= (bit_val
>> bit_pos
++) & 1;
795 /* Exactly 4 bytes. Used internally for bool packing and a few other
796 places. We can't simply use uint32_t because (a) alignment and
797 (b) we need little-endian for the bool streaming rewinding to make
801 bytes_out::u32 (unsigned val
)
803 if (char *ptr
= write (4))
816 if (const char *ptr
= read (4))
818 val
|= (unsigned char)ptr
[0];
819 val
|= (unsigned char)ptr
[1] << 8;
820 val
|= (unsigned char)ptr
[2] << 16;
821 val
|= (unsigned char)ptr
[3] << 24;
827 /* Chars are unsigned and written as single bytes. */
830 bytes_out::c (unsigned char v
)
832 if (char *ptr
= write (1))
840 if (const char *ptr
= read (1))
841 v
= (unsigned char)ptr
[0];
845 /* Ints 7-bit as a byte. Otherwise a 3bit count of following bytes in
846 big-endian form. 4 bits are in the first byte. */
851 if (char *ptr
= write (1))
853 if (v
<= 0x3f && v
>= -0x40)
860 for (probe
= v
>> 8; probe
> 0x7; probe
>>= 8)
863 for (probe
= v
>> 8; probe
< -0x8; probe
>>= 8)
865 *ptr
= 0x80 | bytes
<< 4 | (probe
& 0xf);
866 if ((ptr
= write (++bytes
)))
867 for (; bytes
--; v
>>= 8)
868 ptr
[bytes
] = v
& 0xff;
877 if (const char *ptr
= read (1))
882 unsigned bytes
= (v
>> 4) & 0x7;
886 /* unsigned necessary due to left shifts of -ve values. */
887 unsigned uv
= unsigned (v
);
888 if ((ptr
= read (++bytes
)))
890 uv
= (uv
<< 8) | (*ptr
++ & 0xff);
901 bytes_out::u (unsigned v
)
903 if (char *ptr
= write (1))
911 for (probe
= v
>> 8; probe
> 0xf; probe
>>= 8)
913 *ptr
= 0x80 | bytes
<< 4 | probe
;
914 if ((ptr
= write (++bytes
)))
915 for (; bytes
--; v
>>= 8)
916 ptr
[bytes
] = v
& 0xff;
926 if (const char *ptr
= read (1))
931 unsigned bytes
= (v
>> 4) & 0x7;
933 if ((ptr
= read (++bytes
)))
935 v
= (v
<< 8) | (*ptr
++ & 0xff);
943 bytes_out::wi (HOST_WIDE_INT v
)
945 if (char *ptr
= write (1))
947 if (v
<= 0x3f && v
>= -0x40)
954 for (probe
= v
>> 8; probe
> 0x7; probe
>>= 8)
957 for (probe
= v
>> 8; probe
< -0x8; probe
>>= 8)
959 *ptr
= 0x80 | bytes
<< 4 | (probe
& 0xf);
960 if ((ptr
= write (++bytes
)))
961 for (; bytes
--; v
>>= 8)
962 ptr
[bytes
] = v
& 0xff;
971 if (const char *ptr
= read (1))
976 unsigned bytes
= (v
>> 4) & 0x7;
980 /* unsigned necessary due to left shifts of -ve values. */
981 unsigned HOST_WIDE_INT uv
= (unsigned HOST_WIDE_INT
) v
;
982 if ((ptr
= read (++bytes
)))
984 uv
= (uv
<< 8) | (*ptr
++ & 0xff);
985 v
= (HOST_WIDE_INT
) uv
;
994 /* unsigned wide ints are just written as signed wide ints. */
997 bytes_out::wu (unsigned HOST_WIDE_INT v
)
999 wi ((HOST_WIDE_INT
) v
);
1002 inline unsigned HOST_WIDE_INT
1005 return (unsigned HOST_WIDE_INT
) wi ();
1008 /* size_t written as unsigned or unsigned wide int. */
1011 bytes_out::z (size_t s
)
1013 if (sizeof (s
) == sizeof (unsigned))
1022 if (sizeof (size_t) == sizeof (unsigned))
1028 /* Buffer simply memcpied. */
1030 bytes_out::buf (size_t len
)
1032 align (sizeof (void *) * 2);
1037 bytes_out::buf (const void *src
, size_t len
)
1039 if (void *ptr
= buf (len
))
1040 memcpy (ptr
, src
, len
);
1044 bytes_in::buf (size_t len
)
1046 align (sizeof (void *) * 2);
1047 const char *ptr
= read (len
);
1052 /* strings as an size_t length, followed by the buffer. Make sure
1053 there's a NUL terminator on read. */
1056 bytes_out::str (const char *string
, size_t len
)
1061 gcc_checking_assert (!string
[len
]);
1062 buf (string
, len
+ 1);
1067 bytes_in::str (size_t *len_p
)
1071 /* We're about to trust some user data. */
1076 const char *str
= NULL
;
1079 str
= reinterpret_cast<const char *> (buf (len
+ 1));
1080 if (!str
|| str
[len
])
1086 return str
? str
: "";
1090 bytes_in::cpp_node ()
1093 const char *s
= str (&len
);
1096 return ::cpp_node (get_identifier_with_length (s
, len
));
1099 /* Format a string directly to the buffer, including a terminating
1100 NUL. Intended for human consumption. */
1103 bytes_out::printf (const char *format
, ...)
1106 /* Exercise buffer expansion. */
1107 size_t len
= EXPERIMENT (10, 500);
1109 while (char *ptr
= write (len
))
1111 va_start (args
, format
);
1112 size_t actual
= vsnprintf (ptr
, len
, format
, args
) + 1;
1116 unuse (len
- actual
);
1125 bytes_out::print_time (const char *kind
, const tm
*time
, const char *tz
)
1127 printf ("%stime: %4u/%02u/%02u %02u:%02u:%02u %s",
1128 kind
, time
->tm_year
+ 1900, time
->tm_mon
+ 1, time
->tm_mday
,
1129 time
->tm_hour
, time
->tm_min
, time
->tm_sec
, tz
);
1132 /* Encapsulated Lazy Records Of Named Declarations.
1133 Header: Stunningly Elf32_Ehdr-like
1134 Sections: Sectional data
1135 [1-N) : User data sections
1136 N .strtab : strings, stunningly ELF STRTAB-like
1137 Index: Section table, stunningly ELF32_Shdr-like. */
1141 /* Constants used within the format. */
1142 enum private_constants
{
1154 /* Section numbering. */
1156 SHN_LORESERVE
= 0xff00,
1157 SHN_XINDEX
= 0xffff,
1159 /* Section types. */
1160 SHT_NONE
= 0, /* No contents. */
1161 SHT_PROGBITS
= 1, /* Random bytes. */
1162 SHT_STRTAB
= 3, /* A string table. */
1164 /* Section flags. */
1165 SHF_NONE
= 0x00, /* Nothing. */
1166 SHF_STRINGS
= 0x20, /* NUL-Terminated strings. */
1168 /* I really hope we do not get CMI files larger than 4GB. */
1170 /* It is host endianness that is relevant. */
1171 MY_ENDIAN
= DATA2LSB
1172 #ifdef WORDS_BIGENDIAN
1173 ^ DATA2LSB
^ DATA2MSB
1178 /* Constants visible to users. */
1179 enum public_constants
{
1180 /* Special error codes. Breaking layering a bit. */
1181 E_BAD_DATA
= -1, /* Random unexpected data errors. */
1182 E_BAD_LAZY
= -2, /* Badly ordered laziness. */
1183 E_BAD_IMPORT
= -3 /* A nested import failed. */
1187 /* File identification. On-disk representation. */
1189 uint8_t magic
[4]; /* 0x7f, 'E', 'L', 'F' */
1190 uint8_t klass
; /* 4:CLASS32 */
1191 uint8_t data
; /* 5:DATA2[LM]SB */
1192 uint8_t version
; /* 6:EV_CURRENT */
1193 uint8_t osabi
; /* 7:OSABI_NONE */
1194 uint8_t abiver
; /* 8: 0 */
1195 uint8_t pad
[7]; /* 9-15 */
1197 /* File header. On-disk representation. */
1200 uint16_t type
; /* ET_NONE */
1201 uint16_t machine
; /* EM_NONE */
1202 uint32_t version
; /* EV_CURRENT */
1203 uint32_t entry
; /* 0 */
1204 uint32_t phoff
; /* 0 */
1205 uint32_t shoff
; /* Section Header Offset in file */
1207 uint16_t ehsize
; /* ELROND Header SIZE -- sizeof (header) */
1208 uint16_t phentsize
; /* 0 */
1209 uint16_t phnum
; /* 0 */
1210 uint16_t shentsize
; /* Section Header SIZE -- sizeof (section) */
1211 uint16_t shnum
; /* Section Header NUM */
1212 uint16_t shstrndx
; /* Section Header STRing iNDeX */
1214 /* File section. On-disk representation. */
1216 uint32_t name
; /* String table offset. */
1217 uint32_t type
; /* SHT_* */
1218 uint32_t flags
; /* SHF_* */
1219 uint32_t addr
; /* 0 */
1220 uint32_t offset
; /* OFFSET in file */
1221 uint32_t size
; /* SIZE of section */
1222 uint32_t link
; /* 0 */
1223 uint32_t info
; /* 0 */
1224 uint32_t addralign
; /* 0 */
1225 uint32_t entsize
; /* ENTry SIZE, usually 0 */
1229 data hdr
; /* The header. */
1230 data sectab
; /* The section table. */
1231 data strtab
; /* String table. */
1232 int fd
; /* File descriptor we're reading or writing. */
1233 int err
; /* Sticky error code. */
1236 /* Construct from STREAM. E is errno if STREAM NULL. */
1238 :hdr (), sectab (), strtab (), fd (fd
), err (fd
>= 0 ? 0 : e
)
1242 gcc_checking_assert (fd
< 0 && !hdr
.buffer
1243 && !sectab
.buffer
&& !strtab
.buffer
);
1247 /* Return the error, if we have an error. */
1248 int get_error () const
1252 /* Set the error, unless it's already been set. */
1253 void set_error (int e
= E_BAD_DATA
)
1258 /* Get an error string. */
1259 const char *get_error (const char *) const;
1262 /* Begin reading/writing file. Return false on error. */
1265 return !get_error ();
1267 /* Finish reading/writing file. Return false on error. */
1271 /* Return error string. */
1274 elf::get_error (const char *name
) const
1277 return "Unknown CMI mapping";
1284 return "Bad file data";
1286 return "Bad import dependency";
1288 return "Bad lazy ordering";
1290 return xstrerror (err
);
1294 /* Finish file, return true if there's an error. */
1299 /* Close the stream and free the section table. */
1300 if (fd
>= 0 && close (fd
))
1304 return !get_error ();
1307 /* ELROND reader. */
1309 class elf_in
: public elf
{
1313 /* For freezing & defrosting. */
1314 #if !defined (HOST_LACKS_INODE_NUMBERS)
1320 elf_in (int fd
, int e
)
1329 bool is_frozen () const
1331 return fd
< 0 && hdr
.pos
;
1333 bool is_freezable () const
1335 return fd
>= 0 && hdr
.pos
;
1338 bool defrost (const char *);
1340 /* If BYTES is in the mmapped area, allocate a new buffer for it. */
1341 void preserve (bytes_in
&bytes ATTRIBUTE_UNUSED
)
1344 if (hdr
.buffer
&& bytes
.buffer
>= hdr
.buffer
1345 && bytes
.buffer
< hdr
.buffer
+ hdr
.pos
)
1347 char *buf
= bytes
.buffer
;
1348 bytes
.buffer
= data::simple_memory
.grow (NULL
, bytes
.size
);
1349 memcpy (bytes
.buffer
, buf
, bytes
.size
);
1353 /* If BYTES is not in SELF's mmapped area, free it. SELF might be
1355 static void release (elf_in
*self ATTRIBUTE_UNUSED
, bytes_in
&bytes
)
1358 if (!(self
&& self
->hdr
.buffer
&& bytes
.buffer
>= self
->hdr
.buffer
1359 && bytes
.buffer
< self
->hdr
.buffer
+ self
->hdr
.pos
))
1361 data::simple_memory
.shrink (bytes
.buffer
);
1362 bytes
.buffer
= NULL
;
1367 static void grow (data
&data
, unsigned needed
)
1369 gcc_checking_assert (!data
.buffer
);
1371 data
.buffer
= XNEWVEC (char, needed
);
1375 static void shrink (data
&data
)
1378 XDELETEVEC (data
.buffer
);
1385 const section
*get_section (unsigned s
) const
1387 if (s
* sizeof (section
) < sectab
.size
)
1388 return reinterpret_cast<const section
*>
1389 (§ab
.buffer
[s
* sizeof (section
)]);
1393 unsigned get_section_limit () const
1395 return sectab
.size
/ sizeof (section
);
1399 const char *read (data
*, unsigned, unsigned);
1402 /* Read section by number. */
1403 bool read (data
*d
, const section
*s
)
1405 return s
&& read (d
, s
->offset
, s
->size
);
1408 /* Find section by name. */
1409 unsigned find (const char *name
);
1410 /* Find section by index. */
1411 const section
*find (unsigned snum
, unsigned type
= SHT_PROGBITS
);
1414 /* Release the string table, when we're done with it. */
1421 bool begin (location_t
);
1427 munmap (hdr
.buffer
, hdr
.pos
);
1432 return parent::end ();
1436 /* Return string name at OFFSET. Checks OFFSET range. Always
1437 returns non-NULL. We know offset 0 is an empty string. */
1438 const char *name (unsigned offset
)
1440 return &strtab
.buffer
[offset
< strtab
.size
? offset
: 0];
1444 /* ELROND writer. */
1446 class elf_out
: public elf
, public data::allocator
{
1448 /* Desired section alignment on disk. */
1449 static const int SECTION_ALIGN
= 16;
1452 ptr_int_hash_map identtab
; /* Map of IDENTIFIERS to strtab offsets. */
1453 unsigned pos
; /* Write position in file. */
1455 unsigned offset
; /* Offset of the mapping. */
1456 unsigned extent
; /* Length of mapping. */
1457 unsigned page_size
; /* System page size. */
1461 elf_out (int fd
, int e
)
1462 :parent (fd
, e
), identtab (500), pos (0)
1465 offset
= extent
= 0;
1466 page_size
= sysconf (_SC_PAGE_SIZE
);
1467 if (page_size
< SECTION_ALIGN
)
1468 /* Something really strange. */
1474 data::simple_memory
.shrink (hdr
);
1475 data::simple_memory
.shrink (sectab
);
1476 data::simple_memory
.shrink (strtab
);
1481 void create_mapping (unsigned ext
, bool extending
= true);
1482 void remove_mapping ();
1486 using allocator::grow
;
1487 char *grow (char *, unsigned needed
) final override
;
1489 using allocator::shrink
;
1490 void shrink (char *) final override
;
1494 unsigned get_section_limit () const
1496 return sectab
.pos
/ sizeof (section
);
1500 unsigned add (unsigned type
, unsigned name
= 0,
1501 unsigned off
= 0, unsigned size
= 0, unsigned flags
= SHF_NONE
);
1502 unsigned write (const data
&);
1504 unsigned write (const bytes_out
&);
1508 /* IDENTIFIER to strtab offset. */
1509 unsigned name (tree ident
);
1510 /* String literal to strtab offset. */
1511 unsigned name (const char *n
);
1512 /* Qualified name of DECL to strtab offset. */
1513 unsigned qualified_name (tree decl
, bool is_defn
);
1516 unsigned strtab_write (const char *s
, unsigned l
);
1517 void strtab_write (tree decl
, int);
1520 /* Add a section with contents or strings. */
1521 unsigned add (const bytes_out
&, bool string_p
, unsigned name
);
1524 /* Begin and end writing. */
1529 /* Begin reading section NAME (of type PROGBITS) from SOURCE.
1530 Data always checked for CRC. */
1533 bytes_in::begin (location_t loc
, elf_in
*source
, const char *name
)
1535 unsigned snum
= source
->find (name
);
1537 return begin (loc
, source
, snum
, name
);
1540 /* Begin reading section numbered SNUM with NAME (may be NULL). */
1543 bytes_in::begin (location_t loc
, elf_in
*source
, unsigned snum
, const char *name
)
1545 if (!source
->read (this, source
->find (snum
))
1546 || !size
|| !check_crc ())
1548 source
->set_error (elf::E_BAD_DATA
);
1549 source
->shrink (*this);
1551 error_at (loc
, "section %qs is missing or corrupted", name
);
1553 error_at (loc
, "section #%u is missing or corrupted", snum
);
1560 /* Finish reading a section. */
1563 bytes_in::end (elf_in
*src
)
1570 src
->shrink (*this);
1575 /* Begin writing buffer. */
1578 bytes_out::begin (bool need_crc
)
1582 memory
->grow (*this, 0, false);
1585 /* Finish writing buffer. Stream out to SINK as named section NAME.
1586 Return section number or 0 on failure. If CRC_PTR is true, crc
1587 the data. Otherwise it is a string section. */
1590 bytes_out::end (elf_out
*sink
, unsigned name
, unsigned *crc_ptr
)
1596 unsigned sec_num
= sink
->add (*this, !crc_ptr
, name
);
1597 memory
->shrink (*this);
1602 /* Close and open the file, without destroying it. */
1607 gcc_checking_assert (!is_frozen ());
1609 if (munmap (hdr
.buffer
, hdr
.pos
) < 0)
1618 elf_in::defrost (const char *name
)
1620 gcc_checking_assert (is_frozen ());
1623 fd
= open (name
, O_RDONLY
| O_CLOEXEC
| O_BINARY
);
1624 if (fd
< 0 || fstat (fd
, &stat
) < 0)
1628 bool ok
= hdr
.pos
== unsigned (stat
.st_size
);
1629 #ifndef HOST_LACKS_INODE_NUMBERS
1630 if (device
!= stat
.st_dev
1631 || inode
!= stat
.st_ino
)
1639 char *mapping
= reinterpret_cast<char *>
1640 (mmap (NULL
, hdr
.pos
, PROT_READ
, MAP_SHARED
, fd
, 0));
1641 if (mapping
== MAP_FAILED
)
1646 if (madvise (mapping
, hdr
.pos
, MADV_RANDOM
))
1649 /* These buffers are never NULL in this case. */
1650 strtab
.buffer
= mapping
+ strtab
.pos
;
1651 sectab
.buffer
= mapping
+ sectab
.pos
;
1652 hdr
.buffer
= mapping
;
1658 return !get_error ();
1661 /* Read at current position into BUFFER. Return true on success. */
1664 elf_in::read (data
*data
, unsigned pos
, unsigned length
)
1667 if (pos
+ length
> hdr
.pos
)
1673 if (pos
!= ~0u && lseek (fd
, pos
, SEEK_SET
) < 0)
1679 grow (*data
, length
);
1681 data
->buffer
= hdr
.buffer
+ pos
;
1683 if (::read (fd
, data
->buffer
, data
->size
) != ssize_t (length
))
1691 return data
->buffer
;
1694 /* Read section SNUM of TYPE. Return section pointer or NULL on error. */
1696 const elf::section
*
1697 elf_in::find (unsigned snum
, unsigned type
)
1699 const section
*sec
= get_section (snum
);
1700 if (!snum
|| !sec
|| sec
->type
!= type
)
1705 /* Find a section NAME and TYPE. Return section number, or zero on
1709 elf_in::find (const char *sname
)
1711 for (unsigned pos
= sectab
.size
; pos
-= sizeof (section
); )
1714 = reinterpret_cast<const section
*> (§ab
.buffer
[pos
]);
1716 if (0 == strcmp (sname
, name (sec
->name
)))
1717 return pos
/ sizeof (section
);
1723 /* Begin reading file. Verify header. Pull in section and string
1724 tables. Return true on success. */
1727 elf_in::begin (location_t loc
)
1729 if (!parent::begin ())
1734 if (!fstat (fd
, &stat
))
1736 #if !defined (HOST_LACKS_INODE_NUMBERS)
1737 device
= stat
.st_dev
;
1738 inode
= stat
.st_ino
;
1740 /* Never generate files > 4GB, check we've not been given one. */
1741 if (stat
.st_size
== unsigned (stat
.st_size
))
1742 size
= unsigned (stat
.st_size
);
1746 /* MAP_SHARED so that the file is backing store. If someone else
1747 concurrently writes it, they're wrong. */
1748 void *mapping
= mmap (NULL
, size
, PROT_READ
, MAP_SHARED
, fd
, 0);
1749 if (mapping
== MAP_FAILED
)
1755 /* We'll be hopping over this randomly. Some systems declare the
1756 first parm as char *, and other declare it as void *. */
1757 if (madvise (reinterpret_cast <char *> (mapping
), size
, MADV_RANDOM
))
1760 hdr
.buffer
= (char *)mapping
;
1762 read (&hdr
, 0, sizeof (header
));
1764 hdr
.pos
= size
; /* Record size of the file. */
1766 const header
*h
= reinterpret_cast<const header
*> (hdr
.buffer
);
1770 if (h
->ident
.magic
[0] != 0x7f
1771 || h
->ident
.magic
[1] != 'E'
1772 || h
->ident
.magic
[2] != 'L'
1773 || h
->ident
.magic
[3] != 'F')
1775 error_at (loc
, "not Encapsulated Lazy Records of Named Declarations");
1781 /* We expect a particular format -- the ELF is not intended to be
1783 if (h
->ident
.klass
!= MY_CLASS
1784 || h
->ident
.data
!= MY_ENDIAN
1785 || h
->ident
.version
!= EV_CURRENT
1786 || h
->type
!= ET_NONE
1787 || h
->machine
!= EM_NONE
1788 || h
->ident
.osabi
!= OSABI_NONE
)
1790 error_at (loc
, "unexpected encapsulation format or type");
1795 if (!h
->shoff
|| h
->shentsize
!= sizeof (section
))
1799 error_at (loc
, "encapsulation is malformed");
1803 unsigned strndx
= h
->shstrndx
;
1804 unsigned shnum
= h
->shnum
;
1805 if (shnum
== SHN_XINDEX
)
1807 if (!read (§ab
, h
->shoff
, sizeof (section
)))
1813 shnum
= get_section (0)->size
;
1814 /* Freeing does mean we'll re-read it in the case we're not
1815 mapping, but this is going to be rare. */
1822 if (!read (§ab
, h
->shoff
, shnum
* sizeof (section
)))
1823 goto section_table_fail
;
1825 if (strndx
== SHN_XINDEX
)
1826 strndx
= get_section (0)->link
;
1828 if (!read (&strtab
, find (strndx
, SHT_STRTAB
)))
1831 /* The string table should be at least one byte, with NUL chars
1833 if (!(strtab
.size
&& !strtab
.buffer
[0]
1834 && !strtab
.buffer
[strtab
.size
- 1]))
1838 /* Record the offsets of the section and string tables. */
1839 sectab
.pos
= h
->shoff
;
1840 strtab
.pos
= shnum
* sizeof (section
);
1848 /* Create a new mapping. */
1852 elf_out::create_mapping (unsigned ext
, bool extending
)
1854 #ifndef HAVE_POSIX_FALLOCATE
1855 #define posix_fallocate(fd,off,len) ftruncate (fd, off + len)
1857 void *mapping
= MAP_FAILED
;
1858 if (extending
&& ext
< 1024 * 1024)
1860 if (!posix_fallocate (fd
, offset
, ext
* 2))
1861 mapping
= mmap (NULL
, ext
* 2, PROT_READ
| PROT_WRITE
,
1862 MAP_SHARED
, fd
, offset
);
1863 if (mapping
!= MAP_FAILED
)
1866 if (mapping
== MAP_FAILED
)
1868 if (!extending
|| !posix_fallocate (fd
, offset
, ext
))
1869 mapping
= mmap (NULL
, ext
, PROT_READ
| PROT_WRITE
,
1870 MAP_SHARED
, fd
, offset
);
1871 if (mapping
== MAP_FAILED
)
1878 #undef posix_fallocate
1879 hdr
.buffer
= (char *)mapping
;
1884 /* Flush out the current mapping. */
1888 elf_out::remove_mapping ()
1892 /* MS_ASYNC dtrt with the removed mapping, including a
1893 subsequent overlapping remap. */
1894 if (msync (hdr
.buffer
, extent
, MS_ASYNC
)
1895 || munmap (hdr
.buffer
, extent
))
1896 /* We're somewhat screwed at this point. */
1904 /* Grow a mapping of PTR to be NEEDED bytes long. This gets
1905 interesting if the new size grows the EXTENT. */
1908 elf_out::grow (char *data
, unsigned needed
)
1912 /* First allocation, check we're aligned. */
1913 gcc_checking_assert (!(pos
& (SECTION_ALIGN
- 1)));
1915 data
= hdr
.buffer
+ (pos
- offset
);
1920 unsigned off
= data
- hdr
.buffer
;
1921 if (off
+ needed
> extent
)
1923 /* We need to grow the mapping. */
1924 unsigned lwm
= off
& ~(page_size
- 1);
1925 unsigned hwm
= (off
+ needed
+ page_size
- 1) & ~(page_size
- 1);
1927 gcc_checking_assert (hwm
> extent
);
1932 create_mapping (extent
< hwm
- lwm
? hwm
- lwm
: extent
);
1934 data
= hdr
.buffer
+ (off
- lwm
);
1937 data
= allocator::grow (data
, needed
);
1944 /* Shrinking is a NOP. */
1946 elf_out::shrink (char *)
1951 /* Write S of length L to the strtab buffer. L must include the ending
1952 NUL, if that's what you want. */
1955 elf_out::strtab_write (const char *s
, unsigned l
)
1957 if (strtab
.pos
+ l
> strtab
.size
)
1958 data::simple_memory
.grow (strtab
, strtab
.pos
+ l
, false);
1959 memcpy (strtab
.buffer
+ strtab
.pos
, s
, l
);
1960 unsigned res
= strtab
.pos
;
1965 /* Write qualified name of decl. INNER >0 if this is a definition, <0
1966 if this is a qualifier of an outer name. */
1969 elf_out::strtab_write (tree decl
, int inner
)
1971 tree ctx
= CP_DECL_CONTEXT (decl
);
1973 ctx
= TYPE_NAME (ctx
);
1974 if (ctx
!= global_namespace
)
1975 strtab_write (ctx
, -1);
1977 tree name
= DECL_NAME (decl
);
1979 name
= DECL_ASSEMBLER_NAME_RAW (decl
);
1980 strtab_write (IDENTIFIER_POINTER (name
), IDENTIFIER_LENGTH (name
));
1983 strtab_write (&"::{}"[inner
+1], 2);
1986 /* Map IDENTIFIER IDENT to strtab offset. Inserts into strtab if not
1990 elf_out::name (tree ident
)
1996 int *slot
= &identtab
.get_or_insert (ident
, &existed
);
1998 *slot
= strtab_write (IDENTIFIER_POINTER (ident
),
1999 IDENTIFIER_LENGTH (ident
) + 1);
2005 /* Map LITERAL to strtab offset. Does not detect duplicates and
2006 expects LITERAL to remain live until strtab is written out. */
2009 elf_out::name (const char *literal
)
2011 return strtab_write (literal
, strlen (literal
) + 1);
2014 /* Map a DECL's qualified name to strtab offset. Does not detect
2018 elf_out::qualified_name (tree decl
, bool is_defn
)
2020 gcc_checking_assert (DECL_P (decl
) && decl
!= global_namespace
);
2021 unsigned result
= strtab
.pos
;
2023 strtab_write (decl
, is_defn
);
2024 strtab_write ("", 1);
2029 /* Add section to file. Return section number. TYPE & NAME identify
2030 the section. OFF and SIZE identify the file location of its
2031 data. FLAGS contains additional info. */
2034 elf_out::add (unsigned type
, unsigned name
, unsigned off
, unsigned size
,
2037 gcc_checking_assert (!(off
& (SECTION_ALIGN
- 1)));
2038 if (sectab
.pos
+ sizeof (section
) > sectab
.size
)
2039 data::simple_memory
.grow (sectab
, sectab
.pos
+ sizeof (section
), false);
2040 section
*sec
= reinterpret_cast<section
*> (sectab
.buffer
+ sectab
.pos
);
2041 memset (sec
, 0, sizeof (section
));
2047 if (flags
& SHF_STRINGS
)
2050 unsigned res
= sectab
.pos
;
2051 sectab
.pos
+= sizeof (section
);
2052 return res
/ sizeof (section
);
2055 /* Pad to the next alignment boundary, then write BUFFER to disk.
2056 Return the position of the start of the write, or zero on failure. */
2059 elf_out::write (const data
&buffer
)
2062 /* HDR is always mapped. */
2063 if (&buffer
!= &hdr
)
2065 bytes_out
out (this);
2066 grow (out
, buffer
.pos
, true);
2068 memcpy (out
.buffer
, buffer
.buffer
, buffer
.pos
);
2072 /* We should have been aligned during the first allocation. */
2073 gcc_checking_assert (!(pos
& (SECTION_ALIGN
- 1)));
2075 if (::write (fd
, buffer
.buffer
, buffer
.pos
) != ssize_t (buffer
.pos
))
2084 if (unsigned padding
= -pos
& (SECTION_ALIGN
- 1))
2087 /* Align the section on disk, should help the necessary copies.
2088 fseeking to extend is non-portable. */
2089 static char zero
[SECTION_ALIGN
];
2090 if (::write (fd
, &zero
, padding
) != ssize_t (padding
))
2098 /* Write a streaming buffer. It must be using us as an allocator. */
2102 elf_out::write (const bytes_out
&buf
)
2104 gcc_checking_assert (buf
.memory
== this);
2105 /* A directly mapped buffer. */
2106 gcc_checking_assert (buf
.buffer
- hdr
.buffer
>= 0
2107 && buf
.buffer
- hdr
.buffer
+ buf
.size
<= extent
);
2111 /* Align up. We're not going to advance into the next page. */
2112 pos
+= -pos
& (SECTION_ALIGN
- 1);
2118 /* Write data and add section. STRING_P is true for a string
2119 section, false for PROGBITS. NAME identifies the section (0 is the
2120 empty name). DATA is the contents. Return section number or 0 on
2121 failure (0 is the undef section). */
2124 elf_out::add (const bytes_out
&data
, bool string_p
, unsigned name
)
2126 unsigned off
= write (data
);
2128 return add (string_p
? SHT_STRTAB
: SHT_PROGBITS
, name
,
2129 off
, data
.pos
, string_p
? SHF_STRINGS
: SHF_NONE
);
2132 /* Begin writing the file. Initialize the section table and write an
2133 empty header. Return false on failure. */
2138 if (!parent::begin ())
2141 /* Let the allocators pick a default. */
2142 data::simple_memory
.grow (strtab
, 0, false);
2143 data::simple_memory
.grow (sectab
, 0, false);
2145 /* The string table starts with an empty string. */
2148 /* Create the UNDEF section. */
2152 /* Start a mapping. */
2153 create_mapping (EXPERIMENT (page_size
,
2154 (32767 + page_size
) & ~(page_size
- 1)));
2159 /* Write an empty header. */
2160 grow (hdr
, sizeof (header
), true);
2161 header
*h
= reinterpret_cast<header
*> (hdr
.buffer
);
2162 memset (h
, 0, sizeof (header
));
2165 return !get_error ();
2168 /* Finish writing the file. Write out the string & section tables.
2169 Fill in the header. Return true on error. */
2176 /* Write the string table. */
2177 unsigned strnam
= name (".strtab");
2178 unsigned stroff
= write (strtab
);
2179 unsigned strndx
= add (SHT_STRTAB
, strnam
, stroff
, strtab
.pos
,
2182 /* Store escape values in section[0]. */
2183 if (strndx
>= SHN_LORESERVE
)
2185 reinterpret_cast<section
*> (sectab
.buffer
)->link
= strndx
;
2186 strndx
= SHN_XINDEX
;
2188 unsigned shnum
= sectab
.pos
/ sizeof (section
);
2189 if (shnum
>= SHN_LORESERVE
)
2191 reinterpret_cast<section
*> (sectab
.buffer
)->size
= shnum
;
2195 unsigned shoff
= write (sectab
);
2202 create_mapping ((sizeof (header
) + page_size
- 1) & ~(page_size
- 1),
2205 unsigned length
= pos
;
2207 if (lseek (fd
, 0, SEEK_SET
) < 0)
2213 /* Write the correct header now. */
2214 header
*h
= reinterpret_cast<header
*> (hdr
.buffer
);
2215 h
->ident
.magic
[0] = 0x7f;
2216 h
->ident
.magic
[1] = 'E'; /* Elrond */
2217 h
->ident
.magic
[2] = 'L'; /* is an */
2218 h
->ident
.magic
[3] = 'F'; /* elf. */
2219 h
->ident
.klass
= MY_CLASS
;
2220 h
->ident
.data
= MY_ENDIAN
;
2221 h
->ident
.version
= EV_CURRENT
;
2222 h
->ident
.osabi
= OSABI_NONE
;
2224 h
->machine
= EM_NONE
;
2225 h
->version
= EV_CURRENT
;
2227 h
->ehsize
= sizeof (header
);
2228 h
->shentsize
= sizeof (section
);
2230 h
->shstrndx
= strndx
;
2238 if (ftruncate (fd
, length
))
2243 data::simple_memory
.shrink (sectab
);
2244 data::simple_memory
.shrink (strtab
);
2246 return parent::end ();
2249 /********************************************************************/
2251 /* A dependency set. This is used during stream out to determine the
2252 connectivity of the graph. Every namespace-scope declaration that
2253 needs writing has a depset. The depset is filled with the (depsets
2254 of) declarations within this module that it references. For a
2255 declaration that'll generally be named types. For definitions
2256 it'll also be declarations in the body.
2258 From that we can convert the graph to a DAG, via determining the
2259 Strongly Connected Clusters. Each cluster is streamed
2260 independently, and thus we achieve lazy loading.
2262 Other decls that get a depset are namespaces themselves and
2263 unnameable declarations. */
2267 tree entity
; /* Entity, or containing namespace. */
2268 uintptr_t discriminator
; /* Flags or identifier. */
2271 /* The kinds of entity the depset could describe. The ordering is
2272 significant, see entity_kind_name. */
2275 EK_DECL
, /* A decl. */
2276 EK_SPECIALIZATION
, /* A specialization. */
2277 EK_PARTIAL
, /* A partial specialization. */
2278 EK_USING
, /* A using declaration (at namespace scope). */
2279 EK_NAMESPACE
, /* A namespace. */
2280 EK_REDIRECT
, /* Redirect to a template_decl. */
2282 EK_BINDING
= EK_EXPLICIT_HWM
, /* Implicitly encoded. */
2283 EK_FOR_BINDING
, /* A decl being inserted for a binding. */
2284 EK_INNER_DECL
, /* A decl defined outside of its imported
2286 EK_DIRECT_HWM
= EK_PARTIAL
+ 1,
2288 EK_BITS
= 3 /* Only need to encode below EK_EXPLICIT_HWM. */
2292 /* Placement of bit fields in discriminator. */
2295 DB_ZERO_BIT
, /* Set to disambiguate identifier from flags */
2296 DB_SPECIAL_BIT
, /* First dep slot is special. */
2297 DB_KIND_BIT
, /* Kind of the entity. */
2298 DB_KIND_BITS
= EK_BITS
,
2299 DB_DEFN_BIT
= DB_KIND_BIT
+ DB_KIND_BITS
,
2300 DB_IS_MEMBER_BIT
, /* Is an out-of-class member. */
2301 DB_IS_INTERNAL_BIT
, /* It is an (erroneous)
2302 internal-linkage entity. */
2303 DB_REFS_INTERNAL_BIT
, /* Refers to an internal-linkage
2305 DB_IMPORTED_BIT
, /* An imported entity. */
2306 DB_UNREACHED_BIT
, /* A yet-to-be reached entity. */
2307 DB_HIDDEN_BIT
, /* A hidden binding. */
2308 /* The following bits are not independent, but enumerating them is
2310 DB_ALIAS_TMPL_INST_BIT
, /* An alias template instantiation. */
2311 DB_ALIAS_SPEC_BIT
, /* Specialization of an alias template
2312 (in both spec tables). */
2313 DB_TYPE_SPEC_BIT
, /* Specialization in the type table.
2315 DB_FRIEND_SPEC_BIT
, /* An instantiated template friend. */
2319 /* The first slot is special for EK_SPECIALIZATIONS it is a
2320 spec_entry pointer. It is not relevant for the SCC
2322 vec
<depset
*> deps
; /* Depsets we reference. */
2325 unsigned cluster
; /* Strongly connected cluster, later entity number */
2326 unsigned section
; /* Section written to. */
2327 /* During SCC construction, section is lowlink, until the depset is
2328 removed from the stack. See Tarjan algorithm for details. */
2331 /* Construction via factories. Destruction via hash traits. */
2332 depset (tree entity
);
2336 static depset
*make_binding (tree
, tree
);
2337 static depset
*make_entity (tree
, entity_kind
, bool = false);
2338 /* Late setting a binding name -- /then/ insert into hash! */
2339 inline void set_binding_name (tree name
)
2341 gcc_checking_assert (!get_name ());
2342 discriminator
= reinterpret_cast<uintptr_t> (name
);
2346 template<unsigned I
> void set_flag_bit ()
2348 gcc_checking_assert (I
< 2 || !is_binding ());
2349 discriminator
|= 1u << I
;
2351 template<unsigned I
> void clear_flag_bit ()
2353 gcc_checking_assert (I
< 2 || !is_binding ());
2354 discriminator
&= ~(1u << I
);
2356 template<unsigned I
> bool get_flag_bit () const
2358 gcc_checking_assert (I
< 2 || !is_binding ());
2359 return bool ((discriminator
>> I
) & 1);
2363 bool is_binding () const
2365 return !get_flag_bit
<DB_ZERO_BIT
> ();
2367 entity_kind
get_entity_kind () const
2371 return entity_kind ((discriminator
>> DB_KIND_BIT
) & ((1u << EK_BITS
) - 1));
2373 const char *entity_kind_name () const;
2376 bool has_defn () const
2378 return get_flag_bit
<DB_DEFN_BIT
> ();
2382 /* This class-member is defined here, but the class was imported. */
2383 bool is_member () const
2385 gcc_checking_assert (get_entity_kind () == EK_DECL
);
2386 return get_flag_bit
<DB_IS_MEMBER_BIT
> ();
2389 bool is_internal () const
2391 return get_flag_bit
<DB_IS_INTERNAL_BIT
> ();
2393 bool refs_internal () const
2395 return get_flag_bit
<DB_REFS_INTERNAL_BIT
> ();
2397 bool is_import () const
2399 return get_flag_bit
<DB_IMPORTED_BIT
> ();
2401 bool is_unreached () const
2403 return get_flag_bit
<DB_UNREACHED_BIT
> ();
2405 bool is_alias_tmpl_inst () const
2407 return get_flag_bit
<DB_ALIAS_TMPL_INST_BIT
> ();
2409 bool is_alias () const
2411 return get_flag_bit
<DB_ALIAS_SPEC_BIT
> ();
2413 bool is_hidden () const
2415 return get_flag_bit
<DB_HIDDEN_BIT
> ();
2417 bool is_type_spec () const
2419 return get_flag_bit
<DB_TYPE_SPEC_BIT
> ();
2421 bool is_friend_spec () const
2423 return get_flag_bit
<DB_FRIEND_SPEC_BIT
> ();
2427 /* We set these bit outside of depset. */
2428 void set_hidden_binding ()
2430 set_flag_bit
<DB_HIDDEN_BIT
> ();
2432 void clear_hidden_binding ()
2434 clear_flag_bit
<DB_HIDDEN_BIT
> ();
2438 bool is_special () const
2440 return get_flag_bit
<DB_SPECIAL_BIT
> ();
2444 set_flag_bit
<DB_SPECIAL_BIT
> ();
2448 tree
get_entity () const
2452 tree
get_name () const
2454 gcc_checking_assert (is_binding ());
2455 return reinterpret_cast <tree
> (discriminator
);
2459 /* Traits for a hash table of pointers to bindings. */
2461 /* Each entry is a pointer to a depset. */
2462 typedef depset
*value_type
;
2463 /* We lookup by container:maybe-identifier pair. */
2464 typedef std::pair
<tree
,tree
> compare_type
;
2466 static const bool empty_zero_p
= true;
2468 /* hash and equality for compare_type. */
2469 inline static hashval_t
hash (const compare_type
&p
)
2471 hashval_t h
= pointer_hash
<tree_node
>::hash (p
.first
);
2474 hashval_t nh
= IDENTIFIER_HASH_VALUE (p
.second
);
2475 h
= iterative_hash_hashval_t (h
, nh
);
2479 inline static bool equal (const value_type b
, const compare_type
&p
)
2481 if (b
->entity
!= p
.first
)
2485 return b
->discriminator
== reinterpret_cast<uintptr_t> (p
.second
);
2487 return !b
->is_binding ();
2490 /* (re)hasher for a binding itself. */
2491 inline static hashval_t
hash (const value_type b
)
2493 hashval_t h
= pointer_hash
<tree_node
>::hash (b
->entity
);
2494 if (b
->is_binding ())
2496 hashval_t nh
= IDENTIFIER_HASH_VALUE (b
->get_name ());
2497 h
= iterative_hash_hashval_t (h
, nh
);
2502 /* Empty via NULL. */
2503 static inline void mark_empty (value_type
&p
) {p
= NULL
;}
2504 static inline bool is_empty (value_type p
) {return !p
;}
2506 /* Nothing is deletable. Everything is insertable. */
2507 static bool is_deleted (value_type
) { return false; }
2508 static void mark_deleted (value_type
) { gcc_unreachable (); }
2510 /* We own the entities in the hash table. */
2511 static void remove (value_type p
)
2518 class hash
: public hash_table
<traits
> {
2519 typedef traits::compare_type key_t
;
2520 typedef hash_table
<traits
> parent
;
2523 vec
<depset
*> worklist
; /* Worklist of decls to walk. */
2524 hash
*chain
; /* Original table. */
2525 depset
*current
; /* Current depset being depended. */
2526 unsigned section
; /* When writing out, the section. */
2527 bool sneakoscope
; /* Detecting dark magic (of a voldemort). */
2528 bool reached_unreached
; /* We reached an unreached entity. */
2531 hash (size_t size
, hash
*c
= NULL
)
2532 : parent (size
), chain (c
), current (NULL
), section (0),
2533 sneakoscope (false), reached_unreached (false)
2535 worklist
.create (size
);
2539 worklist
.release ();
2543 bool is_key_order () const
2545 return chain
!= NULL
;
2549 depset
**entity_slot (tree entity
, bool = true);
2550 depset
**binding_slot (tree ctx
, tree name
, bool = true);
2551 depset
*maybe_add_declaration (tree decl
);
2554 depset
*find_dependency (tree entity
);
2555 depset
*find_binding (tree ctx
, tree name
);
2556 depset
*make_dependency (tree decl
, entity_kind
);
2557 void add_dependency (depset
*);
2560 void add_mergeable (depset
*);
2561 depset
*add_dependency (tree decl
, entity_kind
);
2562 void add_namespace_context (depset
*, tree ns
);
2565 static bool add_binding_entity (tree
, WMB_Flags
, void *);
2568 bool add_namespace_entities (tree ns
, bitmap partitions
);
2569 void add_specializations (bool decl_p
);
2570 void add_partial_entities (vec
<tree
, va_gc
> *);
2571 void add_class_entities (vec
<tree
, va_gc
> *);
2574 void find_dependencies (module_state
*);
2575 bool finalize_dependencies ();
2576 vec
<depset
*> connect ();
2581 vec
<depset
*> result
;
2582 vec
<depset
*> stack
;
2585 tarjan (unsigned size
)
2588 result
.create (size
);
2593 gcc_assert (!stack
.length ());
2598 void connect (depset
*);
2603 depset::depset (tree entity
)
2604 :entity (entity
), discriminator (0), cluster (0), section (0)
2616 depset::entity_kind_name () const
2618 /* Same order as entity_kind. */
2619 static const char *const names
[] =
2620 {"decl", "specialization", "partial", "using",
2621 "namespace", "redirect", "binding"};
2622 entity_kind kind
= get_entity_kind ();
2623 gcc_checking_assert (kind
< ARRAY_SIZE (names
));
2627 /* Create a depset for a namespace binding NS::NAME. */
2629 depset
*depset::make_binding (tree ns
, tree name
)
2631 depset
*binding
= new depset (ns
);
2633 binding
->discriminator
= reinterpret_cast <uintptr_t> (name
);
2638 depset
*depset::make_entity (tree entity
, entity_kind ek
, bool is_defn
)
2640 depset
*r
= new depset (entity
);
2642 r
->discriminator
= ((1 << DB_ZERO_BIT
)
2643 | (ek
<< DB_KIND_BIT
)
2644 | is_defn
<< DB_DEFN_BIT
);
2657 struct default_hash_traits
<pending_key
>
2659 using value_type
= pending_key
;
2661 static const bool empty_zero_p
= false;
2662 static hashval_t
hash (const value_type
&k
)
2664 hashval_t h
= IDENTIFIER_HASH_VALUE (k
.id
);
2665 h
= iterative_hash_hashval_t (DECL_UID (k
.ns
), h
);
2669 static bool equal (const value_type
&k
, const value_type
&l
)
2671 return k
.ns
== l
.ns
&& k
.id
== l
.id
;
2673 static void mark_empty (value_type
&k
)
2675 k
.ns
= k
.id
= NULL_TREE
;
2677 static void mark_deleted (value_type
&k
)
2680 gcc_checking_assert (k
.id
);
2682 static bool is_empty (const value_type
&k
)
2684 return k
.ns
== NULL_TREE
&& k
.id
== NULL_TREE
;
2686 static bool is_deleted (const value_type
&k
)
2688 return k
.ns
== NULL_TREE
&& k
.id
!= NULL_TREE
;
2690 static void remove (value_type
&)
2695 typedef hash_map
<pending_key
, auto_vec
<unsigned>> pending_map_t
;
2697 /* Not-loaded entities that are keyed to a namespace-scope
2698 identifier. See module_state::write_pendings for details. */
2699 pending_map_t
*pending_table
;
2701 /* Decls that need some post processing once a batch of lazy loads has
2703 vec
<tree
, va_heap
, vl_embed
> *post_load_decls
;
2705 /* Some entities are keyed to another entitity for ODR purposes.
2706 For example, at namespace scope, 'inline auto var = []{};', that
2707 lambda is keyed to 'var', and follows its ODRness. */
2708 typedef hash_map
<tree
, auto_vec
<tree
>> keyed_map_t
;
2709 static keyed_map_t
*keyed_table
;
2711 /********************************************************************/
2712 /* Tree streaming. The tree streaming is very specific to the tree
2713 structures themselves. A tag indicates the kind of tree being
2714 streamed. -ve tags indicate backreferences to already-streamed
2715 trees. Backreferences are auto-numbered. */
2719 tt_null
, /* NULL_TREE. */
2720 tt_fixed
, /* Fixed vector index. */
2722 tt_node
, /* By-value node. */
2723 tt_decl
, /* By-value mergeable decl. */
2724 tt_tpl_parm
, /* Template parm. */
2726 /* The ordering of the following 4 is relied upon in
2727 trees_out::tree_node. */
2728 tt_id
, /* Identifier node. */
2729 tt_conv_id
, /* Conversion operator name. */
2730 tt_anon_id
, /* Anonymous name. */
2731 tt_lambda_id
, /* Lambda name. */
2733 tt_typedef_type
, /* A (possibly implicit) typedefed type. */
2734 tt_derived_type
, /* A type derived from another type. */
2735 tt_variant_type
, /* A variant of another type. */
2737 tt_tinfo_var
, /* Typeinfo object. */
2738 tt_tinfo_typedef
, /* Typeinfo typedef. */
2739 tt_ptrmem_type
, /* Pointer to member type. */
2740 tt_nttp_var
, /* NTTP_OBJECT VAR_DECL. */
2742 tt_parm
, /* Function parameter or result. */
2743 tt_enum_value
, /* An enum value. */
2744 tt_enum_decl
, /* An enum decl. */
2745 tt_data_member
, /* Data member/using-decl. */
2747 tt_binfo
, /* A BINFO. */
2748 tt_vtable
, /* A vtable. */
2749 tt_thunk
, /* A thunk. */
2752 tt_entity
, /* A extra-cluster entity. */
2754 tt_template
, /* The TEMPLATE_RESULT of a template. */
2758 WK_none
, /* No walk to do (a back- or fixed-ref happened). */
2759 WK_normal
, /* Normal walk (by-name if possible). */
2761 WK_value
, /* By-value walk. */
2766 MK_unique
, /* Known unique. */
2767 MK_named
, /* Found by CTX, NAME + maybe_arg types etc. */
2768 MK_field
, /* Found by CTX and index on TYPE_FIELDS */
2769 MK_vtable
, /* Found by CTX and index on TYPE_VTABLES */
2770 MK_as_base
, /* Found by CTX. */
2774 MK_enum
, /* Found by CTX, & 1stMemberNAME. */
2775 MK_keyed
, /* Found by key & index. */
2777 MK_friend_spec
, /* Like named, but has a tmpl & args too. */
2778 MK_local_friend
, /* Found by CTX, index. */
2780 MK_indirect_lwm
= MK_enum
,
2782 /* Template specialization kinds below. These are all found via
2783 primary template and specialization args. */
2784 MK_template_mask
= 0x10, /* A template specialization. */
2786 MK_tmpl_decl_mask
= 0x4, /* In decl table. */
2787 MK_tmpl_alias_mask
= 0x2, /* Also in type table */
2789 MK_tmpl_tmpl_mask
= 0x1, /* We want TEMPLATE_DECL. */
2791 MK_type_spec
= MK_template_mask
,
2792 MK_decl_spec
= MK_template_mask
| MK_tmpl_decl_mask
,
2793 MK_alias_spec
= MK_decl_spec
| MK_tmpl_alias_mask
,
2797 /* This is more than a debugging array. NULLs are used to determine
2798 an invalid merge_kind number. */
2799 static char const *const merge_kind_name
[MK_hwm
] =
2801 "unique", "named", "field", "vtable", /* 0...3 */
2802 "asbase", "partial", "enum", "attached", /* 4...7 */
2804 "friend spec", "local friend", NULL
, NULL
, /* 8...11 */
2805 NULL
, NULL
, NULL
, NULL
,
2807 "type spec", "type tmpl spec", /* 16,17 type (template). */
2810 "decl spec", "decl tmpl spec", /* 20,21 decl (template). */
2811 "alias spec", "alias tmpl spec", /* 22,23 alias (template). */
2812 NULL
, NULL
, NULL
, NULL
,
2813 NULL
, NULL
, NULL
, NULL
,
2816 /* Mergeable entity location data. */
2818 cp_ref_qualifier ref_q
: 2;
2821 tree ret
; /* Return type, if appropriate. */
2822 tree args
; /* Arg types, if appropriate. */
2824 tree constraints
; /* Constraints. */
2827 :ref_q (REF_QUAL_NONE
), index (0),
2828 ret (NULL_TREE
), args (NULL_TREE
),
2829 constraints (NULL_TREE
)
2834 /* Hashmap of merged duplicates. Usually decls, but can contain
2836 typedef hash_map
<tree
,uintptr_t,
2837 simple_hashmap_traits
<nodel_ptr_hash
<tree_node
>,uintptr_t> >
2840 /* Tree stream reader. Note that reading a stream doesn't mark the
2841 read trees with TREE_VISITED. Thus it's quite safe to have
2842 multiple concurrent readers. Which is good, because lazy
2844 class trees_in
: public bytes_in
{
2845 typedef bytes_in parent
;
2848 module_state
*state
; /* Module being imported. */
2849 vec
<tree
> back_refs
; /* Back references. */
2850 duplicate_hash_map
*duplicates
; /* Map from existings to duplicate. */
2851 vec
<tree
> post_decls
; /* Decls to post process. */
2852 unsigned unused
; /* Inhibit any interior TREE_USED
2856 trees_in (module_state
*);
2861 tree
back_ref (int);
2864 tree
start (unsigned = 0);
2867 /* Needed for binfo writing */
2868 bool core_bools (tree
);
2871 /* Stream tree_core, lang_decl_specific and lang_type_specific
2873 bool core_vals (tree
);
2874 bool lang_type_bools (tree
);
2875 bool lang_type_vals (tree
);
2876 bool lang_decl_bools (tree
);
2877 bool lang_decl_vals (tree
);
2878 bool lang_vals (tree
);
2879 bool tree_node_bools (tree
);
2880 bool tree_node_vals (tree
);
2883 tree
tpl_parm_value ();
2886 tree
chained_decls (); /* Follow DECL_CHAIN. */
2887 vec
<tree
, va_heap
> *vec_chained_decls ();
2888 vec
<tree
, va_gc
> *tree_vec (); /* vec of tree. */
2889 vec
<tree_pair_s
, va_gc
> *tree_pair_vec (); /* vec of tree_pair. */
2890 tree
tree_list (bool has_purpose
);
2893 /* Read a tree node. */
2894 tree
tree_node (bool is_use
= false);
2897 bool install_entity (tree decl
);
2898 tree
tpl_parms (unsigned &tpl_levels
);
2899 bool tpl_parms_fini (tree decl
, unsigned tpl_levels
);
2900 bool tpl_header (tree decl
, unsigned *tpl_levels
);
2901 int fn_parms_init (tree
);
2902 void fn_parms_fini (int tag
, tree fn
, tree existing
, bool has_defn
);
2903 unsigned add_indirect_tpl_parms (tree
);
2905 bool add_indirects (tree
);
2908 /* Serialize various definitions. */
2909 bool read_definition (tree decl
);
2912 bool is_matching_decl (tree existing
, tree decl
, bool is_typedef
);
2913 static bool install_implicit_member (tree decl
);
2914 bool read_function_def (tree decl
, tree maybe_template
);
2915 bool read_var_def (tree decl
, tree maybe_template
);
2916 bool read_class_def (tree decl
, tree maybe_template
);
2917 bool read_enum_def (tree decl
, tree maybe_template
);
2920 tree
decl_container ();
2921 tree
key_mergeable (int tag
, merge_kind
, tree decl
, tree inner
, tree type
,
2922 tree container
, bool is_attached
);
2923 unsigned binfo_mergeable (tree
*);
2926 uintptr_t *find_duplicate (tree existing
);
2927 void register_duplicate (tree decl
, tree existing
);
2928 /* Mark as an already diagnosed bad duplicate. */
2929 void unmatched_duplicate (tree existing
)
2931 *find_duplicate (existing
) |= 1;
2935 bool is_duplicate (tree decl
)
2937 return find_duplicate (decl
) != NULL
;
2939 tree
maybe_duplicate (tree decl
)
2941 if (uintptr_t *dup
= find_duplicate (decl
))
2942 return reinterpret_cast<tree
> (*dup
& ~uintptr_t (1));
2945 tree
odr_duplicate (tree decl
, bool has_defn
);
2948 /* Return the next decl to postprocess, or NULL. */
2949 tree
post_process ()
2951 return post_decls
.length () ? post_decls
.pop () : NULL_TREE
;
2954 /* Register DECL for postprocessing. */
2955 void post_process (tree decl
)
2957 post_decls
.safe_push (decl
);
2961 void assert_definition (tree
, bool installing
);
2964 trees_in::trees_in (module_state
*state
)
2965 :parent (), state (state
), unused (0)
2968 back_refs
.create (500);
2969 post_decls
.create (0);
2972 trees_in::~trees_in ()
2974 delete (duplicates
);
2975 back_refs
.release ();
2976 post_decls
.release ();
2979 /* Tree stream writer. */
2980 class trees_out
: public bytes_out
{
2981 typedef bytes_out parent
;
2984 module_state
*state
; /* The module we are writing. */
2985 ptr_int_hash_map tree_map
; /* Trees to references */
2986 depset::hash
*dep_hash
; /* Dependency table. */
2987 int ref_num
; /* Back reference number. */
2990 int importedness
; /* Checker that imports not occurring
2991 inappropriately. +ve imports ok,
2992 -ve imports not ok. */
2996 trees_out (allocator
*, module_state
*, depset::hash
&deps
, unsigned sec
= 0);
3001 void unmark_trees ();
3004 /* Hey, let's ignore the well known STL iterator idiom. */
3006 unsigned end (elf_out
*sink
, unsigned name
, unsigned *crc_ptr
);
3012 tag_backref
= -1, /* Upper bound on the backrefs. */
3013 tag_value
= 0, /* Write by value. */
3014 tag_fixed
/* Lower bound on the fixed trees. */
3018 bool is_key_order () const
3020 return dep_hash
->is_key_order ();
3024 int insert (tree
, walk_kind
= WK_normal
);
3027 void start (tree
, bool = false);
3030 walk_kind
ref_node (tree
);
3033 void set_importing (int i ATTRIBUTE_UNUSED
)
3041 void core_bools (tree
);
3042 void core_vals (tree
);
3043 void lang_type_bools (tree
);
3044 void lang_type_vals (tree
);
3045 void lang_decl_bools (tree
);
3046 void lang_decl_vals (tree
);
3047 void lang_vals (tree
);
3048 void tree_node_bools (tree
);
3049 void tree_node_vals (tree
);
3052 void chained_decls (tree
);
3053 void vec_chained_decls (tree
);
3054 void tree_vec (vec
<tree
, va_gc
> *);
3055 void tree_pair_vec (vec
<tree_pair_s
, va_gc
> *);
3056 void tree_list (tree
, bool has_purpose
);
3059 /* Mark a node for by-value walking. */
3060 void mark_by_value (tree
);
3063 void tree_node (tree
);
3066 void install_entity (tree decl
, depset
*);
3067 void tpl_parms (tree parms
, unsigned &tpl_levels
);
3068 void tpl_parms_fini (tree decl
, unsigned tpl_levels
);
3069 void fn_parms_fini (tree
) {}
3070 unsigned add_indirect_tpl_parms (tree
);
3072 void add_indirects (tree
);
3073 void fn_parms_init (tree
);
3074 void tpl_header (tree decl
, unsigned *tpl_levels
);
3077 merge_kind
get_merge_kind (tree decl
, depset
*maybe_dep
);
3078 tree
decl_container (tree decl
);
3079 void key_mergeable (int tag
, merge_kind
, tree decl
, tree inner
,
3080 tree container
, depset
*maybe_dep
);
3081 void binfo_mergeable (tree binfo
);
3084 bool decl_node (tree
, walk_kind ref
);
3085 void type_node (tree
);
3086 void tree_value (tree
);
3087 void tpl_parm_value (tree
);
3090 void decl_value (tree
, depset
*);
3093 /* Serialize various definitions. */
3094 void write_definition (tree decl
);
3095 void mark_declaration (tree decl
, bool do_defn
);
3098 void mark_function_def (tree decl
);
3099 void mark_var_def (tree decl
);
3100 void mark_class_def (tree decl
);
3101 void mark_enum_def (tree decl
);
3102 void mark_class_member (tree decl
, bool do_defn
= true);
3103 void mark_binfos (tree type
);
3106 void write_var_def (tree decl
);
3107 void write_function_def (tree decl
);
3108 void write_class_def (tree decl
);
3109 void write_enum_def (tree decl
);
3112 static void assert_definition (tree
);
3115 static void instrument ();
3118 /* Tree instrumentation. */
3119 static unsigned tree_val_count
;
3120 static unsigned decl_val_count
;
3121 static unsigned back_ref_count
;
3122 static unsigned null_count
;
3125 /* Instrumentation counters. */
3126 unsigned trees_out::tree_val_count
;
3127 unsigned trees_out::decl_val_count
;
3128 unsigned trees_out::back_ref_count
;
3129 unsigned trees_out::null_count
;
3131 trees_out::trees_out (allocator
*mem
, module_state
*state
, depset::hash
&deps
,
3133 :parent (mem
), state (state
), tree_map (500),
3134 dep_hash (&deps
), ref_num (0), section (section
)
3141 trees_out::~trees_out ()
3145 /********************************************************************/
3146 /* Location. We're aware of the line-map concept and reproduce it
3147 here. Each imported module allocates a contiguous span of ordinary
3148 maps, and of macro maps. adhoc maps are serialized by contents,
3149 not pre-allocated. The scattered linemaps of a module are
3150 coalesced when writing. */
3153 /* I use half-open [first,second) ranges. */
3154 typedef std::pair
<unsigned,unsigned> range_t
;
3156 /* A range of locations. */
3157 typedef std::pair
<location_t
,location_t
> loc_range_t
;
3159 /* Spans of the line maps that are occupied by this TU. I.e. not
3160 within imports. Only extended when in an interface unit.
3161 Interval zero corresponds to the forced header linemap(s). This
3162 is a singleton object. */
3166 /* An interval of line maps. The line maps here represent a contiguous
3167 non-imported range. */
3169 loc_range_t ordinary
; /* Ordinary map location range. */
3170 loc_range_t macro
; /* Macro map location range. */
3171 int ordinary_delta
; /* Add to ordinary loc to get serialized loc. */
3172 int macro_delta
; /* Likewise for macro loc. */
3180 /* Do not preallocate spans, as that causes
3181 --enable-detailed-mem-stats problems. */
3191 span
&operator[] (unsigned ix
)
3193 return (*spans
)[ix
];
3195 unsigned length () const
3197 return spans
->length ();
3201 bool init_p () const
3203 return spans
!= nullptr;
3206 void init (const line_maps
*lmaps
, const line_map_ordinary
*map
);
3208 /* Slightly skewed preprocessed files can cause us to miss an
3209 initialization in some places. Fallback initializer. */
3213 init (line_table
, nullptr);
3218 SPAN_RESERVED
= 0, /* Reserved (fixed) locations. */
3219 SPAN_FIRST
= 1, /* LWM of locations to stream */
3220 SPAN_MAIN
= 2 /* Main file and onwards. */
3224 location_t
main_start () const
3226 return (*spans
)[SPAN_MAIN
].ordinary
.first
;
3230 void open (location_t
);
3234 /* Propagate imported linemaps to us, if needed. */
3235 bool maybe_propagate (module_state
*import
, location_t loc
);
3238 const span
*ordinary (location_t
);
3239 const span
*macro (location_t
);
3242 static loc_spans spans
;
3244 /* Information about ordinary locations we stream out. */
3247 const line_map_ordinary
*src
; // line map we're based on
3248 unsigned offset
; // offset to this line
3249 unsigned span
; // number of locs we span
3250 unsigned remap
; // serialization
3252 static int compare (const void *a_
, const void *b_
)
3254 auto *a
= static_cast<const ord_loc_info
*> (a_
);
3255 auto *b
= static_cast<const ord_loc_info
*> (b_
);
3257 if (a
->src
!= b
->src
)
3258 return a
->src
< b
->src
? -1 : +1;
3260 // Ensure no overlap
3261 gcc_checking_assert (a
->offset
+ a
->span
<= b
->offset
3262 || b
->offset
+ b
->span
<= a
->offset
);
3264 gcc_checking_assert (a
->offset
!= b
->offset
);
3265 return a
->offset
< b
->offset
? -1 : +1;
3268 struct ord_loc_traits
3270 typedef ord_loc_info value_type
;
3271 typedef value_type compare_type
;
3273 static const bool empty_zero_p
= false;
3275 static hashval_t
hash (const value_type
&v
)
3277 auto h
= pointer_hash
<const line_map_ordinary
>::hash (v
.src
);
3278 return iterative_hash_hashval_t (v
.offset
, h
);
3280 static bool equal (const value_type
&v
, const compare_type p
)
3282 return v
.src
== p
.src
&& v
.offset
== p
.offset
;
3285 static void mark_empty (value_type
&v
)
3289 static bool is_empty (value_type
&v
)
3294 static bool is_deleted (value_type
&) { return false; }
3295 static void mark_deleted (value_type
&) { gcc_unreachable (); }
3297 static void remove (value_type
&) {}
3299 /* Table keyed by ord_loc_info, used for noting. */
3300 static hash_table
<ord_loc_traits
> *ord_loc_table
;
3301 /* Sorted vector, used for writing. */
3302 static vec
<ord_loc_info
> *ord_loc_remap
;
3304 /* Information about macro locations we stream out. */
3305 struct macro_loc_info
3307 const line_map_macro
*src
; // original expansion
3308 unsigned remap
; // serialization
3310 static int compare (const void *a_
, const void *b_
)
3312 auto *a
= static_cast<const macro_loc_info
*> (a_
);
3313 auto *b
= static_cast<const macro_loc_info
*> (b_
);
3315 gcc_checking_assert (MAP_START_LOCATION (a
->src
)
3316 != MAP_START_LOCATION (b
->src
));
3317 if (MAP_START_LOCATION (a
->src
) < MAP_START_LOCATION (b
->src
))
3323 struct macro_loc_traits
3325 typedef macro_loc_info value_type
;
3326 typedef const line_map_macro
*compare_type
;
3328 static const bool empty_zero_p
= false;
3330 static hashval_t
hash (compare_type p
)
3332 return pointer_hash
<const line_map_macro
>::hash (p
);
3334 static hashval_t
hash (const value_type
&v
)
3336 return hash (v
.src
);
3338 static bool equal (const value_type
&v
, const compare_type p
)
3343 static void mark_empty (value_type
&v
)
3347 static bool is_empty (value_type
&v
)
3352 static bool is_deleted (value_type
&) { return false; }
3353 static void mark_deleted (value_type
&) { gcc_unreachable (); }
3355 static void remove (value_type
&) {}
3357 /* Table keyed by line_map_macro, used for noting. */
3358 static hash_table
<macro_loc_traits
> *macro_loc_table
;
3359 /* Sorted vector, used for writing. */
3360 static vec
<macro_loc_info
> *macro_loc_remap
;
3362 /* Indirection to allow bsearching imports by ordinary location. */
3363 static vec
<module_state
*> *ool
;
3365 /********************************************************************/
3366 /* Data needed by a module during the process of loading. */
3367 struct GTY(()) slurping
{
3369 /* Remap import's module numbering to our numbering. Values are
3370 shifted by 1. Bit0 encodes if the import is direct. */
3371 vec
<unsigned, va_heap
, vl_embed
> *
3372 GTY((skip
)) remap
; /* Module owner remapping. */
3374 elf_in
*GTY((skip
)) from
; /* The elf loader. */
3376 /* This map is only for header imports themselves -- the global
3377 headers bitmap hold it for the current TU. */
3378 bitmap headers
; /* Transitive set of direct imports, including
3379 self. Used for macro visibility and
3382 /* These objects point into the mmapped area, unless we're not doing
3383 that, or we got frozen or closed. In those cases they point to
3385 bytes_in macro_defs
; /* Macro definitions. */
3386 bytes_in macro_tbl
; /* Macro table. */
3388 /* Location remapping. first->ordinary, second->macro. */
3389 range_t
GTY((skip
)) loc_deltas
;
3391 unsigned current
; /* Section currently being loaded. */
3392 unsigned remaining
; /* Number of lazy sections yet to read. */
3393 unsigned lru
; /* An LRU counter. */
3396 slurping (elf_in
*);
3400 /* Close the ELF file, if it's open. */
3412 void release_macros ();
3415 void alloc_remap (unsigned size
)
3417 gcc_assert (!remap
);
3418 vec_safe_reserve (remap
, size
);
3419 for (unsigned ix
= size
; ix
--;)
3420 remap
->quick_push (0);
3422 unsigned remap_module (unsigned owner
)
3424 if (owner
< remap
->length ())
3425 return (*remap
)[owner
] >> 1;
3430 /* GC allocation. But we must explicitly delete it. */
3431 static void *operator new (size_t x
)
3433 return ggc_alloc_atomic (x
);
3435 static void operator delete (void *p
)
3441 slurping::slurping (elf_in
*from
)
3442 : remap (NULL
), from (from
),
3443 headers (BITMAP_GGC_ALLOC ()), macro_defs (), macro_tbl (),
3445 current (~0u), remaining (0), lru (0)
3449 slurping::~slurping ()
3457 void slurping::release_macros ()
3459 if (macro_defs
.size
)
3460 elf_in::release (from
, macro_defs
);
3462 elf_in::release (from
, macro_tbl
);
3465 /* Flags for extensions that end up being streamed. */
3467 enum streamed_extensions
{
3472 /* Counter indices. */
3473 enum module_state_counts
3486 /********************************************************************/
3487 struct module_state_config
;
3489 /* Increasing levels of loadedness. */
3490 enum module_loadedness
{
3491 ML_NONE
, /* Not loaded. */
3492 ML_CONFIG
, /* Config loaed. */
3493 ML_PREPROCESSOR
, /* Preprocessor loaded. */
3494 ML_LANGUAGE
, /* Language loaded. */
3497 /* Increasing levels of directness (toplevel) of import. */
3498 enum module_directness
{
3499 MD_NONE
, /* Not direct. */
3500 MD_PARTITION_DIRECT
, /* Direct import of a partition. */
3501 MD_DIRECT
, /* Direct import. */
3502 MD_PURVIEW_DIRECT
, /* direct import in purview. */
3505 /* State of a particular module. */
3507 class GTY((chain_next ("%h.parent"), for_user
)) module_state
{
3509 /* We always import & export ourselves. */
3510 bitmap imports
; /* Transitive modules we're importing. */
3511 bitmap exports
; /* Subset of that, that we're exporting. */
3513 module_state
*parent
;
3514 tree name
; /* Name of the module. */
3516 slurping
*slurp
; /* Data for loading. */
3518 const char *flatname
; /* Flatname of module. */
3519 char *filename
; /* CMI Filename */
3521 /* Indices into the entity_ary. */
3522 unsigned entity_lwm
;
3523 unsigned entity_num
;
3525 /* Location ranges for this module. adhoc-locs are decomposed, so
3526 don't have a range. */
3527 loc_range_t
GTY((skip
)) ordinary_locs
;
3528 loc_range_t
GTY((skip
)) macro_locs
; // [lwm,num)
3530 /* LOC is first set too the importing location. When initially
3531 loaded it refers to a module loc whose parent is the importing
3533 location_t loc
; /* Location referring to module itself. */
3534 unsigned crc
; /* CRC we saw reading it in. */
3536 unsigned mod
; /* Module owner number. */
3537 unsigned remap
; /* Remapping during writing. */
3539 unsigned short subst
; /* Mangle subst if !0. */
3541 /* How loaded this module is. */
3542 enum module_loadedness loadedness
: 2;
3544 bool module_p
: 1; /* /The/ module of this TU. */
3545 bool header_p
: 1; /* Is a header unit. */
3546 bool interface_p
: 1; /* An interface. */
3547 bool partition_p
: 1; /* A partition. */
3549 /* How directly this module is imported. */
3550 enum module_directness directness
: 2;
3552 bool exported_p
: 1; /* directness != MD_NONE && exported. */
3553 bool cmi_noted_p
: 1; /* We've told the user about the CMI, don't
3555 bool active_init_p
: 1; /* This module's global initializer needs
3557 bool inform_cmi_p
: 1; /* Inform of a read/write. */
3558 bool visited_p
: 1; /* A walk-once flag. */
3559 /* Record extensions emitted or permitted. */
3560 unsigned extensions
: SE_BITS
;
3561 /* 14 bits used, 2 bits remain */
3564 module_state (tree name
, module_state
*, bool);
3570 imports
= exports
= NULL
;
3578 elf_in
*from () const
3584 /* Kind of this module. */
3585 bool is_module () const
3589 bool is_header () const
3593 bool is_interface () const
3597 bool is_partition () const
3602 /* How this module is used in the current TU. */
3603 bool is_exported () const
3607 bool is_direct () const
3609 return directness
>= MD_DIRECT
;
3611 bool is_purview_direct () const
3613 return directness
== MD_PURVIEW_DIRECT
;
3615 bool is_partition_direct () const
3617 return directness
== MD_PARTITION_DIRECT
;
3621 /* Is this a real module? */
3622 bool has_location () const
3624 return loc
!= UNKNOWN_LOCATION
;
3628 bool check_not_purview (location_t loc
);
3631 void mangle (bool include_partition
);
3634 void set_import (module_state
const *, bool is_export
);
3635 void announce (const char *) const;
3638 /* Read and write module. */
3639 void write_begin (elf_out
*to
, cpp_reader
*,
3640 module_state_config
&, unsigned &crc
);
3641 void write_end (elf_out
*to
, cpp_reader
*,
3642 module_state_config
&, unsigned &crc
);
3643 bool read_initial (cpp_reader
*);
3644 bool read_preprocessor (bool);
3645 bool read_language (bool);
3648 /* Read a section. */
3649 bool load_section (unsigned snum
, binding_slot
*mslot
);
3650 /* Lazily read a section. */
3651 bool lazy_load (unsigned index
, binding_slot
*mslot
);
3654 /* Juggle a limited number of file numbers. */
3655 static void freeze_an_elf ();
3656 bool maybe_defrost ();
3659 void maybe_completed_reading ();
3660 bool check_read (bool outermost
, bool ok
);
3663 /* The README, for human consumption. */
3664 void write_readme (elf_out
*to
, cpp_reader
*, const char *dialect
);
3665 void write_env (elf_out
*to
);
3668 /* Import tables. */
3669 void write_imports (bytes_out
&cfg
, bool direct
);
3670 unsigned read_imports (bytes_in
&cfg
, cpp_reader
*, line_maps
*maps
);
3673 void write_imports (elf_out
*to
, unsigned *crc_ptr
);
3674 bool read_imports (cpp_reader
*, line_maps
*);
3677 void write_partitions (elf_out
*to
, unsigned, unsigned *crc_ptr
);
3678 bool read_partitions (unsigned);
3681 void write_config (elf_out
*to
, struct module_state_config
&, unsigned crc
);
3682 bool read_config (struct module_state_config
&);
3683 static void write_counts (elf_out
*to
, unsigned [MSC_HWM
], unsigned *crc_ptr
);
3684 bool read_counts (unsigned *);
3687 void note_cmi_name ();
3690 static unsigned write_bindings (elf_out
*to
, vec
<depset
*> depsets
,
3692 bool read_bindings (unsigned count
, unsigned lwm
, unsigned hwm
);
3694 static void write_namespace (bytes_out
&sec
, depset
*ns_dep
);
3695 tree
read_namespace (bytes_in
&sec
);
3697 void write_namespaces (elf_out
*to
, vec
<depset
*> spaces
,
3698 unsigned, unsigned *crc_ptr
);
3699 bool read_namespaces (unsigned);
3701 void intercluster_seed (trees_out
&sec
, unsigned index
, depset
*dep
);
3702 unsigned write_cluster (elf_out
*to
, depset
*depsets
[], unsigned size
,
3703 depset::hash
&, unsigned *counts
, unsigned *crc_ptr
);
3704 bool read_cluster (unsigned snum
);
3707 unsigned write_inits (elf_out
*to
, depset::hash
&, unsigned *crc_ptr
);
3708 bool read_inits (unsigned count
);
3711 unsigned write_pendings (elf_out
*to
, vec
<depset
*> depsets
,
3712 depset::hash
&, unsigned *crc_ptr
);
3713 bool read_pendings (unsigned count
);
3716 void write_entities (elf_out
*to
, vec
<depset
*> depsets
,
3717 unsigned count
, unsigned *crc_ptr
);
3718 bool read_entities (unsigned count
, unsigned lwm
, unsigned hwm
);
3721 void write_init_maps ();
3722 range_t
write_prepare_maps (module_state_config
*, bool);
3723 bool read_prepare_maps (const module_state_config
*);
3725 void write_ordinary_maps (elf_out
*to
, range_t
&,
3726 bool, unsigned *crc_ptr
);
3727 bool read_ordinary_maps (unsigned, unsigned);
3728 void write_macro_maps (elf_out
*to
, range_t
&, unsigned *crc_ptr
);
3729 bool read_macro_maps (unsigned);
3732 void write_define (bytes_out
&, const cpp_macro
*);
3733 cpp_macro
*read_define (bytes_in
&, cpp_reader
*) const;
3734 vec
<cpp_hashnode
*> *prepare_macros (cpp_reader
*);
3735 unsigned write_macros (elf_out
*to
, vec
<cpp_hashnode
*> *, unsigned *crc_ptr
);
3736 bool read_macros ();
3737 void install_macros ();
3740 void import_macros ();
3743 static void undef_macro (cpp_reader
*, location_t
, cpp_hashnode
*);
3744 static cpp_macro
*deferred_macro (cpp_reader
*, location_t
, cpp_hashnode
*);
3747 static bool note_location (location_t
);
3748 static void write_location (bytes_out
&, location_t
);
3749 location_t
read_location (bytes_in
&) const;
3752 void set_flatname ();
3753 const char *get_flatname () const
3757 location_t
imported_from () const;
3760 void set_filename (const Cody::Packet
&);
3761 bool do_import (cpp_reader
*, bool outermost
);
3764 /* Hash module state by name. This cannot be a member of
3765 module_state, because of GTY restrictions. We never delete from
3766 the hash table, but ggc_ptr_hash doesn't support that
3769 struct module_state_hash
: ggc_ptr_hash
<module_state
> {
3770 typedef std::pair
<tree
,uintptr_t> compare_type
; /* {name,parent} */
3772 static inline hashval_t
hash (const value_type m
);
3773 static inline hashval_t
hash (const compare_type
&n
);
3774 static inline bool equal (const value_type existing
,
3775 const compare_type
&candidate
);
3778 module_state::module_state (tree name
, module_state
*parent
, bool partition
)
3779 : imports (BITMAP_GGC_ALLOC ()), exports (BITMAP_GGC_ALLOC ()),
3780 parent (parent
), name (name
), slurp (NULL
),
3781 flatname (NULL
), filename (NULL
),
3782 entity_lwm (~0u >> 1), entity_num (0),
3783 ordinary_locs (0, 0), macro_locs (0, 0),
3784 loc (UNKNOWN_LOCATION
),
3785 crc (0), mod (MODULE_UNKNOWN
), remap (0), subst (0)
3787 loadedness
= ML_NONE
;
3789 module_p
= header_p
= interface_p
= partition_p
= false;
3791 directness
= MD_NONE
;
3794 cmi_noted_p
= false;
3795 active_init_p
= false;
3797 partition_p
= partition
;
3799 inform_cmi_p
= false;
3803 if (name
&& TREE_CODE (name
) == STRING_CST
)
3807 const char *string
= TREE_STRING_POINTER (name
);
3808 gcc_checking_assert (string
[0] == '.'
3809 ? IS_DIR_SEPARATOR (string
[1])
3810 : IS_ABSOLUTE_PATH (string
));
3813 gcc_checking_assert (!(parent
&& header_p
));
3816 module_state::~module_state ()
3821 /* Hash module state. */
3823 module_name_hash (const_tree name
)
3825 if (TREE_CODE (name
) == STRING_CST
)
3826 return htab_hash_string (TREE_STRING_POINTER (name
));
3828 return IDENTIFIER_HASH_VALUE (name
);
3832 module_state_hash::hash (const value_type m
)
3834 hashval_t ph
= pointer_hash
<void>::hash
3835 (reinterpret_cast<void *> (reinterpret_cast<uintptr_t> (m
->parent
)
3836 | m
->is_partition ()));
3837 hashval_t nh
= module_name_hash (m
->name
);
3838 return iterative_hash_hashval_t (ph
, nh
);
3843 module_state_hash::hash (const compare_type
&c
)
3845 hashval_t ph
= pointer_hash
<void>::hash (reinterpret_cast<void *> (c
.second
));
3846 hashval_t nh
= module_name_hash (c
.first
);
3848 return iterative_hash_hashval_t (ph
, nh
);
3852 module_state_hash::equal (const value_type existing
,
3853 const compare_type
&candidate
)
3855 uintptr_t ep
= (reinterpret_cast<uintptr_t> (existing
->parent
)
3856 | existing
->is_partition ());
3857 if (ep
!= candidate
.second
)
3860 /* Identifier comparison is by pointer. If the string_csts happen
3861 to be the same object, then they're equal too. */
3862 if (existing
->name
== candidate
.first
)
3865 /* If neither are string csts, they can't be equal. */
3866 if (TREE_CODE (candidate
.first
) != STRING_CST
3867 || TREE_CODE (existing
->name
) != STRING_CST
)
3870 /* String equality. */
3871 if (TREE_STRING_LENGTH (existing
->name
)
3872 == TREE_STRING_LENGTH (candidate
.first
)
3873 && !memcmp (TREE_STRING_POINTER (existing
->name
),
3874 TREE_STRING_POINTER (candidate
.first
),
3875 TREE_STRING_LENGTH (existing
->name
)))
3881 /********************************************************************/
3885 static const char *module_mapper_name
;
3887 /* Deferred import queue (FIFO). */
3888 static vec
<module_state
*, va_heap
, vl_embed
> *pending_imports
;
3890 /* CMI repository path and workspace. */
3891 static char *cmi_repo
;
3892 static size_t cmi_repo_length
;
3893 static char *cmi_path
;
3894 static size_t cmi_path_alloc
;
3896 /* Count of available and loaded clusters. */
3897 static unsigned available_clusters
;
3898 static unsigned loaded_clusters
;
3900 /* What the current TU is. */
3901 unsigned module_kind
;
3904 static const std::pair
<tree
*, unsigned> global_tree_arys
[] =
3906 std::pair
<tree
*, unsigned> (sizetype_tab
, stk_type_kind_last
),
3907 std::pair
<tree
*, unsigned> (integer_types
, itk_none
),
3908 std::pair
<tree
*, unsigned> (global_trees
, TI_MODULE_HWM
),
3909 std::pair
<tree
*, unsigned> (c_global_trees
, CTI_MODULE_HWM
),
3910 std::pair
<tree
*, unsigned> (cp_global_trees
, CPTI_MODULE_HWM
),
3911 std::pair
<tree
*, unsigned> (NULL
, 0)
3913 static GTY(()) vec
<tree
, va_gc
> *fixed_trees
;
3914 static unsigned global_crc
;
3916 /* Lazy loading can open many files concurrently, there are
3917 per-process limits on that. We pay attention to the process limit,
3918 and attempt to increase it when we run out. Otherwise we use an
3919 LRU scheme to figure out who to flush. Note that if the import
3920 graph /depth/ exceeds lazy_limit, we'll exceed the limit. */
3921 static unsigned lazy_lru
; /* LRU counter. */
3922 static unsigned lazy_open
; /* Number of open modules */
3923 static unsigned lazy_limit
; /* Current limit of open modules. */
3924 static unsigned lazy_hard_limit
; /* Hard limit on open modules. */
3925 /* Account for source, assembler and dump files & directory searches.
3926 We don't keep the source file's open, so we don't have to account
3927 for #include depth. I think dump files are opened and closed per
3929 #define LAZY_HEADROOM 15 /* File descriptor headroom. */
3931 /* Vector of module state. Indexed by OWNER. Has at least 2 slots. */
3932 static GTY(()) vec
<module_state
*, va_gc
> *modules
;
3934 /* Hash of module state, findable by {name, parent}. */
3935 static GTY(()) hash_table
<module_state_hash
> *modules_hash
;
3937 /* Map of imported entities. We map DECL_UID to index of entity
3939 typedef hash_map
<unsigned/*UID*/, unsigned/*index*/,
3940 simple_hashmap_traits
<int_hash
<unsigned,0>, unsigned>
3942 static entity_map_t
*entity_map
;
3943 /* Doesn't need GTYing, because any tree referenced here is also
3944 findable by, symbol table, specialization table, return type of
3945 reachable function. */
3946 static vec
<binding_slot
, va_heap
, vl_embed
> *entity_ary
;
3948 /* Members entities of imported classes that are defined in this TU.
3949 These are where the entity's context is not from the current TU.
3950 We need to emit the definition (but not the enclosing class).
3952 We could find these by walking ALL the imported classes that we
3953 could provide a member definition. But that's expensive,
3954 especially when you consider lazy implicit member declarations,
3955 which could be ANY imported class. */
3956 static GTY(()) vec
<tree
, va_gc
> *class_members
;
3958 /* The same problem exists for class template partial
3959 specializations. Now that we have constraints, the invariant of
3960 expecting them in the instantiation table no longer holds. One of
3961 the constrained partial specializations will be there, but the
3962 others not so much. It's not even an unconstrained partial
3963 spacialization in the table :( so any partial template declaration
3964 is added to this list too. */
3965 static GTY(()) vec
<tree
, va_gc
> *partial_specializations
;
3967 /********************************************************************/
3969 /* Our module mapper (created lazily). */
3970 module_client
*mapper
;
3972 static module_client
*make_mapper (location_t loc
);
3973 inline module_client
*get_mapper (location_t loc
)
3977 res
= make_mapper (loc
);
3981 /********************************************************************/
3983 get_clone_target (tree decl
)
3987 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3989 tree res_orig
= DECL_CLONED_FUNCTION (DECL_TEMPLATE_RESULT (decl
));
3991 target
= DECL_TI_TEMPLATE (res_orig
);
3994 target
= DECL_CLONED_FUNCTION (decl
);
3996 gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (target
));
4001 /* Like FOR_EACH_CLONE, but will walk cloned templates. */
4002 #define FOR_EVERY_CLONE(CLONE, FN) \
4003 if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)); \
4005 for (CLONE = DECL_CHAIN (FN); \
4006 CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
4007 CLONE = DECL_CHAIN (CLONE))
4009 /* It'd be nice if USE_TEMPLATE was a field of template_info
4010 (a) it'd solve the enum case dealt with below,
4011 (b) both class templates and decl templates would store this in the
4013 (c) this function wouldn't need the by-ref arg, which is annoying. */
4016 node_template_info (tree decl
, int &use
)
4018 tree ti
= NULL_TREE
;
4020 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
4022 tree type
= TREE_TYPE (decl
);
4024 ti
= TYPE_TEMPLATE_INFO (type
);
4027 if (TYPE_LANG_SPECIFIC (type
))
4028 use_tpl
= CLASSTYPE_USE_TEMPLATE (type
);
4031 /* An enum, where we don't explicitly encode use_tpl.
4032 If the containing context (a type or a function), is
4033 an ({im,ex}plicit) instantiation, then this is too.
4034 If it's a partial or explicit specialization, then
4036 tree ctx
= CP_DECL_CONTEXT (decl
);
4038 ctx
= TYPE_NAME (ctx
);
4039 node_template_info (ctx
, use
);
4040 use_tpl
= use
!= 2 ? use
: 0;
4044 else if (DECL_LANG_SPECIFIC (decl
)
4046 || TREE_CODE (decl
) == TYPE_DECL
4047 || TREE_CODE (decl
) == FUNCTION_DECL
4048 || TREE_CODE (decl
) == FIELD_DECL
4049 || TREE_CODE (decl
) == CONCEPT_DECL
4050 || TREE_CODE (decl
) == TEMPLATE_DECL
))
4052 use_tpl
= DECL_USE_TEMPLATE (decl
);
4053 ti
= DECL_TEMPLATE_INFO (decl
);
4060 /* Find the index in entity_ary for an imported DECL. It should
4061 always be there, but bugs can cause it to be missing, and that can
4062 crash the crash reporting -- let's not do that! When streaming
4063 out we place entities from this module there too -- with negated
4067 import_entity_index (tree decl
, bool null_ok
= false)
4069 if (unsigned *slot
= entity_map
->get (DECL_UID (decl
)))
4072 gcc_checking_assert (null_ok
);
4076 /* Find the module for an imported entity at INDEX in the entity ary.
4077 There must be one. */
4079 static module_state
*
4080 import_entity_module (unsigned index
)
4082 if (index
> ~(~0u >> 1))
4083 /* This is an index for an exported entity. */
4084 return (*modules
)[0];
4086 /* Do not include the current TU (not an off-by-one error). */
4088 unsigned len
= modules
->length () - pos
;
4091 unsigned half
= len
/ 2;
4092 module_state
*probe
= (*modules
)[pos
+ half
];
4093 if (index
< probe
->entity_lwm
)
4095 else if (index
< probe
->entity_lwm
+ probe
->entity_num
)
4100 len
= len
- (half
+ 1);
4107 /********************************************************************/
4108 /* A dumping machinery. */
4113 LOCATION
= TDF_LINENO
, /* -lineno:Source location streaming. */
4114 DEPEND
= TDF_GRAPH
, /* -graph:Dependency graph construction. */
4115 CLUSTER
= TDF_BLOCKS
, /* -blocks:Clusters. */
4116 TREE
= TDF_UID
, /* -uid:Tree streaming. */
4117 MERGE
= TDF_ALIAS
, /* -alias:Mergeable Entities. */
4118 ELF
= TDF_ASMNAME
, /* -asmname:Elf data. */
4119 MACRO
= TDF_VOPS
/* -vops:Macros. */
4124 typedef vec
<module_state
*, va_heap
, vl_embed
> stack_t
;
4126 FILE *stream
; /* Dump stream. */
4127 unsigned indent
; /* Local indentation. */
4128 bool bol
; /* Beginning of line. */
4129 stack_t stack
; /* Trailing array of module_state. */
4131 bool nested_name (tree
); /* Dump a name following DECL_CONTEXT. */
4140 /* Push/pop module state dumping. */
4141 unsigned push (module_state
*);
4142 void pop (unsigned);
4145 /* Change local indentation. */
4155 gcc_checking_assert (dumps
->indent
);
4161 /* Is dump enabled?. */
4162 bool operator () (int mask
= 0)
4164 if (!dumps
|| !dumps
->stream
)
4166 if (mask
&& !(mask
& flags
))
4170 /* Dump some information. */
4171 bool operator () (const char *, ...);
4175 static dumper dump
= {0, dump_flags_t (0)};
4177 /* Push to dumping M. Return previous indentation level. */
4180 dumper::push (module_state
*m
)
4182 FILE *stream
= NULL
;
4183 if (!dumps
|| !dumps
->stack
.length ())
4185 stream
= dump_begin (module_dump_id
, &flags
);
4190 if (!dumps
|| !dumps
->stack
.space (1))
4192 /* Create or extend the dump implementor. */
4193 unsigned current
= dumps
? dumps
->stack
.length () : 0;
4194 unsigned count
= current
? current
* 2 : EXPERIMENT (1, 20);
4195 size_t alloc
= (offsetof (impl
, stack
)
4196 + impl::stack_t::embedded_size (count
));
4197 dumps
= XRESIZEVAR (impl
, dumps
, alloc
);
4198 dumps
->stack
.embedded_init (count
, current
);
4201 dumps
->stream
= stream
;
4203 unsigned n
= dumps
->indent
;
4206 dumps
->stack
.quick_push (m
);
4209 module_state
*from
= NULL
;
4211 if (dumps
->stack
.length () > 1)
4212 from
= dumps
->stack
[dumps
->stack
.length () - 2];
4215 dump (from
? "Starting module %M (from %M)"
4216 : "Starting module %M", m
, from
);
4222 /* Pop from dumping. Restore indentation to N. */
4224 void dumper::pop (unsigned n
)
4229 gcc_checking_assert (dump () && !dumps
->indent
);
4230 if (module_state
*m
= dumps
->stack
[dumps
->stack
.length () - 1])
4232 module_state
*from
= (dumps
->stack
.length () > 1
4233 ? dumps
->stack
[dumps
->stack
.length () - 2] : NULL
);
4234 dump (from
? "Finishing module %M (returning to %M)"
4235 : "Finishing module %M", m
, from
);
4237 dumps
->stack
.pop ();
4239 if (!dumps
->stack
.length ())
4241 dump_end (module_dump_id
, dumps
->stream
);
4242 dumps
->stream
= NULL
;
4246 /* Dump a nested name for arbitrary tree T. Sometimes it won't have a
4250 dumper::impl::nested_name (tree t
)
4252 tree ti
= NULL_TREE
;
4254 tree name
= NULL_TREE
;
4256 if (t
&& TREE_CODE (t
) == TREE_BINFO
)
4259 if (t
&& TYPE_P (t
))
4262 if (t
&& DECL_P (t
))
4264 if (t
== global_namespace
|| DECL_TEMPLATE_PARM_P (t
))
4266 else if (tree ctx
= DECL_CONTEXT (t
))
4267 if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
4268 || nested_name (ctx
))
4269 fputs ("::", stream
);
4272 ti
= node_template_info (t
, use_tpl
);
4273 if (ti
&& TREE_CODE (TI_TEMPLATE (ti
)) == TEMPLATE_DECL
4274 && (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
)) == t
))
4275 t
= TI_TEMPLATE (ti
);
4277 if (TREE_CODE (t
) == TEMPLATE_DECL
)
4279 fputs ("template ", stream
);
4280 not_tmpl
= DECL_TEMPLATE_RESULT (t
);
4284 && DECL_P (not_tmpl
)
4285 && DECL_LANG_SPECIFIC (not_tmpl
)
4286 && DECL_MODULE_IMPORT_P (not_tmpl
))
4288 /* We need to be careful here, so as to not explode on
4289 inconsistent data -- we're probably debugging, because
4290 Something Is Wrong. */
4291 unsigned index
= import_entity_index (t
, true);
4292 if (!(index
& ~(~0u >> 1)))
4293 origin
= import_entity_module (index
)->mod
;
4294 else if (index
> ~(~0u >> 1))
4295 /* An imported partition member that we're emitting. */
4301 name
= DECL_NAME (t
) ? DECL_NAME (t
)
4302 : HAS_DECL_ASSEMBLER_NAME_P (t
) ? DECL_ASSEMBLER_NAME_RAW (t
)
4309 switch (TREE_CODE (name
))
4312 fputs ("#unnamed#", stream
);
4315 case IDENTIFIER_NODE
:
4316 fwrite (IDENTIFIER_POINTER (name
), 1, IDENTIFIER_LENGTH (name
), stream
);
4320 print_hex (wi::to_wide (name
), stream
);
4324 /* If TREE_TYPE is NULL, this is a raw string. */
4325 fwrite (TREE_STRING_POINTER (name
), 1,
4326 TREE_STRING_LENGTH (name
) - (TREE_TYPE (name
) != NULL_TREE
),
4331 fputs ("#null#", stream
);
4335 const module_state
*module
= (*modules
)[origin
];
4336 fprintf (stream
, "@%s:%d", !module
? "" : !module
->name
? "(unnamed)"
4337 : module
->get_flatname (), origin
);
4339 else if (origin
== -2)
4340 fprintf (stream
, "@???");
4344 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (ti
));
4345 fputs ("<", stream
);
4347 for (int ix
= 0; ix
!= TREE_VEC_LENGTH (args
); ix
++)
4350 fputs (",", stream
);
4351 nested_name (TREE_VEC_ELT (args
, ix
));
4353 fputs (">", stream
);
4359 /* Formatted dumping. FORMAT begins with '+' do not emit a trailing
4360 new line. (Normally it is appended.)
4365 %N - name -- DECL_NAME
4366 %P - context:name pair
4367 %R - unsigned:unsigned ratio
4368 %S - symbol -- DECL_ASSEMBLER_NAME
4371 --- the following are printf-like, but without its flexibility
4378 We do not implement the printf modifiers. */
4381 dumper::operator () (const char *format
, ...)
4386 bool no_nl
= format
[0] == '+';
4391 /* Module import indent. */
4392 if (unsigned depth
= dumps
->stack
.length () - 1)
4394 const char *prefix
= ">>>>";
4395 fprintf (dumps
->stream
, (depth
<= strlen (prefix
)
4396 ? &prefix
[strlen (prefix
) - depth
]
4397 : ">.%d.>"), depth
);
4401 if (unsigned indent
= dumps
->indent
)
4403 const char *prefix
= " ";
4404 fprintf (dumps
->stream
, (indent
<= strlen (prefix
)
4405 ? &prefix
[strlen (prefix
) - indent
]
4406 : " .%d. "), indent
);
4412 va_start (args
, format
);
4413 while (const char *esc
= strchr (format
, '%'))
4415 fwrite (format
, 1, (size_t)(esc
- format
), dumps
->stream
);
4423 fputc ('%', dumps
->stream
);
4426 case 'C': /* Code */
4428 tree_code code
= (tree_code
)va_arg (args
, unsigned);
4429 fputs (get_tree_code_name (code
), dumps
->stream
);
4433 case 'I': /* Identifier. */
4435 tree t
= va_arg (args
, tree
);
4436 dumps
->nested_name (t
);
4440 case 'M': /* Module. */
4442 const char *str
= "(none)";
4443 if (module_state
*m
= va_arg (args
, module_state
*))
4445 if (!m
->has_location ())
4448 str
= m
->get_flatname ();
4450 fputs (str
, dumps
->stream
);
4454 case 'N': /* Name. */
4456 tree t
= va_arg (args
, tree
);
4457 while (t
&& TREE_CODE (t
) == OVERLOAD
)
4458 t
= OVL_FUNCTION (t
);
4459 fputc ('\'', dumps
->stream
);
4460 dumps
->nested_name (t
);
4461 fputc ('\'', dumps
->stream
);
4465 case 'P': /* Pair. */
4467 tree ctx
= va_arg (args
, tree
);
4468 tree name
= va_arg (args
, tree
);
4469 fputc ('\'', dumps
->stream
);
4470 dumps
->nested_name (ctx
);
4471 if (ctx
&& ctx
!= global_namespace
)
4472 fputs ("::", dumps
->stream
);
4473 dumps
->nested_name (name
);
4474 fputc ('\'', dumps
->stream
);
4478 case 'R': /* Ratio */
4480 unsigned a
= va_arg (args
, unsigned);
4481 unsigned b
= va_arg (args
, unsigned);
4482 fprintf (dumps
->stream
, "%.1f", (float) a
/ (b
+ !b
));
4486 case 'S': /* Symbol name */
4488 tree t
= va_arg (args
, tree
);
4489 if (t
&& TYPE_P (t
))
4491 if (t
&& HAS_DECL_ASSEMBLER_NAME_P (t
)
4492 && DECL_ASSEMBLER_NAME_SET_P (t
))
4494 fputc ('(', dumps
->stream
);
4495 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
)),
4497 fputc (')', dumps
->stream
);
4502 case 'U': /* long unsigned. */
4504 unsigned long u
= va_arg (args
, unsigned long);
4505 fprintf (dumps
->stream
, "%lu", u
);
4509 case 'V': /* Verson. */
4511 unsigned v
= va_arg (args
, unsigned);
4514 version2string (v
, string
);
4515 fputs (string
, dumps
->stream
);
4519 case 'c': /* Character. */
4521 int c
= va_arg (args
, int);
4522 fputc (c
, dumps
->stream
);
4526 case 'd': /* Decimal Int. */
4528 int d
= va_arg (args
, int);
4529 fprintf (dumps
->stream
, "%d", d
);
4533 case 'p': /* Pointer. */
4535 void *p
= va_arg (args
, void *);
4536 fprintf (dumps
->stream
, "%p", p
);
4540 case 's': /* String. */
4542 const char *s
= va_arg (args
, char *);
4543 gcc_checking_assert (s
);
4544 fputs (s
, dumps
->stream
);
4548 case 'u': /* Unsigned. */
4550 unsigned u
= va_arg (args
, unsigned);
4551 fprintf (dumps
->stream
, "%u", u
);
4555 case 'x': /* Hex. */
4557 unsigned x
= va_arg (args
, unsigned);
4558 fprintf (dumps
->stream
, "%x", x
);
4563 fputs (format
, dumps
->stream
);
4568 fputc ('\n', dumps
->stream
);
4573 struct note_def_cache_hasher
: ggc_cache_ptr_hash
<tree_node
>
4575 static int keep_cache_entry (tree t
)
4578 /* GTY is unfortunately not clever enough to conditionalize
4582 if (ggc_marked_p (t
))
4585 unsigned n
= dump
.push (NULL
);
4586 /* This might or might not be an error. We should note its
4587 dropping whichever. */
4588 dump () && dump ("Dropping %N from note_defs table", t
);
4595 /* We should stream each definition at most once.
4596 This needs to be a cache because there are cases where a definition
4597 ends up being not retained, and we need to drop those so we don't
4598 get confused if memory is reallocated. */
4599 typedef hash_table
<note_def_cache_hasher
> note_defs_table_t
;
4600 static GTY((cache
)) note_defs_table_t
*note_defs
;
4603 trees_in::assert_definition (tree decl ATTRIBUTE_UNUSED
,
4604 bool installing ATTRIBUTE_UNUSED
)
4607 tree
*slot
= note_defs
->find_slot (decl
, installing
? INSERT
: NO_INSERT
);
4608 tree not_tmpl
= STRIP_TEMPLATE (decl
);
4611 /* We must be inserting for the first time. */
4612 gcc_assert (!*slot
);
4616 /* If this is not the mergeable entity, it should not be in the
4617 table. If it is a non-global-module mergeable entity, it
4618 should be in the table. Global module entities could have been
4619 defined textually in the current TU and so might or might not
4621 gcc_assert (!is_duplicate (decl
)
4624 || !DECL_LANG_SPECIFIC (not_tmpl
)
4625 || !DECL_MODULE_PURVIEW_P (not_tmpl
)
4626 || (!DECL_MODULE_IMPORT_P (not_tmpl
)
4627 && header_module_p ())));
4629 if (not_tmpl
!= decl
)
4630 gcc_assert (!note_defs
->find_slot (not_tmpl
, NO_INSERT
));
4635 trees_out::assert_definition (tree decl ATTRIBUTE_UNUSED
)
4638 tree
*slot
= note_defs
->find_slot (decl
, INSERT
);
4639 gcc_assert (!*slot
);
4641 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4642 gcc_assert (!note_defs
->find_slot (DECL_TEMPLATE_RESULT (decl
), NO_INSERT
));
4646 /********************************************************************/
4653 pp_needs_newline (global_dc
->printer
) = true;
4654 diagnostic_set_last_function (global_dc
, (diagnostic_info
*) NULL
);
4659 /* Set the cmi repo. Strip trailing '/', '.' becomes NULL. */
4662 set_cmi_repo (const char *r
)
4664 XDELETEVEC (cmi_repo
);
4665 XDELETEVEC (cmi_path
);
4669 cmi_repo_length
= 0;
4674 size_t len
= strlen (r
);
4675 cmi_repo
= XNEWVEC (char, len
+ 1);
4676 memcpy (cmi_repo
, r
, len
+ 1);
4678 if (len
> 1 && IS_DIR_SEPARATOR (cmi_repo
[len
-1]))
4680 if (len
== 1 && cmi_repo
[0] == '.')
4683 cmi_repo_length
= len
;
4686 /* TO is a repo-relative name. Provide one that we may use from where
4690 maybe_add_cmi_prefix (const char *to
, size_t *len_p
= NULL
)
4692 size_t len
= len_p
|| cmi_repo_length
? strlen (to
) : 0;
4694 if (cmi_repo_length
&& !IS_ABSOLUTE_PATH (to
))
4696 if (cmi_path_alloc
< cmi_repo_length
+ len
+ 2)
4698 XDELETEVEC (cmi_path
);
4699 cmi_path_alloc
= cmi_repo_length
+ len
* 2 + 2;
4700 cmi_path
= XNEWVEC (char, cmi_path_alloc
);
4702 memcpy (cmi_path
, cmi_repo
, cmi_repo_length
);
4703 cmi_path
[cmi_repo_length
] = DIR_SEPARATOR
;
4706 memcpy (&cmi_path
[cmi_repo_length
+ 1], to
, len
+ 1);
4707 len
+= cmi_repo_length
+ 1;
4717 /* Try and create the directories of PATH. */
4720 create_dirs (char *path
)
4722 /* Try and create the missing directories. */
4723 for (char *base
= path
; *base
; base
++)
4724 if (IS_DIR_SEPARATOR (*base
))
4728 int failed
= mkdir (path
, S_IRWXU
| S_IRWXG
| S_IRWXO
);
4729 dump () && dump ("Mkdir ('%s') errno:=%u", path
, failed
? errno
: 0);
4732 /* Maybe racing with another creator (of a *different*
4739 /* Given a CLASSTYPE_DECL_LIST VALUE get the template friend decl,
4740 if that's what this is. */
4743 friend_from_decl_list (tree frnd
)
4747 if (TREE_CODE (frnd
) != TEMPLATE_DECL
)
4749 tree tmpl
= NULL_TREE
;
4752 res
= TYPE_NAME (frnd
);
4753 if (CLASS_TYPE_P (frnd
)
4754 && CLASSTYPE_TEMPLATE_INFO (frnd
))
4755 tmpl
= CLASSTYPE_TI_TEMPLATE (frnd
);
4757 else if (DECL_TEMPLATE_INFO (frnd
))
4759 tmpl
= DECL_TI_TEMPLATE (frnd
);
4760 if (TREE_CODE (tmpl
) != TEMPLATE_DECL
)
4764 if (tmpl
&& DECL_TEMPLATE_RESULT (tmpl
) == res
)
4772 find_enum_member (tree ctx
, tree name
)
4774 for (tree values
= TYPE_VALUES (ctx
);
4775 values
; values
= TREE_CHAIN (values
))
4776 if (DECL_NAME (TREE_VALUE (values
)) == name
)
4777 return TREE_VALUE (values
);
4782 /********************************************************************/
4783 /* Instrumentation gathered writing bytes. */
4786 bytes_out::instrument ()
4788 dump ("Wrote %u bytes in %u blocks", lengths
[3], spans
[3]);
4789 dump ("Wrote %u bits in %u bytes", lengths
[0] + lengths
[1], lengths
[2]);
4790 for (unsigned ix
= 0; ix
< 2; ix
++)
4791 dump (" %u %s spans of %R bits", spans
[ix
],
4792 ix
? "one" : "zero", lengths
[ix
], spans
[ix
]);
4793 dump (" %u blocks with %R bits padding", spans
[2],
4794 lengths
[2] * 8 - (lengths
[0] + lengths
[1]), spans
[2]);
4797 /* Instrumentation gathered writing trees. */
4799 trees_out::instrument ()
4803 bytes_out::instrument ();
4805 dump (" %u decl trees", decl_val_count
);
4806 dump (" %u other trees", tree_val_count
);
4807 dump (" %u back references", back_ref_count
);
4808 dump (" %u null trees", null_count
);
4812 /* Setup and teardown for a tree walk. */
4817 gcc_assert (!streaming_p () || !tree_map
.elements ());
4825 trees_out::end (elf_out
*sink
, unsigned name
, unsigned *crc_ptr
)
4827 gcc_checking_assert (streaming_p ());
4830 return parent::end (sink
, name
, crc_ptr
);
4836 gcc_assert (!streaming_p ());
4839 /* Do not parent::end -- we weren't streaming. */
4843 trees_out::mark_trees ()
4845 if (size_t size
= tree_map
.elements ())
4847 /* This isn't our first rodeo, destroy and recreate the
4848 tree_map. I'm a bad bad man. Use the previous size as a
4849 guess for the next one (so not all bad). */
4850 tree_map
.~ptr_int_hash_map ();
4851 new (&tree_map
) ptr_int_hash_map (size
);
4854 /* Install the fixed trees, with +ve references. */
4855 unsigned limit
= fixed_trees
->length ();
4856 for (unsigned ix
= 0; ix
!= limit
; ix
++)
4858 tree val
= (*fixed_trees
)[ix
];
4859 bool existed
= tree_map
.put (val
, ix
+ tag_fixed
);
4860 gcc_checking_assert (!TREE_VISITED (val
) && !existed
);
4861 TREE_VISITED (val
) = true;
4867 /* Unmark the trees we encountered */
4870 trees_out::unmark_trees ()
4872 ptr_int_hash_map::iterator
end (tree_map
.end ());
4873 for (ptr_int_hash_map::iterator
iter (tree_map
.begin ()); iter
!= end
; ++iter
)
4875 tree node
= reinterpret_cast<tree
> ((*iter
).first
);
4876 int ref
= (*iter
).second
;
4877 /* We should have visited the node, and converted its mergeable
4878 reference to a regular reference. */
4879 gcc_checking_assert (TREE_VISITED (node
)
4880 && (ref
<= tag_backref
|| ref
>= tag_fixed
));
4881 TREE_VISITED (node
) = false;
4885 /* Mark DECL for by-value walking. We do this by inserting it into
4886 the tree map with a reference of zero. May be called multiple
4887 times on the same node. */
4890 trees_out::mark_by_value (tree decl
)
4892 gcc_checking_assert (DECL_P (decl
)
4893 /* Enum consts are INTEGER_CSTS. */
4894 || TREE_CODE (decl
) == INTEGER_CST
4895 || TREE_CODE (decl
) == TREE_BINFO
);
4897 if (TREE_VISITED (decl
))
4898 /* Must already be forced or fixed. */
4899 gcc_checking_assert (*tree_map
.get (decl
) >= tag_value
);
4902 bool existed
= tree_map
.put (decl
, tag_value
);
4903 gcc_checking_assert (!existed
);
4904 TREE_VISITED (decl
) = true;
4909 trees_out::get_tag (tree t
)
4911 gcc_checking_assert (TREE_VISITED (t
));
4912 return *tree_map
.get (t
);
4915 /* Insert T into the map, return its tag number. */
4918 trees_out::insert (tree t
, walk_kind walk
)
4920 gcc_checking_assert (walk
!= WK_normal
|| !TREE_VISITED (t
));
4921 int tag
= --ref_num
;
4923 int &slot
= tree_map
.get_or_insert (t
, &existed
);
4924 gcc_checking_assert (TREE_VISITED (t
) == existed
4926 || (walk
== WK_value
&& slot
== tag_value
)));
4927 TREE_VISITED (t
) = true;
4933 /* Insert T into the backreference array. Return its back reference
4937 trees_in::insert (tree t
)
4939 gcc_checking_assert (t
|| get_overrun ());
4940 back_refs
.safe_push (t
);
4941 return -(int)back_refs
.length ();
4944 /* A chained set of decls. */
4947 trees_out::chained_decls (tree decls
)
4949 for (; decls
; decls
= DECL_CHAIN (decls
))
4951 if (VAR_OR_FUNCTION_DECL_P (decls
)
4952 && DECL_LOCAL_DECL_P (decls
))
4954 /* Make sure this is the first encounter, and mark for
4956 gcc_checking_assert (!TREE_VISITED (decls
)
4957 && !DECL_TEMPLATE_INFO (decls
));
4958 mark_by_value (decls
);
4962 tree_node (NULL_TREE
);
4966 trees_in::chained_decls ()
4968 tree decls
= NULL_TREE
;
4969 for (tree
*chain
= &decls
;;)
4970 if (tree decl
= tree_node ())
4972 if (!DECL_P (decl
) || DECL_CHAIN (decl
))
4978 chain
= &DECL_CHAIN (decl
);
4986 /* A vector of decls following DECL_CHAIN. */
4989 trees_out::vec_chained_decls (tree decls
)
4995 for (tree decl
= decls
; decl
; decl
= DECL_CHAIN (decl
))
5000 for (tree decl
= decls
; decl
; decl
= DECL_CHAIN (decl
))
5002 if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5003 && TYPE_NAME (TREE_TYPE (decl
)) != decl
)
5004 /* An anonynmous struct with a typedef name. An odd thing to
5006 tree_node (NULL_TREE
);
5012 vec
<tree
, va_heap
> *
5013 trees_in::vec_chained_decls ()
5015 vec
<tree
, va_heap
> *v
= NULL
;
5017 if (unsigned len
= u ())
5021 for (unsigned ix
= 0; ix
< len
; ix
++)
5023 tree decl
= tree_node ();
5024 if (decl
&& !DECL_P (decl
))
5029 v
->quick_push (decl
);
5042 /* A vector of trees. */
5045 trees_out::tree_vec (vec
<tree
, va_gc
> *v
)
5047 unsigned len
= vec_safe_length (v
);
5050 for (unsigned ix
= 0; ix
!= len
; ix
++)
5051 tree_node ((*v
)[ix
]);
5055 trees_in::tree_vec ()
5057 vec
<tree
, va_gc
> *v
= NULL
;
5058 if (unsigned len
= u ())
5061 for (unsigned ix
= 0; ix
!= len
; ix
++)
5062 v
->quick_push (tree_node ());
5067 /* A vector of tree pairs. */
5070 trees_out::tree_pair_vec (vec
<tree_pair_s
, va_gc
> *v
)
5072 unsigned len
= vec_safe_length (v
);
5076 for (unsigned ix
= 0; ix
!= len
; ix
++)
5078 tree_pair_s
const &s
= (*v
)[ix
];
5079 tree_node (s
.purpose
);
5080 tree_node (s
.value
);
5084 vec
<tree_pair_s
, va_gc
> *
5085 trees_in::tree_pair_vec ()
5087 vec
<tree_pair_s
, va_gc
> *v
= NULL
;
5088 if (unsigned len
= u ())
5091 for (unsigned ix
= 0; ix
!= len
; ix
++)
5094 s
.purpose
= tree_node ();
5095 s
.value
= tree_node ();
5103 trees_out::tree_list (tree list
, bool has_purpose
)
5105 for (; list
; list
= TREE_CHAIN (list
))
5107 gcc_checking_assert (TREE_VALUE (list
));
5108 tree_node (TREE_VALUE (list
));
5110 tree_node (TREE_PURPOSE (list
));
5112 tree_node (NULL_TREE
);
5116 trees_in::tree_list (bool has_purpose
)
5118 tree res
= NULL_TREE
;
5120 for (tree
*chain
= &res
; tree value
= tree_node ();
5121 chain
= &TREE_CHAIN (*chain
))
5123 tree purpose
= has_purpose
? tree_node () : NULL_TREE
;
5124 *chain
= build_tree_list (purpose
, value
);
5129 /* Start tree write. Write information to allocate the receiving
5133 trees_out::start (tree t
, bool code_streamed
)
5137 enum tree_code code
= TREE_CODE (t
);
5138 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
5139 /* All these types are TYPE_NON_COMMON. */
5140 gcc_checking_assert (code
== RECORD_TYPE
5141 || code
== UNION_TYPE
5142 || code
== ENUMERAL_TYPE
5143 || code
== TEMPLATE_TYPE_PARM
5144 || code
== TEMPLATE_TEMPLATE_PARM
5145 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
);
5151 switch (TREE_CODE (t
))
5154 if (VL_EXP_CLASS_P (t
))
5155 u (VL_EXP_OPERAND_LENGTH (t
));
5159 u (TREE_INT_CST_NUNITS (t
));
5160 u (TREE_INT_CST_EXT_NUNITS (t
));
5161 u (TREE_INT_CST_OFFSET_NUNITS (t
));
5165 state
->extensions
|= SE_OPENMP
;
5166 u (OMP_CLAUSE_CODE (t
));
5170 str (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
5174 u (VECTOR_CST_LOG2_NPATTERNS (t
));
5175 u (VECTOR_CST_NELTS_PER_PATTERN (t
));
5179 u (BINFO_N_BASE_BINFOS (t
));
5183 u (TREE_VEC_LENGTH (t
));
5188 gcc_unreachable (); /* Not supported in C++. */
5191 case IDENTIFIER_NODE
:
5193 case TARGET_MEM_REF
:
5194 case TRANSLATION_UNIT_DECL
:
5195 /* We shouldn't meet these. */
5201 /* Start tree read. Allocate the receiving node. */
5204 trees_in::start (unsigned code
)
5214 if (code
>= MAX_TREE_CODES
)
5220 else if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5222 unsigned ops
= u ();
5223 t
= build_vl_exp (tree_code (code
), ops
);
5226 t
= make_node (tree_code (code
));
5233 t
= make_int_cst (n
, e
);
5234 TREE_INT_CST_OFFSET_NUNITS(t
) = u ();
5240 if (!(state
->extensions
& SE_OPENMP
))
5243 unsigned omp_code
= u ();
5244 t
= build_omp_clause (UNKNOWN_LOCATION
, omp_clause_code (omp_code
));
5251 const char *chars
= str (&l
);
5252 t
= build_string (l
, chars
);
5258 unsigned log2_npats
= u ();
5259 unsigned elts_per
= u ();
5260 t
= make_vector (log2_npats
, elts_per
);
5265 t
= make_tree_binfo (u ());
5269 t
= make_tree_vec (u ());
5273 case IDENTIFIER_NODE
:
5276 case TARGET_MEM_REF
:
5277 case TRANSLATION_UNIT_DECL
:
5284 /* The structure streamers access the raw fields, because the
5285 alternative, of using the accessor macros can require using
5286 different accessors for the same underlying field, depending on the
5287 tree code. That's both confusing and annoying. */
5289 /* Read & write the core boolean flags. */
5292 trees_out::core_bools (tree t
)
5294 #define WB(X) (b (X))
5295 tree_code code
= TREE_CODE (t
);
5297 WB (t
->base
.side_effects_flag
);
5298 WB (t
->base
.constant_flag
);
5299 WB (t
->base
.addressable_flag
);
5300 WB (t
->base
.volatile_flag
);
5301 WB (t
->base
.readonly_flag
);
5302 /* base.asm_written_flag is a property of the current TU's use of
5304 WB (t
->base
.nowarning_flag
);
5305 /* base.visited read as zero (it's set for writer, because that's
5306 how we mark nodes). */
5307 /* base.used_flag is not streamed. Readers may set TREE_USED of
5309 WB (t
->base
.nothrow_flag
);
5310 WB (t
->base
.static_flag
);
5311 if (TREE_CODE_CLASS (code
) != tcc_type
)
5312 /* This is TYPE_CACHED_VALUES_P for types. */
5313 WB (t
->base
.public_flag
);
5314 WB (t
->base
.private_flag
);
5315 WB (t
->base
.protected_flag
);
5316 WB (t
->base
.deprecated_flag
);
5317 WB (t
->base
.default_def_flag
);
5324 case TARGET_MEM_REF
:
5326 /* These use different base.u fields. */
5330 WB (t
->base
.u
.bits
.lang_flag_0
);
5331 bool flag_1
= t
->base
.u
.bits
.lang_flag_1
;
5334 else if (code
== TEMPLATE_INFO
)
5335 /* This is TI_PENDING_TEMPLATE_FLAG, not relevant to reader. */
5337 else if (code
== VAR_DECL
)
5339 /* This is DECL_INITIALIZED_P. */
5340 if (TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
5341 /* We'll set this when reading the definition. */
5345 WB (t
->base
.u
.bits
.lang_flag_2
);
5346 WB (t
->base
.u
.bits
.lang_flag_3
);
5347 WB (t
->base
.u
.bits
.lang_flag_4
);
5348 WB (t
->base
.u
.bits
.lang_flag_5
);
5349 WB (t
->base
.u
.bits
.lang_flag_6
);
5350 WB (t
->base
.u
.bits
.saturating_flag
);
5351 WB (t
->base
.u
.bits
.unsigned_flag
);
5352 WB (t
->base
.u
.bits
.packed_flag
);
5353 WB (t
->base
.u
.bits
.user_align
);
5354 WB (t
->base
.u
.bits
.nameless_flag
);
5355 WB (t
->base
.u
.bits
.atomic_flag
);
5359 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5361 WB (t
->type_common
.no_force_blk_flag
);
5362 WB (t
->type_common
.needs_constructing_flag
);
5363 WB (t
->type_common
.transparent_aggr_flag
);
5364 WB (t
->type_common
.restrict_flag
);
5365 WB (t
->type_common
.string_flag
);
5366 WB (t
->type_common
.lang_flag_0
);
5367 WB (t
->type_common
.lang_flag_1
);
5368 WB (t
->type_common
.lang_flag_2
);
5369 WB (t
->type_common
.lang_flag_3
);
5370 WB (t
->type_common
.lang_flag_4
);
5371 WB (t
->type_common
.lang_flag_5
);
5372 WB (t
->type_common
.lang_flag_6
);
5373 WB (t
->type_common
.typeless_storage
);
5376 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5378 WB (t
->decl_common
.nonlocal_flag
);
5379 WB (t
->decl_common
.virtual_flag
);
5380 WB (t
->decl_common
.ignored_flag
);
5381 WB (t
->decl_common
.abstract_flag
);
5382 WB (t
->decl_common
.artificial_flag
);
5383 WB (t
->decl_common
.preserve_flag
);
5384 WB (t
->decl_common
.debug_expr_is_from
);
5385 WB (t
->decl_common
.lang_flag_0
);
5386 WB (t
->decl_common
.lang_flag_1
);
5387 WB (t
->decl_common
.lang_flag_2
);
5388 WB (t
->decl_common
.lang_flag_3
);
5389 WB (t
->decl_common
.lang_flag_4
);
5390 WB (t
->decl_common
.lang_flag_5
);
5391 WB (t
->decl_common
.lang_flag_6
);
5392 WB (t
->decl_common
.lang_flag_7
);
5393 WB (t
->decl_common
.lang_flag_8
);
5394 WB (t
->decl_common
.decl_flag_0
);
5397 /* DECL_EXTERNAL -> decl_flag_1
5398 == it is defined elsewhere
5399 DECL_NOT_REALLY_EXTERN -> base.not_really_extern
5400 == that was a lie, it is here */
5402 bool is_external
= t
->decl_common
.decl_flag_1
;
5404 /* decl_flag_1 is DECL_EXTERNAL. Things we emit here, might
5405 well be external from the POV of an importer. */
5406 // FIXME: Do we need to know if this is a TEMPLATE_RESULT --
5407 // a flag from the caller?
5415 && !(TREE_STATIC (t
)
5416 && DECL_FUNCTION_SCOPE_P (t
)
5417 && DECL_DECLARED_INLINE_P (DECL_CONTEXT (t
)))
5418 && !DECL_VAR_DECLARED_INLINE_P (t
))
5424 && !DECL_DECLARED_INLINE_P (t
))
5431 WB (t
->decl_common
.decl_flag_2
);
5432 WB (t
->decl_common
.decl_flag_3
);
5433 WB (t
->decl_common
.not_gimple_reg_flag
);
5434 WB (t
->decl_common
.decl_by_reference_flag
);
5435 WB (t
->decl_common
.decl_read_flag
);
5436 WB (t
->decl_common
.decl_nonshareable_flag
);
5437 WB (t
->decl_common
.decl_not_flexarray
);
5440 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
5442 WB (t
->decl_with_vis
.defer_output
);
5443 WB (t
->decl_with_vis
.hard_register
);
5444 WB (t
->decl_with_vis
.common_flag
);
5445 WB (t
->decl_with_vis
.in_text_section
);
5446 WB (t
->decl_with_vis
.in_constant_pool
);
5447 WB (t
->decl_with_vis
.dllimport_flag
);
5448 WB (t
->decl_with_vis
.weak_flag
);
5449 WB (t
->decl_with_vis
.seen_in_bind_expr
);
5450 WB (t
->decl_with_vis
.comdat_flag
);
5451 WB (t
->decl_with_vis
.visibility_specified
);
5452 WB (t
->decl_with_vis
.init_priority_p
);
5453 WB (t
->decl_with_vis
.shadowed_for_var_p
);
5454 WB (t
->decl_with_vis
.cxx_constructor
);
5455 WB (t
->decl_with_vis
.cxx_destructor
);
5456 WB (t
->decl_with_vis
.final
);
5457 WB (t
->decl_with_vis
.regdecl_flag
);
5460 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
5462 WB (t
->function_decl
.static_ctor_flag
);
5463 WB (t
->function_decl
.static_dtor_flag
);
5464 WB (t
->function_decl
.uninlinable
);
5465 WB (t
->function_decl
.possibly_inlined
);
5466 WB (t
->function_decl
.novops_flag
);
5467 WB (t
->function_decl
.returns_twice_flag
);
5468 WB (t
->function_decl
.malloc_flag
);
5469 WB (t
->function_decl
.declared_inline_flag
);
5470 WB (t
->function_decl
.no_inline_warning_flag
);
5471 WB (t
->function_decl
.no_instrument_function_entry_exit
);
5472 WB (t
->function_decl
.no_limit_stack
);
5473 WB (t
->function_decl
.disregard_inline_limits
);
5474 WB (t
->function_decl
.pure_flag
);
5475 WB (t
->function_decl
.looping_const_or_pure_flag
);
5477 WB (t
->function_decl
.has_debug_args_flag
);
5478 WB (t
->function_decl
.versioned_function
);
5480 /* decl_type is a (misnamed) 2 bit discriminator. */
5481 unsigned kind
= t
->function_decl
.decl_type
;
5482 WB ((kind
>> 0) & 1);
5483 WB ((kind
>> 1) & 1);
5489 trees_in::core_bools (tree t
)
5491 #define RB(X) ((X) = b ())
5492 tree_code code
= TREE_CODE (t
);
5494 RB (t
->base
.side_effects_flag
);
5495 RB (t
->base
.constant_flag
);
5496 RB (t
->base
.addressable_flag
);
5497 RB (t
->base
.volatile_flag
);
5498 RB (t
->base
.readonly_flag
);
5499 /* base.asm_written_flag is not streamed. */
5500 RB (t
->base
.nowarning_flag
);
5501 /* base.visited is not streamed. */
5502 /* base.used_flag is not streamed. */
5503 RB (t
->base
.nothrow_flag
);
5504 RB (t
->base
.static_flag
);
5505 if (TREE_CODE_CLASS (code
) != tcc_type
)
5506 RB (t
->base
.public_flag
);
5507 RB (t
->base
.private_flag
);
5508 RB (t
->base
.protected_flag
);
5509 RB (t
->base
.deprecated_flag
);
5510 RB (t
->base
.default_def_flag
);
5517 case TARGET_MEM_REF
:
5519 /* These use different base.u fields. */
5523 RB (t
->base
.u
.bits
.lang_flag_0
);
5524 RB (t
->base
.u
.bits
.lang_flag_1
);
5525 RB (t
->base
.u
.bits
.lang_flag_2
);
5526 RB (t
->base
.u
.bits
.lang_flag_3
);
5527 RB (t
->base
.u
.bits
.lang_flag_4
);
5528 RB (t
->base
.u
.bits
.lang_flag_5
);
5529 RB (t
->base
.u
.bits
.lang_flag_6
);
5530 RB (t
->base
.u
.bits
.saturating_flag
);
5531 RB (t
->base
.u
.bits
.unsigned_flag
);
5532 RB (t
->base
.u
.bits
.packed_flag
);
5533 RB (t
->base
.u
.bits
.user_align
);
5534 RB (t
->base
.u
.bits
.nameless_flag
);
5535 RB (t
->base
.u
.bits
.atomic_flag
);
5539 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5541 RB (t
->type_common
.no_force_blk_flag
);
5542 RB (t
->type_common
.needs_constructing_flag
);
5543 RB (t
->type_common
.transparent_aggr_flag
);
5544 RB (t
->type_common
.restrict_flag
);
5545 RB (t
->type_common
.string_flag
);
5546 RB (t
->type_common
.lang_flag_0
);
5547 RB (t
->type_common
.lang_flag_1
);
5548 RB (t
->type_common
.lang_flag_2
);
5549 RB (t
->type_common
.lang_flag_3
);
5550 RB (t
->type_common
.lang_flag_4
);
5551 RB (t
->type_common
.lang_flag_5
);
5552 RB (t
->type_common
.lang_flag_6
);
5553 RB (t
->type_common
.typeless_storage
);
5556 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5558 RB (t
->decl_common
.nonlocal_flag
);
5559 RB (t
->decl_common
.virtual_flag
);
5560 RB (t
->decl_common
.ignored_flag
);
5561 RB (t
->decl_common
.abstract_flag
);
5562 RB (t
->decl_common
.artificial_flag
);
5563 RB (t
->decl_common
.preserve_flag
);
5564 RB (t
->decl_common
.debug_expr_is_from
);
5565 RB (t
->decl_common
.lang_flag_0
);
5566 RB (t
->decl_common
.lang_flag_1
);
5567 RB (t
->decl_common
.lang_flag_2
);
5568 RB (t
->decl_common
.lang_flag_3
);
5569 RB (t
->decl_common
.lang_flag_4
);
5570 RB (t
->decl_common
.lang_flag_5
);
5571 RB (t
->decl_common
.lang_flag_6
);
5572 RB (t
->decl_common
.lang_flag_7
);
5573 RB (t
->decl_common
.lang_flag_8
);
5574 RB (t
->decl_common
.decl_flag_0
);
5575 RB (t
->decl_common
.decl_flag_1
);
5576 RB (t
->decl_common
.decl_flag_2
);
5577 RB (t
->decl_common
.decl_flag_3
);
5578 RB (t
->decl_common
.not_gimple_reg_flag
);
5579 RB (t
->decl_common
.decl_by_reference_flag
);
5580 RB (t
->decl_common
.decl_read_flag
);
5581 RB (t
->decl_common
.decl_nonshareable_flag
);
5582 RB (t
->decl_common
.decl_not_flexarray
);
5585 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
5587 RB (t
->decl_with_vis
.defer_output
);
5588 RB (t
->decl_with_vis
.hard_register
);
5589 RB (t
->decl_with_vis
.common_flag
);
5590 RB (t
->decl_with_vis
.in_text_section
);
5591 RB (t
->decl_with_vis
.in_constant_pool
);
5592 RB (t
->decl_with_vis
.dllimport_flag
);
5593 RB (t
->decl_with_vis
.weak_flag
);
5594 RB (t
->decl_with_vis
.seen_in_bind_expr
);
5595 RB (t
->decl_with_vis
.comdat_flag
);
5596 RB (t
->decl_with_vis
.visibility_specified
);
5597 RB (t
->decl_with_vis
.init_priority_p
);
5598 RB (t
->decl_with_vis
.shadowed_for_var_p
);
5599 RB (t
->decl_with_vis
.cxx_constructor
);
5600 RB (t
->decl_with_vis
.cxx_destructor
);
5601 RB (t
->decl_with_vis
.final
);
5602 RB (t
->decl_with_vis
.regdecl_flag
);
5605 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
5607 RB (t
->function_decl
.static_ctor_flag
);
5608 RB (t
->function_decl
.static_dtor_flag
);
5609 RB (t
->function_decl
.uninlinable
);
5610 RB (t
->function_decl
.possibly_inlined
);
5611 RB (t
->function_decl
.novops_flag
);
5612 RB (t
->function_decl
.returns_twice_flag
);
5613 RB (t
->function_decl
.malloc_flag
);
5614 RB (t
->function_decl
.declared_inline_flag
);
5615 RB (t
->function_decl
.no_inline_warning_flag
);
5616 RB (t
->function_decl
.no_instrument_function_entry_exit
);
5617 RB (t
->function_decl
.no_limit_stack
);
5618 RB (t
->function_decl
.disregard_inline_limits
);
5619 RB (t
->function_decl
.pure_flag
);
5620 RB (t
->function_decl
.looping_const_or_pure_flag
);
5622 RB (t
->function_decl
.has_debug_args_flag
);
5623 RB (t
->function_decl
.versioned_function
);
5625 /* decl_type is a (misnamed) 2 bit discriminator. */
5627 kind
|= unsigned (b ()) << 0;
5628 kind
|= unsigned (b ()) << 1;
5629 t
->function_decl
.decl_type
= function_decl_type (kind
);
5632 return !get_overrun ();
5636 trees_out::lang_decl_bools (tree t
)
5638 #define WB(X) (b (X))
5639 const struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
5641 WB (lang
->u
.base
.language
== lang_cplusplus
);
5642 WB ((lang
->u
.base
.use_template
>> 0) & 1);
5643 WB ((lang
->u
.base
.use_template
>> 1) & 1);
5644 /* Do not write lang->u.base.not_really_extern, importer will set
5645 when reading the definition (if any). */
5646 WB (lang
->u
.base
.initialized_in_class
);
5647 WB (lang
->u
.base
.threadprivate_or_deleted_p
);
5648 /* Do not write lang->u.base.anticipated_p, it is a property of the
5650 WB (lang
->u
.base
.friend_or_tls
);
5651 WB (lang
->u
.base
.unknown_bound_p
);
5652 /* Do not write lang->u.base.odr_used, importer will recalculate if
5653 they do ODR use this decl. */
5654 WB (lang
->u
.base
.concept_p
);
5655 WB (lang
->u
.base
.var_declared_inline_p
);
5656 WB (lang
->u
.base
.dependent_init_p
);
5657 /* When building a header unit, everthing is marked as purview, (so
5658 we know which decls to write). But when we import them we do not
5659 want to mark them as in module purview. */
5660 WB (lang
->u
.base
.module_purview_p
&& !header_module_p ());
5661 WB (lang
->u
.base
.module_attach_p
);
5662 if (VAR_OR_FUNCTION_DECL_P (t
))
5663 WB (lang
->u
.base
.module_keyed_decls_p
);
5664 switch (lang
->u
.base
.selector
)
5669 case lds_fn
: /* lang_decl_fn. */
5670 WB (lang
->u
.fn
.global_ctor_p
);
5671 WB (lang
->u
.fn
.global_dtor_p
);
5672 WB (lang
->u
.fn
.static_function
);
5673 WB (lang
->u
.fn
.pure_virtual
);
5674 WB (lang
->u
.fn
.defaulted_p
);
5675 WB (lang
->u
.fn
.has_in_charge_parm_p
);
5676 WB (lang
->u
.fn
.has_vtt_parm_p
);
5677 /* There shouldn't be a pending inline at this point. */
5678 gcc_assert (!lang
->u
.fn
.pending_inline_p
);
5679 WB (lang
->u
.fn
.nonconverting
);
5680 WB (lang
->u
.fn
.thunk_p
);
5681 WB (lang
->u
.fn
.this_thunk_p
);
5682 /* Do not stream lang->u.hidden_friend_p, it is a property of
5684 WB (lang
->u
.fn
.omp_declare_reduction_p
);
5685 WB (lang
->u
.fn
.has_dependent_explicit_spec_p
);
5686 WB (lang
->u
.fn
.immediate_fn_p
);
5687 WB (lang
->u
.fn
.maybe_deleted
);
5690 case lds_decomp
: /* lang_decl_decomp. */
5694 case lds_min
: /* lang_decl_min. */
5699 case lds_ns
: /* lang_decl_ns. */
5703 case lds_parm
: /* lang_decl_parm. */
5711 trees_in::lang_decl_bools (tree t
)
5713 #define RB(X) ((X) = b ())
5714 struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
5716 lang
->u
.base
.language
= b () ? lang_cplusplus
: lang_c
;
5720 lang
->u
.base
.use_template
= v
;
5721 /* lang->u.base.not_really_extern is not streamed. */
5722 RB (lang
->u
.base
.initialized_in_class
);
5723 RB (lang
->u
.base
.threadprivate_or_deleted_p
);
5724 /* lang->u.base.anticipated_p is not streamed. */
5725 RB (lang
->u
.base
.friend_or_tls
);
5726 RB (lang
->u
.base
.unknown_bound_p
);
5727 /* lang->u.base.odr_used is not streamed. */
5728 RB (lang
->u
.base
.concept_p
);
5729 RB (lang
->u
.base
.var_declared_inline_p
);
5730 RB (lang
->u
.base
.dependent_init_p
);
5731 RB (lang
->u
.base
.module_purview_p
);
5732 RB (lang
->u
.base
.module_attach_p
);
5733 if (VAR_OR_FUNCTION_DECL_P (t
))
5734 RB (lang
->u
.base
.module_keyed_decls_p
);
5735 switch (lang
->u
.base
.selector
)
5740 case lds_fn
: /* lang_decl_fn. */
5741 RB (lang
->u
.fn
.global_ctor_p
);
5742 RB (lang
->u
.fn
.global_dtor_p
);
5743 RB (lang
->u
.fn
.static_function
);
5744 RB (lang
->u
.fn
.pure_virtual
);
5745 RB (lang
->u
.fn
.defaulted_p
);
5746 RB (lang
->u
.fn
.has_in_charge_parm_p
);
5747 RB (lang
->u
.fn
.has_vtt_parm_p
);
5748 RB (lang
->u
.fn
.nonconverting
);
5749 RB (lang
->u
.fn
.thunk_p
);
5750 RB (lang
->u
.fn
.this_thunk_p
);
5751 /* lang->u.fn.hidden_friend_p is not streamed. */
5752 RB (lang
->u
.fn
.omp_declare_reduction_p
);
5753 RB (lang
->u
.fn
.has_dependent_explicit_spec_p
);
5754 RB (lang
->u
.fn
.immediate_fn_p
);
5755 RB (lang
->u
.fn
.maybe_deleted
);
5758 case lds_decomp
: /* lang_decl_decomp. */
5762 case lds_min
: /* lang_decl_min. */
5767 case lds_ns
: /* lang_decl_ns. */
5771 case lds_parm
: /* lang_decl_parm. */
5776 return !get_overrun ();
5780 trees_out::lang_type_bools (tree t
)
5782 #define WB(X) (b (X))
5783 const struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
5785 WB (lang
->has_type_conversion
);
5786 WB (lang
->has_copy_ctor
);
5787 WB (lang
->has_default_ctor
);
5788 WB (lang
->const_needs_init
);
5789 WB (lang
->ref_needs_init
);
5790 WB (lang
->has_const_copy_assign
);
5791 WB ((lang
->use_template
>> 0) & 1);
5792 WB ((lang
->use_template
>> 1) & 1);
5794 WB (lang
->has_mutable
);
5795 WB (lang
->com_interface
);
5796 WB (lang
->non_pod_class
);
5797 WB (lang
->nearly_empty_p
);
5798 WB (lang
->user_align
);
5799 WB (lang
->has_copy_assign
);
5801 WB (lang
->has_array_new
);
5803 WB ((lang
->gets_delete
>> 0) & 1);
5804 WB ((lang
->gets_delete
>> 1) & 1);
5805 // Interfaceness is recalculated upon reading. May have to revisit?
5806 // How do dllexport and dllimport interact across a module?
5807 // lang->interface_only
5808 // lang->interface_unknown
5809 WB (lang
->contains_empty_class_p
);
5810 WB (lang
->anon_aggr
);
5811 WB (lang
->non_zero_init
);
5814 WB (lang
->vec_new_uses_cookie
);
5815 WB (lang
->declared_class
);
5816 WB (lang
->diamond_shaped
);
5817 WB (lang
->repeated_base
);
5818 gcc_assert (!lang
->being_defined
);
5819 // lang->debug_requested
5820 WB (lang
->fields_readonly
);
5821 WB (lang
->ptrmemfunc_flag
);
5823 WB (lang
->lazy_default_ctor
);
5824 WB (lang
->lazy_copy_ctor
);
5825 WB (lang
->lazy_copy_assign
);
5826 WB (lang
->lazy_destructor
);
5827 WB (lang
->has_const_copy_ctor
);
5828 WB (lang
->has_complex_copy_ctor
);
5829 WB (lang
->has_complex_copy_assign
);
5830 WB (lang
->non_aggregate
);
5832 WB (lang
->has_complex_dflt
);
5833 WB (lang
->has_list_ctor
);
5834 WB (lang
->non_std_layout
);
5835 WB (lang
->is_literal
);
5836 WB (lang
->lazy_move_ctor
);
5837 WB (lang
->lazy_move_assign
);
5838 WB (lang
->has_complex_move_ctor
);
5839 WB (lang
->has_complex_move_assign
);
5841 WB (lang
->has_constexpr_ctor
);
5842 WB (lang
->unique_obj_representations
);
5843 WB (lang
->unique_obj_representations_set
);
5848 trees_in::lang_type_bools (tree t
)
5850 #define RB(X) ((X) = b ())
5851 struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
5853 RB (lang
->has_type_conversion
);
5854 RB (lang
->has_copy_ctor
);
5855 RB (lang
->has_default_ctor
);
5856 RB (lang
->const_needs_init
);
5857 RB (lang
->ref_needs_init
);
5858 RB (lang
->has_const_copy_assign
);
5862 lang
->use_template
= v
;
5864 RB (lang
->has_mutable
);
5865 RB (lang
->com_interface
);
5866 RB (lang
->non_pod_class
);
5867 RB (lang
->nearly_empty_p
);
5868 RB (lang
->user_align
);
5869 RB (lang
->has_copy_assign
);
5871 RB (lang
->has_array_new
);
5875 lang
->gets_delete
= v
;
5876 // lang->interface_only
5877 // lang->interface_unknown
5878 lang
->interface_unknown
= true; // Redetermine interface
5879 RB (lang
->contains_empty_class_p
);
5880 RB (lang
->anon_aggr
);
5881 RB (lang
->non_zero_init
);
5884 RB (lang
->vec_new_uses_cookie
);
5885 RB (lang
->declared_class
);
5886 RB (lang
->diamond_shaped
);
5887 RB (lang
->repeated_base
);
5888 gcc_assert (!lang
->being_defined
);
5889 gcc_assert (!lang
->debug_requested
);
5890 RB (lang
->fields_readonly
);
5891 RB (lang
->ptrmemfunc_flag
);
5893 RB (lang
->lazy_default_ctor
);
5894 RB (lang
->lazy_copy_ctor
);
5895 RB (lang
->lazy_copy_assign
);
5896 RB (lang
->lazy_destructor
);
5897 RB (lang
->has_const_copy_ctor
);
5898 RB (lang
->has_complex_copy_ctor
);
5899 RB (lang
->has_complex_copy_assign
);
5900 RB (lang
->non_aggregate
);
5902 RB (lang
->has_complex_dflt
);
5903 RB (lang
->has_list_ctor
);
5904 RB (lang
->non_std_layout
);
5905 RB (lang
->is_literal
);
5906 RB (lang
->lazy_move_ctor
);
5907 RB (lang
->lazy_move_assign
);
5908 RB (lang
->has_complex_move_ctor
);
5909 RB (lang
->has_complex_move_assign
);
5911 RB (lang
->has_constexpr_ctor
);
5912 RB (lang
->unique_obj_representations
);
5913 RB (lang
->unique_obj_representations_set
);
5915 return !get_overrun ();
5918 /* Read & write the core values and pointers. */
5921 trees_out::core_vals (tree t
)
5923 #define WU(X) (u (X))
5924 #define WT(X) (tree_node (X))
5925 tree_code code
= TREE_CODE (t
);
5927 /* First by shape of the tree. */
5929 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
5931 /* Write this early, for better log information. */
5932 WT (t
->decl_minimal
.name
);
5933 if (!DECL_TEMPLATE_PARM_P (t
))
5934 WT (t
->decl_minimal
.context
);
5937 state
->write_location (*this, t
->decl_minimal
.locus
);
5940 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5942 /* The only types we write also have TYPE_NON_COMMON. */
5943 gcc_checking_assert (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
));
5945 /* We only stream the main variant. */
5946 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
5948 /* Stream the name & context first, for better log information */
5949 WT (t
->type_common
.name
);
5950 WT (t
->type_common
.context
);
5952 /* By construction we want to make sure we have the canonical
5953 and main variants already in the type table, so emit them
5955 WT (t
->type_common
.main_variant
);
5957 tree canonical
= t
->type_common
.canonical
;
5958 if (canonical
&& DECL_TEMPLATE_PARM_P (TYPE_NAME (t
)))
5959 /* We do not want to wander into different templates.
5960 Reconstructed on stream in. */
5964 /* type_common.next_variant is internally manipulated. */
5965 /* type_common.pointer_to, type_common.reference_to. */
5969 WU (t
->type_common
.precision
);
5970 WU (t
->type_common
.contains_placeholder_bits
);
5971 WU (t
->type_common
.mode
);
5972 WU (t
->type_common
.align
);
5975 if (!RECORD_OR_UNION_CODE_P (code
))
5977 WT (t
->type_common
.size
);
5978 WT (t
->type_common
.size_unit
);
5980 WT (t
->type_common
.attributes
);
5982 WT (t
->type_common
.common
.chain
); /* TYPE_STUB_DECL. */
5985 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5989 WU (t
->decl_common
.mode
);
5990 WU (t
->decl_common
.off_align
);
5991 WU (t
->decl_common
.align
);
5994 /* For templates these hold instantiation (partial and/or
5995 specialization) information. */
5996 if (code
!= TEMPLATE_DECL
)
5998 WT (t
->decl_common
.size
);
5999 WT (t
->decl_common
.size_unit
);
6002 WT (t
->decl_common
.attributes
);
6003 // FIXME: Does this introduce cross-decl links? For instance
6004 // from instantiation to the template. If so, we'll need more
6005 // deduplication logic. I think we'll need to walk the blocks
6006 // of the owning function_decl's abstract origin in tandem, to
6007 // generate the locating data needed?
6008 WT (t
->decl_common
.abstract_origin
);
6011 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
6013 WT (t
->decl_with_vis
.assembler_name
);
6015 WU (t
->decl_with_vis
.visibility
);
6018 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
6020 if (code
== ENUMERAL_TYPE
)
6022 /* These fields get set even for opaque enums that lack a
6023 definition, so we stream them directly for each ENUMERAL_TYPE.
6024 We stream TYPE_VALUES as part of the definition. */
6025 WT (t
->type_non_common
.maxval
);
6026 WT (t
->type_non_common
.minval
);
6028 /* Records and unions hold FIELDS, VFIELD & BINFO on these
6030 else if (!RECORD_OR_UNION_CODE_P (code
))
6032 // FIXME: These are from tpl_parm_value's 'type' writing.
6033 // Perhaps it should just be doing them directly?
6034 gcc_checking_assert (code
== TEMPLATE_TYPE_PARM
6035 || code
== TEMPLATE_TEMPLATE_PARM
6036 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
);
6037 gcc_checking_assert (!TYPE_CACHED_VALUES_P (t
));
6038 WT (t
->type_non_common
.values
);
6039 WT (t
->type_non_common
.maxval
);
6040 WT (t
->type_non_common
.minval
);
6043 WT (t
->type_non_common
.lang_1
);
6046 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
6049 state
->write_location (*this, t
->exp
.locus
);
6051 /* Walk in forward order, as (for instance) REQUIRES_EXPR has a
6052 bunch of unscoped parms on its first operand. It's safer to
6053 create those in order. */
6054 bool vl
= TREE_CODE_CLASS (code
) == tcc_vl_exp
;
6055 for (unsigned limit
= (vl
? VL_EXP_OPERAND_LENGTH (t
)
6056 : TREE_OPERAND_LENGTH (t
)),
6057 ix
= unsigned (vl
); ix
!= limit
; ix
++)
6058 WT (TREE_OPERAND (t
, ix
));
6061 /* The CODE_CONTAINS tables were inaccurate when I started. */
6062 gcc_checking_assert (TREE_CODE_CLASS (code
) != tcc_expression
6063 && TREE_CODE_CLASS (code
) != tcc_binary
6064 && TREE_CODE_CLASS (code
) != tcc_unary
6065 && TREE_CODE_CLASS (code
) != tcc_reference
6066 && TREE_CODE_CLASS (code
) != tcc_comparison
6067 && TREE_CODE_CLASS (code
) != tcc_statement
6068 && TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6070 /* Then by CODE. Special cases and/or 1:1 tree shape
6077 case ARGUMENT_PACK_SELECT
: /* Transient during instantiation. */
6078 case DEFERRED_PARSE
: /* Expanded upon completion of
6080 case IDENTIFIER_NODE
: /* Streamed specially. */
6081 case BINDING_VECTOR
: /* Only in namespace-scope symbol
6084 case TRANSLATION_UNIT_DECL
: /* There is only one, it is a
6086 case USERDEF_LITERAL
: /* Expanded during parsing. */
6087 gcc_unreachable (); /* Should never meet. */
6091 WT (TREE_REALPART (t
));
6092 WT (TREE_IMAGPART (t
));
6096 gcc_unreachable (); /* Not supported in C++. */
6101 unsigned num
= TREE_INT_CST_EXT_NUNITS (t
);
6102 for (unsigned ix
= 0; ix
!= num
; ix
++)
6103 wu (TREE_INT_CST_ELT (t
, ix
));
6108 gcc_unreachable (); /* Not supported in C++. */
6112 buf (TREE_REAL_CST_PTR (t
), sizeof (real_value
));
6116 /* Streamed during start. */
6120 for (unsigned ix
= vector_cst_encoded_nelts (t
); ix
--;)
6121 WT (VECTOR_CST_ENCODED_ELT (t
, ix
));
6126 if (DECL_CONTEXT (t
)
6127 && TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
6133 if (DECL_HAS_VALUE_EXPR_P (t
))
6134 WT (DECL_VALUE_EXPR (t
));
6139 WT (t
->decl_common
.initial
);
6143 WT (t
->field_decl
.offset
);
6144 WT (t
->field_decl
.bit_field_type
);
6145 WT (t
->field_decl
.qualifier
); /* bitfield unit. */
6146 WT (t
->field_decl
.bit_offset
);
6147 WT (t
->field_decl
.fcontext
);
6148 WT (t
->decl_common
.initial
);
6154 WU (t
->label_decl
.label_decl_uid
);
6155 WU (t
->label_decl
.eh_landing_pad_nr
);
6162 /* Builtins can be streamed by value when a header declares
6164 WU (DECL_BUILT_IN_CLASS (t
));
6165 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
6166 WU (DECL_UNCHECKED_FUNCTION_CODE (t
));
6169 WT (t
->function_decl
.personality
);
6170 WT (t
->function_decl
.function_specific_target
);
6171 WT (t
->function_decl
.function_specific_optimization
);
6172 WT (t
->function_decl
.vindex
);
6174 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
6175 WT (lookup_explicit_specifier (t
));
6179 /* USING_DECL_DECLS */
6180 WT (t
->decl_common
.initial
);
6184 /* USING_DECL: USING_DECL_SCOPE */
6185 /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6186 WT (t
->decl_non_common
.result
);
6189 /* Miscellaneous common nodes. */
6193 state
->write_location (*this, t
->block
.locus
);
6194 state
->write_location (*this, t
->block
.end_locus
);
6197 /* DECL_LOCAL_DECL_P decls are first encountered here and
6198 streamed by value. */
6199 chained_decls (t
->block
.vars
);
6200 /* nonlocalized_vars is a middle-end thing. */
6201 WT (t
->block
.subblocks
);
6202 WT (t
->block
.supercontext
);
6203 // FIXME: As for decl's abstract_origin, does this introduce crosslinks?
6204 WT (t
->block
.abstract_origin
);
6205 /* fragment_origin, fragment_chain are middle-end things. */
6206 WT (t
->block
.chain
);
6207 /* nonlocalized_vars, block_num & die are middle endy/debug
6218 unsigned len
= vec_safe_length (t
->constructor
.elts
);
6222 for (unsigned ix
= 0; ix
!= len
; ix
++)
6224 const constructor_elt
&elt
= (*t
->constructor
.elts
)[ix
];
6234 /* The ompcode is serialized in start. */
6236 WU (t
->omp_clause
.subcode
.map_kind
);
6238 state
->write_location (*this, t
->omp_clause
.locus
);
6240 unsigned len
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)];
6241 for (unsigned ix
= 0; ix
!= len
; ix
++)
6242 WT (t
->omp_clause
.ops
[ix
]);
6246 case STATEMENT_LIST
:
6247 for (tree stmt
: tsi_range (t
))
6253 case OPTIMIZATION_NODE
:
6254 case TARGET_OPTION_NODE
:
6255 // FIXME: Our representation for these two nodes is a cache of
6256 // the resulting set of options. Not a record of the options
6257 // that got changed by a particular attribute or pragma. Should
6258 // we record that, or should we record the diff from the command
6259 // line options? The latter seems the right behaviour, but is
6260 // (a) harder, and I guess could introduce strangeness if the
6261 // importer has set some incompatible set of optimization flags?
6267 WT (t
->binfo
.common
.chain
);
6268 WT (t
->binfo
.offset
);
6269 WT (t
->binfo
.inheritance
);
6270 WT (t
->binfo
.vptr_field
);
6272 WT (t
->binfo
.vtable
);
6273 WT (t
->binfo
.virtuals
);
6274 WT (t
->binfo
.vtt_subvtt
);
6275 WT (t
->binfo
.vtt_vptr
);
6277 tree_vec (BINFO_BASE_ACCESSES (t
));
6278 unsigned num
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
6279 for (unsigned ix
= 0; ix
!= num
; ix
++)
6280 WT (BINFO_BASE_BINFO (t
, ix
));
6285 WT (t
->list
.purpose
);
6287 WT (t
->list
.common
.chain
);
6291 for (unsigned ix
= TREE_VEC_LENGTH (t
); ix
--;)
6292 WT (TREE_VEC_ELT (t
, ix
));
6293 /* We stash NON_DEFAULT_TEMPLATE_ARGS_COUNT on TREE_CHAIN! */
6294 gcc_checking_assert (!t
->type_common
.common
.chain
6295 || (TREE_CODE (t
->type_common
.common
.chain
)
6297 WT (t
->type_common
.common
.chain
);
6300 /* C++-specific nodes ... */
6302 WT (((lang_tree_node
*)t
)->baselink
.binfo
);
6303 WT (((lang_tree_node
*)t
)->baselink
.functions
);
6304 WT (((lang_tree_node
*)t
)->baselink
.access_binfo
);
6307 case CONSTRAINT_INFO
:
6308 WT (((lang_tree_node
*)t
)->constraint_info
.template_reqs
);
6309 WT (((lang_tree_node
*)t
)->constraint_info
.declarator_reqs
);
6310 WT (((lang_tree_node
*)t
)->constraint_info
.associated_constr
);
6313 case DEFERRED_NOEXCEPT
:
6314 WT (((lang_tree_node
*)t
)->deferred_noexcept
.pattern
);
6315 WT (((lang_tree_node
*)t
)->deferred_noexcept
.args
);
6319 WT (((lang_tree_node
*)t
)->lambda_expression
.capture_list
);
6320 WT (((lang_tree_node
*)t
)->lambda_expression
.this_capture
);
6321 WT (((lang_tree_node
*)t
)->lambda_expression
.extra_scope
);
6322 /* pending_proxies is a parse-time thing. */
6323 gcc_assert (!((lang_tree_node
*)t
)->lambda_expression
.pending_proxies
);
6325 state
->write_location
6326 (*this, ((lang_tree_node
*)t
)->lambda_expression
.locus
);
6329 WU (((lang_tree_node
*)t
)->lambda_expression
.default_capture_mode
);
6330 WU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_scope
);
6331 WU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_sig
);
6336 WT (((lang_tree_node
*)t
)->overload
.function
);
6337 WT (t
->common
.chain
);
6341 WT (((lang_tree_node
*)t
)->ptrmem
.member
);
6345 WT (((lang_tree_node
*)t
)->static_assertion
.condition
);
6346 WT (((lang_tree_node
*)t
)->static_assertion
.message
);
6348 state
->write_location
6349 (*this, ((lang_tree_node
*)t
)->static_assertion
.location
);
6353 /* Streamed with the template_decl node itself. */
6355 (TREE_VISITED (((lang_tree_node
*)t
)->template_decl
.arguments
));
6357 (TREE_VISITED (((lang_tree_node
*)t
)->template_decl
.result
)
6358 || dep_hash
->find_dependency (t
)->is_alias_tmpl_inst ());
6359 if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t
))
6360 WT (DECL_CHAIN (t
));
6365 WT (((lang_tree_node
*)t
)->template_info
.tmpl
);
6366 WT (((lang_tree_node
*)t
)->template_info
.args
);
6367 WT (((lang_tree_node
*)t
)->template_info
.partial
);
6369 const auto *ac
= (((lang_tree_node
*)t
)
6370 ->template_info
.deferred_access_checks
);
6371 unsigned len
= vec_safe_length (ac
);
6376 for (unsigned ix
= 0; ix
!= len
; ix
++)
6378 const auto &m
= (*ac
)[ix
];
6383 state
->write_location (*this, m
.loc
);
6389 case TEMPLATE_PARM_INDEX
:
6392 WU (((lang_tree_node
*)t
)->tpi
.index
);
6393 WU (((lang_tree_node
*)t
)->tpi
.level
);
6394 WU (((lang_tree_node
*)t
)->tpi
.orig_level
);
6396 WT (((lang_tree_node
*)t
)->tpi
.decl
);
6397 /* TEMPLATE_PARM_DESCENDANTS (AKA TREE_CHAIN) is an internal
6398 cache, do not stream. */
6402 WT (((lang_tree_node
*)t
)->trait_expression
.type1
);
6403 WT (((lang_tree_node
*)t
)->trait_expression
.type2
);
6405 WU (((lang_tree_node
*)t
)->trait_expression
.kind
);
6409 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
6411 /* We want to stream the type of a expression-like nodes /after/
6412 we've streamed the operands. The type often contains (bits
6413 of the) types of the operands, and with things like decltype
6414 and noexcept in play, we really want to stream the decls
6415 defining the type before we try and stream the type on its
6416 own. Otherwise we can find ourselves trying to read in a
6417 decl, when we're already partially reading in a component of
6418 its type. And that's bad. */
6419 tree type
= t
->typed
.type
;
6428 /* We fill in the template's type separately. */
6433 if (DECL_ORIGINAL_TYPE (t
) && t
== TYPE_NAME (type
))
6434 /* This is a typedef. We set its type separately. */
6439 if (type
&& !ENUM_FIXED_UNDERLYING_TYPE_P (t
))
6441 /* Type is a restricted range integer type derived from the
6442 integer_types. Find the right one. */
6443 prec
= TYPE_PRECISION (type
);
6444 tree name
= DECL_NAME (TYPE_NAME (type
));
6446 for (unsigned itk
= itk_none
; itk
--;)
6447 if (integer_types
[itk
]
6448 && DECL_NAME (TYPE_NAME (integer_types
[itk
])) == name
)
6450 type
= integer_types
[itk
];
6453 gcc_assert (type
!= t
->typed
.type
);
6459 if (prec
&& streaming_p ())
6467 // Streaming in a reference to a decl can cause that decl to be
6468 // TREE_USED, which is the mark_used behaviour we need most of the
6469 // time. The trees_in::unused can be incremented to inhibit this,
6470 // which is at least needed for vtables.
6473 trees_in::core_vals (tree t
)
6475 #define RU(X) ((X) = u ())
6476 #define RUC(T,X) ((X) = T (u ()))
6477 #define RT(X) ((X) = tree_node ())
6478 #define RTU(X) ((X) = tree_node (true))
6479 tree_code code
= TREE_CODE (t
);
6481 /* First by tree shape. */
6482 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
6484 RT (t
->decl_minimal
.name
);
6485 if (!DECL_TEMPLATE_PARM_P (t
))
6486 RT (t
->decl_minimal
.context
);
6488 /* Don't zap the locus just yet, we don't record it correctly
6489 and thus lose all location information. */
6490 t
->decl_minimal
.locus
= state
->read_location (*this);
6493 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
6495 RT (t
->type_common
.name
);
6496 RT (t
->type_common
.context
);
6498 RT (t
->type_common
.main_variant
);
6499 RT (t
->type_common
.canonical
);
6501 /* type_common.next_variant is internally manipulated. */
6502 /* type_common.pointer_to, type_common.reference_to. */
6504 RU (t
->type_common
.precision
);
6505 RU (t
->type_common
.contains_placeholder_bits
);
6506 RUC (machine_mode
, t
->type_common
.mode
);
6507 RU (t
->type_common
.align
);
6509 if (!RECORD_OR_UNION_CODE_P (code
))
6511 RT (t
->type_common
.size
);
6512 RT (t
->type_common
.size_unit
);
6514 RT (t
->type_common
.attributes
);
6516 RT (t
->type_common
.common
.chain
); /* TYPE_STUB_DECL. */
6519 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
6521 RUC (machine_mode
, t
->decl_common
.mode
);
6522 RU (t
->decl_common
.off_align
);
6523 RU (t
->decl_common
.align
);
6525 if (code
!= TEMPLATE_DECL
)
6527 RT (t
->decl_common
.size
);
6528 RT (t
->decl_common
.size_unit
);
6531 RT (t
->decl_common
.attributes
);
6532 RT (t
->decl_common
.abstract_origin
);
6535 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
6537 RT (t
->decl_with_vis
.assembler_name
);
6538 RUC (symbol_visibility
, t
->decl_with_vis
.visibility
);
6541 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
6543 if (code
== ENUMERAL_TYPE
)
6545 /* These fields get set even for opaque enums that lack a
6546 definition, so we stream them directly for each ENUMERAL_TYPE.
6547 We stream TYPE_VALUES as part of the definition. */
6548 RT (t
->type_non_common
.maxval
);
6549 RT (t
->type_non_common
.minval
);
6551 /* Records and unions hold FIELDS, VFIELD & BINFO on these
6553 else if (!RECORD_OR_UNION_CODE_P (code
))
6555 /* This is not clobbering TYPE_CACHED_VALUES, because this
6556 is a type that doesn't have any. */
6557 gcc_checking_assert (!TYPE_CACHED_VALUES_P (t
));
6558 RT (t
->type_non_common
.values
);
6559 RT (t
->type_non_common
.maxval
);
6560 RT (t
->type_non_common
.minval
);
6563 RT (t
->type_non_common
.lang_1
);
6566 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
6568 t
->exp
.locus
= state
->read_location (*this);
6570 bool vl
= TREE_CODE_CLASS (code
) == tcc_vl_exp
;
6571 for (unsigned limit
= (vl
? VL_EXP_OPERAND_LENGTH (t
)
6572 : TREE_OPERAND_LENGTH (t
)),
6573 ix
= unsigned (vl
); ix
!= limit
; ix
++)
6574 RTU (TREE_OPERAND (t
, ix
));
6577 /* Then by CODE. Special cases and/or 1:1 tree shape
6584 case ARGUMENT_PACK_SELECT
:
6585 case DEFERRED_PARSE
:
6586 case IDENTIFIER_NODE
:
6587 case BINDING_VECTOR
:
6589 case TRANSLATION_UNIT_DECL
:
6590 case USERDEF_LITERAL
:
6591 return false; /* Should never meet. */
6595 RT (TREE_REALPART (t
));
6596 RT (TREE_IMAGPART (t
));
6600 /* Not suported in C++. */
6605 unsigned num
= TREE_INT_CST_EXT_NUNITS (t
);
6606 for (unsigned ix
= 0; ix
!= num
; ix
++)
6607 TREE_INT_CST_ELT (t
, ix
) = wu ();
6612 /* Not suported in C++. */
6616 if (const void *bytes
= buf (sizeof (real_value
)))
6617 memcpy (TREE_REAL_CST_PTR (t
), bytes
, sizeof (real_value
));
6621 /* Streamed during start. */
6625 for (unsigned ix
= vector_cst_encoded_nelts (t
); ix
--;)
6626 RT (VECTOR_CST_ENCODED_ELT (t
, ix
));
6631 if (DECL_CONTEXT (t
)
6632 && TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
6638 if (DECL_HAS_VALUE_EXPR_P (t
))
6640 /* The DECL_VALUE hash table is a cache, thus if we're
6641 reading a duplicate (which we end up discarding), the
6642 value expr will also be cleaned up at the next gc. */
6643 tree val
= tree_node ();
6644 SET_DECL_VALUE_EXPR (t
, val
);
6650 RT (t
->decl_common
.initial
);
6654 RT (t
->field_decl
.offset
);
6655 RT (t
->field_decl
.bit_field_type
);
6656 RT (t
->field_decl
.qualifier
);
6657 RT (t
->field_decl
.bit_offset
);
6658 RT (t
->field_decl
.fcontext
);
6659 RT (t
->decl_common
.initial
);
6663 RU (t
->label_decl
.label_decl_uid
);
6664 RU (t
->label_decl
.eh_landing_pad_nr
);
6669 unsigned bltin
= u ();
6670 t
->function_decl
.built_in_class
= built_in_class (bltin
);
6671 if (bltin
!= NOT_BUILT_IN
)
6674 DECL_UNCHECKED_FUNCTION_CODE (t
) = built_in_function (bltin
);
6677 RT (t
->function_decl
.personality
);
6678 RT (t
->function_decl
.function_specific_target
);
6679 RT (t
->function_decl
.function_specific_optimization
);
6680 RT (t
->function_decl
.vindex
);
6682 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
6686 store_explicit_specifier (t
, spec
);
6692 /* USING_DECL_DECLS */
6693 RT (t
->decl_common
.initial
);
6697 /* USING_DECL: USING_DECL_SCOPE */
6698 /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6699 RT (t
->decl_non_common
.result
);
6702 /* Miscellaneous common nodes. */
6704 t
->block
.locus
= state
->read_location (*this);
6705 t
->block
.end_locus
= state
->read_location (*this);
6706 t
->block
.vars
= chained_decls ();
6707 /* nonlocalized_vars is middle-end. */
6708 RT (t
->block
.subblocks
);
6709 RT (t
->block
.supercontext
);
6710 RT (t
->block
.abstract_origin
);
6711 /* fragment_origin, fragment_chain are middle-end. */
6712 RT (t
->block
.chain
);
6713 /* nonlocalized_vars, block_num, die are middle endy/debug
6718 RUC (internal_fn
, t
->base
.u
.ifn
);
6722 if (unsigned len
= u ())
6724 vec_alloc (t
->constructor
.elts
, len
);
6725 for (unsigned ix
= 0; ix
!= len
; ix
++)
6727 constructor_elt elt
;
6731 t
->constructor
.elts
->quick_push (elt
);
6738 RU (t
->omp_clause
.subcode
.map_kind
);
6739 t
->omp_clause
.locus
= state
->read_location (*this);
6741 unsigned len
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)];
6742 for (unsigned ix
= 0; ix
!= len
; ix
++)
6743 RT (t
->omp_clause
.ops
[ix
]);
6747 case STATEMENT_LIST
:
6749 tree_stmt_iterator iter
= tsi_start (t
);
6750 for (tree stmt
; RT (stmt
);)
6751 tsi_link_after (&iter
, stmt
, TSI_CONTINUE_LINKING
);
6755 case OPTIMIZATION_NODE
:
6756 case TARGET_OPTION_NODE
:
6757 /* Not yet implemented, see trees_out::core_vals. */
6762 RT (t
->binfo
.common
.chain
);
6763 RT (t
->binfo
.offset
);
6764 RT (t
->binfo
.inheritance
);
6765 RT (t
->binfo
.vptr_field
);
6767 /* Do not mark the vtables as USED in the address expressions
6770 RT (t
->binfo
.vtable
);
6771 RT (t
->binfo
.virtuals
);
6772 RT (t
->binfo
.vtt_subvtt
);
6773 RT (t
->binfo
.vtt_vptr
);
6776 BINFO_BASE_ACCESSES (t
) = tree_vec ();
6777 if (!get_overrun ())
6779 unsigned num
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
6780 for (unsigned ix
= 0; ix
!= num
; ix
++)
6781 BINFO_BASE_APPEND (t
, tree_node ());
6786 RT (t
->list
.purpose
);
6788 RT (t
->list
.common
.chain
);
6792 for (unsigned ix
= TREE_VEC_LENGTH (t
); ix
--;)
6793 RT (TREE_VEC_ELT (t
, ix
));
6794 RT (t
->type_common
.common
.chain
);
6797 /* C++-specific nodes ... */
6799 RT (((lang_tree_node
*)t
)->baselink
.binfo
);
6800 RTU (((lang_tree_node
*)t
)->baselink
.functions
);
6801 RT (((lang_tree_node
*)t
)->baselink
.access_binfo
);
6804 case CONSTRAINT_INFO
:
6805 RT (((lang_tree_node
*)t
)->constraint_info
.template_reqs
);
6806 RT (((lang_tree_node
*)t
)->constraint_info
.declarator_reqs
);
6807 RT (((lang_tree_node
*)t
)->constraint_info
.associated_constr
);
6810 case DEFERRED_NOEXCEPT
:
6811 RT (((lang_tree_node
*)t
)->deferred_noexcept
.pattern
);
6812 RT (((lang_tree_node
*)t
)->deferred_noexcept
.args
);
6816 RT (((lang_tree_node
*)t
)->lambda_expression
.capture_list
);
6817 RT (((lang_tree_node
*)t
)->lambda_expression
.this_capture
);
6818 RT (((lang_tree_node
*)t
)->lambda_expression
.extra_scope
);
6819 /* lambda_expression.pending_proxies is NULL */
6820 ((lang_tree_node
*)t
)->lambda_expression
.locus
6821 = state
->read_location (*this);
6822 RUC (cp_lambda_default_capture_mode_type
,
6823 ((lang_tree_node
*)t
)->lambda_expression
.default_capture_mode
);
6824 RU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_scope
);
6825 RU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_sig
);
6829 RT (((lang_tree_node
*)t
)->overload
.function
);
6830 RT (t
->common
.chain
);
6834 RT (((lang_tree_node
*)t
)->ptrmem
.member
);
6838 RT (((lang_tree_node
*)t
)->static_assertion
.condition
);
6839 RT (((lang_tree_node
*)t
)->static_assertion
.message
);
6840 ((lang_tree_node
*)t
)->static_assertion
.location
6841 = state
->read_location (*this);
6845 /* Streamed when reading the raw template decl itself. */
6846 gcc_assert (((lang_tree_node
*)t
)->template_decl
.arguments
);
6847 gcc_assert (((lang_tree_node
*)t
)->template_decl
.result
);
6848 if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t
))
6849 RT (DECL_CHAIN (t
));
6853 RT (((lang_tree_node
*)t
)->template_info
.tmpl
);
6854 RT (((lang_tree_node
*)t
)->template_info
.args
);
6855 RT (((lang_tree_node
*)t
)->template_info
.partial
);
6856 if (unsigned len
= u ())
6858 auto &ac
= (((lang_tree_node
*)t
)
6859 ->template_info
.deferred_access_checks
);
6860 vec_alloc (ac
, len
);
6861 for (unsigned ix
= 0; ix
!= len
; ix
++)
6863 deferred_access_check m
;
6868 m
.loc
= state
->read_location (*this);
6874 case TEMPLATE_PARM_INDEX
:
6875 RU (((lang_tree_node
*)t
)->tpi
.index
);
6876 RU (((lang_tree_node
*)t
)->tpi
.level
);
6877 RU (((lang_tree_node
*)t
)->tpi
.orig_level
);
6878 RT (((lang_tree_node
*)t
)->tpi
.decl
);
6882 RT (((lang_tree_node
*)t
)->trait_expression
.type1
);
6883 RT (((lang_tree_node
*)t
)->trait_expression
.type2
);
6884 RUC (cp_trait_kind
, ((lang_tree_node
*)t
)->trait_expression
.kind
);
6888 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
6890 tree type
= tree_node ();
6892 if (type
&& code
== ENUMERAL_TYPE
&& !ENUM_FIXED_UNDERLYING_TYPE_P (t
))
6894 unsigned precision
= u ();
6896 type
= build_distinct_type_copy (type
);
6897 TYPE_PRECISION (type
) = precision
;
6898 set_min_and_max_values_for_integral_type (type
, precision
,
6902 if (code
!= TEMPLATE_DECL
)
6903 t
->typed
.type
= type
;
6909 return !get_overrun ();
6913 trees_out::lang_decl_vals (tree t
)
6915 const struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
6916 #define WU(X) (u (X))
6917 #define WT(X) (tree_node (X))
6918 /* Module index already written. */
6919 switch (lang
->u
.base
.selector
)
6924 case lds_fn
: /* lang_decl_fn. */
6927 if (DECL_NAME (t
) && IDENTIFIER_OVL_OP_P (DECL_NAME (t
)))
6928 WU (lang
->u
.fn
.ovl_op_code
);
6931 if (DECL_CLASS_SCOPE_P (t
))
6932 WT (lang
->u
.fn
.context
);
6934 if (lang
->u
.fn
.thunk_p
)
6936 /* The thunked-to function. */
6937 WT (lang
->u
.fn
.befriending_classes
);
6939 wi (lang
->u
.fn
.u5
.fixed_offset
);
6942 WT (lang
->u
.fn
.u5
.cloned_function
);
6944 if (FNDECL_USED_AUTO (t
))
6945 WT (lang
->u
.fn
.u
.saved_auto_return_type
);
6949 case lds_decomp
: /* lang_decl_decomp. */
6950 WT (lang
->u
.decomp
.base
);
6953 case lds_min
: /* lang_decl_min. */
6955 WT (lang
->u
.min
.template_info
);
6957 tree access
= lang
->u
.min
.access
;
6959 /* DECL_ACCESS needs to be maintained by the definition of the
6960 (derived) class that changes the access. The other users
6961 of DECL_ACCESS need to write it here. */
6962 if (!DECL_THUNK_P (t
)
6963 && (DECL_CONTEXT (t
) && TYPE_P (DECL_CONTEXT (t
))))
6970 case lds_ns
: /* lang_decl_ns. */
6973 case lds_parm
: /* lang_decl_parm. */
6976 WU (lang
->u
.parm
.level
);
6977 WU (lang
->u
.parm
.index
);
6986 trees_in::lang_decl_vals (tree t
)
6988 struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
6989 #define RU(X) ((X) = u ())
6990 #define RT(X) ((X) = tree_node ())
6992 /* Module index already read. */
6993 switch (lang
->u
.base
.selector
)
6998 case lds_fn
: /* lang_decl_fn. */
6999 if (DECL_NAME (t
) && IDENTIFIER_OVL_OP_P (DECL_NAME (t
)))
7001 unsigned code
= u ();
7003 /* Check consistency. */
7004 if (code
>= OVL_OP_MAX
7005 || (ovl_op_info
[IDENTIFIER_ASSIGN_OP_P (DECL_NAME (t
))][code
]
7006 .ovl_op_code
) == OVL_OP_ERROR_MARK
)
7009 lang
->u
.fn
.ovl_op_code
= code
;
7012 if (DECL_CLASS_SCOPE_P (t
))
7013 RT (lang
->u
.fn
.context
);
7015 if (lang
->u
.fn
.thunk_p
)
7017 RT (lang
->u
.fn
.befriending_classes
);
7018 lang
->u
.fn
.u5
.fixed_offset
= wi ();
7021 RT (lang
->u
.fn
.u5
.cloned_function
);
7023 if (FNDECL_USED_AUTO (t
))
7024 RT (lang
->u
.fn
.u
.saved_auto_return_type
);
7027 case lds_decomp
: /* lang_decl_decomp. */
7028 RT (lang
->u
.decomp
.base
);
7031 case lds_min
: /* lang_decl_min. */
7033 RT (lang
->u
.min
.template_info
);
7034 RT (lang
->u
.min
.access
);
7037 case lds_ns
: /* lang_decl_ns. */
7040 case lds_parm
: /* lang_decl_parm. */
7041 RU (lang
->u
.parm
.level
);
7042 RU (lang
->u
.parm
.index
);
7047 return !get_overrun ();
7050 /* Most of the value contents of lang_type is streamed in
7054 trees_out::lang_type_vals (tree t
)
7056 const struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
7057 #define WU(X) (u (X))
7058 #define WT(X) (tree_node (X))
7066 trees_in::lang_type_vals (tree t
)
7068 struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
7069 #define RU(X) ((X) = u ())
7070 #define RT(X) ((X) = tree_node ())
7074 return !get_overrun ();
7077 /* Write out the bools of T, including information about any
7078 LANG_SPECIFIC information. Including allocation of any lang
7082 trees_out::tree_node_bools (tree t
)
7084 gcc_checking_assert (streaming_p ());
7086 /* We should never stream a namespace. */
7087 gcc_checking_assert (TREE_CODE (t
) != NAMESPACE_DECL
7088 || DECL_NAMESPACE_ALIAS (t
));
7092 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7094 case tcc_declaration
:
7096 bool specific
= DECL_LANG_SPECIFIC (t
) != NULL
;
7098 if (specific
&& VAR_P (t
))
7099 b (DECL_DECOMPOSITION_P (t
));
7101 lang_decl_bools (t
);
7107 bool specific
= (TYPE_MAIN_VARIANT (t
) == t
7108 && TYPE_LANG_SPECIFIC (t
) != NULL
);
7109 gcc_assert (TYPE_LANG_SPECIFIC (t
)
7110 == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t
)));
7114 lang_type_bools (t
);
7126 trees_in::tree_node_bools (tree t
)
7128 bool ok
= core_bools (t
);
7131 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7133 case tcc_declaration
:
7136 bool decomp
= VAR_P (t
) && b ();
7138 ok
= maybe_add_lang_decl_raw (t
, decomp
);
7140 ok
= lang_decl_bools (t
);
7147 ok
= maybe_add_lang_type_raw (t
);
7149 ok
= lang_type_bools (t
);
7158 if (!ok
|| get_overrun ())
7165 /* Write out the lang-specifc vals of node T. */
7168 trees_out::lang_vals (tree t
)
7170 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7172 case tcc_declaration
:
7173 if (DECL_LANG_SPECIFIC (t
))
7178 if (TYPE_MAIN_VARIANT (t
) == t
&& TYPE_LANG_SPECIFIC (t
))
7188 trees_in::lang_vals (tree t
)
7192 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7194 case tcc_declaration
:
7195 if (DECL_LANG_SPECIFIC (t
))
7196 ok
= lang_decl_vals (t
);
7200 if (TYPE_LANG_SPECIFIC (t
))
7201 ok
= lang_type_vals (t
);
7203 TYPE_LANG_SPECIFIC (t
) = TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t
));
7213 /* Write out the value fields of node T. */
7216 trees_out::tree_node_vals (tree t
)
7223 trees_in::tree_node_vals (tree t
)
7225 bool ok
= core_vals (t
);
7233 /* If T is a back reference, fixed reference or NULL, write out its
7234 code and return WK_none. Otherwise return WK_value if we must write
7235 by value, or WK_normal otherwise. */
7238 trees_out::ref_node (tree t
)
7244 /* NULL_TREE -> tt_null. */
7251 if (!TREE_VISITED (t
))
7254 /* An already-visited tree. It must be in the map. */
7255 int val
= get_tag (t
);
7257 if (val
== tag_value
)
7258 /* An entry we should walk into. */
7263 if (val
<= tag_backref
)
7265 /* Back reference -> -ve number */
7270 else if (val
>= tag_fixed
)
7272 /* Fixed reference -> tt_fixed */
7275 i (tt_fixed
), u (val
);
7283 && dump ("Wrote %s:%d %C:%N%S", kind
, val
, TREE_CODE (t
), t
, t
);
7289 trees_in::back_ref (int tag
)
7291 tree res
= NULL_TREE
;
7293 if (tag
< 0 && unsigned (~tag
) < back_refs
.length ())
7294 res
= back_refs
[~tag
];
7297 /* Checking TREE_CODE is a dereference, so we know this is not a
7298 wild pointer. Checking the code provides evidence we've not
7299 corrupted something. */
7300 || TREE_CODE (res
) >= MAX_TREE_CODES
)
7303 dump (dumper::TREE
) && dump ("Read backref:%d found %C:%N%S", tag
,
7304 TREE_CODE (res
), res
, res
);
7309 trees_out::add_indirect_tpl_parms (tree parms
)
7312 for (; parms
; parms
= TREE_CHAIN (parms
), len
++)
7314 if (TREE_VISITED (parms
))
7317 int tag
= insert (parms
);
7320 && dump ("Indirect:%d template's parameter %u %C:%N",
7321 tag
, len
, TREE_CODE (parms
), parms
);
7331 trees_in::add_indirect_tpl_parms (tree parms
)
7333 unsigned len
= u ();
7334 for (unsigned ix
= 0; ix
!= len
; parms
= TREE_CHAIN (parms
), ix
++)
7336 int tag
= insert (parms
);
7338 && dump ("Indirect:%d template's parameter %u %C:%N",
7339 tag
, ix
, TREE_CODE (parms
), parms
);
7345 /* We've just found DECL by name. Insert nodes that come with it, but
7346 cannot be found by name, so we'll not accidentally walk into them. */
7349 trees_out::add_indirects (tree decl
)
7353 // FIXME:OPTIMIZATION We'll eventually want default fn parms of
7354 // templates and perhaps default template parms too. The former can
7355 // be referenced from instantiations (as they are lazily
7356 // instantiated). Also (deferred?) exception specifications of
7357 // templates. See the note about PARM_DECLs in trees_out::decl_node.
7359 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7361 count
+= add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl
));
7363 inner
= DECL_TEMPLATE_RESULT (decl
);
7364 int tag
= insert (inner
);
7367 && dump ("Indirect:%d template's result %C:%N",
7368 tag
, TREE_CODE (inner
), inner
);
7372 if (TREE_CODE (inner
) == TYPE_DECL
)
7374 /* Make sure the type is in the map too. Otherwise we get
7375 different RECORD_TYPEs for the same type, and things go
7377 tree type
= TREE_TYPE (inner
);
7378 gcc_checking_assert (DECL_ORIGINAL_TYPE (inner
)
7379 || TYPE_NAME (type
) == inner
);
7380 int tag
= insert (type
);
7382 dump (dumper::TREE
) && dump ("Indirect:%d decl's type %C:%N", tag
,
7383 TREE_CODE (type
), type
);
7390 dump (dumper::TREE
) && dump ("Inserted %u indirects", count
);
7395 trees_in::add_indirects (tree decl
)
7400 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7402 count
+= add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl
));
7404 inner
= DECL_TEMPLATE_RESULT (decl
);
7405 int tag
= insert (inner
);
7407 && dump ("Indirect:%d templates's result %C:%N", tag
,
7408 TREE_CODE (inner
), inner
);
7412 if (TREE_CODE (inner
) == TYPE_DECL
)
7414 tree type
= TREE_TYPE (inner
);
7415 gcc_checking_assert (DECL_ORIGINAL_TYPE (inner
)
7416 || TYPE_NAME (type
) == inner
);
7417 int tag
= insert (type
);
7419 && dump ("Indirect:%d decl's type %C:%N", tag
, TREE_CODE (type
), type
);
7423 dump (dumper::TREE
) && dump ("Inserted %u indirects", count
);
7424 return count
== u ();
7427 /* Stream a template parameter. There are 4.5 kinds of parameter:
7428 a) Template - TEMPLATE_DECL->TYPE_DECL->TEMPLATE_TEMPLATE_PARM
7429 TEMPLATE_TYPE_PARM_INDEX TPI
7430 b) Type - TYPE_DECL->TEMPLATE_TYPE_PARM TEMPLATE_TYPE_PARM_INDEX TPI
7431 c.1) NonTYPE - PARM_DECL DECL_INITIAL TPI We meet this first
7432 c.2) NonTYPE - CONST_DECL DECL_INITIAL Same TPI
7433 d) BoundTemplate - TYPE_DECL->BOUND_TEMPLATE_TEMPLATE_PARM
7434 TEMPLATE_TYPE_PARM_INDEX->TPI
7435 TEMPLATE_TEMPLATE_PARM_INFO->TEMPLATE_INFO
7437 All of these point to a TEMPLATE_PARM_INDEX, and #B also has a TEMPLATE_INFO
7441 trees_out::tpl_parm_value (tree parm
)
7443 gcc_checking_assert (DECL_P (parm
) && DECL_TEMPLATE_PARM_P (parm
));
7445 int parm_tag
= insert (parm
);
7449 dump (dumper::TREE
) && dump ("Writing template parm:%d %C:%N",
7450 parm_tag
, TREE_CODE (parm
), parm
);
7452 tree_node_bools (parm
);
7456 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7458 inner
= DECL_TEMPLATE_RESULT (inner
);
7459 int inner_tag
= insert (inner
);
7462 dump (dumper::TREE
) && dump ("Writing inner template parm:%d %C:%N",
7463 inner_tag
, TREE_CODE (inner
), inner
);
7465 tree_node_bools (inner
);
7469 tree type
= NULL_TREE
;
7470 if (TREE_CODE (inner
) == TYPE_DECL
)
7472 type
= TREE_TYPE (inner
);
7473 int type_tag
= insert (type
);
7476 dump (dumper::TREE
) && dump ("Writing template parm type:%d %C:%N",
7477 type_tag
, TREE_CODE (type
), type
);
7479 tree_node_bools (type
);
7485 /* This is a template-template parameter. */
7486 unsigned tpl_levels
= 0;
7487 tpl_header (parm
, &tpl_levels
);
7488 tpl_parms_fini (parm
, tpl_levels
);
7491 tree_node_vals (parm
);
7493 tree_node_vals (inner
);
7496 tree_node_vals (type
);
7497 if (DECL_NAME (inner
) == auto_identifier
7498 || DECL_NAME (inner
) == decltype_auto_identifier
)
7500 /* Placeholder auto. */
7501 tree_node (DECL_INITIAL (inner
));
7502 tree_node (DECL_SIZE_UNIT (inner
));
7507 dump (dumper::TREE
) && dump ("Wrote template parm:%d %C:%N",
7508 parm_tag
, TREE_CODE (parm
), parm
);
7512 trees_in::tpl_parm_value ()
7514 tree parm
= start ();
7515 if (!parm
|| !tree_node_bools (parm
))
7518 int parm_tag
= insert (parm
);
7519 dump (dumper::TREE
) && dump ("Reading template parm:%d %C:%N",
7520 parm_tag
, TREE_CODE (parm
), parm
);
7523 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7526 if (!inner
|| !tree_node_bools (inner
))
7528 int inner_tag
= insert (inner
);
7529 dump (dumper::TREE
) && dump ("Reading inner template parm:%d %C:%N",
7530 inner_tag
, TREE_CODE (inner
), inner
);
7531 DECL_TEMPLATE_RESULT (parm
) = inner
;
7534 tree type
= NULL_TREE
;
7535 if (TREE_CODE (inner
) == TYPE_DECL
)
7538 if (!type
|| !tree_node_bools (type
))
7540 int type_tag
= insert (type
);
7541 dump (dumper::TREE
) && dump ("Reading template parm type:%d %C:%N",
7542 type_tag
, TREE_CODE (type
), type
);
7544 TREE_TYPE (inner
) = TREE_TYPE (parm
) = type
;
7545 TYPE_NAME (type
) = parm
;
7550 /* A template template parameter. */
7551 unsigned tpl_levels
= 0;
7552 tpl_header (parm
, &tpl_levels
);
7553 tpl_parms_fini (parm
, tpl_levels
);
7556 tree_node_vals (parm
);
7558 tree_node_vals (inner
);
7561 tree_node_vals (type
);
7562 if (DECL_NAME (inner
) == auto_identifier
7563 || DECL_NAME (inner
) == decltype_auto_identifier
)
7565 /* Placeholder auto. */
7566 DECL_INITIAL (inner
) = tree_node ();
7567 DECL_SIZE_UNIT (inner
) = tree_node ();
7569 if (TYPE_CANONICAL (type
))
7571 gcc_checking_assert (TYPE_CANONICAL (type
) == type
);
7572 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
7576 dump (dumper::TREE
) && dump ("Read template parm:%d %C:%N",
7577 parm_tag
, TREE_CODE (parm
), parm
);
7583 trees_out::install_entity (tree decl
, depset
*dep
)
7585 gcc_checking_assert (streaming_p ());
7587 /* Write the entity index, so we can insert it as soon as we
7588 know this is new. */
7589 u (dep
? dep
->cluster
+ 1 : 0);
7590 if (CHECKING_P
&& dep
)
7592 /* Add it to the entity map, such that we can tell it is
7595 unsigned *slot
= &entity_map
->get_or_insert
7596 (DECL_UID (decl
), &existed
);
7598 /* If it existed, it should match. */
7599 gcc_checking_assert (decl
== (*entity_ary
)[*slot
]);
7600 *slot
= ~dep
->cluster
;
7605 trees_in::install_entity (tree decl
)
7607 unsigned entity_index
= u ();
7611 if (entity_index
> state
->entity_num
)
7617 /* Insert the real decl into the entity ary. */
7618 unsigned ident
= state
->entity_lwm
+ entity_index
- 1;
7619 (*entity_ary
)[ident
] = decl
;
7621 /* And into the entity map, if it's not already there. */
7622 tree not_tmpl
= STRIP_TEMPLATE (decl
);
7623 if (!DECL_LANG_SPECIFIC (not_tmpl
)
7624 || !DECL_MODULE_ENTITY_P (not_tmpl
))
7626 retrofit_lang_decl (not_tmpl
);
7627 DECL_MODULE_ENTITY_P (not_tmpl
) = true;
7629 /* Insert into the entity hash (it cannot already be there). */
7631 unsigned &slot
= entity_map
->get_or_insert (DECL_UID (decl
), &existed
);
7632 gcc_checking_assert (!existed
);
7639 static bool has_definition (tree decl
);
7641 /* DECL is a decl node that must be written by value. DEP is the
7645 trees_out::decl_value (tree decl
, depset
*dep
)
7647 /* We should not be writing clones or template parms. */
7648 gcc_checking_assert (DECL_P (decl
)
7649 && !DECL_CLONED_FUNCTION_P (decl
)
7650 && !DECL_TEMPLATE_PARM_P (decl
));
7652 /* We should never be writing non-typedef ptrmemfuncs by value. */
7653 gcc_checking_assert (TREE_CODE (decl
) != TYPE_DECL
7654 || DECL_ORIGINAL_TYPE (decl
)
7655 || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)));
7657 merge_kind mk
= get_merge_kind (decl
, dep
);
7661 /* Never start in the middle of a template. */
7663 if (tree ti
= node_template_info (decl
, use_tpl
))
7664 gcc_checking_assert (TREE_CODE (TI_TEMPLATE (ti
)) == OVERLOAD
7665 || TREE_CODE (TI_TEMPLATE (ti
)) == FIELD_DECL
7666 || (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
))
7672 /* A new node -> tt_decl. */
7678 if (mk
!= MK_unique
)
7680 if (!(mk
& MK_template_mask
) && !state
->is_header ())
7682 /* Tell the importer whether this is a global module entity,
7683 or a module entity. This bool merges into the next block
7684 of bools. Sneaky. */
7685 tree o
= get_originating_module_decl (decl
);
7686 bool is_attached
= false;
7688 tree not_tmpl
= STRIP_TEMPLATE (o
);
7689 if (DECL_LANG_SPECIFIC (not_tmpl
)
7690 && DECL_MODULE_ATTACH_P (not_tmpl
))
7695 b (dep
&& dep
->has_defn ());
7697 tree_node_bools (decl
);
7700 int tag
= insert (decl
, WK_value
);
7703 && dump ("Writing %s:%d %C:%N%S", merge_kind_name
[mk
], tag
,
7704 TREE_CODE (decl
), decl
, decl
);
7708 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7710 inner
= DECL_TEMPLATE_RESULT (decl
);
7711 inner_tag
= insert (inner
, WK_value
);
7715 int code
= TREE_CODE (inner
);
7717 start (inner
, true);
7718 tree_node_bools (inner
);
7720 && dump ("Writing %s:%d %C:%N%S", merge_kind_name
[mk
], inner_tag
,
7721 TREE_CODE (inner
), inner
, inner
);
7725 tree type
= NULL_TREE
;
7727 tree stub_decl
= NULL_TREE
;
7729 if (TREE_CODE (inner
) == TYPE_DECL
)
7731 type
= TREE_TYPE (inner
);
7732 bool has_type
= (type
== TYPE_MAIN_VARIANT (type
)
7733 && TYPE_NAME (type
) == inner
);
7736 u (has_type
? TREE_CODE (type
) : 0);
7740 type_tag
= insert (type
, WK_value
);
7744 tree_node_bools (type
);
7746 && dump ("Writing type:%d %C:%N", type_tag
,
7747 TREE_CODE (type
), type
);
7750 stub_decl
= TYPE_STUB_DECL (type
);
7751 bool has_stub
= inner
!= stub_decl
;
7753 u (has_stub
? TREE_CODE (stub_decl
) : 0);
7756 stub_tag
= insert (stub_decl
);
7759 start (stub_decl
, true);
7760 tree_node_bools (stub_decl
);
7762 && dump ("Writing stub_decl:%d %C:%N", stub_tag
,
7763 TREE_CODE (stub_decl
), stub_decl
);
7767 stub_decl
= NULL_TREE
;
7770 /* Regular typedef. */
7774 /* Stream the container, we want it correctly canonicalized before
7775 we start emitting keys for this decl. */
7776 tree container
= decl_container (decl
);
7778 unsigned tpl_levels
= 0;
7780 tpl_header (decl
, &tpl_levels
);
7781 if (TREE_CODE (inner
) == FUNCTION_DECL
)
7782 fn_parms_init (inner
);
7784 /* Now write out the merging information, and then really
7785 install the tag values. */
7786 key_mergeable (tag
, mk
, decl
, inner
, container
, dep
);
7789 dump (dumper::MERGE
)
7790 && dump ("Wrote:%d's %s merge key %C:%N", tag
,
7791 merge_kind_name
[mk
], TREE_CODE (decl
), decl
);
7793 if (TREE_CODE (inner
) == FUNCTION_DECL
)
7794 fn_parms_fini (inner
);
7796 if (!is_key_order ())
7797 tree_node_vals (decl
);
7801 if (!is_key_order ())
7802 tree_node_vals (inner
);
7803 tpl_parms_fini (decl
, tpl_levels
);
7806 if (type
&& !is_key_order ())
7808 tree_node_vals (type
);
7810 tree_node_vals (stub_decl
);
7813 if (!is_key_order ())
7815 if (mk
& MK_template_mask
7817 || mk
== MK_friend_spec
)
7819 if (mk
!= MK_partial
)
7821 // FIXME: We should make use of the merge-key by
7822 // exposing it outside of key_mergeable. But this gets
7824 auto *entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
7827 u (get_mergeable_specialization_flags (entry
->tmpl
, decl
));
7828 tree_node (entry
->tmpl
);
7829 tree_node (entry
->args
);
7833 tree ti
= get_template_info (inner
);
7834 tree_node (TI_TEMPLATE (ti
));
7835 tree_node (TI_ARGS (ti
));
7838 tree_node (get_constraints (decl
));
7843 /* Do not stray outside this section. */
7844 gcc_checking_assert (!dep
|| dep
->section
== dep_hash
->section
);
7846 /* Write the entity index, so we can insert it as soon as we
7847 know this is new. */
7848 install_entity (decl
, dep
);
7851 if (VAR_OR_FUNCTION_DECL_P (inner
)
7852 && DECL_LANG_SPECIFIC (inner
)
7853 && DECL_MODULE_KEYED_DECLS_P (inner
)
7854 && !is_key_order ())
7856 /* Stream the keyed entities. */
7857 auto *attach_vec
= keyed_table
->get (inner
);
7858 unsigned num
= attach_vec
->length ();
7861 for (unsigned ix
= 0; ix
!= num
; ix
++)
7863 tree attached
= (*attach_vec
)[ix
];
7864 tree_node (attached
);
7866 dump (dumper::MERGE
)
7867 && dump ("Written %d[%u] attached decl %N", tag
, ix
, attached
);
7871 bool is_typedef
= false;
7872 if (!type
&& TREE_CODE (inner
) == TYPE_DECL
)
7874 tree t
= TREE_TYPE (inner
);
7875 unsigned tdef_flags
= 0;
7876 if (DECL_ORIGINAL_TYPE (inner
)
7877 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
7880 if (TYPE_STRUCTURAL_EQUALITY_P (t
)
7881 && TYPE_DEPENDENT_P_VALID (t
)
7882 && TYPE_DEPENDENT_P (t
))
7890 /* A typedef type. */
7891 int type_tag
= insert (t
);
7894 && dump ("Cloned:%d %s %C:%N", type_tag
,
7895 tdef_flags
& 2 ? "depalias" : "typedef",
7902 if (streaming_p () && DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
))
7905 = (DECL_CHAIN (decl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
7906 bool needs_vtt_parm_p
7907 = (cloned_p
&& CLASSTYPE_VBASECLASSES (DECL_CONTEXT (decl
)));
7908 bool omit_inherited_parms_p
7909 = (cloned_p
&& DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
7910 && base_ctor_omit_inherited_parms (decl
));
7911 unsigned flags
= (int (cloned_p
) << 0
7912 | int (needs_vtt_parm_p
) << 1
7913 | int (omit_inherited_parms_p
) << 2);
7915 dump (dumper::TREE
) && dump ("CDTOR %N is %scloned",
7916 decl
, cloned_p
? "" : "not ");
7920 dump (dumper::TREE
) && dump ("Written decl:%d %C:%N", tag
,
7921 TREE_CODE (decl
), decl
);
7923 if (NAMESPACE_SCOPE_P (inner
))
7924 gcc_checking_assert (!dep
== (VAR_OR_FUNCTION_DECL_P (inner
)
7925 && DECL_LOCAL_DECL_P (inner
)));
7926 else if ((TREE_CODE (inner
) == TYPE_DECL
7928 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
7929 || TREE_CODE (inner
) == FUNCTION_DECL
)
7931 bool write_defn
= !dep
&& has_definition (decl
);
7935 write_definition (decl
);
7940 trees_in::decl_value ()
7943 bool is_attached
= false;
7944 bool has_defn
= false;
7945 unsigned mk_u
= u ();
7946 if (mk_u
>= MK_hwm
|| !merge_kind_name
[mk_u
])
7952 unsigned saved_unused
= unused
;
7955 merge_kind mk
= merge_kind (mk_u
);
7957 tree decl
= start ();
7960 if (mk
!= MK_unique
)
7962 if (!(mk
& MK_template_mask
) && !state
->is_header ())
7963 /* See note in trees_out about where this bool is sequenced. */
7969 if (!tree_node_bools (decl
))
7973 /* Insert into map. */
7974 tag
= insert (decl
);
7977 && dump ("Reading:%d %C", tag
, TREE_CODE (decl
));
7981 if (decl
&& TREE_CODE (decl
) == TEMPLATE_DECL
)
7984 inner
= start (code
);
7985 if (inner
&& tree_node_bools (inner
))
7986 DECL_TEMPLATE_RESULT (decl
) = inner
;
7990 inner_tag
= insert (inner
);
7993 && dump ("Reading:%d %C", inner_tag
, TREE_CODE (inner
));
7996 tree type
= NULL_TREE
;
7998 tree stub_decl
= NULL_TREE
;
8000 if (decl
&& TREE_CODE (inner
) == TYPE_DECL
)
8002 if (unsigned type_code
= u ())
8004 type
= start (type_code
);
8005 if (type
&& tree_node_bools (type
))
8007 TREE_TYPE (inner
) = type
;
8008 TYPE_NAME (type
) = inner
;
8013 type_tag
= insert (type
);
8016 && dump ("Reading type:%d %C", type_tag
, TREE_CODE (type
));
8018 if (unsigned stub_code
= u ())
8020 stub_decl
= start (stub_code
);
8021 if (stub_decl
&& tree_node_bools (stub_decl
))
8023 TREE_TYPE (stub_decl
) = type
;
8024 TYPE_STUB_DECL (type
) = stub_decl
;
8029 stub_tag
= insert (stub_decl
);
8032 && dump ("Reading stub_decl:%d %C", stub_tag
,
8033 TREE_CODE (stub_decl
));
8042 back_refs
[~inner_tag
] = NULL_TREE
;
8044 back_refs
[~type_tag
] = NULL_TREE
;
8046 back_refs
[~stub_tag
] = NULL_TREE
;
8048 back_refs
[~tag
] = NULL_TREE
;
8051 unused
= saved_unused
;
8055 /* Read the container, to ensure it's already been streamed in. */
8056 tree container
= decl_container ();
8057 unsigned tpl_levels
= 0;
8059 /* Figure out if this decl is already known about. */
8063 if (!tpl_header (decl
, &tpl_levels
))
8065 if (TREE_CODE (inner
) == FUNCTION_DECL
)
8066 parm_tag
= fn_parms_init (inner
);
8068 tree existing
= key_mergeable (tag
, mk
, decl
, inner
, type
, container
,
8070 tree existing_inner
= existing
;
8073 if (existing
== error_mark_node
)
8076 if (TREE_CODE (STRIP_TEMPLATE (existing
)) == TYPE_DECL
)
8078 tree etype
= TREE_TYPE (existing
);
8079 if (TYPE_LANG_SPECIFIC (etype
)
8080 && COMPLETE_TYPE_P (etype
)
8081 && !CLASSTYPE_MEMBER_VEC (etype
))
8082 /* Give it a member vec, we're likely gonna be looking
8084 set_class_bindings (etype
, -1);
8087 /* Install the existing decl into the back ref array. */
8088 register_duplicate (decl
, existing
);
8089 back_refs
[~tag
] = existing
;
8092 existing_inner
= DECL_TEMPLATE_RESULT (existing
);
8093 back_refs
[~inner_tag
] = existing_inner
;
8098 tree existing_type
= TREE_TYPE (existing
);
8099 back_refs
[~type_tag
] = existing_type
;
8101 back_refs
[~stub_tag
] = TYPE_STUB_DECL (existing_type
);
8106 fn_parms_fini (parm_tag
, inner
, existing_inner
, has_defn
);
8108 if (!tree_node_vals (decl
))
8113 gcc_checking_assert (DECL_TEMPLATE_RESULT (decl
) == inner
);
8115 if (!tree_node_vals (inner
))
8118 if (!tpl_parms_fini (decl
, tpl_levels
))
8122 if (type
&& (!tree_node_vals (type
)
8123 || (stub_decl
&& !tree_node_vals (stub_decl
))))
8127 unsigned spec_flags
= 0;
8128 if (mk
& MK_template_mask
8130 || mk
== MK_friend_spec
)
8132 if (mk
== MK_partial
)
8137 spec
.tmpl
= tree_node ();
8138 spec
.args
= tree_node ();
8140 /* Hold constraints on the spec field, for a short while. */
8141 spec
.spec
= tree_node ();
8143 dump (dumper::TREE
) && dump ("Read:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8145 existing
= back_refs
[~tag
];
8146 bool installed
= install_entity (existing
);
8147 bool is_new
= existing
== decl
;
8149 if (VAR_OR_FUNCTION_DECL_P (inner
)
8150 && DECL_LANG_SPECIFIC (inner
)
8151 && DECL_MODULE_KEYED_DECLS_P (inner
))
8153 /* Read and maybe install the attached entities. */
8155 auto &set
= keyed_table
->get_or_insert (STRIP_TEMPLATE (existing
),
8157 unsigned num
= u ();
8158 if (is_new
== existed
)
8162 for (unsigned ix
= 0; !get_overrun () && ix
!= num
; ix
++)
8164 tree attached
= tree_node ();
8165 dump (dumper::MERGE
)
8166 && dump ("Read %d[%u] %s attached decl %N", tag
, ix
,
8167 is_new
? "new" : "matched", attached
);
8169 set
.quick_push (attached
);
8170 else if (set
[ix
] != attached
)
8175 /* Regular typedefs will have a NULL TREE_TYPE at this point. */
8176 unsigned tdef_flags
= 0;
8177 bool is_typedef
= false;
8178 if (!type
&& TREE_CODE (inner
) == TYPE_DECL
)
8187 /* A newly discovered node. */
8188 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
8189 /* Mark this identifier as naming a virtual function --
8190 lookup_overrides relies on this optimization. */
8191 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = true;
8195 /* Mark the entity as imported. */
8196 retrofit_lang_decl (inner
);
8197 DECL_MODULE_IMPORT_P (inner
) = true;
8201 set_constraints (decl
, spec
.spec
);
8203 if (TREE_CODE (decl
) == INTEGER_CST
&& !TREE_OVERFLOW (decl
))
8205 decl
= cache_integer_cst (decl
, true);
8206 back_refs
[~tag
] = decl
;
8211 /* Frob it to be ready for cloning. */
8212 TREE_TYPE (inner
) = DECL_ORIGINAL_TYPE (inner
);
8213 DECL_ORIGINAL_TYPE (inner
) = NULL_TREE
;
8214 set_underlying_type (inner
);
8217 /* Match instantiate_alias_template's handling. */
8218 tree type
= TREE_TYPE (inner
);
8219 TYPE_DEPENDENT_P (type
) = true;
8220 TYPE_DEPENDENT_P_VALID (type
) = true;
8221 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8226 /* Set the TEMPLATE_DECL's type. */
8227 TREE_TYPE (decl
) = TREE_TYPE (inner
);
8229 /* Add to specialization tables now that constraints etc are
8231 if (mk
== MK_partial
)
8233 bool is_type
= TREE_CODE (inner
) == TYPE_DECL
;
8234 spec
.spec
= is_type
? type
: inner
;
8235 add_mergeable_specialization (!is_type
, false,
8236 &spec
, decl
, spec_flags
);
8238 else if (mk
& MK_template_mask
)
8240 bool is_type
= !(mk
& MK_tmpl_decl_mask
);
8241 spec
.spec
= is_type
? type
: mk
& MK_tmpl_tmpl_mask
? inner
: decl
;
8242 add_mergeable_specialization (!is_type
,
8243 !is_type
&& mk
& MK_tmpl_alias_mask
,
8244 &spec
, decl
, spec_flags
);
8247 if (NAMESPACE_SCOPE_P (decl
)
8248 && (mk
== MK_named
|| mk
== MK_unique
8249 || mk
== MK_enum
|| mk
== MK_friend_spec
)
8250 && !(VAR_OR_FUNCTION_DECL_P (decl
) && DECL_LOCAL_DECL_P (decl
)))
8251 add_module_namespace_decl (CP_DECL_CONTEXT (decl
), decl
);
8253 if (DECL_ARTIFICIAL (decl
)
8254 && TREE_CODE (decl
) == FUNCTION_DECL
8255 && !DECL_TEMPLATE_INFO (decl
)
8256 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
8257 && TYPE_SIZE (DECL_CONTEXT (decl
))
8258 && !DECL_THUNK_P (decl
))
8259 /* A new implicit member function, when the class is
8260 complete. This means the importee declared it, and
8261 we must now add it to the class. Note that implicit
8262 member fns of template instantiations do not themselves
8263 look like templates. */
8264 if (!install_implicit_member (inner
))
8269 /* DECL is the to-be-discarded decl. Its internal pointers will
8270 be to the EXISTING's structure. Frob it to point to its
8271 own other structures, so loading its definition will alter
8272 it, and not the existing decl. */
8273 dump (dumper::MERGE
) && dump ("Deduping %N", existing
);
8276 DECL_TEMPLATE_RESULT (decl
) = inner
;
8280 /* Point at the to-be-discarded type & decl. */
8281 TYPE_NAME (type
) = inner
;
8282 TREE_TYPE (inner
) = type
;
8284 TYPE_STUB_DECL (type
) = stub_decl
? stub_decl
: inner
;
8286 TREE_TYPE (stub_decl
) = type
;
8290 /* Set the TEMPLATE_DECL's type. */
8291 TREE_TYPE (decl
) = TREE_TYPE (inner
);
8293 if (!is_matching_decl (existing
, decl
, is_typedef
))
8294 unmatched_duplicate (existing
);
8296 if (TREE_CODE (inner
) == FUNCTION_DECL
)
8298 tree e_inner
= STRIP_TEMPLATE (existing
);
8299 for (auto parm
= DECL_ARGUMENTS (inner
);
8300 parm
; parm
= DECL_CHAIN (parm
))
8301 DECL_CONTEXT (parm
) = e_inner
;
8304 /* And our result is the existing node. */
8308 if (mk
== MK_friend_spec
)
8310 tree e
= match_mergeable_specialization (true, &spec
);
8314 add_mergeable_specialization (true, false, &spec
, decl
, spec_flags
);
8316 else if (e
!= existing
)
8322 /* Insert the type into the array now. */
8323 tag
= insert (TREE_TYPE (decl
));
8325 && dump ("Cloned:%d typedef %C:%N",
8326 tag
, TREE_CODE (TREE_TYPE (decl
)), TREE_TYPE (decl
));
8329 unused
= saved_unused
;
8331 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
))
8333 unsigned flags
= u ();
8337 bool cloned_p
= flags
& 1;
8338 dump (dumper::TREE
) && dump ("CDTOR %N is %scloned",
8339 decl
, cloned_p
? "" : "not ");
8341 build_cdtor_clones (decl
, flags
& 2, flags
& 4,
8342 /* Update the member vec, if there is
8343 one (we're in a different cluster
8344 to the class defn). */
8345 CLASSTYPE_MEMBER_VEC (DECL_CONTEXT (decl
)));
8349 if (!NAMESPACE_SCOPE_P (inner
)
8350 && ((TREE_CODE (inner
) == TYPE_DECL
8352 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
8353 || TREE_CODE (inner
) == FUNCTION_DECL
)
8355 read_definition (decl
);
8360 /* DECL is an unnameable member of CTX. Return a suitable identifying
8364 get_field_ident (tree ctx
, tree decl
)
8366 gcc_checking_assert (TREE_CODE (decl
) == USING_DECL
8367 || !DECL_NAME (decl
)
8368 || IDENTIFIER_ANON_P (DECL_NAME (decl
)));
8371 for (tree fields
= TYPE_FIELDS (ctx
);
8372 fields
; fields
= DECL_CHAIN (fields
))
8377 if (DECL_CONTEXT (fields
) == ctx
8378 && (TREE_CODE (fields
) == USING_DECL
8379 || (TREE_CODE (fields
) == FIELD_DECL
8380 && (!DECL_NAME (fields
)
8381 || IDENTIFIER_ANON_P (DECL_NAME (fields
))))))
8382 /* Count this field. */
8389 lookup_field_ident (tree ctx
, unsigned ix
)
8391 for (tree fields
= TYPE_FIELDS (ctx
);
8392 fields
; fields
= DECL_CHAIN (fields
))
8393 if (DECL_CONTEXT (fields
) == ctx
8394 && (TREE_CODE (fields
) == USING_DECL
8395 || (TREE_CODE (fields
) == FIELD_DECL
8396 && (!DECL_NAME (fields
)
8397 || IDENTIFIER_ANON_P (DECL_NAME (fields
))))))
8404 /* Reference DECL. REF indicates the walk kind we are performing.
8405 Return true if we should write this decl by value. */
8408 trees_out::decl_node (tree decl
, walk_kind ref
)
8410 gcc_checking_assert (DECL_P (decl
) && !DECL_TEMPLATE_PARM_P (decl
)
8411 && DECL_CONTEXT (decl
));
8413 if (ref
== WK_value
)
8415 depset
*dep
= dep_hash
->find_dependency (decl
);
8416 decl_value (decl
, dep
);
8420 switch (TREE_CODE (decl
))
8426 gcc_checking_assert (!DECL_LOCAL_DECL_P (decl
));
8430 /* Unlike PARM_DECLs, RESULT_DECLs are only generated and
8431 referenced when we're inside the function itself. */
8438 tree_node (DECL_CONTEXT (decl
));
8441 /* That must have put this in the map. */
8442 walk_kind ref
= ref_node (decl
);
8444 // FIXME:OPTIMIZATION We can wander into bits of the
8445 // template this was instantiated from. For instance
8446 // deferred noexcept and default parms. Currently we'll
8447 // end up cloning those bits of tree. It would be nice
8448 // to reference those specific nodes. I think putting
8449 // those things in the map when we reference their
8450 // template by name. See the note in add_indirects.
8454 && dump ("Wrote %s reference %N",
8455 TREE_CODE (decl
) == PARM_DECL
? "parameter" : "result",
8462 /* This describes a USING_DECL to the ME's debug machinery. It
8463 originates from the fortran FE, and has nothing to do with
8472 /* If I end up cloning enum decls, implementing C++20 using
8473 E::v, this will need tweaking. */
8476 tree ctx
= DECL_CONTEXT (decl
);
8477 gcc_checking_assert (TREE_CODE (ctx
) == ENUMERAL_TYPE
);
8479 tree_node (DECL_NAME (decl
));
8481 int tag
= insert (decl
);
8484 && dump ("Wrote enum decl:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8490 if (TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8499 tree ctx
= DECL_CONTEXT (decl
);
8502 tree name
= NULL_TREE
;
8504 if (TREE_CODE (decl
) == USING_DECL
)
8508 name
= DECL_NAME (decl
);
8509 if (name
&& IDENTIFIER_ANON_P (name
))
8514 if (!name
&& streaming_p ())
8516 unsigned ix
= get_field_ident (ctx
, decl
);
8520 int tag
= insert (decl
);
8523 && dump ("Wrote member:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8529 gcc_checking_assert (!DECL_LOCAL_DECL_P (decl
));
8530 if (DECL_VTABLE_OR_VTT_P (decl
))
8532 /* VTT or VTABLE, they are all on the vtables list. */
8533 tree ctx
= CP_DECL_CONTEXT (decl
);
8534 tree vtable
= CLASSTYPE_VTABLES (ctx
);
8535 for (unsigned ix
= 0; ; vtable
= DECL_CHAIN (vtable
), ix
++)
8538 gcc_checking_assert (DECL_VIRTUAL_P (decl
));
8544 && dump ("Writing vtable %N[%u]", ctx
, ix
);
8552 if (DECL_TINFO_P (decl
))
8555 /* A typeinfo, tt_tinfo_typedef or tt_tinfo_var. */
8556 bool is_var
= VAR_P (decl
);
8557 tree type
= TREE_TYPE (decl
);
8558 unsigned ix
= get_pseudo_tinfo_index (type
);
8561 i (is_var
? tt_tinfo_var
: tt_tinfo_typedef
);
8567 /* We also need the type it is for and mangled name, so
8568 the reader doesn't need to complete the type (which
8569 would break section ordering). The type it is for is
8570 stashed on the name's TREE_TYPE. */
8571 tree name
= DECL_NAME (decl
);
8573 type
= TREE_TYPE (name
);
8577 int tag
= insert (decl
);
8580 && dump ("Wrote tinfo_%s:%d %u %N", is_var
? "var" : "type",
8585 tag
= insert (type
);
8588 && dump ("Wrote tinfo_type:%d %u %N", tag
, ix
, type
);
8593 if (DECL_NTTP_OBJECT_P (decl
))
8595 /* A NTTP parm object. */
8598 tree_node (tparm_object_argument (decl
));
8599 tree_node (DECL_NAME (decl
));
8600 int tag
= insert (decl
);
8603 && dump ("Wrote nttp object:%d %N", tag
, DECL_NAME (decl
));
8610 if (DECL_TINFO_P (decl
))
8615 if (DECL_THUNK_P (decl
))
8617 /* Thunks are similar to binfos -- write the thunked-to decl and
8618 then thunk-specific key info. */
8622 i (THUNK_FIXED_OFFSET (decl
));
8626 while (DECL_THUNK_P (target
))
8627 target
= THUNK_TARGET (target
);
8629 tree_node (THUNK_VIRTUAL_OFFSET (decl
));
8630 int tag
= insert (decl
);
8633 && dump ("Wrote:%d thunk %N to %N", tag
, DECL_NAME (decl
), target
);
8637 if (DECL_CLONED_FUNCTION_P (decl
))
8639 tree target
= get_clone_target (decl
);
8644 tree_node (DECL_NAME (decl
));
8645 int tag
= insert (decl
);
8648 && dump ("Wrote:%d clone %N of %N", tag
, DECL_NAME (decl
), target
);
8652 /* Everything left should be a thing that is in the entity table.
8653 Mostly things that can be defined outside of their (original
8654 declaration) context. */
8655 gcc_checking_assert (TREE_CODE (decl
) == TEMPLATE_DECL
8657 || TREE_CODE (decl
) == FUNCTION_DECL
8658 || TREE_CODE (decl
) == TYPE_DECL
8659 || TREE_CODE (decl
) == USING_DECL
8660 || TREE_CODE (decl
) == CONCEPT_DECL
8661 || TREE_CODE (decl
) == NAMESPACE_DECL
);
8664 tree ti
= node_template_info (decl
, use_tpl
);
8665 tree tpl
= NULL_TREE
;
8667 /* If this is the TEMPLATE_DECL_RESULT of a TEMPLATE_DECL, get the
8668 TEMPLATE_DECL. Note TI_TEMPLATE is not a TEMPLATE_DECL for
8669 (some) friends, so we need to check that. */
8670 // FIXME: Should local friend template specializations be by value?
8671 // They don't get idents so we'll never know they're imported, but I
8672 // think we can only reach them from the TU that defines the
8673 // befriending class?
8674 if (ti
&& TREE_CODE (TI_TEMPLATE (ti
)) == TEMPLATE_DECL
8675 && DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
)) == decl
)
8677 tpl
= TI_TEMPLATE (ti
);
8683 && dump ("Writing implicit template %C:%N%S",
8684 TREE_CODE (tpl
), tpl
, tpl
);
8688 /* Streaming TPL caused us to visit DECL and maybe its type. */
8689 gcc_checking_assert (TREE_VISITED (decl
));
8690 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
8691 gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl
)));
8695 tree ctx
= CP_DECL_CONTEXT (decl
);
8698 dep
= dep_hash
->find_dependency (decl
);
8699 else if (TREE_CODE (ctx
) != FUNCTION_DECL
8700 || TREE_CODE (decl
) == TEMPLATE_DECL
8701 || (dep_hash
->sneakoscope
&& DECL_IMPLICIT_TYPEDEF_P (decl
))
8702 || (DECL_LANG_SPECIFIC (decl
)
8703 && DECL_MODULE_IMPORT_P (decl
)))
8705 auto kind
= (TREE_CODE (decl
) == NAMESPACE_DECL
8706 && !DECL_NAMESPACE_ALIAS (decl
)
8707 ? depset::EK_NAMESPACE
: depset::EK_DECL
);
8708 dep
= dep_hash
->add_dependency (decl
, kind
);
8713 /* Some internal entity of context. Do by value. */
8714 decl_value (decl
, NULL
);
8718 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
8720 /* The DECL_TEMPLATE_RESULT of a partial specialization.
8721 Write the partial specialization's template. */
8722 depset
*redirect
= dep
->deps
[0];
8723 gcc_checking_assert (redirect
->get_entity_kind () == depset::EK_PARTIAL
);
8724 tpl
= redirect
->get_entity ();
8725 goto partial_template
;
8730 /* Locate the entity. */
8731 unsigned index
= dep
->cluster
;
8732 unsigned import
= 0;
8734 if (dep
->is_import ())
8735 import
= dep
->section
;
8736 else if (CHECKING_P
)
8737 /* It should be what we put there. */
8738 gcc_checking_assert (index
== ~import_entity_index (decl
));
8741 gcc_assert (!import
|| importedness
>= 0);
8748 int tag
= insert (decl
);
8749 if (streaming_p () && dump (dumper::TREE
))
8751 char const *kind
= "import";
8752 module_state
*from
= (*modules
)[0];
8753 if (dep
->is_import ())
8754 /* Rediscover the unremapped index. */
8755 from
= import_entity_module (import_entity_index (decl
));
8758 tree o
= get_originating_module_decl (decl
);
8759 o
= STRIP_TEMPLATE (o
);
8760 kind
= (DECL_LANG_SPECIFIC (o
) && DECL_MODULE_PURVIEW_P (o
)
8761 ? "purview" : "GMF");
8763 dump ("Wrote %s:%d %C:%N@%M", kind
,
8764 tag
, TREE_CODE (decl
), decl
, from
);
8767 add_indirects (decl
);
8773 trees_out::type_node (tree type
)
8775 gcc_assert (TYPE_P (type
));
8777 tree root
= (TYPE_NAME (type
)
8778 ? TREE_TYPE (TYPE_NAME (type
)) : TYPE_MAIN_VARIANT (type
));
8783 i (tt_variant_type
);
8788 if (TREE_CODE (type
) == FUNCTION_TYPE
8789 || TREE_CODE (type
) == METHOD_TYPE
)
8791 int quals
= type_memfn_quals (type
);
8792 int rquals
= type_memfn_rqual (type
);
8793 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
8794 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
8796 if (raises
!= TYPE_RAISES_EXCEPTIONS (root
)
8797 || rquals
!= type_memfn_rqual (root
)
8798 || quals
!= type_memfn_quals (root
)
8799 || late
!= TYPE_HAS_LATE_RETURN_TYPE (root
))
8800 flags
= rquals
| (int (late
) << 2) | (quals
<< 3);
8804 if (TYPE_USER_ALIGN (type
))
8805 flags
= TYPE_ALIGN_RAW (type
);
8813 else if (TREE_CODE (type
) == FUNCTION_TYPE
8814 || TREE_CODE (type
) == METHOD_TYPE
)
8816 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
8817 if (raises
== TYPE_RAISES_EXCEPTIONS (root
))
8818 raises
= error_mark_node
;
8822 tree_node (TYPE_ATTRIBUTES (type
));
8827 int rquals
= cp_type_quals (root
);
8828 int quals
= cp_type_quals (type
);
8829 if (quals
== rquals
)
8834 if (ref_node (type
) != WK_none
)
8836 int tag
= insert (type
);
8841 && dump ("Wrote:%d variant type %C", tag
, TREE_CODE (type
));
8847 if (tree name
= TYPE_NAME (type
))
8848 if ((TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
))
8849 || DECL_TEMPLATE_PARM_P (name
)
8850 || TREE_CODE (type
) == RECORD_TYPE
8851 || TREE_CODE (type
) == UNION_TYPE
8852 || TREE_CODE (type
) == ENUMERAL_TYPE
)
8854 /* We can meet template parms that we didn't meet in the
8855 tpl_parms walk, because we're referring to a derived type
8856 that was previously constructed from equivalent template
8860 i (tt_typedef_type
);
8862 && dump ("Writing %stypedef %C:%N",
8863 DECL_IMPLICIT_TYPEDEF_P (name
) ? "implicit " : "",
8864 TREE_CODE (name
), name
);
8868 dump (dumper::TREE
) && dump ("Wrote typedef %C:%N%S",
8869 TREE_CODE (name
), name
, name
);
8870 gcc_checking_assert (TREE_VISITED (type
));
8874 if (TYPE_PTRMEMFUNC_P (type
))
8876 /* This is a distinct type node, masquerading as a structure. */
8877 tree fn_type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
8880 tree_node (fn_type
);
8881 int tag
= insert (type
);
8883 dump (dumper::TREE
) && dump ("Written:%d ptrmem type", tag
);
8889 u (tt_derived_type
);
8890 u (TREE_CODE (type
));
8893 tree_node (TREE_TYPE (type
));
8894 switch (TREE_CODE (type
))
8897 /* We should never meet a type here that is indescribable in
8898 terms of other types. */
8902 tree_node (TYPE_DOMAIN (type
));
8904 /* Dependent arrays are constructed with TYPE_DEPENENT_P
8906 u (TYPE_DEPENDENT_P (type
));
8910 /* No additional data. */
8914 /* A non-standard boolean type. */
8916 u (TYPE_PRECISION (type
));
8920 if (TREE_TYPE (type
))
8922 /* A range type (representing an array domain). */
8923 tree_node (TYPE_MIN_VALUE (type
));
8924 tree_node (TYPE_MAX_VALUE (type
));
8928 /* A new integral type (representing a bitfield). */
8931 unsigned prec
= TYPE_PRECISION (type
);
8932 bool unsigned_p
= TYPE_UNSIGNED (type
);
8934 u ((prec
<< 1) | unsigned_p
);
8942 gcc_checking_assert (type_memfn_rqual (type
) == REF_QUAL_NONE
);
8944 tree arg_types
= TYPE_ARG_TYPES (type
);
8945 if (TREE_CODE (type
) == METHOD_TYPE
)
8947 tree_node (TREE_TYPE (TREE_VALUE (arg_types
)));
8948 arg_types
= TREE_CHAIN (arg_types
);
8950 tree_node (arg_types
);
8955 tree_node (TYPE_OFFSET_BASETYPE (type
));
8959 /* No additional data. */
8962 case REFERENCE_TYPE
:
8964 u (TYPE_REF_IS_RVALUE (type
));
8969 case DEPENDENT_OPERATOR_TYPE
:
8970 tree_node (TYPE_VALUES_RAW (type
));
8971 if (TREE_CODE (type
) == DECLTYPE_TYPE
)
8972 /* We stash a whole bunch of things into decltype's
8975 tree_node_bools (type
);
8979 tree_node (TRAIT_TYPE_KIND_RAW (type
));
8980 tree_node (TRAIT_TYPE_TYPE1 (type
));
8981 tree_node (TRAIT_TYPE_TYPE2 (type
));
8984 case TYPE_ARGUMENT_PACK
:
8985 /* No additional data. */
8988 case TYPE_PACK_EXPANSION
:
8990 u (PACK_EXPANSION_LOCAL_P (type
));
8991 tree_node (PACK_EXPANSION_PARAMETER_PACKS (type
));
8992 tree_node (PACK_EXPANSION_EXTRA_ARGS (type
));
8997 tree_node (TYPE_CONTEXT (type
));
8998 tree_node (DECL_NAME (TYPE_NAME (type
)));
8999 tree_node (TYPENAME_TYPE_FULLNAME (type
));
9002 enum tag_types tag_type
= none_type
;
9003 if (TYPENAME_IS_ENUM_P (type
))
9004 tag_type
= enum_type
;
9005 else if (TYPENAME_IS_CLASS_P (type
))
9006 tag_type
= class_type
;
9012 case UNBOUND_CLASS_TEMPLATE
:
9014 tree decl
= TYPE_NAME (type
);
9015 tree_node (DECL_CONTEXT (decl
));
9016 tree_node (DECL_NAME (decl
));
9017 tree_node (DECL_TEMPLATE_PARMS (decl
));
9024 poly_uint64 nunits
= TYPE_VECTOR_SUBPARTS (type
);
9025 /* to_constant asserts that only coeff[0] is of interest. */
9026 wu (static_cast<unsigned HOST_WIDE_INT
> (nunits
.to_constant ()));
9031 /* We may have met the type during emitting the above. */
9032 if (ref_node (type
) != WK_none
)
9034 int tag
= insert (type
);
9039 && dump ("Wrote:%d derived type %C", tag
, TREE_CODE (type
));
9046 /* T is (mostly*) a non-mergeable node that must be written by value.
9047 The mergeable case is a BINFO, which are as-if DECLSs. */
9050 trees_out::tree_value (tree t
)
9052 /* We should never be writing a type by value. tree_type should
9053 have streamed it, or we're going via its TYPE_DECL. */
9054 gcc_checking_assert (!TYPE_P (t
));
9057 /* No template, type, var or function, except anonymous
9058 non-context vars. */
9059 gcc_checking_assert ((TREE_CODE (t
) != TEMPLATE_DECL
9060 && TREE_CODE (t
) != TYPE_DECL
9061 && (TREE_CODE (t
) != VAR_DECL
9062 || (!DECL_NAME (t
) && !DECL_CONTEXT (t
)))
9063 && TREE_CODE (t
) != FUNCTION_DECL
));
9067 /* A new node -> tt_node. */
9071 tree_node_bools (t
);
9074 if (TREE_CODE (t
) == TREE_BINFO
)
9075 /* Binfos are decl-like and need merging information. */
9076 binfo_mergeable (t
);
9078 int tag
= insert (t
, WK_value
);
9081 && dump ("Writing tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9086 dump (dumper::TREE
) && dump ("Written tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9090 trees_in::tree_value ()
9093 if (!t
|| !tree_node_bools (t
))
9097 if (TREE_CODE (t
) == TREE_BINFO
)
9100 unsigned ix
= binfo_mergeable (&type
);
9101 if (TYPE_BINFO (type
))
9103 /* We already have a definition, this must be a duplicate. */
9104 dump (dumper::MERGE
)
9105 && dump ("Deduping binfo %N[%u]", type
, ix
);
9106 existing
= TYPE_BINFO (type
);
9107 while (existing
&& ix
--)
9108 existing
= TREE_CHAIN (existing
);
9110 register_duplicate (t
, existing
);
9112 /* Error, mismatch -- diagnose in read_class_def's
9118 /* Insert into map. */
9119 int tag
= insert (existing
);
9121 && dump ("Reading tree:%d %C", tag
, TREE_CODE (t
));
9123 if (!tree_node_vals (t
))
9125 back_refs
[~tag
] = NULL_TREE
;
9131 dump (dumper::TREE
) && dump ("Read tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9133 if (TREE_CODE (existing
) == INTEGER_CST
&& !TREE_OVERFLOW (existing
))
9135 existing
= cache_integer_cst (t
, true);
9136 back_refs
[~tag
] = existing
;
9142 /* Stream out tree node T. We automatically create local back
9143 references, which is essentially a single pass lisp
9144 self-referential structure pretty-printer. */
9147 trees_out::tree_node (tree t
)
9150 walk_kind ref
= ref_node (t
);
9154 if (ref
!= WK_normal
)
9157 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
9159 /* An identifier node -> tt_id, tt_conv_id, tt_anon_id, tt_lambda_id. */
9161 if (IDENTIFIER_ANON_P (t
))
9162 code
= IDENTIFIER_LAMBDA_P (t
) ? tt_lambda_id
: tt_anon_id
;
9163 else if (IDENTIFIER_CONV_OP_P (t
))
9169 if (code
== tt_conv_id
)
9171 tree type
= TREE_TYPE (t
);
9172 gcc_checking_assert (type
|| t
== conv_op_identifier
);
9175 else if (code
== tt_id
&& streaming_p ())
9176 str (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
9178 int tag
= insert (t
);
9181 /* We know the ordering of the 4 id tags. */
9182 static const char *const kinds
[] =
9183 {"", "conv_op ", "anon ", "lambda "};
9185 && dump ("Written:%d %sidentifier:%N", tag
,
9186 kinds
[code
- tt_id
],
9187 code
== tt_conv_id
? TREE_TYPE (t
) : t
);
9192 if (TREE_CODE (t
) == TREE_BINFO
)
9194 /* A BINFO -> tt_binfo.
9195 We must do this by reference. We stream the binfo tree
9196 itself when streaming its owning RECORD_TYPE. That we got
9197 here means the dominating type is not in this SCC. */
9200 binfo_mergeable (t
);
9201 gcc_checking_assert (!TREE_VISITED (t
));
9202 int tag
= insert (t
);
9204 dump (dumper::TREE
) && dump ("Inserting binfo:%d %N", tag
, t
);
9208 if (TREE_CODE (t
) == INTEGER_CST
9209 && !TREE_OVERFLOW (t
)
9210 && TREE_CODE (TREE_TYPE (t
)) == ENUMERAL_TYPE
)
9212 /* An integral constant of enumeral type. See if it matches one
9213 of the enumeration values. */
9214 for (tree values
= TYPE_VALUES (TREE_TYPE (t
));
9215 values
; values
= TREE_CHAIN (values
))
9217 tree decl
= TREE_VALUE (values
);
9218 if (tree_int_cst_equal (DECL_INITIAL (decl
), t
))
9223 dump (dumper::TREE
) && dump ("Written enum value %N", decl
);
9227 /* It didn't match. We'll write it a an explicit INTEGER_CST
9239 if (DECL_TEMPLATE_PARM_P (t
))
9245 if (!DECL_CONTEXT (t
))
9247 /* There are a few cases of decls with no context. We'll write
9248 these by value, but first assert they are cases we expect. */
9249 gcc_checking_assert (ref
== WK_normal
);
9250 switch (TREE_CODE (t
))
9252 default: gcc_unreachable ();
9255 /* CASE_LABEL_EXPRs contain uncontexted LABEL_DECLs. */
9256 gcc_checking_assert (!DECL_NAME (t
));
9260 /* AGGR_INIT_EXPRs cons up anonymous uncontexted VAR_DECLs. */
9261 gcc_checking_assert (!DECL_NAME (t
)
9262 && DECL_ARTIFICIAL (t
));
9266 /* REQUIRES_EXPRs have a tree list of uncontexted
9267 PARM_DECLS. It'd be nice if they had a
9268 distinguishing flag to double check. */
9276 if (DECL_P (t
) && !decl_node (t
, ref
))
9279 /* Otherwise by value */
9284 /* And, breath out. */
9288 /* Stream in a tree node. */
9291 trees_in::tree_node (bool is_use
)
9298 tree res
= NULL_TREE
;
9302 /* backref, pull it out of the map. */
9303 res
= back_ref (tag
);
9311 /* A fixed ref, find it in the fixed_ref array. */
9313 unsigned fix
= u ();
9314 if (fix
< (*fixed_trees
).length ())
9316 res
= (*fixed_trees
)[fix
];
9317 dump (dumper::TREE
) && dump ("Read fixed:%u %C:%N%S", fix
,
9318 TREE_CODE (res
), res
, res
);
9328 tree fn
= tree_node ();
9329 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
9333 && dump ("Read %s reference %N",
9334 TREE_CODE (res
) == PARM_DECL
? "parameter" : "result",
9340 /* A new node. Stream it in. */
9341 res
= tree_value ();
9345 /* A new decl. Stream it in. */
9346 res
= decl_value ();
9350 /* A template parameter. Stream it in. */
9351 res
= tpl_parm_value ();
9355 /* An identifier node. */
9358 const char *chars
= str (&l
);
9359 res
= get_identifier_with_length (chars
, l
);
9360 int tag
= insert (res
);
9362 && dump ("Read identifier:%d %N", tag
, res
);
9367 /* A conversion operator. Get the type and recreate the
9370 tree type
= tree_node ();
9371 if (!get_overrun ())
9373 res
= type
? make_conv_op_name (type
) : conv_op_identifier
;
9374 int tag
= insert (res
);
9376 && dump ("Created conv_op:%d %S for %N", tag
, res
, type
);
9383 /* An anonymous or lambda id. */
9385 res
= make_anon_name ();
9386 if (tag
== tt_lambda_id
)
9387 IDENTIFIER_LAMBDA_P (res
) = true;
9388 int tag
= insert (res
);
9390 && dump ("Read %s identifier:%d %N",
9391 IDENTIFIER_LAMBDA_P (res
) ? "lambda" : "anon", tag
, res
);
9395 case tt_typedef_type
:
9400 && dump ("Read %stypedef %C:%N",
9401 DECL_IMPLICIT_TYPEDEF_P (res
) ? "implicit " : "",
9402 TREE_CODE (res
), res
);
9403 res
= TREE_TYPE (res
);
9407 case tt_derived_type
:
9408 /* A type derived from some other type. */
9410 enum tree_code code
= tree_code (u ());
9421 tree domain
= tree_node ();
9423 if (!get_overrun ())
9424 res
= build_cplus_array_type (res
, domain
, dep
);
9429 if (!get_overrun ())
9430 res
= build_complex_type (res
);
9435 unsigned precision
= u ();
9436 if (!get_overrun ())
9437 res
= build_nonstandard_boolean_type (precision
);
9444 /* A range type (representing an array domain). */
9445 tree min
= tree_node ();
9446 tree max
= tree_node ();
9448 if (!get_overrun ())
9449 res
= build_range_type (res
, min
, max
);
9453 /* A new integral type (representing a bitfield). */
9454 unsigned enc
= u ();
9455 if (!get_overrun ())
9456 res
= build_nonstandard_integer_type (enc
>> 1, enc
& 1);
9463 tree klass
= code
== METHOD_TYPE
? tree_node () : NULL_TREE
;
9464 tree args
= tree_node ();
9465 if (!get_overrun ())
9468 res
= build_method_type_directly (klass
, res
, args
);
9470 res
= build_function_type (res
, args
);
9477 tree base
= tree_node ();
9478 if (!get_overrun ())
9479 res
= build_offset_type (base
, res
);
9484 if (!get_overrun ())
9485 res
= build_pointer_type (res
);
9488 case REFERENCE_TYPE
:
9490 bool rval
= bool (u ());
9491 if (!get_overrun ())
9492 res
= cp_build_reference_type (res
, rval
);
9498 case DEPENDENT_OPERATOR_TYPE
:
9500 tree expr
= tree_node ();
9501 if (!get_overrun ())
9503 res
= cxx_make_type (code
);
9504 TYPE_VALUES_RAW (res
) = expr
;
9505 if (code
== DECLTYPE_TYPE
)
9506 tree_node_bools (res
);
9507 SET_TYPE_STRUCTURAL_EQUALITY (res
);
9514 tree kind
= tree_node ();
9515 tree type1
= tree_node ();
9516 tree type2
= tree_node ();
9517 if (!get_overrun ())
9519 res
= cxx_make_type (TRAIT_TYPE
);
9520 TRAIT_TYPE_KIND_RAW (res
) = kind
;
9521 TRAIT_TYPE_TYPE1 (res
) = type1
;
9522 TRAIT_TYPE_TYPE2 (res
) = type2
;
9523 SET_TYPE_STRUCTURAL_EQUALITY (res
);
9528 case TYPE_ARGUMENT_PACK
:
9529 if (!get_overrun ())
9531 tree pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9532 ARGUMENT_PACK_ARGS (pack
) = res
;
9537 case TYPE_PACK_EXPANSION
:
9540 tree param_packs
= tree_node ();
9541 tree extra_args
= tree_node ();
9542 if (!get_overrun ())
9544 tree expn
= cxx_make_type (TYPE_PACK_EXPANSION
);
9545 SET_TYPE_STRUCTURAL_EQUALITY (expn
);
9546 PACK_EXPANSION_PATTERN (expn
) = res
;
9547 PACK_EXPANSION_PARAMETER_PACKS (expn
) = param_packs
;
9548 PACK_EXPANSION_EXTRA_ARGS (expn
) = extra_args
;
9549 PACK_EXPANSION_LOCAL_P (expn
) = local
;
9557 tree ctx
= tree_node ();
9558 tree name
= tree_node ();
9559 tree fullname
= tree_node ();
9560 enum tag_types tag_type
= tag_types (u ());
9562 if (!get_overrun ())
9563 res
= build_typename_type (ctx
, name
, fullname
, tag_type
);
9567 case UNBOUND_CLASS_TEMPLATE
:
9569 tree ctx
= tree_node ();
9570 tree name
= tree_node ();
9571 tree parms
= tree_node ();
9573 if (!get_overrun ())
9574 res
= make_unbound_class_template_raw (ctx
, name
, parms
);
9580 unsigned HOST_WIDE_INT nunits
= wu ();
9581 if (!get_overrun ())
9582 res
= build_vector_type (res
, static_cast<poly_int64
> (nunits
));
9593 && dump ("Created:%d derived type %C", tag
, code
);
9596 res
= back_ref (tag
);
9600 case tt_variant_type
:
9601 /* Variant of some type. */
9609 else if (TREE_CODE (res
) == FUNCTION_TYPE
9610 || TREE_CODE (res
) == METHOD_TYPE
)
9612 cp_ref_qualifier rqual
= cp_ref_qualifier (flags
& 3);
9613 bool late
= (flags
>> 2) & 1;
9614 cp_cv_quals quals
= cp_cv_quals (flags
>> 3);
9616 tree raises
= tree_node ();
9617 if (raises
== error_mark_node
)
9618 raises
= TYPE_RAISES_EXCEPTIONS (res
);
9620 res
= build_cp_fntype_variant (res
, rqual
, raises
, late
);
9621 if (TREE_CODE (res
) == FUNCTION_TYPE
)
9622 res
= apply_memfn_quals (res
, quals
, rqual
);
9626 res
= build_aligned_type (res
, (1u << flags
) >> 1);
9627 TYPE_USER_ALIGN (res
) = true;
9630 if (tree attribs
= tree_node ())
9631 res
= cp_build_type_attribute_variant (res
, attribs
);
9634 if (quals
>= 0 && !get_overrun ())
9635 res
= cp_build_qualified_type (res
, quals
);
9643 && dump ("Created:%d variant type %C", tag
, TREE_CODE (res
));
9646 res
= back_ref (tag
);
9651 case tt_tinfo_typedef
:
9652 /* A tinfo var or typedef. */
9654 bool is_var
= tag
== tt_tinfo_var
;
9656 tree type
= NULL_TREE
;
9660 tree name
= tree_node ();
9661 type
= tree_node ();
9663 if (!get_overrun ())
9664 res
= get_tinfo_decl_direct (type
, name
, int (ix
));
9668 if (!get_overrun ())
9670 type
= get_pseudo_tinfo_type (ix
);
9671 res
= TYPE_NAME (type
);
9676 int tag
= insert (res
);
9678 && dump ("Created tinfo_%s:%d %S:%u for %N",
9679 is_var
? "var" : "decl", tag
, res
, ix
, type
);
9682 tag
= insert (type
);
9684 && dump ("Created tinfo_type:%d %u %N", tag
, ix
, type
);
9690 case tt_ptrmem_type
:
9691 /* A pointer to member function. */
9693 tree type
= tree_node ();
9694 if (type
&& TREE_CODE (type
) == POINTER_TYPE
9695 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
9697 res
= build_ptrmemfunc_type (type
);
9698 int tag
= insert (res
);
9699 dump (dumper::TREE
) && dump ("Created:%d ptrmem type", tag
);
9707 /* An NTTP object. */
9709 tree init
= tree_node ();
9710 tree name
= tree_node ();
9711 if (!get_overrun ())
9713 res
= get_template_parm_object (init
, name
);
9714 int tag
= insert (res
);
9716 && dump ("Created nttp object:%d %N", tag
, name
);
9722 /* An enum const value. */
9724 if (tree decl
= tree_node ())
9726 dump (dumper::TREE
) && dump ("Read enum value %N", decl
);
9727 res
= DECL_INITIAL (decl
);
9738 tree ctx
= tree_node ();
9739 tree name
= tree_node ();
9742 && TREE_CODE (ctx
) == ENUMERAL_TYPE
)
9743 res
= find_enum_member (ctx
, name
);
9749 int tag
= insert (res
);
9751 && dump ("Read enum decl:%d %C:%N", tag
, TREE_CODE (res
), res
);
9756 case tt_data_member
:
9757 /* A data member. */
9759 tree ctx
= tree_node ();
9760 tree name
= tree_node ();
9763 && RECORD_OR_UNION_TYPE_P (ctx
))
9766 res
= lookup_class_binding (ctx
, name
);
9768 res
= lookup_field_ident (ctx
, u ());
9771 || TREE_CODE (res
) != FIELD_DECL
9772 || DECL_CONTEXT (res
) != ctx
)
9780 int tag
= insert (res
);
9782 && dump ("Read member:%d %C:%N", tag
, TREE_CODE (res
), res
);
9788 /* A BINFO. Walk the tree of the dominating type. */
9791 unsigned ix
= binfo_mergeable (&type
);
9794 res
= TYPE_BINFO (type
);
9795 for (; ix
&& res
; res
= TREE_CHAIN (res
))
9804 /* Insert binfo into backreferences. */
9806 dump (dumper::TREE
) && dump ("Read binfo:%d %N", tag
, res
);
9813 tree ctx
= tree_node ();
9814 dump (dumper::TREE
) && dump ("Reading vtable %N[%u]", ctx
, ix
);
9815 if (TREE_CODE (ctx
) == RECORD_TYPE
&& TYPE_LANG_SPECIFIC (ctx
))
9816 for (res
= CLASSTYPE_VTABLES (ctx
); res
; res
= DECL_CHAIN (res
))
9827 tree target
= tree_node ();
9828 tree virt
= tree_node ();
9830 for (tree thunk
= DECL_THUNKS (target
);
9831 thunk
; thunk
= DECL_CHAIN (thunk
))
9832 if (THUNK_FIXED_OFFSET (thunk
) == fixed
9833 && !THUNK_VIRTUAL_OFFSET (thunk
) == !virt
9835 || tree_int_cst_equal (virt
, THUNK_VIRTUAL_OFFSET (thunk
))))
9841 int tag
= insert (res
);
9844 && dump ("Read:%d thunk %N to %N", tag
, DECL_NAME (res
), target
);
9852 tree target
= tree_node ();
9853 tree name
= tree_node ();
9855 if (DECL_P (target
) && DECL_MAYBE_IN_CHARGE_CDTOR_P (target
))
9858 FOR_EVERY_CLONE (clone
, target
)
9859 if (DECL_NAME (clone
) == name
)
9868 int tag
= insert (res
);
9871 && dump ("Read:%d clone %N of %N", tag
, DECL_NAME (res
), target
);
9878 /* Index into the entity table. Perhaps not loaded yet! */
9880 unsigned origin
= state
->slurp
->remap_module (u ());
9881 unsigned ident
= u ();
9882 module_state
*from
= (*modules
)[origin
];
9884 if (!origin
|| ident
>= from
->entity_num
)
9886 if (!get_overrun ())
9888 binding_slot
*slot
= &(*entity_ary
)[from
->entity_lwm
+ ident
];
9889 if (slot
->is_lazy ())
9890 if (!from
->lazy_load (ident
, slot
))
9897 const char *kind
= (origin
!= state
->mod
? "Imported" : "Named");
9898 int tag
= insert (res
);
9900 && dump ("%s:%d %C:%N@%M", kind
, tag
, TREE_CODE (res
),
9901 res
, (*modules
)[origin
]);
9903 if (!add_indirects (res
))
9914 if (tree tpl
= tree_node ())
9916 res
= DECL_TEMPLATE_RESULT (tpl
);
9918 && dump ("Read template %C:%N", TREE_CODE (res
), res
);
9923 if (is_use
&& !unused
&& res
&& DECL_P (res
) && !TREE_USED (res
))
9925 /* Mark decl used as mark_used does -- we cannot call
9926 mark_used in the middle of streaming, we only need a subset
9927 of its functionality. */
9928 TREE_USED (res
) = true;
9930 /* And for structured bindings also the underlying decl. */
9931 if (DECL_DECOMPOSITION_P (res
) && DECL_DECOMP_BASE (res
))
9932 TREE_USED (DECL_DECOMP_BASE (res
)) = true;
9934 if (DECL_CLONED_FUNCTION_P (res
))
9935 TREE_USED (DECL_CLONED_FUNCTION (res
)) = true;
9943 trees_out::tpl_parms (tree parms
, unsigned &tpl_levels
)
9948 if (TREE_VISITED (parms
))
9954 tpl_parms (TREE_CHAIN (parms
), tpl_levels
);
9956 tree vec
= TREE_VALUE (parms
);
9957 unsigned len
= TREE_VEC_LENGTH (vec
);
9959 int tag
= insert (parms
);
9964 && dump ("Writing template parms:%d level:%N length:%d",
9965 tag
, TREE_PURPOSE (parms
), len
);
9967 tree_node (TREE_PURPOSE (parms
));
9969 for (unsigned ix
= 0; ix
!= len
; ix
++)
9971 tree parm
= TREE_VEC_ELT (vec
, ix
);
9972 tree decl
= TREE_VALUE (parm
);
9974 gcc_checking_assert (DECL_TEMPLATE_PARM_P (decl
));
9976 switch (TREE_CODE (decl
))
9978 default: gcc_unreachable ();
9981 gcc_assert ((TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TEMPLATE_PARM
)
9982 && (TREE_CODE (DECL_TEMPLATE_RESULT (decl
)) == TYPE_DECL
)
9983 && (TYPE_NAME (TREE_TYPE (decl
)) == decl
));
9987 gcc_assert ((TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TYPE_PARM
)
9988 && (TYPE_NAME (TREE_TYPE (decl
)) == decl
));
9992 gcc_assert ((TREE_CODE (DECL_INITIAL (decl
)) == TEMPLATE_PARM_INDEX
)
9993 && (TREE_CODE (TEMPLATE_PARM_DECL (DECL_INITIAL (decl
)))
9995 && (DECL_TEMPLATE_PARM_P
9996 (TEMPLATE_PARM_DECL (DECL_INITIAL (decl
)))));
10001 tree_node (TEMPLATE_PARM_CONSTRAINTS (parm
));
10008 trees_in::tpl_parms (unsigned &tpl_levels
)
10010 tree parms
= NULL_TREE
;
10012 while (int len
= i ())
10016 parms
= back_ref (len
);
10021 parms
= tree_cons (NULL_TREE
, NULL_TREE
, parms
);
10022 int tag
= insert (parms
);
10023 TREE_PURPOSE (parms
) = tree_node ();
10025 dump (dumper::TREE
)
10026 && dump ("Reading template parms:%d level:%N length:%d",
10027 tag
, TREE_PURPOSE (parms
), len
);
10029 tree vec
= make_tree_vec (len
);
10030 for (int ix
= 0; ix
!= len
; ix
++)
10032 tree decl
= tree_node ();
10036 tree parm
= build_tree_list (NULL
, decl
);
10037 TEMPLATE_PARM_CONSTRAINTS (parm
) = tree_node ();
10039 TREE_VEC_ELT (vec
, ix
) = parm
;
10042 TREE_VALUE (parms
) = vec
;
10050 trees_out::tpl_parms_fini (tree tmpl
, unsigned tpl_levels
)
10052 for (tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
10053 tpl_levels
--; parms
= TREE_CHAIN (parms
))
10055 tree vec
= TREE_VALUE (parms
);
10057 tree_node (TREE_TYPE (vec
));
10058 for (unsigned ix
= TREE_VEC_LENGTH (vec
); ix
--;)
10060 tree parm
= TREE_VEC_ELT (vec
, ix
);
10061 tree dflt
= TREE_PURPOSE (parm
);
10064 if (streaming_p ())
10066 tree decl
= TREE_VALUE (parm
);
10067 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10069 tree ctx
= DECL_CONTEXT (decl
);
10070 tree inner
= DECL_TEMPLATE_RESULT (decl
);
10071 tree tpi
= (TREE_CODE (inner
) == TYPE_DECL
10072 ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl
))
10073 : DECL_INITIAL (inner
));
10074 bool original
= (TEMPLATE_PARM_LEVEL (tpi
)
10075 == TEMPLATE_PARM_ORIG_LEVEL (tpi
));
10076 /* Original template template parms have a context
10077 of their owning template. Reduced ones do not. */
10078 gcc_checking_assert (original
? ctx
== tmpl
: !ctx
);
10086 trees_in::tpl_parms_fini (tree tmpl
, unsigned tpl_levels
)
10088 for (tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
10089 tpl_levels
--; parms
= TREE_CHAIN (parms
))
10091 tree vec
= TREE_VALUE (parms
);
10093 TREE_TYPE (vec
) = tree_node ();
10094 for (unsigned ix
= TREE_VEC_LENGTH (vec
); ix
--;)
10096 tree parm
= TREE_VEC_ELT (vec
, ix
);
10097 tree dflt
= tree_node ();
10098 if (get_overrun ())
10100 TREE_PURPOSE (parm
) = dflt
;
10102 tree decl
= TREE_VALUE (parm
);
10103 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10105 tree inner
= DECL_TEMPLATE_RESULT (decl
);
10106 tree tpi
= (TREE_CODE (inner
) == TYPE_DECL
10107 ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl
))
10108 : DECL_INITIAL (inner
));
10109 bool original
= (TEMPLATE_PARM_LEVEL (tpi
)
10110 == TEMPLATE_PARM_ORIG_LEVEL (tpi
));
10111 /* Original template template parms have a context
10112 of their owning template. Reduced ones do not. */
10114 DECL_CONTEXT (decl
) = tmpl
;
10121 /* PARMS is a LIST, one node per level.
10122 TREE_VALUE is a TREE_VEC of parm info for that level.
10123 each ELT is a TREE_LIST
10124 TREE_VALUE is PARM_DECL, TYPE_DECL or TEMPLATE_DECL
10125 TREE_PURPOSE is the default value. */
10128 trees_out::tpl_header (tree tpl
, unsigned *tpl_levels
)
10130 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
10131 tpl_parms (parms
, *tpl_levels
);
10134 if (streaming_p ())
10138 tree_node (TEMPLATE_PARMS_CONSTRAINTS (parms
));
10142 trees_in::tpl_header (tree tpl
, unsigned *tpl_levels
)
10144 tree parms
= tpl_parms (*tpl_levels
);
10148 DECL_TEMPLATE_PARMS (tpl
) = parms
;
10151 TEMPLATE_PARMS_CONSTRAINTS (parms
) = tree_node ();
10156 /* Stream skeleton parm nodes, with their flags, type & parm indices.
10157 All the parms will have consecutive tags. */
10160 trees_out::fn_parms_init (tree fn
)
10162 /* First init them. */
10163 int base_tag
= ref_num
- 1;
10165 for (tree parm
= DECL_ARGUMENTS (fn
);
10166 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10168 if (streaming_p ())
10171 tree_node_bools (parm
);
10173 int tag
= insert (parm
);
10174 gcc_checking_assert (base_tag
- ix
== tag
);
10176 /* Mark the end. */
10177 if (streaming_p ())
10180 /* Now stream their contents. */
10182 for (tree parm
= DECL_ARGUMENTS (fn
);
10183 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10185 if (streaming_p ())
10186 dump (dumper::TREE
)
10187 && dump ("Writing parm:%d %u (%N) of %N",
10188 base_tag
- ix
, ix
, parm
, fn
);
10189 tree_node_vals (parm
);
10192 if (!streaming_p ())
10194 /* We must walk contract attrs so the dependency graph is complete. */
10195 for (tree contract
= DECL_CONTRACTS (fn
);
10197 contract
= CONTRACT_CHAIN (contract
))
10198 tree_node (contract
);
10201 /* Write a reference to contracts pre/post functions, if any, to avoid
10202 regenerating them in importers. */
10203 tree_node (DECL_PRE_FN (fn
));
10204 tree_node (DECL_POST_FN (fn
));
10207 /* Build skeleton parm nodes, read their flags, type & parm indices. */
10210 trees_in::fn_parms_init (tree fn
)
10212 int base_tag
= ~(int)back_refs
.length ();
10214 tree
*parm_ptr
= &DECL_ARGUMENTS (fn
);
10216 for (; int code
= u (); ix
++)
10218 tree parm
= start (code
);
10219 if (!tree_node_bools (parm
))
10222 int tag
= insert (parm
);
10223 gcc_checking_assert (base_tag
- ix
== tag
);
10225 parm_ptr
= &DECL_CHAIN (parm
);
10229 for (tree parm
= DECL_ARGUMENTS (fn
);
10230 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10232 dump (dumper::TREE
)
10233 && dump ("Reading parm:%d %u (%N) of %N",
10234 base_tag
- ix
, ix
, parm
, fn
);
10235 if (!tree_node_vals (parm
))
10239 /* Reload references to contract functions, if any. */
10240 tree pre_fn
= tree_node ();
10241 tree post_fn
= tree_node ();
10242 set_contract_functions (fn
, pre_fn
, post_fn
);
10247 /* Read the remaining parm node data. Replace with existing (if
10248 non-null) in the map. */
10251 trees_in::fn_parms_fini (int tag
, tree fn
, tree existing
, bool is_defn
)
10253 tree existing_parm
= existing
? DECL_ARGUMENTS (existing
) : NULL_TREE
;
10254 tree parms
= DECL_ARGUMENTS (fn
);
10256 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
), ix
++)
10260 if (is_defn
&& !DECL_SAVED_TREE (existing
))
10262 /* If we're about to become the definition, set the
10263 names of the parms from us. */
10264 DECL_NAME (existing_parm
) = DECL_NAME (parm
);
10265 DECL_SOURCE_LOCATION (existing_parm
) = DECL_SOURCE_LOCATION (parm
);
10268 back_refs
[~tag
] = existing_parm
;
10269 existing_parm
= DECL_CHAIN (existing_parm
);
10275 /* DEP is the depset of some decl we're streaming by value. Determine
10276 the merging behaviour. */
10279 trees_out::get_merge_kind (tree decl
, depset
*dep
)
10283 if (VAR_OR_FUNCTION_DECL_P (decl
))
10285 /* Any var or function with template info should have DEP. */
10286 gcc_checking_assert (!DECL_LANG_SPECIFIC (decl
)
10287 || !DECL_TEMPLATE_INFO (decl
));
10288 if (DECL_LOCAL_DECL_P (decl
))
10292 /* Either unique, or some member of a class that cannot have an
10293 out-of-class definition. For instance a FIELD_DECL. */
10294 tree ctx
= CP_DECL_CONTEXT (decl
);
10295 if (TREE_CODE (ctx
) == FUNCTION_DECL
)
10297 /* USING_DECLs and NAMESPACE_DECLs cannot have DECL_TEMPLATE_INFO --
10298 this isn't permitting them to have one. */
10299 gcc_checking_assert (TREE_CODE (decl
) == USING_DECL
10300 || TREE_CODE (decl
) == NAMESPACE_DECL
10301 || !DECL_LANG_SPECIFIC (decl
)
10302 || !DECL_TEMPLATE_INFO (decl
));
10307 if (TREE_CODE (decl
) == TEMPLATE_DECL
10308 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10309 return MK_local_friend
;
10311 gcc_checking_assert (TYPE_P (ctx
));
10312 if (TREE_CODE (decl
) == USING_DECL
)
10315 if (TREE_CODE (decl
) == FIELD_DECL
)
10317 if (DECL_NAME (decl
))
10319 /* Anonymous FIELD_DECLs have a NULL name. */
10320 gcc_checking_assert (!IDENTIFIER_ANON_P (DECL_NAME (decl
)));
10324 if (!DECL_NAME (decl
)
10325 && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
10326 && !DECL_BIT_FIELD_REPRESENTATIVE (decl
))
10328 /* The underlying storage unit for a bitfield. We do not
10329 need to dedup it, because it's only reachable through
10330 the bitfields it represents. And those are deduped. */
10331 // FIXME: Is that assertion correct -- do we ever fish it
10332 // out and put it in an expr?
10333 gcc_checking_assert ((TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
10334 ? TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
10335 : TREE_CODE (TREE_TYPE (decl
)))
10343 if (TREE_CODE (decl
) == CONST_DECL
)
10346 if (TREE_CODE (decl
) == VAR_DECL
10347 && DECL_VTABLE_OR_VTT_P (decl
))
10350 if (DECL_THUNK_P (decl
))
10351 /* Thunks are unique-enough, because they're only referenced
10352 from the vtable. And that's either new (so we want the
10353 thunks), or it's a duplicate (so it will be dropped). */
10356 /* There should be no other cases. */
10357 gcc_unreachable ();
10360 gcc_checking_assert (TREE_CODE (decl
) != FIELD_DECL
10361 && TREE_CODE (decl
) != USING_DECL
10362 && TREE_CODE (decl
) != CONST_DECL
);
10364 if (is_key_order ())
10366 /* When doing the mergeablilty graph, there's an indirection to
10367 the actual depset. */
10368 gcc_assert (dep
->is_special ());
10369 dep
= dep
->deps
[0];
10372 gcc_checking_assert (decl
== dep
->get_entity ());
10374 merge_kind mk
= MK_named
;
10375 switch (dep
->get_entity_kind ())
10378 gcc_unreachable ();
10380 case depset::EK_PARTIAL
:
10384 case depset::EK_DECL
:
10386 tree ctx
= CP_DECL_CONTEXT (decl
);
10388 switch (TREE_CODE (ctx
))
10391 gcc_unreachable ();
10393 case FUNCTION_DECL
:
10394 // FIXME: This can occur for (a) voldemorty TYPE_DECLS
10395 // (which are returned from a function), or (b)
10396 // block-scope class definitions in template functions.
10397 // These are as unique as the containing function. While
10398 // on read-back we can discover if the CTX was a
10399 // duplicate, we don't have a mechanism to get from the
10400 // existing CTX to the existing version of this decl.
10401 gcc_checking_assert
10402 (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl
)));
10409 if (DECL_NAME (decl
) == as_base_identifier
)
10411 else if (IDENTIFIER_ANON_P (DECL_NAME (decl
)))
10415 case NAMESPACE_DECL
:
10416 if (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl
))
10417 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
10419 = LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
10420 (TREE_TYPE (decl
))))
10421 if (TREE_CODE (scope
) == VAR_DECL
10422 && DECL_MODULE_KEYED_DECLS_P (scope
))
10428 if (TREE_CODE (decl
) == TEMPLATE_DECL
10429 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10430 mk
= MK_local_friend
;
10431 else if (IDENTIFIER_ANON_P (DECL_NAME (decl
)))
10433 if (DECL_IMPLICIT_TYPEDEF_P (decl
)
10434 && UNSCOPED_ENUM_P (TREE_TYPE (decl
))
10435 && TYPE_VALUES (TREE_TYPE (decl
)))
10436 /* Keyed by first enum value, and underlying type. */
10439 /* No way to merge it, it is an ODR land-mine. */
10446 case depset::EK_SPECIALIZATION
:
10448 gcc_checking_assert (dep
->is_special ());
10450 if (TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
10451 /* An block-scope classes of templates are themselves
10453 gcc_checking_assert (DECL_IMPLICIT_TYPEDEF_P (decl
));
10455 if (dep
->is_friend_spec ())
10456 mk
= MK_friend_spec
;
10457 else if (dep
->is_type_spec ())
10459 else if (dep
->is_alias ())
10460 mk
= MK_alias_spec
;
10464 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10466 spec_entry
*entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
10467 if (TREE_CODE (entry
->spec
) != TEMPLATE_DECL
)
10468 mk
= merge_kind (mk
| MK_tmpl_tmpl_mask
);
10478 /* The container of DECL -- not necessarily its context! */
10481 trees_out::decl_container (tree decl
)
10484 tree tpl
= NULL_TREE
;
10485 if (tree template_info
= node_template_info (decl
, use_tpl
))
10486 tpl
= TI_TEMPLATE (template_info
);
10490 /* Stream the template we're instantiated from. */
10493 tree container
= NULL_TREE
;
10494 if (TREE_CODE (decl
) == TEMPLATE_DECL
10495 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10496 container
= DECL_CHAIN (decl
);
10498 container
= CP_DECL_CONTEXT (decl
);
10500 if (TYPE_P (container
))
10501 container
= TYPE_NAME (container
);
10503 tree_node (container
);
10509 trees_in::decl_container ()
10511 /* The maybe-template. */
10512 (void)tree_node ();
10514 tree container
= tree_node ();
10519 /* Write out key information about a mergeable DEP. Does not write
10520 the contents of DEP itself. The context has already been
10521 written. The container has already been streamed. */
10524 trees_out::key_mergeable (int tag
, merge_kind mk
, tree decl
, tree inner
,
10525 tree container
, depset
*dep
)
10527 if (dep
&& is_key_order ())
10529 gcc_checking_assert (dep
->is_special ());
10530 dep
= dep
->deps
[0];
10533 if (streaming_p ())
10534 dump (dumper::MERGE
)
10535 && dump ("Writing:%d's %s merge key (%s) %C:%N", tag
, merge_kind_name
[mk
],
10536 dep
? dep
->entity_kind_name () : "contained",
10537 TREE_CODE (decl
), decl
);
10539 /* Now write the locating information. */
10540 if (mk
& MK_template_mask
)
10542 /* Specializations are located via their originating template,
10543 and the set of template args they specialize. */
10544 gcc_checking_assert (dep
&& dep
->is_special ());
10545 spec_entry
*entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
10547 tree_node (entry
->tmpl
);
10548 tree_node (entry
->args
);
10549 if (mk
& MK_tmpl_decl_mask
)
10550 if (flag_concepts
&& TREE_CODE (inner
) == VAR_DECL
)
10552 /* Variable template partial specializations might need
10553 constraints (see spec_hasher::equal). It's simpler to
10554 write NULL when we don't need them. */
10555 tree constraints
= NULL_TREE
;
10557 if (uses_template_parms (entry
->args
))
10558 constraints
= get_constraints (inner
);
10559 tree_node (constraints
);
10564 /* Make sure we can locate the decl. */
10565 tree existing
= match_mergeable_specialization
10566 (bool (mk
& MK_tmpl_decl_mask
), entry
);
10568 gcc_assert (existing
);
10569 if (mk
& MK_tmpl_decl_mask
)
10571 if (mk
& MK_tmpl_alias_mask
)
10572 /* It should be in both tables. */
10573 gcc_checking_assert
10574 (same_type_p (match_mergeable_specialization (false, entry
),
10575 TREE_TYPE (existing
)));
10576 if (mk
& MK_tmpl_tmpl_mask
)
10577 existing
= DECL_TI_TEMPLATE (existing
);
10581 if (mk
& MK_tmpl_tmpl_mask
)
10582 existing
= CLASSTYPE_TI_TEMPLATE (existing
);
10584 existing
= TYPE_NAME (existing
);
10587 /* The walkabout should have found ourselves. */
10588 gcc_checking_assert (TREE_CODE (decl
) == TYPE_DECL
10589 ? same_type_p (TREE_TYPE (decl
),
10590 TREE_TYPE (existing
))
10591 : existing
== decl
);
10594 else if (mk
!= MK_unique
)
10597 tree name
= DECL_NAME (decl
);
10602 gcc_unreachable ();
10605 case MK_friend_spec
:
10606 if (IDENTIFIER_CONV_OP_P (name
))
10607 name
= conv_op_identifier
;
10609 if (TREE_CODE (inner
) == FUNCTION_DECL
)
10611 /* Functions are distinguished by parameter types. */
10612 tree fn_type
= TREE_TYPE (inner
);
10614 key
.ref_q
= type_memfn_rqual (fn_type
);
10615 key
.args
= TYPE_ARG_TYPES (fn_type
);
10617 if (tree reqs
= get_constraints (inner
))
10619 if (cxx_dialect
< cxx20
)
10620 reqs
= CI_ASSOCIATED_CONSTRAINTS (reqs
);
10622 reqs
= CI_DECLARATOR_REQS (reqs
);
10623 key
.constraints
= reqs
;
10626 if (IDENTIFIER_CONV_OP_P (name
)
10628 && !(name
== fun_identifier
10629 /* In case the user names something _FUN */
10630 && LAMBDA_TYPE_P (DECL_CONTEXT (inner
)))))
10631 /* And a function template, or conversion operator needs
10632 the return type. Except for the _FUN thunk of a
10633 generic lambda, which has a recursive decl_type'd
10635 // FIXME: What if the return type is a voldemort?
10636 key
.ret
= fndecl_declared_return_type (inner
);
10643 if (TREE_CODE (inner
) != FIELD_DECL
)
10646 gcc_checking_assert (!name
|| !IDENTIFIER_ANON_P (name
));
10648 for (tree field
= TYPE_FIELDS (TREE_TYPE (container
));
10649 ; field
= DECL_CHAIN (field
))
10651 tree finner
= STRIP_TEMPLATE (field
);
10652 if (TREE_CODE (finner
) == TREE_CODE (inner
))
10654 if (finner
== inner
)
10665 tree vtable
= CLASSTYPE_VTABLES (TREE_TYPE (container
));
10666 for (unsigned ix
= 0; ; vtable
= DECL_CHAIN (vtable
), ix
++)
10667 if (vtable
== decl
)
10677 gcc_checking_assert
10678 (decl
== TYPE_NAME (CLASSTYPE_AS_BASE (TREE_TYPE (container
))));
10681 case MK_local_friend
:
10683 /* Find by index on the class's DECL_LIST */
10685 for (tree decls
= CLASSTYPE_DECL_LIST (TREE_CHAIN (decl
));
10686 decls
; decls
= TREE_CHAIN (decls
))
10687 if (!TREE_PURPOSE (decls
))
10689 tree frnd
= friend_from_decl_list (TREE_VALUE (decls
));
10701 /* Anonymous enums are located by their first identifier,
10702 and underlying type. */
10703 tree type
= TREE_TYPE (decl
);
10705 gcc_checking_assert (UNSCOPED_ENUM_P (type
));
10706 /* Using the type name drops the bit precision we might
10707 have been using on the enum. */
10708 key
.ret
= TYPE_NAME (ENUM_UNDERLYING_TYPE (type
));
10709 if (tree values
= TYPE_VALUES (type
))
10710 name
= DECL_NAME (TREE_VALUE (values
));
10716 gcc_checking_assert (LAMBDA_TYPE_P (TREE_TYPE (inner
)));
10717 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
10718 (TREE_TYPE (inner
)));
10719 gcc_checking_assert (TREE_CODE (scope
) == VAR_DECL
);
10720 auto *root
= keyed_table
->get (scope
);
10721 unsigned ix
= root
->length ();
10722 /* If we don't find it, we'll write a really big number
10723 that the reader will ignore. */
10725 if ((*root
)[ix
] == inner
)
10728 /* Use the keyed-to decl as the 'name'. */
10736 tree ti
= get_template_info (inner
);
10737 key
.constraints
= get_constraints (inner
);
10738 key
.ret
= TI_TEMPLATE (ti
);
10739 key
.args
= TI_ARGS (ti
);
10745 if (streaming_p ())
10747 unsigned code
= (key
.ref_q
<< 0) | (key
.index
<< 2);
10752 tree_node (key
.ret
);
10753 else if (mk
== MK_partial
10754 || (mk
== MK_named
&& inner
10755 && TREE_CODE (inner
) == FUNCTION_DECL
))
10757 tree_node (key
.ret
);
10758 tree arg
= key
.args
;
10759 if (mk
== MK_named
)
10760 while (arg
&& arg
!= void_list_node
)
10762 tree_node (TREE_VALUE (arg
));
10763 arg
= TREE_CHAIN (arg
);
10766 tree_node (key
.constraints
);
10771 /* DECL is a new declaration that may be duplicated in OVL. Use RET &
10772 ARGS to find its clone, or NULL. If DECL's DECL_NAME is NULL, this
10773 has been found by a proxy. It will be an enum type located by its
10776 We're conservative with matches, so ambiguous decls will be
10777 registered as different, then lead to a lookup error if the two
10778 modules are both visible. Perhaps we want to do something similar
10779 to duplicate decls to get ODR errors on loading? We already have
10780 some special casing for namespaces. */
10783 check_mergeable_decl (merge_kind mk
, tree decl
, tree ovl
, merge_key
const &key
)
10785 tree found
= NULL_TREE
;
10786 for (ovl_iterator
iter (ovl
); !found
&& iter
; ++iter
)
10788 tree match
= *iter
;
10790 tree d_inner
= decl
;
10791 tree m_inner
= match
;
10794 if (TREE_CODE (d_inner
) != TREE_CODE (m_inner
))
10796 if (TREE_CODE (match
) == NAMESPACE_DECL
10797 && !DECL_NAMESPACE_ALIAS (match
))
10798 /* Namespaces are never overloaded. */
10804 switch (TREE_CODE (d_inner
))
10806 case TEMPLATE_DECL
:
10807 if (template_heads_equivalent_p (d_inner
, m_inner
))
10809 d_inner
= DECL_TEMPLATE_RESULT (d_inner
);
10810 m_inner
= DECL_TEMPLATE_RESULT (m_inner
);
10811 if (d_inner
== error_mark_node
10812 && TYPE_DECL_ALIAS_P (m_inner
))
10821 case FUNCTION_DECL
:
10822 if (tree m_type
= TREE_TYPE (m_inner
))
10824 || same_type_p (key
.ret
, fndecl_declared_return_type (m_inner
)))
10825 && type_memfn_rqual (m_type
) == key
.ref_q
10826 && compparms (key
.args
, TYPE_ARG_TYPES (m_type
))
10827 /* Reject if old is a "C" builtin and new is not "C".
10828 Matches decls_match behaviour. */
10829 && (!DECL_IS_UNDECLARED_BUILTIN (m_inner
)
10830 || !DECL_EXTERN_C_P (m_inner
)
10831 || DECL_EXTERN_C_P (d_inner
))
10832 /* Reject if one is a different member of a
10833 guarded/pre/post fn set. */
10834 && (!flag_contracts
10835 || (DECL_IS_PRE_FN_P (d_inner
)
10836 == DECL_IS_PRE_FN_P (m_inner
)))
10837 && (!flag_contracts
10838 || (DECL_IS_POST_FN_P (d_inner
)
10839 == DECL_IS_POST_FN_P (m_inner
))))
10841 tree m_reqs
= get_constraints (m_inner
);
10844 if (cxx_dialect
< cxx20
)
10845 m_reqs
= CI_ASSOCIATED_CONSTRAINTS (m_reqs
);
10847 m_reqs
= CI_DECLARATOR_REQS (m_reqs
);
10850 if (cp_tree_equal (key
.constraints
, m_reqs
))
10856 if (DECL_IMPLICIT_TYPEDEF_P (d_inner
)
10857 == DECL_IMPLICIT_TYPEDEF_P (m_inner
))
10859 if (!IDENTIFIER_ANON_P (DECL_NAME (m_inner
)))
10861 else if (mk
== MK_enum
10862 && (TYPE_NAME (ENUM_UNDERLYING_TYPE (TREE_TYPE (m_inner
)))
10877 /* DECL, INNER & TYPE are a skeleton set of nodes for a decl. Only
10878 the bools have been filled in. Read its merging key and merge it.
10879 Returns the existing decl if there is one. */
10882 trees_in::key_mergeable (int tag
, merge_kind mk
, tree decl
, tree inner
,
10883 tree type
, tree container
, bool is_attached
)
10885 const char *kind
= "new";
10886 tree existing
= NULL_TREE
;
10888 if (mk
& MK_template_mask
)
10890 // FIXME: We could stream the specialization hash?
10892 spec
.tmpl
= tree_node ();
10893 spec
.args
= tree_node ();
10895 if (get_overrun ())
10896 return error_mark_node
;
10898 DECL_NAME (decl
) = DECL_NAME (spec
.tmpl
);
10899 DECL_CONTEXT (decl
) = DECL_CONTEXT (spec
.tmpl
);
10900 DECL_NAME (inner
) = DECL_NAME (decl
);
10901 DECL_CONTEXT (inner
) = DECL_CONTEXT (decl
);
10903 tree constr
= NULL_TREE
;
10904 bool is_decl
= mk
& MK_tmpl_decl_mask
;
10907 if (flag_concepts
&& TREE_CODE (inner
) == VAR_DECL
)
10909 constr
= tree_node ();
10911 set_constraints (inner
, constr
);
10913 spec
.spec
= (mk
& MK_tmpl_tmpl_mask
) ? inner
: decl
;
10917 existing
= match_mergeable_specialization (is_decl
, &spec
);
10919 /* We'll add these back later, if this is the new decl. */
10920 remove_constraints (inner
);
10923 ; /* We'll add to the table once read. */
10924 else if (mk
& MK_tmpl_decl_mask
)
10926 /* A declaration specialization. */
10927 if (mk
& MK_tmpl_tmpl_mask
)
10928 existing
= DECL_TI_TEMPLATE (existing
);
10932 /* A type specialization. */
10933 if (mk
& MK_tmpl_tmpl_mask
)
10934 existing
= CLASSTYPE_TI_TEMPLATE (existing
);
10936 existing
= TYPE_NAME (existing
);
10939 else if (mk
== MK_unique
)
10943 tree name
= tree_node ();
10946 unsigned code
= u ();
10947 key
.ref_q
= cp_ref_qualifier ((code
>> 0) & 3);
10948 key
.index
= code
>> 2;
10951 key
.ret
= tree_node ();
10952 else if (mk
== MK_partial
10953 || ((mk
== MK_named
|| mk
== MK_friend_spec
)
10954 && TREE_CODE (inner
) == FUNCTION_DECL
))
10956 key
.ret
= tree_node ();
10957 tree arg
, *arg_ptr
= &key
.args
;
10958 while ((arg
= tree_node ())
10959 && arg
!= void_list_node
10960 && mk
!= MK_partial
)
10962 *arg_ptr
= tree_cons (NULL_TREE
, arg
, NULL_TREE
);
10963 arg_ptr
= &TREE_CHAIN (*arg_ptr
);
10966 key
.constraints
= tree_node ();
10969 if (get_overrun ())
10970 return error_mark_node
;
10972 if (mk
< MK_indirect_lwm
)
10974 DECL_NAME (decl
) = name
;
10975 DECL_CONTEXT (decl
) = FROB_CONTEXT (container
);
10977 DECL_NAME (inner
) = DECL_NAME (decl
);
10978 DECL_CONTEXT (inner
) = DECL_CONTEXT (decl
);
10980 if (mk
== MK_partial
)
10982 for (tree spec
= DECL_TEMPLATE_SPECIALIZATIONS (key
.ret
);
10983 spec
; spec
= TREE_CHAIN (spec
))
10985 tree tmpl
= TREE_VALUE (spec
);
10986 tree ti
= get_template_info (tmpl
);
10987 if (template_args_equal (key
.args
, TI_ARGS (ti
))
10988 && cp_tree_equal (key
.constraints
,
10990 (DECL_TEMPLATE_RESULT (tmpl
))))
10998 switch (TREE_CODE (container
))
11001 gcc_unreachable ();
11003 case NAMESPACE_DECL
:
11004 if (mk
== MK_keyed
)
11006 if (DECL_LANG_SPECIFIC (name
)
11007 && VAR_OR_FUNCTION_DECL_P (name
)
11008 && DECL_MODULE_KEYED_DECLS_P (name
))
11009 if (auto *set
= keyed_table
->get (name
))
11010 if (key
.index
< set
->length ())
11012 existing
= (*set
)[key
.index
];
11015 gcc_checking_assert
11016 (DECL_IMPLICIT_TYPEDEF_P (existing
));
11019 = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (existing
));
11023 else if (is_attached
11024 && !(state
->is_module () || state
->is_partition ()))
11028 gcc_checking_assert (mk
== MK_named
|| mk
== MK_enum
);
11030 tree
*vslot
= mergeable_namespace_slots (container
, name
,
11031 is_attached
, &mvec
);
11032 existing
= check_mergeable_decl (mk
, decl
, *vslot
, key
);
11034 add_mergeable_namespace_entity (vslot
, decl
);
11037 /* Note that we now have duplicates to deal with in
11040 BINDING_VECTOR_PARTITION_DUPS_P (mvec
) = true;
11042 BINDING_VECTOR_GLOBAL_DUPS_P (mvec
) = true;
11047 case FUNCTION_DECL
:
11048 // FIXME: What about a voldemort? how do we find what it
11049 // duplicates? Do we have to number vmorts relative to
11050 // their containing function? But how would that work
11051 // when matching an in-TU declaration?
11056 if (is_attached
&& !(state
->is_module () || state
->is_partition ())
11057 /* Implicit member functions can come from
11059 && !(DECL_ARTIFICIAL (decl
)
11060 && TREE_CODE (decl
) == FUNCTION_DECL
11061 && !DECL_THUNK_P (decl
)))
11065 tree ctx
= TREE_TYPE (container
);
11067 /* For some reason templated enumeral types are not marked
11068 as COMPLETE_TYPE_P, even though they have members.
11069 This may well be a bug elsewhere. */
11070 if (TREE_CODE (ctx
) == ENUMERAL_TYPE
)
11071 existing
= find_enum_member (ctx
, name
);
11072 else if (COMPLETE_TYPE_P (ctx
))
11077 gcc_unreachable ();
11080 existing
= lookup_class_binding (ctx
, name
);
11084 if (TREE_CODE (inner
) == TEMPLATE_DECL
11085 && !DECL_MEMBER_TEMPLATE_P (inner
))
11086 inner
= DECL_TEMPLATE_RESULT (inner
);
11088 existing
= check_mergeable_decl
11089 (mk
, inner
, existing
, key
);
11091 if (!existing
&& DECL_ALIAS_TEMPLATE_P (decl
))
11092 {} // FIXME: Insert into specialization
11093 // tables, we'll need the arguments for that!
11099 unsigned ix
= key
.index
;
11100 for (tree field
= TYPE_FIELDS (ctx
);
11101 field
; field
= DECL_CHAIN (field
))
11103 tree finner
= STRIP_TEMPLATE (field
);
11104 if (TREE_CODE (finner
) == TREE_CODE (inner
))
11116 unsigned ix
= key
.index
;
11117 for (tree vtable
= CLASSTYPE_VTABLES (ctx
);
11118 vtable
; vtable
= DECL_CHAIN (vtable
))
11129 tree as_base
= CLASSTYPE_AS_BASE (ctx
);
11130 if (as_base
&& as_base
!= ctx
)
11131 existing
= TYPE_NAME (as_base
);
11135 case MK_local_friend
:
11137 unsigned ix
= key
.index
;
11138 for (tree decls
= CLASSTYPE_DECL_LIST (ctx
);
11139 decls
; decls
= TREE_CHAIN (decls
))
11140 if (!TREE_PURPOSE (decls
) && !ix
--)
11143 = friend_from_decl_list (TREE_VALUE (decls
));
11150 if (existing
&& mk
< MK_indirect_lwm
&& mk
!= MK_partial
11151 && TREE_CODE (decl
) == TEMPLATE_DECL
11152 && !DECL_MEMBER_TEMPLATE_P (decl
))
11155 if (DECL_IMPLICIT_TYPEDEF_P (existing
))
11156 ti
= TYPE_TEMPLATE_INFO (TREE_TYPE (existing
));
11158 ti
= DECL_TEMPLATE_INFO (existing
);
11159 existing
= TI_TEMPLATE (ti
);
11166 dump (dumper::MERGE
)
11167 && dump ("Read:%d's %s merge key (%s) %C:%N", tag
, merge_kind_name
[mk
],
11168 existing
? "matched" : kind
, TREE_CODE (decl
), decl
);
11174 trees_out::binfo_mergeable (tree binfo
)
11177 while (tree parent
= BINFO_INHERITANCE_CHAIN (dom
))
11179 tree type
= BINFO_TYPE (dom
);
11180 gcc_checking_assert (TYPE_BINFO (type
) == dom
);
11182 if (streaming_p ())
11185 for (; dom
!= binfo
; dom
= TREE_CHAIN (dom
))
11192 trees_in::binfo_mergeable (tree
*type
)
11194 *type
= tree_node ();
11198 /* DECL is a just streamed mergeable decl that should match EXISTING. Check
11199 it does and issue an appropriate diagnostic if not. Merge any
11200 bits from DECL to EXISTING. This is stricter matching than
11201 decls_match, because we can rely on ODR-sameness, and we cannot use
11202 decls_match because it can cause instantiations of constraints. */
11205 trees_in::is_matching_decl (tree existing
, tree decl
, bool is_typedef
)
11207 // FIXME: We should probably do some duplicate decl-like stuff here
11208 // (beware, default parms should be the same?) Can we just call
11209 // duplicate_decls and teach it how to handle the module-specific
11210 // permitted/required duplications?
11212 // We know at this point that the decls have matched by key, so we
11213 // can elide some of the checking
11214 gcc_checking_assert (TREE_CODE (existing
) == TREE_CODE (decl
));
11216 tree d_inner
= decl
;
11217 tree e_inner
= existing
;
11218 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
11220 d_inner
= DECL_TEMPLATE_RESULT (d_inner
);
11221 e_inner
= DECL_TEMPLATE_RESULT (e_inner
);
11222 gcc_checking_assert (TREE_CODE (e_inner
) == TREE_CODE (d_inner
));
11225 if (TREE_CODE (d_inner
) == FUNCTION_DECL
)
11227 tree e_ret
= fndecl_declared_return_type (existing
);
11228 tree d_ret
= fndecl_declared_return_type (decl
);
11230 if (decl
!= d_inner
&& DECL_NAME (d_inner
) == fun_identifier
11231 && LAMBDA_TYPE_P (DECL_CONTEXT (d_inner
)))
11232 /* This has a recursive type that will compare different. */;
11233 else if (!same_type_p (d_ret
, e_ret
))
11236 tree e_type
= TREE_TYPE (e_inner
);
11237 tree d_type
= TREE_TYPE (d_inner
);
11239 if (DECL_EXTERN_C_P (d_inner
) != DECL_EXTERN_C_P (e_inner
))
11242 for (tree e_args
= TYPE_ARG_TYPES (e_type
),
11243 d_args
= TYPE_ARG_TYPES (d_type
);
11244 e_args
!= d_args
&& (e_args
|| d_args
);
11245 e_args
= TREE_CHAIN (e_args
), d_args
= TREE_CHAIN (d_args
))
11247 if (!(e_args
&& d_args
))
11250 if (!same_type_p (TREE_VALUE (d_args
), TREE_VALUE (e_args
)))
11253 // FIXME: Check default values
11256 /* If EXISTING has an undeduced or uninstantiated exception
11257 specification, but DECL does not, propagate the exception
11258 specification. Otherwise we end up asserting or trying to
11259 instantiate it in the middle of loading. */
11260 tree e_spec
= TYPE_RAISES_EXCEPTIONS (e_type
);
11261 tree d_spec
= TYPE_RAISES_EXCEPTIONS (d_type
);
11262 if (DEFERRED_NOEXCEPT_SPEC_P (e_spec
))
11264 if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec
)
11265 || (UNEVALUATED_NOEXCEPT_SPEC_P (e_spec
)
11266 && !UNEVALUATED_NOEXCEPT_SPEC_P (d_spec
)))
11268 dump (dumper::MERGE
)
11269 && dump ("Propagating instantiated noexcept to %N", existing
);
11270 TREE_TYPE (existing
) = d_type
;
11272 /* Propagate to existing clones. */
11274 FOR_EACH_CLONE (clone
, existing
)
11276 if (TREE_TYPE (clone
) == e_type
)
11277 TREE_TYPE (clone
) = d_type
;
11280 = build_exception_variant (TREE_TYPE (clone
), d_spec
);
11284 else if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec
)
11285 && !comp_except_specs (d_spec
, e_spec
, ce_type
))
11288 else if (is_typedef
)
11290 if (!DECL_ORIGINAL_TYPE (e_inner
)
11291 || !same_type_p (DECL_ORIGINAL_TYPE (d_inner
),
11292 DECL_ORIGINAL_TYPE (e_inner
)))
11295 /* Using cp_tree_equal because we can meet TYPE_ARGUMENT_PACKs
11296 here. I suspect the entities that directly do that are things
11297 that shouldn't go to duplicate_decls (FIELD_DECLs etc). */
11298 else if (!cp_tree_equal (TREE_TYPE (decl
), TREE_TYPE (existing
)))
11301 if (DECL_IS_UNDECLARED_BUILTIN (existing
))
11302 /* Just like duplicate_decls, presum the user knows what
11303 they're doing in overriding a builtin. */
11304 TREE_TYPE (existing
) = TREE_TYPE (decl
);
11307 // FIXME:QOI Might be template specialization from a module,
11308 // not necessarily global module
11309 error_at (DECL_SOURCE_LOCATION (decl
),
11310 "conflicting global module declaration %#qD", decl
);
11311 inform (DECL_SOURCE_LOCATION (existing
),
11312 "existing declaration %#qD", existing
);
11317 if (DECL_IS_UNDECLARED_BUILTIN (existing
)
11318 && !DECL_IS_UNDECLARED_BUILTIN (decl
))
11320 /* We're matching a builtin that the user has yet to declare.
11321 We are the one! This is very much duplicate-decl
11323 DECL_SOURCE_LOCATION (existing
) = DECL_SOURCE_LOCATION (decl
);
11324 if (TREE_CODE (decl
) != TYPE_DECL
)
11326 /* Propagate exceptions etc. */
11327 TREE_TYPE (existing
) = TREE_TYPE (decl
);
11328 TREE_NOTHROW (existing
) = TREE_NOTHROW (decl
);
11330 /* This is actually an import! */
11331 DECL_MODULE_IMPORT_P (existing
) = true;
11334 existing
->base
= decl
->base
;
11336 if (TREE_CODE (decl
) == FUNCTION_DECL
)
11339 memcpy (&existing
->decl_common
.size
,
11340 &decl
->decl_common
.size
,
11341 (offsetof (tree_decl_common
, pt_uid
)
11342 - offsetof (tree_decl_common
, size
)));
11343 auto bltin_class
= DECL_BUILT_IN_CLASS (decl
);
11344 existing
->function_decl
.built_in_class
= bltin_class
;
11345 auto fncode
= DECL_UNCHECKED_FUNCTION_CODE (decl
);
11346 DECL_UNCHECKED_FUNCTION_CODE (existing
) = fncode
;
11347 if (existing
->function_decl
.built_in_class
== BUILT_IN_NORMAL
)
11349 if (builtin_decl_explicit_p (built_in_function (fncode
)))
11352 case BUILT_IN_STPCPY
:
11353 set_builtin_decl_implicit_p
11354 (built_in_function (fncode
), true);
11357 set_builtin_decl_declared_p
11358 (built_in_function (fncode
), true);
11361 copy_attributes_to_builtin (decl
);
11366 if (VAR_OR_FUNCTION_DECL_P (decl
)
11367 && DECL_TEMPLATE_INSTANTIATED (decl
))
11368 /* Don't instantiate again! */
11369 DECL_TEMPLATE_INSTANTIATED (existing
) = true;
11371 if (TREE_CODE (d_inner
) == FUNCTION_DECL
11372 && DECL_DECLARED_INLINE_P (d_inner
))
11373 DECL_DECLARED_INLINE_P (e_inner
) = true;
11374 if (!DECL_EXTERNAL (d_inner
))
11375 DECL_EXTERNAL (e_inner
) = false;
11377 // FIXME: Check default tmpl and fn parms here
11382 /* FN is an implicit member function that we've discovered is new to
11383 the class. Add it to the TYPE_FIELDS chain and the method vector.
11384 Reset the appropriate classtype lazy flag. */
11387 trees_in::install_implicit_member (tree fn
)
11389 tree ctx
= DECL_CONTEXT (fn
);
11390 tree name
= DECL_NAME (fn
);
11391 /* We know these are synthesized, so the set of expected prototypes
11392 is quite restricted. We're not validating correctness, just
11393 distinguishing beteeen the small set of possibilities. */
11394 tree parm_type
= TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (fn
));
11395 if (IDENTIFIER_CTOR_P (name
))
11397 if (CLASSTYPE_LAZY_DEFAULT_CTOR (ctx
)
11398 && VOID_TYPE_P (parm_type
))
11399 CLASSTYPE_LAZY_DEFAULT_CTOR (ctx
) = false;
11400 else if (!TYPE_REF_P (parm_type
))
11402 else if (CLASSTYPE_LAZY_COPY_CTOR (ctx
)
11403 && !TYPE_REF_IS_RVALUE (parm_type
))
11404 CLASSTYPE_LAZY_COPY_CTOR (ctx
) = false;
11405 else if (CLASSTYPE_LAZY_MOVE_CTOR (ctx
))
11406 CLASSTYPE_LAZY_MOVE_CTOR (ctx
) = false;
11410 else if (IDENTIFIER_DTOR_P (name
))
11412 if (CLASSTYPE_LAZY_DESTRUCTOR (ctx
))
11413 CLASSTYPE_LAZY_DESTRUCTOR (ctx
) = false;
11416 if (DECL_VIRTUAL_P (fn
))
11417 /* A virtual dtor should have been created when the class
11418 became complete. */
11421 else if (name
== assign_op_identifier
)
11423 if (!TYPE_REF_P (parm_type
))
11425 else if (CLASSTYPE_LAZY_COPY_ASSIGN (ctx
)
11426 && !TYPE_REF_IS_RVALUE (parm_type
))
11427 CLASSTYPE_LAZY_COPY_ASSIGN (ctx
) = false;
11428 else if (CLASSTYPE_LAZY_MOVE_ASSIGN (ctx
))
11429 CLASSTYPE_LAZY_MOVE_ASSIGN (ctx
) = false;
11436 dump (dumper::MERGE
) && dump ("Adding implicit member %N", fn
);
11438 DECL_CHAIN (fn
) = TYPE_FIELDS (ctx
);
11439 TYPE_FIELDS (ctx
) = fn
;
11441 add_method (ctx
, fn
, false);
11443 /* Propagate TYPE_FIELDS. */
11444 fixup_type_variants (ctx
);
11449 /* Return non-zero if DECL has a definition that would be interesting to
11453 has_definition (tree decl
)
11455 bool is_tmpl
= TREE_CODE (decl
) == TEMPLATE_DECL
;
11457 decl
= DECL_TEMPLATE_RESULT (decl
);
11459 switch (TREE_CODE (decl
))
11464 case FUNCTION_DECL
:
11465 if (!DECL_SAVED_TREE (decl
))
11469 if (DECL_DECLARED_INLINE_P (decl
))
11472 if (DECL_THIS_STATIC (decl
)
11473 && (header_module_p ()
11474 || (!DECL_LANG_SPECIFIC (decl
) || !DECL_MODULE_PURVIEW_P (decl
))))
11475 /* GM static function. */
11478 if (DECL_TEMPLATE_INFO (decl
))
11480 int use_tpl
= DECL_USE_TEMPLATE (decl
);
11482 // FIXME: Partial specializations have definitions too.
11490 tree type
= TREE_TYPE (decl
);
11491 if (type
== TYPE_MAIN_VARIANT (type
)
11492 && decl
== TYPE_NAME (type
)
11493 && (TREE_CODE (type
) == ENUMERAL_TYPE
11494 ? TYPE_VALUES (type
) : TYPE_FIELDS (type
)))
11500 if (DECL_LANG_SPECIFIC (decl
)
11501 && DECL_TEMPLATE_INFO (decl
))
11502 return DECL_INITIAL (decl
);
11505 if (!DECL_INITIALIZED_P (decl
))
11508 if (header_module_p ()
11509 || (!DECL_LANG_SPECIFIC (decl
) || !DECL_MODULE_PURVIEW_P (decl
)))
11510 /* GM static variable. */
11513 if (!TREE_CONSTANT (decl
))
11521 if (DECL_INITIAL (decl
))
11531 trees_in::find_duplicate (tree existing
)
11536 return duplicates
->get (existing
);
11539 /* We're starting to read a duplicate DECL. EXISTING is the already
11543 trees_in::register_duplicate (tree decl
, tree existing
)
11546 duplicates
= new duplicate_hash_map (40);
11549 uintptr_t &slot
= duplicates
->get_or_insert (existing
, &existed
);
11550 gcc_checking_assert (!existed
);
11551 slot
= reinterpret_cast<uintptr_t> (decl
);
11554 /* We've read a definition of MAYBE_EXISTING. If not a duplicate,
11555 return MAYBE_EXISTING (into which the definition should be
11556 installed). Otherwise return NULL if already known bad, or the
11557 duplicate we read (for ODR checking, or extracting additional merge
11561 trees_in::odr_duplicate (tree maybe_existing
, bool has_defn
)
11563 tree res
= NULL_TREE
;
11565 if (uintptr_t *dup
= find_duplicate (maybe_existing
))
11568 res
= reinterpret_cast<tree
> (*dup
);
11571 res
= maybe_existing
;
11573 assert_definition (maybe_existing
, res
&& !has_defn
);
11575 // FIXME: We probably need to return the template, so that the
11576 // template header can be checked?
11577 return res
? STRIP_TEMPLATE (res
) : NULL_TREE
;
11580 /* The following writer functions rely on the current behaviour of
11581 depset::hash::add_dependency making the decl and defn depset nodes
11582 depend on eachother. That way we don't have to worry about seeding
11583 the tree map with named decls that cannot be looked up by name (I.e
11584 template and function parms). We know the decl and definition will
11585 be in the same cluster, which is what we want. */
11588 trees_out::write_function_def (tree decl
)
11590 tree_node (DECL_RESULT (decl
));
11591 tree_node (DECL_INITIAL (decl
));
11592 tree_node (DECL_SAVED_TREE (decl
));
11593 tree_node (DECL_FRIEND_CONTEXT (decl
));
11595 constexpr_fundef
*cexpr
= retrieve_constexpr_fundef (decl
);
11597 if (streaming_p ())
11598 u (cexpr
!= nullptr);
11601 chained_decls (cexpr
->parms
);
11602 tree_node (cexpr
->result
);
11603 tree_node (cexpr
->body
);
11606 if (streaming_p ())
11608 unsigned flags
= 0;
11610 if (DECL_NOT_REALLY_EXTERN (decl
))
11618 trees_out::mark_function_def (tree
)
11623 trees_in::read_function_def (tree decl
, tree maybe_template
)
11625 dump () && dump ("Reading function definition %N", decl
);
11626 tree result
= tree_node ();
11627 tree initial
= tree_node ();
11628 tree saved
= tree_node ();
11629 tree context
= tree_node ();
11630 constexpr_fundef cexpr
;
11632 tree maybe_dup
= odr_duplicate (maybe_template
, DECL_SAVED_TREE (decl
));
11633 bool installing
= maybe_dup
&& !DECL_SAVED_TREE (decl
);
11637 cexpr
.parms
= chained_decls ();
11638 cexpr
.result
= tree_node ();
11639 cexpr
.body
= tree_node ();
11643 cexpr
.decl
= NULL_TREE
;
11645 unsigned flags
= u ();
11647 if (get_overrun ())
11652 DECL_NOT_REALLY_EXTERN (decl
) = flags
& 1;
11653 DECL_RESULT (decl
) = result
;
11654 DECL_INITIAL (decl
) = initial
;
11655 DECL_SAVED_TREE (decl
) = saved
;
11657 DECL_ARGUMENTS (decl
) = DECL_ARGUMENTS (maybe_dup
);
11660 SET_DECL_FRIEND_CONTEXT (decl
, context
);
11662 register_constexpr_fundef (cexpr
);
11663 post_process (maybe_template
);
11665 else if (maybe_dup
)
11667 // FIXME:QOI Check matching defn
11673 /* Also for CONCEPT_DECLs. */
11676 trees_out::write_var_def (tree decl
)
11678 tree init
= DECL_INITIAL (decl
);
11682 tree dyn_init
= NULL_TREE
;
11684 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
11686 dyn_init
= value_member (decl
,
11687 CP_DECL_THREAD_LOCAL_P (decl
)
11688 ? tls_aggregates
: static_aggregates
);
11689 gcc_checking_assert (dyn_init
);
11690 /* Mark it so write_inits knows this is needed. */
11691 TREE_LANG_FLAG_0 (dyn_init
) = true;
11692 dyn_init
= TREE_PURPOSE (dyn_init
);
11694 tree_node (dyn_init
);
11699 trees_out::mark_var_def (tree
)
11704 trees_in::read_var_def (tree decl
, tree maybe_template
)
11706 /* Do not mark the virtual table entries as used. */
11707 bool vtable
= VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
);
11709 tree init
= tree_node ();
11710 tree dyn_init
= init
? NULL_TREE
: tree_node ();
11713 if (get_overrun ())
11716 bool initialized
= (VAR_P (decl
) ? bool (DECL_INITIALIZED_P (decl
))
11717 : bool (DECL_INITIAL (decl
)));
11718 tree maybe_dup
= odr_duplicate (maybe_template
, initialized
);
11719 bool installing
= maybe_dup
&& !initialized
;
11722 if (DECL_EXTERNAL (decl
))
11723 DECL_NOT_REALLY_EXTERN (decl
) = true;
11726 DECL_INITIALIZED_P (decl
) = true;
11727 if (maybe_dup
&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (maybe_dup
))
11728 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
11730 DECL_INITIAL (decl
) = init
;
11733 else if (CP_DECL_THREAD_LOCAL_P (decl
))
11734 tls_aggregates
= tree_cons (dyn_init
, decl
, tls_aggregates
);
11736 static_aggregates
= tree_cons (dyn_init
, decl
, static_aggregates
);
11738 else if (maybe_dup
)
11740 // FIXME:QOI Check matching defn
11746 /* If MEMBER doesn't have an independent life outside the class,
11747 return it (or its TEMPLATE_DECL). Otherwise NULL. */
11750 member_owned_by_class (tree member
)
11752 gcc_assert (DECL_P (member
));
11754 /* Clones are owned by their origin. */
11755 if (DECL_CLONED_FUNCTION_P (member
))
11758 if (TREE_CODE (member
) == FIELD_DECL
)
11759 /* FIELD_DECLS can have template info in some cases. We always
11760 want the FIELD_DECL though, as there's never a TEMPLATE_DECL
11765 if (tree ti
= node_template_info (member
, use_tpl
))
11767 // FIXME: Don't bail on things that CANNOT have their own
11768 // template header. No, make sure they're in the same cluster.
11772 if (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
)) == member
)
11773 member
= TI_TEMPLATE (ti
);
11779 trees_out::write_class_def (tree defn
)
11781 gcc_assert (DECL_P (defn
));
11782 if (streaming_p ())
11783 dump () && dump ("Writing class definition %N", defn
);
11785 tree type
= TREE_TYPE (defn
);
11786 tree_node (TYPE_SIZE (type
));
11787 tree_node (TYPE_SIZE_UNIT (type
));
11788 tree_node (TYPE_VFIELD (type
));
11789 tree_node (TYPE_BINFO (type
));
11791 vec_chained_decls (TYPE_FIELDS (type
));
11793 /* Every class but __as_base has a type-specific. */
11794 gcc_checking_assert (!TYPE_LANG_SPECIFIC (type
) == IS_FAKE_BASE_TYPE (type
));
11796 if (TYPE_LANG_SPECIFIC (type
))
11799 vec
<tree
, va_gc
> *v
= CLASSTYPE_MEMBER_VEC (type
);
11802 gcc_checking_assert (!streaming_p ());
11803 /* Force a class vector. */
11804 v
= set_class_bindings (type
, -1);
11805 gcc_checking_assert (v
);
11808 unsigned len
= v
->length ();
11809 if (streaming_p ())
11811 for (unsigned ix
= 0; ix
!= len
; ix
++)
11814 if (TREE_CODE (m
) == TYPE_DECL
11815 && DECL_ARTIFICIAL (m
)
11816 && TYPE_STUB_DECL (TREE_TYPE (m
)) == m
)
11817 /* This is a using-decl for a type, or an anonymous
11818 struct (maybe with a typedef name). Write the type. */
11823 tree_node (CLASSTYPE_LAMBDA_EXPR (type
));
11825 /* TYPE_CONTAINS_VPTR_P looks at the vbase vector, which the
11826 reader won't know at this point. */
11827 int has_vptr
= TYPE_CONTAINS_VPTR_P (type
);
11829 if (streaming_p ())
11831 unsigned nvbases
= vec_safe_length (CLASSTYPE_VBASECLASSES (type
));
11838 tree_vec (CLASSTYPE_PURE_VIRTUALS (type
));
11839 tree_pair_vec (CLASSTYPE_VCALL_INDICES (type
));
11840 tree_node (CLASSTYPE_KEY_METHOD (type
));
11844 if (TYPE_LANG_SPECIFIC (type
))
11846 tree_node (CLASSTYPE_PRIMARY_BINFO (type
));
11848 tree as_base
= CLASSTYPE_AS_BASE (type
);
11850 as_base
= TYPE_NAME (as_base
);
11851 tree_node (as_base
);
11853 /* Write the vtables. */
11854 tree vtables
= CLASSTYPE_VTABLES (type
);
11855 vec_chained_decls (vtables
);
11856 for (; vtables
; vtables
= TREE_CHAIN (vtables
))
11857 write_definition (vtables
);
11859 /* Write the friend classes. */
11860 tree_list (CLASSTYPE_FRIEND_CLASSES (type
), false);
11862 /* Write the friend functions. */
11863 for (tree friends
= DECL_FRIENDLIST (defn
);
11864 friends
; friends
= TREE_CHAIN (friends
))
11866 /* Name of these friends. */
11867 tree_node (TREE_PURPOSE (friends
));
11868 tree_list (TREE_VALUE (friends
), false);
11870 /* End of friend fns. */
11871 tree_node (NULL_TREE
);
11873 /* Write the decl list. */
11874 tree_list (CLASSTYPE_DECL_LIST (type
), true);
11876 if (TYPE_CONTAINS_VPTR_P (type
))
11878 /* Write the thunks. */
11879 for (tree decls
= TYPE_FIELDS (type
);
11880 decls
; decls
= DECL_CHAIN (decls
))
11881 if (TREE_CODE (decls
) == FUNCTION_DECL
11882 && DECL_VIRTUAL_P (decls
)
11883 && DECL_THUNKS (decls
))
11886 /* Thunks are always unique, so chaining is ok. */
11887 chained_decls (DECL_THUNKS (decls
));
11889 tree_node (NULL_TREE
);
11895 trees_out::mark_class_member (tree member
, bool do_defn
)
11897 gcc_assert (DECL_P (member
));
11899 member
= member_owned_by_class (member
);
11901 mark_declaration (member
, do_defn
&& has_definition (member
));
11905 trees_out::mark_class_def (tree defn
)
11907 gcc_assert (DECL_P (defn
));
11908 tree type
= TREE_TYPE (defn
);
11909 /* Mark the class members that are not type-decls and cannot have
11910 independent definitions. */
11911 for (tree member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
11912 if (TREE_CODE (member
) == FIELD_DECL
11913 || TREE_CODE (member
) == USING_DECL
11914 /* A cloned enum-decl from 'using enum unrelated;' */
11915 || (TREE_CODE (member
) == CONST_DECL
11916 && DECL_CONTEXT (member
) == type
))
11918 mark_class_member (member
);
11919 if (TREE_CODE (member
) == FIELD_DECL
)
11920 if (tree repr
= DECL_BIT_FIELD_REPRESENTATIVE (member
))
11921 /* If we're marking a class template definition, then
11922 this'll contain the width (as set by grokbitfield)
11923 instead of a decl. */
11925 mark_declaration (repr
, false);
11928 /* Mark the binfo hierarchy. */
11929 for (tree child
= TYPE_BINFO (type
); child
; child
= TREE_CHAIN (child
))
11930 mark_by_value (child
);
11932 if (TYPE_LANG_SPECIFIC (type
))
11934 for (tree vtable
= CLASSTYPE_VTABLES (type
);
11935 vtable
; vtable
= TREE_CHAIN (vtable
))
11936 mark_declaration (vtable
, true);
11938 if (TYPE_CONTAINS_VPTR_P (type
))
11939 /* Mark the thunks, they belong to the class definition,
11940 /not/ the thunked-to function. */
11941 for (tree decls
= TYPE_FIELDS (type
);
11942 decls
; decls
= DECL_CHAIN (decls
))
11943 if (TREE_CODE (decls
) == FUNCTION_DECL
)
11944 for (tree thunks
= DECL_THUNKS (decls
);
11945 thunks
; thunks
= DECL_CHAIN (thunks
))
11946 mark_declaration (thunks
, false);
11950 /* Nop sorting, needed for resorting the member vec. */
11953 nop (void *, void *, void *)
11958 trees_in::read_class_def (tree defn
, tree maybe_template
)
11960 gcc_assert (DECL_P (defn
));
11961 dump () && dump ("Reading class definition %N", defn
);
11962 tree type
= TREE_TYPE (defn
);
11963 tree size
= tree_node ();
11964 tree size_unit
= tree_node ();
11965 tree vfield
= tree_node ();
11966 tree binfo
= tree_node ();
11967 vec
<tree
, va_gc
> *vbase_vec
= NULL
;
11968 vec
<tree
, va_gc
> *member_vec
= NULL
;
11969 vec
<tree
, va_gc
> *pure_virts
= NULL
;
11970 vec
<tree_pair_s
, va_gc
> *vcall_indices
= NULL
;
11971 tree key_method
= NULL_TREE
;
11972 tree lambda
= NULL_TREE
;
11974 /* Read the fields. */
11975 vec
<tree
, va_heap
> *fields
= vec_chained_decls ();
11977 if (TYPE_LANG_SPECIFIC (type
))
11979 if (unsigned len
= u ())
11981 vec_alloc (member_vec
, len
);
11982 for (unsigned ix
= 0; ix
!= len
; ix
++)
11984 tree m
= tree_node ();
11985 if (get_overrun ())
11988 m
= TYPE_STUB_DECL (m
);
11989 member_vec
->quick_push (m
);
11992 lambda
= tree_node ();
11994 if (!get_overrun ())
11996 unsigned nvbases
= u ();
11999 vec_alloc (vbase_vec
, nvbases
);
12000 for (tree child
= binfo
; child
; child
= TREE_CHAIN (child
))
12001 if (BINFO_VIRTUAL_P (child
))
12002 vbase_vec
->quick_push (child
);
12006 if (!get_overrun ())
12008 int has_vptr
= i ();
12011 pure_virts
= tree_vec ();
12012 vcall_indices
= tree_pair_vec ();
12013 key_method
= tree_node ();
12018 tree maybe_dup
= odr_duplicate (maybe_template
, TYPE_SIZE (type
));
12019 bool installing
= maybe_dup
&& !TYPE_SIZE (type
);
12022 if (DECL_EXTERNAL (defn
) && TYPE_LANG_SPECIFIC (type
))
12024 /* We don't deal with not-really-extern, because, for a
12025 module you want the import to be the interface, and for a
12026 header-unit, you're doing it wrong. */
12027 CLASSTYPE_INTERFACE_UNKNOWN (type
) = false;
12028 CLASSTYPE_INTERFACE_ONLY (type
) = true;
12031 if (maybe_dup
!= defn
)
12033 // FIXME: This is needed on other defns too, almost
12034 // duplicate-decl like? See is_matching_decl too.
12035 /* Copy flags from the duplicate. */
12036 tree type_dup
= TREE_TYPE (maybe_dup
);
12039 TYPE_MODE_RAW (type
) = TYPE_MODE_RAW (type_dup
);
12040 SET_DECL_MODE (defn
, DECL_MODE (maybe_dup
));
12041 TREE_ADDRESSABLE (type
) = TREE_ADDRESSABLE (type_dup
);
12042 DECL_SIZE (defn
) = DECL_SIZE (maybe_dup
);
12043 DECL_SIZE_UNIT (defn
) = DECL_SIZE_UNIT (maybe_dup
);
12044 DECL_ALIGN_RAW (defn
) = DECL_ALIGN_RAW (maybe_dup
);
12045 DECL_WARN_IF_NOT_ALIGN_RAW (defn
)
12046 = DECL_WARN_IF_NOT_ALIGN_RAW (maybe_dup
);
12047 DECL_USER_ALIGN (defn
) = DECL_USER_ALIGN (maybe_dup
);
12050 TYPE_POLYMORPHIC_P (type
) = TYPE_POLYMORPHIC_P (type_dup
);
12051 TYPE_HAS_USER_CONSTRUCTOR (type
)
12052 = TYPE_HAS_USER_CONSTRUCTOR (type_dup
);
12053 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
12054 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type_dup
);
12056 if (auto ls
= TYPE_LANG_SPECIFIC (type_dup
))
12058 if (TYPE_LANG_SPECIFIC (type
))
12060 CLASSTYPE_BEFRIENDING_CLASSES (type_dup
)
12061 = CLASSTYPE_BEFRIENDING_CLASSES (type
);
12062 if (!ANON_AGGR_TYPE_P (type
))
12063 CLASSTYPE_TYPEINFO_VAR (type_dup
)
12064 = CLASSTYPE_TYPEINFO_VAR (type
);
12066 for (tree v
= type
; v
; v
= TYPE_NEXT_VARIANT (v
))
12067 TYPE_LANG_SPECIFIC (v
) = ls
;
12071 TYPE_SIZE (type
) = size
;
12072 TYPE_SIZE_UNIT (type
) = size_unit
;
12076 tree
*chain
= &TYPE_FIELDS (type
);
12077 unsigned len
= fields
->length ();
12078 for (unsigned ix
= 0; ix
!= len
; ix
++)
12080 tree decl
= (*fields
)[ix
];
12084 /* An anonymous struct with typedef name. */
12085 tree tdef
= (*fields
)[ix
+1];
12086 decl
= TYPE_STUB_DECL (TREE_TYPE (tdef
));
12087 gcc_checking_assert (IDENTIFIER_ANON_P (DECL_NAME (decl
))
12091 gcc_checking_assert (!*chain
== !DECL_CLONED_FUNCTION_P (decl
));
12093 chain
= &DECL_CHAIN (decl
);
12095 if (TREE_CODE (decl
) == FIELD_DECL
12096 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
12097 ANON_AGGR_TYPE_FIELD
12098 (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))) = decl
;
12100 if (TREE_CODE (decl
) == USING_DECL
12101 && TREE_CODE (USING_DECL_SCOPE (decl
)) == RECORD_TYPE
)
12103 /* Reconstruct DECL_ACCESS. */
12104 tree decls
= USING_DECL_DECLS (decl
);
12105 tree access
= declared_access (decl
);
12107 for (ovl_iterator
iter (decls
); iter
; ++iter
)
12111 retrofit_lang_decl (d
);
12112 tree list
= DECL_ACCESS (d
);
12114 if (!purpose_member (type
, list
))
12115 DECL_ACCESS (d
) = tree_cons (type
, access
, list
);
12121 TYPE_VFIELD (type
) = vfield
;
12122 TYPE_BINFO (type
) = binfo
;
12124 if (TYPE_LANG_SPECIFIC (type
))
12126 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
12128 CLASSTYPE_MEMBER_VEC (type
) = member_vec
;
12129 CLASSTYPE_PURE_VIRTUALS (type
) = pure_virts
;
12130 CLASSTYPE_VCALL_INDICES (type
) = vcall_indices
;
12132 CLASSTYPE_KEY_METHOD (type
) = key_method
;
12134 CLASSTYPE_VBASECLASSES (type
) = vbase_vec
;
12136 /* Resort the member vector. */
12137 resort_type_member_vec (member_vec
, NULL
, nop
, NULL
);
12140 else if (maybe_dup
)
12142 // FIXME:QOI Check matching defn
12145 if (TYPE_LANG_SPECIFIC (type
))
12147 tree primary
= tree_node ();
12148 tree as_base
= tree_node ();
12151 as_base
= TREE_TYPE (as_base
);
12153 /* Read the vtables. */
12154 vec
<tree
, va_heap
> *vtables
= vec_chained_decls ();
12157 unsigned len
= vtables
->length ();
12158 for (unsigned ix
= 0; ix
!= len
; ix
++)
12160 tree vtable
= (*vtables
)[ix
];
12161 read_var_def (vtable
, vtable
);
12165 tree friend_classes
= tree_list (false);
12166 tree friend_functions
= NULL_TREE
;
12167 for (tree
*chain
= &friend_functions
;
12168 tree name
= tree_node (); chain
= &TREE_CHAIN (*chain
))
12170 tree val
= tree_list (false);
12171 *chain
= build_tree_list (name
, val
);
12173 tree decl_list
= tree_list (true);
12177 CLASSTYPE_PRIMARY_BINFO (type
) = primary
;
12178 CLASSTYPE_AS_BASE (type
) = as_base
;
12182 if (!CLASSTYPE_KEY_METHOD (type
)
12183 /* Sneaky user may have defined it inline
12185 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type
)))
12186 vec_safe_push (keyed_classes
, type
);
12187 unsigned len
= vtables
->length ();
12188 tree
*chain
= &CLASSTYPE_VTABLES (type
);
12189 for (unsigned ix
= 0; ix
!= len
; ix
++)
12191 tree vtable
= (*vtables
)[ix
];
12192 gcc_checking_assert (!*chain
);
12194 chain
= &DECL_CHAIN (vtable
);
12197 CLASSTYPE_FRIEND_CLASSES (type
) = friend_classes
;
12198 DECL_FRIENDLIST (defn
) = friend_functions
;
12199 CLASSTYPE_DECL_LIST (type
) = decl_list
;
12201 for (; friend_classes
; friend_classes
= TREE_CHAIN (friend_classes
))
12203 tree f
= TREE_VALUE (friend_classes
);
12205 if (CLASS_TYPE_P (f
))
12207 CLASSTYPE_BEFRIENDING_CLASSES (f
)
12208 = tree_cons (NULL_TREE
, type
,
12209 CLASSTYPE_BEFRIENDING_CLASSES (f
));
12210 dump () && dump ("Class %N befriending %C:%N",
12211 type
, TREE_CODE (f
), f
);
12215 for (; friend_functions
;
12216 friend_functions
= TREE_CHAIN (friend_functions
))
12217 for (tree friend_decls
= TREE_VALUE (friend_functions
);
12218 friend_decls
; friend_decls
= TREE_CHAIN (friend_decls
))
12220 tree f
= TREE_VALUE (friend_decls
);
12222 DECL_BEFRIENDING_CLASSES (f
)
12223 = tree_cons (NULL_TREE
, type
, DECL_BEFRIENDING_CLASSES (f
));
12224 dump () && dump ("Class %N befriending %C:%N",
12225 type
, TREE_CODE (f
), f
);
12229 if (TYPE_CONTAINS_VPTR_P (type
))
12230 /* Read and install the thunks. */
12231 while (tree vfunc
= tree_node ())
12233 tree thunks
= chained_decls ();
12235 SET_DECL_THUNKS (vfunc
, thunks
);
12238 vec_free (vtables
);
12241 /* Propagate to all variants. */
12243 fixup_type_variants (type
);
12245 /* IS_FAKE_BASE_TYPE is inaccurate at this point, because if this is
12246 the fake base, we've not hooked it into the containing class's
12247 data structure yet. Fortunately it has a unique name. */
12249 && DECL_NAME (defn
) != as_base_identifier
12250 && (!CLASSTYPE_TEMPLATE_INFO (type
)
12251 || !uses_template_parms (TI_ARGS (CLASSTYPE_TEMPLATE_INFO (type
)))))
12252 /* Emit debug info. It'd be nice to know if the interface TU
12253 already emitted this. */
12254 rest_of_type_compilation (type
, !LOCAL_CLASS_P (type
));
12258 return !get_overrun ();
12262 trees_out::write_enum_def (tree decl
)
12264 tree type
= TREE_TYPE (decl
);
12266 tree_node (TYPE_VALUES (type
));
12267 /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
12272 trees_out::mark_enum_def (tree decl
)
12274 tree type
= TREE_TYPE (decl
);
12276 for (tree values
= TYPE_VALUES (type
); values
; values
= TREE_CHAIN (values
))
12278 tree cst
= TREE_VALUE (values
);
12279 mark_by_value (cst
);
12280 /* We must mark the init to avoid circularity in tt_enum_int. */
12281 if (tree init
= DECL_INITIAL (cst
))
12282 if (TREE_CODE (init
) == INTEGER_CST
)
12283 mark_by_value (init
);
12288 trees_in::read_enum_def (tree defn
, tree maybe_template
)
12290 tree type
= TREE_TYPE (defn
);
12291 tree values
= tree_node ();
12293 if (get_overrun ())
12296 tree maybe_dup
= odr_duplicate (maybe_template
, TYPE_VALUES (type
));
12297 bool installing
= maybe_dup
&& !TYPE_VALUES (type
);
12301 TYPE_VALUES (type
) = values
;
12302 /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
12305 rest_of_type_compilation (type
, DECL_NAMESPACE_SCOPE_P (defn
));
12307 else if (maybe_dup
)
12309 tree known
= TYPE_VALUES (type
);
12310 for (; known
&& values
;
12311 known
= TREE_CHAIN (known
), values
= TREE_CHAIN (values
))
12313 tree known_decl
= TREE_VALUE (known
);
12314 tree new_decl
= TREE_VALUE (values
);
12316 if (DECL_NAME (known_decl
) != DECL_NAME (new_decl
))
12319 new_decl
= maybe_duplicate (new_decl
);
12321 if (!cp_tree_equal (DECL_INITIAL (known_decl
),
12322 DECL_INITIAL (new_decl
)))
12326 if (known
|| values
)
12328 error_at (DECL_SOURCE_LOCATION (maybe_dup
),
12329 "definition of %qD does not match", maybe_dup
);
12330 inform (DECL_SOURCE_LOCATION (defn
),
12331 "existing definition %qD", defn
);
12333 tree known_decl
= NULL_TREE
, new_decl
= NULL_TREE
;
12336 known_decl
= TREE_VALUE (known
);
12338 new_decl
= maybe_duplicate (TREE_VALUE (values
));
12340 if (known_decl
&& new_decl
)
12342 inform (DECL_SOURCE_LOCATION (new_decl
),
12343 "... this enumerator %qD", new_decl
);
12344 inform (DECL_SOURCE_LOCATION (known_decl
),
12345 "enumerator %qD does not match ...", known_decl
);
12347 else if (known_decl
|| new_decl
)
12349 tree extra
= known_decl
? known_decl
: new_decl
;
12350 inform (DECL_SOURCE_LOCATION (extra
),
12351 "additional enumerators beginning with %qD", extra
);
12354 inform (DECL_SOURCE_LOCATION (maybe_dup
),
12355 "enumeration range differs");
12358 unmatched_duplicate (maybe_template
);
12365 /* Write out the body of DECL. See above circularity note. */
12368 trees_out::write_definition (tree decl
)
12370 if (streaming_p ())
12372 assert_definition (decl
);
12374 && dump ("Writing definition %C:%N", TREE_CODE (decl
), decl
);
12377 dump (dumper::DEPEND
)
12378 && dump ("Depending definition %C:%N", TREE_CODE (decl
), decl
);
12381 switch (TREE_CODE (decl
))
12384 gcc_unreachable ();
12386 case TEMPLATE_DECL
:
12387 decl
= DECL_TEMPLATE_RESULT (decl
);
12390 case FUNCTION_DECL
:
12391 write_function_def (decl
);
12396 tree type
= TREE_TYPE (decl
);
12397 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12398 && TYPE_NAME (type
) == decl
);
12399 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12400 write_enum_def (decl
);
12402 write_class_def (decl
);
12408 write_var_def (decl
);
12413 /* Mark a declaration for by-value walking. If DO_DEFN is true, mark
12417 trees_out::mark_declaration (tree decl
, bool do_defn
)
12419 mark_by_value (decl
);
12421 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12422 decl
= DECL_TEMPLATE_RESULT (decl
);
12427 switch (TREE_CODE (decl
))
12430 gcc_unreachable ();
12432 case FUNCTION_DECL
:
12433 mark_function_def (decl
);
12438 tree type
= TREE_TYPE (decl
);
12439 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12440 && TYPE_NAME (type
) == decl
);
12441 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12442 mark_enum_def (decl
);
12444 mark_class_def (decl
);
12450 mark_var_def (decl
);
12455 /* Read in the body of DECL. See above circularity note. */
12458 trees_in::read_definition (tree decl
)
12460 dump () && dump ("Reading definition %C %N", TREE_CODE (decl
), decl
);
12462 tree maybe_template
= decl
;
12465 switch (TREE_CODE (decl
))
12470 case TEMPLATE_DECL
:
12471 decl
= DECL_TEMPLATE_RESULT (decl
);
12474 case FUNCTION_DECL
:
12475 return read_function_def (decl
, maybe_template
);
12479 tree type
= TREE_TYPE (decl
);
12480 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12481 && TYPE_NAME (type
) == decl
);
12482 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12483 return read_enum_def (decl
, maybe_template
);
12485 return read_class_def (decl
, maybe_template
);
12491 return read_var_def (decl
, maybe_template
);
12497 /* Lookup an maybe insert a slot for depset for KEY. */
12500 depset::hash::entity_slot (tree entity
, bool insert
)
12502 traits::compare_type
key (entity
, NULL
);
12503 depset
**slot
= find_slot_with_hash (key
, traits::hash (key
),
12504 insert
? INSERT
: NO_INSERT
);
12510 depset::hash::binding_slot (tree ctx
, tree name
, bool insert
)
12512 traits::compare_type
key (ctx
, name
);
12513 depset
**slot
= find_slot_with_hash (key
, traits::hash (key
),
12514 insert
? INSERT
: NO_INSERT
);
12520 depset::hash::find_dependency (tree decl
)
12522 depset
**slot
= entity_slot (decl
, false);
12524 return slot
? *slot
: NULL
;
12528 depset::hash::find_binding (tree ctx
, tree name
)
12530 depset
**slot
= binding_slot (ctx
, name
, false);
12532 return slot
? *slot
: NULL
;
12535 /* DECL is a newly discovered dependency. Create the depset, if it
12536 doesn't already exist. Add it to the worklist if so.
12538 DECL will be an OVL_USING_P OVERLOAD, if it's from a binding that's
12541 We do not have to worry about adding the same dependency more than
12542 once. First it's harmless, but secondly the TREE_VISITED marking
12543 prevents us wanting to do it anyway. */
12546 depset::hash::make_dependency (tree decl
, entity_kind ek
)
12548 /* Make sure we're being told consistent information. */
12549 gcc_checking_assert ((ek
== EK_NAMESPACE
)
12550 == (TREE_CODE (decl
) == NAMESPACE_DECL
12551 && !DECL_NAMESPACE_ALIAS (decl
)));
12552 gcc_checking_assert (ek
!= EK_BINDING
&& ek
!= EK_REDIRECT
);
12553 gcc_checking_assert (TREE_CODE (decl
) != FIELD_DECL
12554 && (TREE_CODE (decl
) != USING_DECL
12555 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
));
12556 gcc_checking_assert (!is_key_order ());
12557 if (ek
== EK_USING
)
12558 gcc_checking_assert (TREE_CODE (decl
) == OVERLOAD
);
12560 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12561 /* The template should have copied these from its result decl. */
12562 gcc_checking_assert (DECL_MODULE_EXPORT_P (decl
)
12563 == DECL_MODULE_EXPORT_P (DECL_TEMPLATE_RESULT (decl
)));
12565 depset
**slot
= entity_slot (decl
, true);
12566 depset
*dep
= *slot
;
12567 bool for_binding
= ek
== EK_FOR_BINDING
;
12571 if ((DECL_IMPLICIT_TYPEDEF_P (decl
)
12572 /* ... not an enum, for instance. */
12573 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
12574 && TYPE_LANG_SPECIFIC (TREE_TYPE (decl
))
12575 && CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)) == 2)
12577 && DECL_LANG_SPECIFIC (decl
)
12578 && DECL_USE_TEMPLATE (decl
) == 2))
12580 /* A partial or explicit specialization. Partial
12581 specializations might not be in the hash table, because
12582 there can be multiple differently-constrained variants.
12584 template<typename T> class silly;
12585 template<typename T> requires true class silly {};
12587 We need to find them, insert their TEMPLATE_DECL in the
12588 dep_hash, and then convert the dep we just found into a
12591 tree ti
= get_template_info (decl
);
12592 tree tmpl
= TI_TEMPLATE (ti
);
12593 tree partial
= NULL_TREE
;
12594 for (tree spec
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
12595 spec
; spec
= TREE_CHAIN (spec
))
12596 if (DECL_TEMPLATE_RESULT (TREE_VALUE (spec
)) == decl
)
12598 partial
= TREE_VALUE (spec
);
12604 /* Eagerly create an empty redirect. The following
12605 make_dependency call could cause hash reallocation,
12606 and invalidate slot's value. */
12607 depset
*redirect
= make_entity (decl
, EK_REDIRECT
);
12609 /* Redirects are never reached -- always snap to their target. */
12610 redirect
->set_flag_bit
<DB_UNREACHED_BIT
> ();
12614 depset
*tmpl_dep
= make_dependency (partial
, EK_PARTIAL
);
12615 gcc_checking_assert (tmpl_dep
->get_entity_kind () == EK_PARTIAL
);
12617 redirect
->deps
.safe_push (tmpl_dep
);
12623 bool has_def
= ek
!= EK_USING
&& has_definition (decl
);
12624 if (ek
> EK_BINDING
)
12627 /* The only OVERLOADS we should see are USING decls from
12629 *slot
= dep
= make_entity (decl
, ek
, has_def
);
12631 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12633 if (DECL_ALIAS_TEMPLATE_P (decl
) && DECL_TEMPLATE_INFO (decl
))
12634 dep
->set_flag_bit
<DB_ALIAS_TMPL_INST_BIT
> ();
12635 else if (CHECKING_P
)
12636 /* The template_result should otherwise not be in the
12637 table, or be an empty redirect (created above). */
12638 if (auto *eslot
= entity_slot (DECL_TEMPLATE_RESULT (decl
), false))
12639 gcc_checking_assert ((*eslot
)->get_entity_kind () == EK_REDIRECT
12640 && !(*eslot
)->deps
.length ());
12643 if (ek
!= EK_USING
)
12645 tree not_tmpl
= STRIP_TEMPLATE (decl
);
12647 if (DECL_LANG_SPECIFIC (not_tmpl
)
12648 && DECL_MODULE_IMPORT_P (not_tmpl
))
12650 /* Store the module number and index in cluster/section,
12651 so we don't have to look them up again. */
12652 unsigned index
= import_entity_index (decl
);
12653 module_state
*from
= import_entity_module (index
);
12654 /* Remap will be zero for imports from partitions, which
12655 we want to treat as-if declared in this TU. */
12658 dep
->cluster
= index
- from
->entity_lwm
;
12659 dep
->section
= from
->remap
;
12660 dep
->set_flag_bit
<DB_IMPORTED_BIT
> ();
12665 && !dep
->is_import ()
12666 && TREE_CODE (CP_DECL_CONTEXT (decl
)) == NAMESPACE_DECL
12667 && !(TREE_CODE (decl
) == TEMPLATE_DECL
12668 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
)))
12670 tree ctx
= CP_DECL_CONTEXT (decl
);
12672 if (!TREE_PUBLIC (ctx
))
12673 /* Member of internal namespace. */
12674 dep
->set_flag_bit
<DB_IS_INTERNAL_BIT
> ();
12675 else if (VAR_OR_FUNCTION_DECL_P (not_tmpl
)
12676 && DECL_THIS_STATIC (not_tmpl
))
12678 /* An internal decl. This is ok in a GM entity. */
12679 if (!(header_module_p ()
12680 || !DECL_LANG_SPECIFIC (not_tmpl
)
12681 || !DECL_MODULE_PURVIEW_P (not_tmpl
)))
12682 dep
->set_flag_bit
<DB_IS_INTERNAL_BIT
> ();
12687 if (!dep
->is_import ())
12688 worklist
.safe_push (dep
);
12691 dump (dumper::DEPEND
)
12692 && dump ("%s on %s %C:%N found",
12693 ek
== EK_REDIRECT
? "Redirect"
12694 : for_binding
? "Binding" : "Dependency",
12695 dep
->entity_kind_name (), TREE_CODE (decl
), decl
);
12700 /* DEP is a newly discovered dependency. Append it to current's
12704 depset::hash::add_dependency (depset
*dep
)
12706 gcc_checking_assert (current
&& !is_key_order ());
12707 current
->deps
.safe_push (dep
);
12709 if (dep
->is_internal () && !current
->is_internal ())
12710 current
->set_flag_bit
<DB_REFS_INTERNAL_BIT
> ();
12712 if (current
->get_entity_kind () == EK_USING
12713 && DECL_IMPLICIT_TYPEDEF_P (dep
->get_entity ())
12714 && TREE_CODE (TREE_TYPE (dep
->get_entity ())) == ENUMERAL_TYPE
)
12716 /* CURRENT is an unwrapped using-decl and DECL is an enum's
12717 implicit typedef. Is CURRENT a member of the enum? */
12718 tree c_decl
= OVL_FUNCTION (current
->get_entity ());
12720 if (TREE_CODE (c_decl
) == CONST_DECL
12721 && (current
->deps
[0]->get_entity ()
12722 == CP_DECL_CONTEXT (dep
->get_entity ())))
12723 /* Make DECL depend on CURRENT. */
12724 dep
->deps
.safe_push (current
);
12727 if (dep
->is_unreached ())
12729 /* The dependency is reachable now. */
12730 reached_unreached
= true;
12731 dep
->clear_flag_bit
<DB_UNREACHED_BIT
> ();
12732 dump (dumper::DEPEND
)
12733 && dump ("Reaching unreached %s %C:%N", dep
->entity_kind_name (),
12734 TREE_CODE (dep
->get_entity ()), dep
->get_entity ());
12739 depset::hash::add_dependency (tree decl
, entity_kind ek
)
12743 if (is_key_order ())
12745 dep
= find_dependency (decl
);
12748 current
->deps
.safe_push (dep
);
12749 dump (dumper::MERGE
)
12750 && dump ("Key dependency on %s %C:%N found",
12751 dep
->entity_kind_name (), TREE_CODE (decl
), decl
);
12755 /* It's not a mergeable decl, look for it in the original
12757 dep
= chain
->find_dependency (decl
);
12758 gcc_checking_assert (dep
);
12763 dep
= make_dependency (decl
, ek
);
12764 if (dep
->get_entity_kind () != EK_REDIRECT
)
12765 add_dependency (dep
);
12772 depset::hash::add_namespace_context (depset
*dep
, tree ns
)
12774 depset
*ns_dep
= make_dependency (ns
, depset::EK_NAMESPACE
);
12775 dep
->deps
.safe_push (ns_dep
);
12777 /* Mark it as special if imported so we don't walk connect when
12779 if (!dep
->is_binding () && ns_dep
->is_import ())
12780 dep
->set_special ();
12783 struct add_binding_data
12788 depset::hash
*hash
;
12789 bool met_namespace
;
12792 /* Return true if we are, or contain something that is exported. */
12795 depset::hash::add_binding_entity (tree decl
, WMB_Flags flags
, void *data_
)
12797 auto data
= static_cast <add_binding_data
*> (data_
);
12799 if (!(TREE_CODE (decl
) == NAMESPACE_DECL
&& !DECL_NAMESPACE_ALIAS (decl
)))
12803 if (TREE_CODE (inner
) == CONST_DECL
12804 && TREE_CODE (DECL_CONTEXT (inner
)) == ENUMERAL_TYPE
)
12805 inner
= TYPE_NAME (DECL_CONTEXT (inner
));
12806 else if (TREE_CODE (inner
) == TEMPLATE_DECL
)
12807 inner
= DECL_TEMPLATE_RESULT (inner
);
12809 if (!DECL_LANG_SPECIFIC (inner
) || !DECL_MODULE_PURVIEW_P (inner
))
12810 /* Ignore global module fragment entities. */
12813 if (VAR_OR_FUNCTION_DECL_P (inner
)
12814 && DECL_THIS_STATIC (inner
))
12816 if (!header_module_p ())
12817 /* Ignore internal-linkage entitites. */
12821 if ((TREE_CODE (decl
) == VAR_DECL
12822 || TREE_CODE (decl
) == TYPE_DECL
)
12823 && DECL_TINFO_P (decl
))
12824 /* Ignore TINFO things. */
12827 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_NTTP_OBJECT_P (decl
))
12828 /* Ignore NTTP objects. */
12831 if (!(flags
& WMB_Using
) && CP_DECL_CONTEXT (decl
) != data
->ns
)
12833 /* A using that lost its wrapper or an unscoped enum
12835 flags
= WMB_Flags (flags
| WMB_Using
);
12836 if (DECL_MODULE_EXPORT_P (TREE_CODE (decl
) == CONST_DECL
12837 ? TYPE_NAME (TREE_TYPE (decl
))
12838 : STRIP_TEMPLATE (decl
)))
12839 flags
= WMB_Flags (flags
| WMB_Export
);
12842 if (!data
->binding
)
12843 /* No binding to check. */;
12844 else if (flags
& WMB_Using
)
12846 /* Look in the binding to see if we already have this
12848 for (unsigned ix
= data
->binding
->deps
.length (); --ix
;)
12850 depset
*d
= data
->binding
->deps
[ix
];
12851 if (d
->get_entity_kind () == EK_USING
12852 && OVL_FUNCTION (d
->get_entity ()) == decl
)
12854 if (!(flags
& WMB_Hidden
))
12855 d
->clear_hidden_binding ();
12856 if (flags
& WMB_Export
)
12857 OVL_EXPORT_P (d
->get_entity ()) = true;
12858 return bool (flags
& WMB_Export
);
12862 else if (flags
& WMB_Dups
)
12864 /* Look in the binding to see if we already have this decl. */
12865 for (unsigned ix
= data
->binding
->deps
.length (); --ix
;)
12867 depset
*d
= data
->binding
->deps
[ix
];
12868 if (d
->get_entity () == decl
)
12870 if (!(flags
& WMB_Hidden
))
12871 d
->clear_hidden_binding ();
12877 /* We're adding something. */
12878 if (!data
->binding
)
12880 data
->binding
= make_binding (data
->ns
, DECL_NAME (decl
));
12881 data
->hash
->add_namespace_context (data
->binding
, data
->ns
);
12883 depset
**slot
= data
->hash
->binding_slot (data
->ns
,
12884 DECL_NAME (decl
), true);
12885 gcc_checking_assert (!*slot
);
12886 *slot
= data
->binding
;
12889 /* Make sure nobody left a tree visited lying about. */
12890 gcc_checking_assert (!TREE_VISITED (decl
));
12892 if (flags
& WMB_Using
)
12894 decl
= ovl_make (decl
, NULL_TREE
);
12895 if (flags
& WMB_Export
)
12896 OVL_EXPORT_P (decl
) = true;
12899 depset
*dep
= data
->hash
->make_dependency
12900 (decl
, flags
& WMB_Using
? EK_USING
: EK_FOR_BINDING
);
12901 if (flags
& WMB_Hidden
)
12902 dep
->set_hidden_binding ();
12903 data
->binding
->deps
.safe_push (dep
);
12904 /* Binding and contents are mutually dependent. */
12905 dep
->deps
.safe_push (data
->binding
);
12907 return (flags
& WMB_Using
12908 ? flags
& WMB_Export
: DECL_MODULE_EXPORT_P (decl
));
12910 else if (DECL_NAME (decl
) && !data
->met_namespace
)
12912 /* Namespace, walk exactly once. */
12913 gcc_checking_assert (TREE_PUBLIC (decl
));
12914 data
->met_namespace
= true;
12915 if (data
->hash
->add_namespace_entities (decl
, data
->partitions
))
12917 /* It contains an exported thing, so it is exported. */
12918 gcc_checking_assert (DECL_MODULE_PURVIEW_P (decl
));
12919 DECL_MODULE_EXPORT_P (decl
) = true;
12922 if (DECL_MODULE_PURVIEW_P (decl
))
12924 data
->hash
->make_dependency (decl
, depset::EK_NAMESPACE
);
12926 return DECL_MODULE_EXPORT_P (decl
);
12933 /* Recursively find all the namespace bindings of NS. Add a depset
12934 for every binding that contains an export or module-linkage entity.
12935 Add a defining depset for every such decl that we need to write a
12936 definition. Such defining depsets depend on the binding depset.
12937 Returns true if we contain something exported. */
12940 depset::hash::add_namespace_entities (tree ns
, bitmap partitions
)
12942 dump () && dump ("Looking for writables in %N", ns
);
12945 unsigned count
= 0;
12946 add_binding_data data
;
12948 data
.partitions
= partitions
;
12951 hash_table
<named_decl_hash
>::iterator end
12952 (DECL_NAMESPACE_BINDINGS (ns
)->end ());
12953 for (hash_table
<named_decl_hash
>::iterator iter
12954 (DECL_NAMESPACE_BINDINGS (ns
)->begin ()); iter
!= end
; ++iter
)
12956 data
.binding
= nullptr;
12957 data
.met_namespace
= false;
12958 if (walk_module_binding (*iter
, partitions
, add_binding_entity
, &data
))
12963 dump () && dump ("Found %u entries", count
);
12970 depset::hash::add_partial_entities (vec
<tree
, va_gc
> *partial_classes
)
12972 for (unsigned ix
= 0; ix
!= partial_classes
->length (); ix
++)
12974 tree inner
= (*partial_classes
)[ix
];
12976 depset
*dep
= make_dependency (inner
, depset::EK_DECL
);
12978 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
12979 /* We should have recorded the template as a partial
12981 gcc_checking_assert (dep
->deps
[0]->get_entity_kind ()
12982 == depset::EK_PARTIAL
);
12984 /* It was an explicit specialization, not a partial one. */
12985 gcc_checking_assert (dep
->get_entity_kind ()
12986 == depset::EK_SPECIALIZATION
);
12990 /* Add the members of imported classes that we defined in this TU.
12991 This will also include lazily created implicit member function
12992 declarations. (All others will be definitions.) */
12995 depset::hash::add_class_entities (vec
<tree
, va_gc
> *class_members
)
12997 for (unsigned ix
= 0; ix
!= class_members
->length (); ix
++)
12999 tree defn
= (*class_members
)[ix
];
13000 depset
*dep
= make_dependency (defn
, EK_INNER_DECL
);
13002 if (dep
->get_entity_kind () == EK_REDIRECT
)
13003 dep
= dep
->deps
[0];
13005 /* Only non-instantiations need marking as members. */
13006 if (dep
->get_entity_kind () == EK_DECL
)
13007 dep
->set_flag_bit
<DB_IS_MEMBER_BIT
> ();
13011 /* We add the partial & explicit specializations, and the explicit
13015 specialization_add (bool decl_p
, spec_entry
*entry
, void *data_
)
13017 vec
<spec_entry
*> *data
= reinterpret_cast <vec
<spec_entry
*> *> (data_
);
13021 /* We exclusively use decls to locate things. Make sure there's
13022 no mismatch between the two specialization tables we keep.
13023 pt.cc optimizes instantiation lookup using a complicated
13024 heuristic. We don't attempt to replicate that algorithm, but
13025 observe its behaviour and reproduce it upon read back. */
13027 gcc_checking_assert (DECL_ALIAS_TEMPLATE_P (entry
->tmpl
)
13028 || TREE_CODE (entry
->spec
) == ENUMERAL_TYPE
13029 || DECL_CLASS_TEMPLATE_P (entry
->tmpl
));
13031 /* Only alias templates can appear in both tables (and
13032 if they're in the type table they must also be in the decl
13034 gcc_checking_assert
13035 (!match_mergeable_specialization (true, entry
)
13036 == !DECL_ALIAS_TEMPLATE_P (entry
->tmpl
));
13038 else if (VAR_OR_FUNCTION_DECL_P (entry
->spec
))
13039 gcc_checking_assert (!DECL_LOCAL_DECL_P (entry
->spec
));
13041 data
->safe_push (entry
);
13044 /* Arbitrary stable comparison. */
13047 specialization_cmp (const void *a_
, const void *b_
)
13049 const spec_entry
*ea
= *reinterpret_cast<const spec_entry
*const *> (a_
);
13050 const spec_entry
*eb
= *reinterpret_cast<const spec_entry
*const *> (b_
);
13064 /* This can happen with friend specializations. Just order by
13065 entry address. See note in depset_cmp. */
13066 return ea
< eb
? -1 : +1;
13068 return DECL_UID (a
) < DECL_UID (b
) ? -1 : +1;
13071 /* We add all kinds of specialializations. Implicit specializations
13072 should only streamed and walked if they are reachable from
13073 elsewhere. Hence the UNREACHED flag. This is making the
13074 assumption that it is cheaper to reinstantiate them on demand
13075 elsewhere, rather than stream them in when we instantiate their
13076 general template. Also, if we do stream them, we can only do that
13077 if they are not internal (which they can become if they themselves
13078 touch an internal entity?). */
13081 depset::hash::add_specializations (bool decl_p
)
13083 vec
<spec_entry
*> data
;
13085 walk_specializations (decl_p
, specialization_add
, &data
);
13086 data
.qsort (specialization_cmp
);
13087 while (data
.length ())
13089 spec_entry
*entry
= data
.pop ();
13090 tree spec
= entry
->spec
;
13092 bool is_alias
= false;
13093 bool is_friend
= false;
13095 if (decl_p
&& DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (entry
->tmpl
))
13096 /* A friend of a template. This is keyed to the
13100 if (!decl_p
&& DECL_ALIAS_TEMPLATE_P (entry
->tmpl
))
13102 spec
= TYPE_NAME (spec
);
13106 if (decl_p
|| is_alias
)
13108 if (tree ti
= DECL_TEMPLATE_INFO (spec
))
13110 tree tmpl
= TI_TEMPLATE (ti
);
13112 use_tpl
= DECL_USE_TEMPLATE (spec
);
13113 if (spec
== DECL_TEMPLATE_RESULT (tmpl
))
13116 gcc_checking_assert (DECL_USE_TEMPLATE (spec
) == use_tpl
);
13118 else if (is_friend
)
13120 if (TI_TEMPLATE (ti
) != entry
->tmpl
13121 || !template_args_equal (TI_ARGS (ti
), entry
->tmpl
))
13122 goto template_friend
;
13128 gcc_checking_assert (is_friend
);
13129 /* This is a friend of a template class, but not the one
13130 that generated entry->spec itself (i.e. it's an
13131 equivalent clone). We do not need to record
13138 if (TREE_CODE (spec
) == ENUMERAL_TYPE
)
13140 tree ctx
= DECL_CONTEXT (TYPE_NAME (spec
));
13143 use_tpl
= CLASSTYPE_USE_TEMPLATE (ctx
);
13145 use_tpl
= DECL_USE_TEMPLATE (ctx
);
13148 use_tpl
= CLASSTYPE_USE_TEMPLATE (spec
);
13150 tree ti
= TYPE_TEMPLATE_INFO (spec
);
13151 tree tmpl
= TI_TEMPLATE (ti
);
13153 spec
= TYPE_NAME (spec
);
13154 if (spec
== DECL_TEMPLATE_RESULT (tmpl
))
13157 use_tpl
= DECL_USE_TEMPLATE (spec
);
13161 bool needs_reaching
= false;
13163 /* Implicit instantiations only walked if we reach them. */
13164 needs_reaching
= true;
13165 else if (!DECL_LANG_SPECIFIC (spec
)
13166 || !DECL_MODULE_PURVIEW_P (STRIP_TEMPLATE (spec
)))
13167 /* Likewise, GMF explicit or partial specializations. */
13168 needs_reaching
= true;
13170 #if false && CHECKING_P
13171 /* The instantiation isn't always on
13172 DECL_TEMPLATE_INSTANTIATIONS, */
13173 // FIXME: we probably need to remember this information?
13174 /* Verify the specialization is on the
13175 DECL_TEMPLATE_INSTANTIATIONS of the template. */
13176 for (tree cons
= DECL_TEMPLATE_INSTANTIATIONS (entry
->tmpl
);
13177 cons
; cons
= TREE_CHAIN (cons
))
13178 if (TREE_VALUE (cons
) == entry
->spec
)
13180 gcc_assert (entry
->args
== TREE_PURPOSE (cons
));
13183 gcc_unreachable ();
13187 /* Make sure nobody left a tree visited lying about. */
13188 gcc_checking_assert (!TREE_VISITED (spec
));
13189 depset
*dep
= make_dependency (spec
, depset::EK_SPECIALIZATION
);
13190 if (dep
->is_special ())
13192 /* An already located specialization, this must be the TYPE
13193 corresponding to an alias_decl we found in the decl
13195 spec_entry
*other
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
13196 gcc_checking_assert (!decl_p
&& is_alias
&& !dep
->is_type_spec ());
13197 gcc_checking_assert (other
->tmpl
== entry
->tmpl
13198 && template_args_equal (other
->args
, entry
->args
)
13199 && TREE_TYPE (other
->spec
) == entry
->spec
);
13200 dep
->set_flag_bit
<DB_ALIAS_SPEC_BIT
> ();
13204 gcc_checking_assert (decl_p
|| !is_alias
);
13205 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
13206 dep
= dep
->deps
[0];
13207 else if (dep
->get_entity_kind () == depset::EK_SPECIALIZATION
)
13209 dep
->set_special ();
13210 dep
->deps
.safe_push (reinterpret_cast<depset
*> (entry
));
13212 dep
->set_flag_bit
<DB_TYPE_SPEC_BIT
> ();
13215 if (needs_reaching
)
13216 dep
->set_flag_bit
<DB_UNREACHED_BIT
> ();
13218 dep
->set_flag_bit
<DB_FRIEND_SPEC_BIT
> ();
13224 /* Add a depset into the mergeable hash. */
13227 depset::hash::add_mergeable (depset
*mergeable
)
13229 gcc_checking_assert (is_key_order ());
13230 entity_kind ek
= mergeable
->get_entity_kind ();
13231 tree decl
= mergeable
->get_entity ();
13232 gcc_checking_assert (ek
< EK_DIRECT_HWM
);
13234 depset
**slot
= entity_slot (decl
, true);
13235 gcc_checking_assert (!*slot
);
13236 depset
*dep
= make_entity (decl
, ek
);
13239 worklist
.safe_push (dep
);
13241 /* So we can locate the mergeable depset this depset refers to,
13242 mark the first dep. */
13243 dep
->set_special ();
13244 dep
->deps
.safe_push (mergeable
);
13247 /* Find the innermost-namespace scope of DECL, and that
13248 namespace-scope decl. */
13251 find_pending_key (tree decl
, tree
*decl_p
= nullptr)
13257 ns
= CP_DECL_CONTEXT (ns
);
13259 ns
= TYPE_NAME (ns
);
13261 while (TREE_CODE (ns
) != NAMESPACE_DECL
);
13269 /* Iteratively find dependencies. During the walk we may find more
13270 entries on the same binding that need walking. */
13273 depset::hash::find_dependencies (module_state
*module
)
13275 trees_out
walker (NULL
, module
, *this);
13276 vec
<depset
*> unreached
;
13277 unreached
.create (worklist
.length ());
13281 reached_unreached
= false;
13282 while (worklist
.length ())
13284 depset
*item
= worklist
.pop ();
13286 gcc_checking_assert (!item
->is_binding ());
13287 if (item
->is_unreached ())
13288 unreached
.quick_push (item
);
13292 tree decl
= current
->get_entity ();
13293 dump (is_key_order () ? dumper::MERGE
: dumper::DEPEND
)
13294 && dump ("Dependencies of %s %C:%N",
13295 is_key_order () ? "key-order"
13296 : current
->entity_kind_name (), TREE_CODE (decl
), decl
);
13299 if (current
->get_entity_kind () == EK_USING
)
13300 walker
.tree_node (OVL_FUNCTION (decl
));
13301 else if (TREE_VISITED (decl
))
13302 /* A global tree. */;
13303 else if (item
->get_entity_kind () == EK_NAMESPACE
)
13305 module
->note_location (DECL_SOURCE_LOCATION (decl
));
13306 add_namespace_context (current
, CP_DECL_CONTEXT (decl
));
13310 walker
.mark_declaration (decl
, current
->has_defn ());
13312 if (!walker
.is_key_order ()
13313 && (item
->get_entity_kind () == EK_SPECIALIZATION
13314 || item
->get_entity_kind () == EK_PARTIAL
13315 || (item
->get_entity_kind () == EK_DECL
13316 && item
->is_member ())))
13318 tree ns
= find_pending_key (decl
, nullptr);
13319 add_namespace_context (item
, ns
);
13322 // FIXME: Perhaps p1815 makes this redundant? Or at
13323 // least simplifies it. Voldemort types are only
13324 // ever emissable when containing (inline) function
13325 // definition is emitted?
13326 /* Turn the Sneakoscope on when depending the decl. */
13327 sneakoscope
= true;
13328 walker
.decl_value (decl
, current
);
13329 sneakoscope
= false;
13330 if (current
->has_defn ())
13331 walker
.write_definition (decl
);
13335 if (!walker
.is_key_order ()
13336 && TREE_CODE (decl
) == TEMPLATE_DECL
13337 && !DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
13338 /* Mark all the explicit & partial specializations as
13340 for (tree cons
= DECL_TEMPLATE_INSTANTIATIONS (decl
);
13341 cons
; cons
= TREE_CHAIN (cons
))
13343 tree spec
= TREE_VALUE (cons
);
13345 spec
= TYPE_NAME (spec
);
13347 node_template_info (spec
, use_tpl
);
13350 depset
*spec_dep
= find_dependency (spec
);
13351 if (spec_dep
->get_entity_kind () == EK_REDIRECT
)
13352 spec_dep
= spec_dep
->deps
[0];
13353 if (spec_dep
->is_unreached ())
13355 reached_unreached
= true;
13356 spec_dep
->clear_flag_bit
<DB_UNREACHED_BIT
> ();
13357 dump (dumper::DEPEND
)
13358 && dump ("Reaching unreached specialization"
13359 " %C:%N", TREE_CODE (spec
), spec
);
13369 if (!reached_unreached
)
13372 /* It's possible the we reached the unreached before we
13373 processed it in the above loop, so we'll be doing this an
13374 extra time. However, to avoid that we have to do some
13375 bit shuffling that also involves a scan of the list.
13376 Swings & roundabouts I guess. */
13377 std::swap (worklist
, unreached
);
13380 unreached
.release ();
13383 /* Compare two entries of a single binding. TYPE_DECL before
13384 non-exported before exported. */
13387 binding_cmp (const void *a_
, const void *b_
)
13389 depset
*a
= *(depset
*const *)a_
;
13390 depset
*b
= *(depset
*const *)b_
;
13392 tree a_ent
= a
->get_entity ();
13393 tree b_ent
= b
->get_entity ();
13394 gcc_checking_assert (a_ent
!= b_ent
13395 && !a
->is_binding ()
13396 && !b
->is_binding ());
13398 /* Implicit typedefs come first. */
13399 bool a_implicit
= DECL_IMPLICIT_TYPEDEF_P (a_ent
);
13400 bool b_implicit
= DECL_IMPLICIT_TYPEDEF_P (b_ent
);
13401 if (a_implicit
|| b_implicit
)
13403 /* A binding with two implicit type decls? That's unpossible! */
13404 gcc_checking_assert (!(a_implicit
&& b_implicit
));
13405 return a_implicit
? -1 : +1; /* Implicit first. */
13408 /* Hidden before non-hidden. */
13409 bool a_hidden
= a
->is_hidden ();
13410 bool b_hidden
= b
->is_hidden ();
13411 if (a_hidden
!= b_hidden
)
13412 return a_hidden
? -1 : +1;
13414 bool a_using
= a
->get_entity_kind () == depset::EK_USING
;
13418 a_export
= OVL_EXPORT_P (a_ent
);
13419 a_ent
= OVL_FUNCTION (a_ent
);
13422 a_export
= DECL_MODULE_EXPORT_P (TREE_CODE (a_ent
) == CONST_DECL
13423 ? TYPE_NAME (TREE_TYPE (a_ent
))
13424 : STRIP_TEMPLATE (a_ent
));
13426 bool b_using
= b
->get_entity_kind () == depset::EK_USING
;
13430 b_export
= OVL_EXPORT_P (b_ent
);
13431 b_ent
= OVL_FUNCTION (b_ent
);
13434 b_export
= DECL_MODULE_EXPORT_P (TREE_CODE (b_ent
) == CONST_DECL
13435 ? TYPE_NAME (TREE_TYPE (b_ent
))
13436 : STRIP_TEMPLATE (b_ent
));
13438 /* Non-exports before exports. */
13439 if (a_export
!= b_export
)
13440 return a_export
? +1 : -1;
13442 /* At this point we don't care, but want a stable sort. */
13444 if (a_using
!= b_using
)
13446 return a_using
? -1 : +1;
13448 return DECL_UID (a_ent
) < DECL_UID (b_ent
) ? -1 : +1;
13451 /* Sort the bindings, issue errors about bad internal refs. */
13454 depset::hash::finalize_dependencies ()
13457 depset::hash::iterator
end (this->end ());
13458 for (depset::hash::iterator
iter (begin ()); iter
!= end
; ++iter
)
13460 depset
*dep
= *iter
;
13461 if (dep
->is_binding ())
13463 /* Keep the containing namespace dep first. */
13464 gcc_checking_assert (dep
->deps
.length () > 1
13465 && (dep
->deps
[0]->get_entity_kind ()
13467 && (dep
->deps
[0]->get_entity ()
13468 == dep
->get_entity ()));
13469 if (dep
->deps
.length () > 2)
13470 gcc_qsort (&dep
->deps
[1], dep
->deps
.length () - 1,
13471 sizeof (dep
->deps
[1]), binding_cmp
);
13473 else if (dep
->refs_internal ())
13475 for (unsigned ix
= dep
->deps
.length (); ix
--;)
13477 depset
*rdep
= dep
->deps
[ix
];
13478 if (rdep
->is_internal ())
13480 // FIXME:QOI Better location information? We're
13481 // losing, so it doesn't matter about efficiency
13482 tree decl
= dep
->get_entity ();
13483 error_at (DECL_SOURCE_LOCATION (decl
),
13484 "%q#D references internal linkage entity %q#D",
13485 decl
, rdep
->get_entity ());
13496 /* Core of TARJAN's algorithm to find Strongly Connected Components
13497 within a graph. See https://en.wikipedia.org/wiki/
13498 Tarjan%27s_strongly_connected_components_algorithm for details.
13500 We use depset::section as lowlink. Completed nodes have
13501 depset::cluster containing the cluster number, with the top
13504 A useful property is that the output vector is a reverse
13505 topological sort of the resulting DAG. In our case that means
13506 dependent SCCs are found before their dependers. We make use of
13510 depset::tarjan::connect (depset
*v
)
13512 gcc_checking_assert (v
->is_binding ()
13513 || !(v
->is_unreached () || v
->is_import ()));
13515 v
->cluster
= v
->section
= ++index
;
13516 stack
.safe_push (v
);
13518 /* Walk all our dependencies, ignore a first marked slot */
13519 for (unsigned ix
= v
->is_special (); ix
!= v
->deps
.length (); ix
++)
13521 depset
*dep
= v
->deps
[ix
];
13523 if (dep
->is_binding () || !dep
->is_import ())
13525 unsigned lwm
= dep
->cluster
;
13529 /* A new node. Connect it. */
13531 lwm
= dep
->section
;
13534 if (dep
->section
&& v
->section
> lwm
)
13539 if (v
->section
== v
->cluster
)
13541 /* Root of a new SCC. Push all the members onto the result list. */
13542 unsigned num
= v
->cluster
;
13549 result
.quick_push (p
);
13555 /* Compare two depsets. The specific ordering is unimportant, we're
13556 just trying to get consistency. */
13559 depset_cmp (const void *a_
, const void *b_
)
13561 depset
*a
= *(depset
*const *)a_
;
13562 depset
*b
= *(depset
*const *)b_
;
13564 depset::entity_kind a_kind
= a
->get_entity_kind ();
13565 depset::entity_kind b_kind
= b
->get_entity_kind ();
13567 if (a_kind
!= b_kind
)
13568 /* Different entity kinds, order by that. */
13569 return a_kind
< b_kind
? -1 : +1;
13571 tree a_decl
= a
->get_entity ();
13572 tree b_decl
= b
->get_entity ();
13573 if (a_kind
== depset::EK_USING
)
13575 /* If one is a using, the other must be too. */
13576 a_decl
= OVL_FUNCTION (a_decl
);
13577 b_decl
= OVL_FUNCTION (b_decl
);
13580 if (a_decl
!= b_decl
)
13581 /* Different entities, order by their UID. */
13582 return DECL_UID (a_decl
) < DECL_UID (b_decl
) ? -1 : +1;
13584 if (a_kind
== depset::EK_BINDING
)
13586 /* Both are bindings. Order by identifier hash. */
13587 gcc_checking_assert (a
->get_name () != b
->get_name ());
13588 return (IDENTIFIER_HASH_VALUE (a
->get_name ())
13589 < IDENTIFIER_HASH_VALUE (b
->get_name ())
13593 /* They are the same decl. This can happen with two using decls
13594 pointing to the same target. The best we can aim for is
13595 consistently telling qsort how to order them. Hopefully we'll
13596 never have to debug a case that depends on this. Oh, who am I
13597 kidding? Good luck. */
13598 gcc_checking_assert (a_kind
== depset::EK_USING
);
13600 /* Order by depset address. Not the best, but it is something. */
13601 return a
< b
? -1 : +1;
13604 /* Sort the clusters in SCC such that those that depend on one another
13605 are placed later. */
13607 // FIXME: I am not convinced this is needed and, if needed,
13608 // sufficient. We emit the decls in this order but that emission
13609 // could walk into later decls (from the body of the decl, or default
13610 // arg-like things). Why doesn't that walk do the right thing? And
13611 // if it DTRT why do we need to sort here -- won't things naturally
13612 // work? I think part of the issue is that when we're going to refer
13613 // to an entity by name, and that entity is in the same cluster as us,
13614 // we need to actually walk that entity, if we've not already walked
13617 sort_cluster (depset::hash
*original
, depset
*scc
[], unsigned size
)
13619 depset::hash
table (size
, original
);
13623 /* Place bindings last, usings before that. It's not strictly
13624 necessary, but it does make things neater. Says Mr OCD. */
13625 unsigned bind_lwm
= size
;
13626 unsigned use_lwm
= size
;
13627 for (unsigned ix
= 0; ix
!= use_lwm
;)
13629 depset
*dep
= scc
[ix
];
13630 switch (dep
->get_entity_kind ())
13632 case depset::EK_BINDING
:
13633 /* Move to end. No increment. Notice this could be moving
13634 a using decl, which we'll then move again. */
13635 if (--bind_lwm
!= ix
)
13637 scc
[ix
] = scc
[bind_lwm
];
13638 scc
[bind_lwm
] = dep
;
13640 if (use_lwm
> bind_lwm
)
13645 /* We must have copied a using, so move it too. */
13647 gcc_checking_assert (dep
->get_entity_kind () == depset::EK_USING
);
13650 case depset::EK_USING
:
13651 if (--use_lwm
!= ix
)
13653 scc
[ix
] = scc
[use_lwm
];
13654 scc
[use_lwm
] = dep
;
13658 case depset::EK_DECL
:
13659 case depset::EK_SPECIALIZATION
:
13660 case depset::EK_PARTIAL
:
13661 table
.add_mergeable (dep
);
13666 gcc_unreachable ();
13670 gcc_checking_assert (use_lwm
<= bind_lwm
);
13671 dump (dumper::MERGE
) && dump ("Ordering %u/%u depsets", use_lwm
, size
);
13673 table
.find_dependencies (nullptr);
13675 vec
<depset
*> order
= table
.connect ();
13676 gcc_checking_assert (order
.length () == use_lwm
);
13678 /* Now rewrite entries [0,lwm), in the dependency order we
13679 discovered. Usually each entity is in its own cluster. Rarely,
13680 we can get multi-entity clusters, in which case all but one must
13681 only be reached from within the cluster. This happens for
13684 template<typename T>
13685 auto Foo (const T &arg) -> TPL<decltype (arg)>;
13687 The instantiation of TPL will be in the specialization table, and
13688 refer to Foo via arg. But we can only get to that specialization
13689 from Foo's declaration, so we only need to treat Foo as mergable
13690 (We'll do structural comparison of TPL<decltype (arg)>).
13692 Finding the single cluster entry dep is very tricky and
13693 expensive. Let's just not do that. It's harmless in this case
13696 unsigned cluster
= ~0u;
13697 for (unsigned ix
= 0; ix
!= order
.length (); ix
++)
13699 gcc_checking_assert (order
[ix
]->is_special ());
13700 depset
*dep
= order
[ix
]->deps
[0];
13702 dump (dumper::MERGE
)
13703 && dump ("Mergeable %u is %N%s", ix
, dep
->get_entity (),
13704 order
[ix
]->cluster
== cluster
? " (tight)" : "");
13705 cluster
= order
[ix
]->cluster
;
13708 gcc_checking_assert (pos
== use_lwm
);
13711 dump (dumper::MERGE
) && dump ("Ordered %u keys", pos
);
13715 /* Reduce graph to SCCS clusters. SCCS will be populated with the
13716 depsets in dependency order. Each depset's CLUSTER field contains
13717 its cluster number. Each SCC has a unique cluster number, and are
13718 contiguous in SCCS. Cluster numbers are otherwise arbitrary. */
13721 depset::hash::connect ()
13723 tarjan
connector (size ());
13724 vec
<depset
*> deps
;
13725 deps
.create (size ());
13726 iterator
end (this->end ());
13727 for (iterator
iter (begin ()); iter
!= end
; ++iter
)
13729 depset
*item
= *iter
;
13731 entity_kind kind
= item
->get_entity_kind ();
13732 if (kind
== EK_BINDING
13733 || !(kind
== EK_REDIRECT
13734 || item
->is_unreached ()
13735 || item
->is_import ()))
13736 deps
.quick_push (item
);
13739 /* Iteration over the hash table is an unspecified ordering. While
13740 that has advantages, it causes 2 problems. Firstly repeatable
13741 builds are tricky. Secondly creating testcases that check
13742 dependencies are correct by making sure a bad ordering would
13743 happen if that was wrong. */
13744 deps
.qsort (depset_cmp
);
13746 while (deps
.length ())
13748 depset
*v
= deps
.pop ();
13749 dump (dumper::CLUSTER
) &&
13751 ? dump ("Connecting binding %P", v
->get_entity (), v
->get_name ())
13752 : dump ("Connecting %s %s %C:%N",
13753 is_key_order () ? "key-order"
13754 : !v
->has_defn () ? "declaration" : "definition",
13755 v
->entity_kind_name (), TREE_CODE (v
->get_entity ()),
13756 v
->get_entity ()));
13758 connector
.connect (v
);
13762 return connector
.result
;
13765 /* Initialize location spans. */
13768 loc_spans::init (const line_maps
*lmaps
, const line_map_ordinary
*map
)
13770 gcc_checking_assert (!init_p ());
13771 spans
= new vec
<span
> ();
13772 spans
->reserve (20);
13775 interval
.ordinary
.first
= 0;
13776 interval
.macro
.second
= MAX_LOCATION_T
+ 1;
13777 interval
.ordinary_delta
= interval
.macro_delta
= 0;
13779 /* A span for reserved fixed locs. */
13780 interval
.ordinary
.second
13781 = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0));
13782 interval
.macro
.first
= interval
.macro
.second
;
13783 dump (dumper::LOCATION
)
13784 && dump ("Fixed span %u ordinary:[%u,%u) macro:[%u,%u)", spans
->length (),
13785 interval
.ordinary
.first
, interval
.ordinary
.second
,
13786 interval
.macro
.first
, interval
.macro
.second
);
13787 spans
->quick_push (interval
);
13789 /* A span for command line & forced headers. */
13790 interval
.ordinary
.first
= interval
.ordinary
.second
;
13791 interval
.macro
.second
= interval
.macro
.first
;
13794 interval
.ordinary
.second
= map
->start_location
;
13795 interval
.macro
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (lmaps
);
13797 dump (dumper::LOCATION
)
13798 && dump ("Pre span %u ordinary:[%u,%u) macro:[%u,%u)", spans
->length (),
13799 interval
.ordinary
.first
, interval
.ordinary
.second
,
13800 interval
.macro
.first
, interval
.macro
.second
);
13801 spans
->quick_push (interval
);
13803 /* Start an interval for the main file. */
13804 interval
.ordinary
.first
= interval
.ordinary
.second
;
13805 interval
.macro
.second
= interval
.macro
.first
;
13806 dump (dumper::LOCATION
)
13807 && dump ("Main span %u ordinary:[%u,*) macro:[*,%u)", spans
->length (),
13808 interval
.ordinary
.first
, interval
.macro
.second
);
13809 spans
->quick_push (interval
);
13812 /* Reopen the span, if we want the about-to-be-inserted set of maps to
13813 be propagated in our own location table. I.e. we are the primary
13814 interface and we're importing a partition. */
13817 loc_spans::maybe_propagate (module_state
*import
, location_t hwm
)
13819 bool opened
= (module_interface_p () && !module_partition_p ()
13820 && import
->is_partition ());
13826 /* Open a new linemap interval. The just-created ordinary map is the
13827 first map of the interval. */
13830 loc_spans::open (location_t hwm
)
13833 interval
.ordinary
.first
= interval
.ordinary
.second
= hwm
;
13834 interval
.macro
.first
= interval
.macro
.second
13835 = LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
13836 interval
.ordinary_delta
= interval
.macro_delta
= 0;
13837 dump (dumper::LOCATION
)
13838 && dump ("Opening span %u ordinary:[%u,... macro:...,%u)",
13839 spans
->length (), interval
.ordinary
.first
,
13840 interval
.macro
.second
);
13841 if (spans
->length ())
13843 /* No overlapping! */
13844 auto &last
= spans
->last ();
13845 gcc_checking_assert (interval
.ordinary
.first
>= last
.ordinary
.second
);
13846 gcc_checking_assert (interval
.macro
.second
<= last
.macro
.first
);
13848 spans
->safe_push (interval
);
13851 /* Close out the current linemap interval. The last maps are within
13855 loc_spans::close ()
13857 span
&interval
= spans
->last ();
13859 interval
.ordinary
.second
13860 = ((line_table
->highest_location
+ (1 << line_table
->default_range_bits
))
13861 & ~((1u << line_table
->default_range_bits
) - 1));
13862 interval
.macro
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
13863 dump (dumper::LOCATION
)
13864 && dump ("Closing span %u ordinary:[%u,%u) macro:[%u,%u)",
13865 spans
->length () - 1,
13866 interval
.ordinary
.first
,interval
.ordinary
.second
,
13867 interval
.macro
.first
, interval
.macro
.second
);
13870 /* Given an ordinary location LOC, return the lmap_interval it resides
13871 in. NULL if it is not in an interval. */
13873 const loc_spans::span
*
13874 loc_spans::ordinary (location_t loc
)
13876 unsigned len
= spans
->length ();
13880 unsigned half
= len
/ 2;
13881 const span
&probe
= (*spans
)[pos
+ half
];
13882 if (loc
< probe
.ordinary
.first
)
13884 else if (loc
< probe
.ordinary
.second
)
13889 len
= len
- (half
+ 1);
13895 /* Likewise, given a macro location LOC, return the lmap interval it
13898 const loc_spans::span
*
13899 loc_spans::macro (location_t loc
)
13901 unsigned len
= spans
->length ();
13905 unsigned half
= len
/ 2;
13906 const span
&probe
= (*spans
)[pos
+ half
];
13907 if (loc
>= probe
.macro
.second
)
13909 else if (loc
>= probe
.macro
.first
)
13914 len
= len
- (half
+ 1);
13920 /* Return the ordinary location closest to FROM. */
13923 ordinary_loc_of (line_maps
*lmaps
, location_t from
)
13925 while (!IS_ORDINARY_LOC (from
))
13927 if (IS_ADHOC_LOC (from
))
13928 from
= get_location_from_adhoc_loc (lmaps
, from
);
13929 if (from
>= LINEMAPS_MACRO_LOWEST_LOCATION (lmaps
))
13931 /* Find the ordinary location nearest FROM. */
13932 const line_map
*map
= linemap_lookup (lmaps
, from
);
13933 const line_map_macro
*mac_map
= linemap_check_macro (map
);
13934 from
= MACRO_MAP_EXPANSION_POINT_LOCATION (mac_map
);
13940 static module_state
**
13941 get_module_slot (tree name
, module_state
*parent
, bool partition
, bool insert
)
13943 module_state_hash::compare_type
ct (name
, uintptr_t (parent
) | partition
);
13944 hashval_t hv
= module_state_hash::hash (ct
);
13946 return modules_hash
->find_slot_with_hash (ct
, hv
, insert
? INSERT
: NO_INSERT
);
13949 static module_state
*
13950 get_primary (module_state
*parent
)
13952 while (parent
->is_partition ())
13953 parent
= parent
->parent
;
13956 // Implementation unit has null name
13957 parent
= parent
->parent
;
13962 /* Find or create module NAME & PARENT in the hash table. */
13965 get_module (tree name
, module_state
*parent
, bool partition
)
13970 parent
= get_primary ((*modules
)[0]);
13972 if (!parent
->is_partition () && !parent
->flatname
)
13973 parent
->set_flatname ();
13976 module_state
**slot
= get_module_slot (name
, parent
, partition
, true);
13977 module_state
*state
= *slot
;
13980 state
= (new (ggc_alloc
<module_state
> ())
13981 module_state (name
, parent
, partition
));
13987 /* Process string name PTR into a module_state. */
13989 static module_state
*
13990 get_module (const char *ptr
)
13992 /* On DOS based file systems, there is an ambiguity with A:B which can be
13993 interpreted as a module Module:Partition or Drive:PATH. Interpret strings
13994 which clearly starts as pathnames as header-names and everything else is
13995 treated as a (possibly malformed) named moduled. */
13996 if (IS_DIR_SEPARATOR (ptr
[ptr
[0] == '.']) // ./FOO or /FOO
13997 #if HAVE_DOS_BASED_FILE_SYSTEM
13998 || (HAS_DRIVE_SPEC (ptr
) && IS_DIR_SEPARATOR (ptr
[2])) // A:/FOO
14001 /* A header name. */
14002 return get_module (build_string (strlen (ptr
), ptr
));
14004 bool partition
= false;
14005 module_state
*mod
= NULL
;
14007 for (const char *probe
= ptr
;; probe
++)
14008 if (!*probe
|| *probe
== '.' || *probe
== ':')
14013 mod
= get_module (get_identifier_with_length (ptr
, probe
- ptr
),
14026 else if (!(ISALPHA (*probe
) || *probe
== '_'
14027 || (probe
!= ptr
&& ISDIGIT (*probe
))))
14033 /* Create a new mapper connecting to OPTION. */
14036 make_mapper (location_t loc
)
14038 timevar_start (TV_MODULE_MAPPER
);
14039 const char *option
= module_mapper_name
;
14041 option
= getenv ("CXX_MODULE_MAPPER");
14043 mapper
= module_client::open_module_client
14044 (loc
, option
, &set_cmi_repo
,
14045 (save_decoded_options
[0].opt_index
== OPT_SPECIAL_program_name
)
14046 && save_decoded_options
[0].arg
!= progname
14047 ? save_decoded_options
[0].arg
: nullptr);
14049 timevar_stop (TV_MODULE_MAPPER
);
14054 static unsigned lazy_snum
;
14057 recursive_lazy (unsigned snum
= ~0u)
14061 error_at (input_location
, "recursive lazy load");
14069 /* If THIS is the current purview, issue an import error and return false. */
14072 module_state::check_not_purview (location_t from
)
14074 module_state
*imp
= (*modules
)[0];
14075 if (imp
&& !imp
->name
)
14079 /* Cannot import the current module. */
14080 error_at (from
, "cannot import module in its own purview");
14081 inform (loc
, "module %qs declared here", get_flatname ());
14087 /* Module name substitutions. */
14088 static vec
<module_state
*,va_heap
> substs
;
14091 module_state::mangle (bool include_partition
)
14094 mangle_module_substitution (subst
);
14098 parent
->mangle (include_partition
);
14099 if (include_partition
|| !is_partition ())
14101 // Partitions are significant for global initializer
14103 bool partition
= is_partition () && !parent
->is_partition ();
14104 subst
= mangle_module_component (name
, partition
);
14105 substs
.safe_push (this);
14111 mangle_module (int mod
, bool include_partition
)
14113 module_state
*imp
= (*modules
)[mod
];
14115 gcc_checking_assert (!imp
->is_header ());
14118 /* Set when importing the primary module interface. */
14121 imp
->mangle (include_partition
);
14124 /* Clean up substitutions. */
14126 mangle_module_fini ()
14128 while (substs
.length ())
14129 substs
.pop ()->subst
= 0;
14132 /* Announce WHAT about the module. */
14135 module_state::announce (const char *what
) const
14139 fprintf (stderr
, " %s:%s", what
, get_flatname ());
14144 /* A human-readable README section. The contents of this section to
14145 not contribute to the CRC, so the contents can change per
14146 compilation. That allows us to embed CWD, hostname, build time and
14147 what not. It is a STRTAB that may be extracted with:
14148 readelf -pgnu.c++.README $(module).gcm */
14151 module_state::write_readme (elf_out
*to
, cpp_reader
*reader
, const char *dialect
)
14153 bytes_out
readme (to
);
14155 readme
.begin (false);
14157 readme
.printf ("GNU C++ %s",
14158 is_header () ? "header unit"
14159 : !is_partition () ? "primary interface"
14160 : is_interface () ? "interface partition"
14161 : "internal partition");
14163 /* Compiler's version. */
14164 readme
.printf ("compiler: %s", version_string
);
14166 /* Module format version. */
14168 version2string (MODULE_VERSION
, string
);
14169 readme
.printf ("version: %s", string
);
14171 /* Module information. */
14172 readme
.printf ("module: %s", get_flatname ());
14173 readme
.printf ("source: %s", main_input_filename
);
14174 readme
.printf ("dialect: %s", dialect
);
14176 readme
.printf ("extensions: %s",
14177 extensions
& SE_OPENMP
? "-fopenmp" : "");
14179 /* The following fields could be expected to change between
14180 otherwise identical compilations. Consider a distributed build
14181 system. We should have a way of overriding that. */
14182 if (char *cwd
= getcwd (NULL
, 0))
14184 readme
.printf ("cwd: %s", cwd
);
14187 readme
.printf ("repository: %s", cmi_repo
? cmi_repo
: ".");
14191 if (!gethostname (hostname
, sizeof (hostname
)))
14192 readme
.printf ("host: %s", hostname
);
14196 /* This of course will change! */
14198 auto kind
= cpp_get_date (reader
, &stampy
);
14199 if (kind
!= CPP_time_kind::UNKNOWN
)
14203 time
= gmtime (&stampy
);
14204 readme
.print_time ("build", time
, "UTC");
14206 if (kind
== CPP_time_kind::DYNAMIC
)
14208 time
= localtime (&stampy
);
14209 readme
.print_time ("local", time
,
14210 #if defined (__USE_MISC) || defined (__USE_BSD) /* Is there a better way? */
14220 /* Its direct imports. */
14221 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14223 module_state
*state
= (*modules
)[ix
];
14225 if (state
->is_direct ())
14226 readme
.printf ("%s: %s %s", state
->exported_p
? "export" : "import",
14227 state
->get_flatname (), state
->filename
);
14230 readme
.end (to
, to
->name (MOD_SNAME_PFX
".README"), NULL
);
14233 /* Sort environment var names in reverse order. */
14236 env_var_cmp (const void *a_
, const void *b_
)
14238 const unsigned char *a
= *(const unsigned char *const *)a_
;
14239 const unsigned char *b
= *(const unsigned char *const *)b_
;
14241 for (unsigned ix
= 0; ; ix
++)
14243 bool a_end
= !a
[ix
] || a
[ix
] == '=';
14244 if (a
[ix
] == b
[ix
])
14251 bool b_end
= !b
[ix
] || b
[ix
] == '=';
14253 if (!a_end
&& !b_end
)
14254 return a
[ix
] < b
[ix
] ? +1 : -1;
14255 if (a_end
&& b_end
)
14257 return a_end
? +1 : -1;
14264 /* Write the environment. It is a STRTAB that may be extracted with:
14265 readelf -pgnu.c++.ENV $(module).gcm */
14268 module_state::write_env (elf_out
*to
)
14270 vec
<const char *> vars
;
14273 extern char **environ
;
14274 while (const char *var
= environ
[vars
.length ()])
14275 vars
.safe_push (var
);
14276 vars
.qsort (env_var_cmp
);
14278 bytes_out
env (to
);
14280 while (vars
.length ())
14281 env
.printf ("%s", vars
.pop ());
14282 env
.end (to
, to
->name (MOD_SNAME_PFX
".ENV"), NULL
);
14287 /* Write the direct or indirect imports.
14293 s:filename (direct)
14294 u:exported (direct)
14299 module_state::write_imports (bytes_out
&sec
, bool direct
)
14301 unsigned count
= 0;
14303 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14305 module_state
*imp
= (*modules
)[ix
];
14307 if (imp
->remap
&& imp
->is_direct () == direct
)
14311 gcc_assert (!direct
|| count
);
14314 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14316 module_state
*imp
= (*modules
)[ix
];
14318 if (imp
->remap
&& imp
->is_direct () == direct
)
14320 dump () && dump ("Writing %simport:%u->%u %M (crc=%x)",
14321 !direct
? "indirect "
14322 : imp
->exported_p
? "exported " : "",
14323 ix
, imp
->remap
, imp
, imp
->crc
);
14324 sec
.u (imp
->remap
);
14325 sec
.str (imp
->get_flatname ());
14326 sec
.u32 (imp
->crc
);
14329 write_location (sec
, imp
->imported_from ());
14330 sec
.str (imp
->filename
);
14331 int exportedness
= 0;
14332 if (imp
->exported_p
)
14334 else if (!imp
->is_purview_direct ())
14336 sec
.i (exportedness
);
14342 /* READER, LMAPS != NULL == direct imports,
14343 == NUL == indirect imports. */
14346 module_state::read_imports (bytes_in
&sec
, cpp_reader
*reader
, line_maps
*lmaps
)
14348 unsigned count
= sec
.u ();
14349 unsigned loaded
= 0;
14353 unsigned ix
= sec
.u ();
14354 if (ix
>= slurp
->remap
->length () || !ix
|| (*slurp
->remap
)[ix
])
14356 sec
.set_overrun ();
14360 const char *name
= sec
.str (NULL
);
14361 module_state
*imp
= get_module (name
);
14362 unsigned crc
= sec
.u32 ();
14363 int exportedness
= 0;
14365 /* If the import is a partition, it must be the same primary
14366 module as this TU. */
14367 if (imp
&& imp
->is_partition () &&
14368 (!named_module_p ()
14369 || (get_primary ((*modules
)[0]) != get_primary (imp
))))
14373 sec
.set_overrun ();
14374 if (sec
.get_overrun ())
14379 /* A direct import, maybe load it. */
14380 location_t floc
= read_location (sec
);
14381 const char *fname
= sec
.str (NULL
);
14382 exportedness
= sec
.i ();
14384 if (sec
.get_overrun ())
14387 if (!imp
->check_not_purview (loc
))
14390 if (imp
->loadedness
== ML_NONE
)
14394 if (!imp
->get_flatname ())
14395 imp
->set_flatname ();
14397 unsigned n
= dump
.push (imp
);
14399 if (!imp
->filename
&& fname
)
14400 imp
->filename
= xstrdup (fname
);
14402 if (imp
->is_partition ())
14403 dump () && dump ("Importing elided partition %M", imp
);
14405 if (!imp
->do_import (reader
, false))
14412 if (is_partition ())
14414 if (!imp
->is_direct ())
14415 imp
->directness
= MD_PARTITION_DIRECT
;
14416 if (exportedness
> 0)
14417 imp
->exported_p
= true;
14422 /* An indirect import, find it, it should already be here. */
14423 if (imp
->loadedness
== ML_NONE
)
14425 error_at (loc
, "indirect import %qs is not already loaded", name
);
14430 if (imp
->crc
!= crc
)
14431 error_at (loc
, "import %qs has CRC mismatch", imp
->get_flatname ());
14433 (*slurp
->remap
)[ix
] = (imp
->mod
<< 1) | (lmaps
!= NULL
);
14435 if (lmaps
&& exportedness
>= 0)
14436 set_import (imp
, bool (exportedness
));
14437 dump () && dump ("Found %simport:%u %M->%u", !lmaps
? "indirect "
14438 : exportedness
> 0 ? "exported "
14439 : exportedness
< 0 ? "gmf" : "", ix
, imp
,
14447 /* Write the import table to MOD_SNAME_PFX.imp. */
14450 module_state::write_imports (elf_out
*to
, unsigned *crc_ptr
)
14452 dump () && dump ("Writing imports");
14455 bytes_out
sec (to
);
14458 write_imports (sec
, true);
14459 write_imports (sec
, false);
14461 sec
.end (to
, to
->name (MOD_SNAME_PFX
".imp"), crc_ptr
);
14466 module_state::read_imports (cpp_reader
*reader
, line_maps
*lmaps
)
14470 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".imp"))
14473 dump () && dump ("Reading %u imports", slurp
->remap
->length () - 1);
14476 /* Read the imports. */
14477 unsigned direct
= read_imports (sec
, reader
, lmaps
);
14478 unsigned indirect
= read_imports (sec
, NULL
, NULL
);
14479 if (direct
+ indirect
+ 1 != slurp
->remap
->length ())
14480 from ()->set_error (elf::E_BAD_IMPORT
);
14483 if (!sec
.end (from ()))
14488 /* We're the primary module interface, but have partitions. Document
14489 them so that non-partition module implementation units know which
14490 have already been loaded. */
14493 module_state::write_partitions (elf_out
*to
, unsigned count
, unsigned *crc_ptr
)
14495 dump () && dump ("Writing %u elided partitions", count
);
14498 bytes_out
sec (to
);
14501 for (unsigned ix
= 1; ix
!= modules
->length (); ix
++)
14503 module_state
*imp
= (*modules
)[ix
];
14504 if (imp
->is_partition ())
14506 dump () && dump ("Writing elided partition %M (crc=%x)",
14508 sec
.str (imp
->get_flatname ());
14509 sec
.u32 (imp
->crc
);
14510 write_location (sec
, imp
->is_direct ()
14511 ? imp
->imported_from () : UNKNOWN_LOCATION
);
14512 sec
.str (imp
->filename
);
14516 sec
.end (to
, to
->name (MOD_SNAME_PFX
".prt"), crc_ptr
);
14521 module_state::read_partitions (unsigned count
)
14524 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".prt"))
14527 dump () && dump ("Reading %u elided partitions", count
);
14532 const char *name
= sec
.str (NULL
);
14533 unsigned crc
= sec
.u32 ();
14534 location_t floc
= read_location (sec
);
14535 const char *fname
= sec
.str (NULL
);
14537 if (sec
.get_overrun ())
14540 dump () && dump ("Reading elided partition %s (crc=%x)", name
, crc
);
14542 module_state
*imp
= get_module (name
);
14543 if (!imp
/* Partition should be ... */
14544 || !imp
->is_partition () /* a partition ... */
14545 || imp
->loadedness
!= ML_NONE
/* that is not yet loaded ... */
14546 || get_primary (imp
) != this) /* whose primary is this. */
14548 sec
.set_overrun ();
14552 if (!imp
->has_location ())
14555 if (!imp
->filename
&& fname
[0])
14556 imp
->filename
= xstrdup (fname
);
14560 if (!sec
.end (from ()))
14565 /* Data for config reading and writing. */
14566 struct module_state_config
{
14567 const char *dialect_str
;
14568 unsigned num_imports
;
14569 unsigned num_partitions
;
14570 unsigned num_entities
;
14571 unsigned ordinary_locs
;
14572 unsigned macro_locs
;
14573 unsigned loc_range_bits
;
14574 unsigned active_init
;
14577 module_state_config ()
14578 :dialect_str (get_dialect ()),
14579 num_imports (0), num_partitions (0), num_entities (0),
14580 ordinary_locs (0), macro_locs (0), loc_range_bits (0),
14585 static void release ()
14587 XDELETEVEC (dialect
);
14592 static const char *get_dialect ();
14593 static char *dialect
;
14596 char *module_state_config::dialect
;
14598 /* Generate a string of the significant compilation options.
14599 Generally assume the user knows what they're doing, in the same way
14600 that object files can be mixed. */
14603 module_state_config::get_dialect ()
14606 dialect
= concat (get_cxx_dialect_name (cxx_dialect
),
14607 /* C++ implies these, only show if disabled. */
14608 flag_exceptions
? "" : "/no-exceptions",
14609 flag_rtti
? "" : "/no-rtti",
14610 flag_new_inheriting_ctors
? "" : "/old-inheriting-ctors",
14611 /* C++ 20 implies concepts. */
14612 cxx_dialect
< cxx20
&& flag_concepts
? "/concepts" : "",
14613 flag_coroutines
? "/coroutines" : "",
14614 flag_module_implicit_inline
? "/implicit-inline" : "",
14615 flag_contracts
? "/contracts" : "",
14621 /* Contents of a cluster. */
14623 ct_decl
, /* A decl. */
14624 ct_defn
, /* A definition. */
14625 ct_bind
, /* A binding. */
14629 /* Binding modifiers. */
14632 cbf_export
= 0x1, /* An exported decl. */
14633 cbf_hidden
= 0x2, /* A hidden (friend) decl. */
14634 cbf_using
= 0x4, /* A using decl. */
14635 cbf_wrapped
= 0x8, /* ... that is wrapped. */
14638 /* DEP belongs to a different cluster, seed it to prevent
14639 unfortunately timed duplicate import. */
14640 // FIXME: QOI For inter-cluster references we could just only pick
14641 // one entity from an earlier cluster. Even better track
14642 // dependencies between earlier clusters
14645 module_state::intercluster_seed (trees_out
&sec
, unsigned index_hwm
, depset
*dep
)
14647 if (dep
->is_import ()
14648 || dep
->cluster
< index_hwm
)
14650 tree ent
= dep
->get_entity ();
14651 if (!TREE_VISITED (ent
))
14653 sec
.tree_node (ent
);
14654 dump (dumper::CLUSTER
)
14655 && dump ("Seeded %s %N",
14656 dep
->is_import () ? "import" : "intercluster", ent
);
14661 /* Write the cluster of depsets in SCC[0-SIZE).
14662 dep->section -> section number
14663 dep->cluster -> entity number
14667 module_state::write_cluster (elf_out
*to
, depset
*scc
[], unsigned size
,
14668 depset::hash
&table
, unsigned *counts
,
14671 dump () && dump ("Writing section:%u %u depsets", table
.section
, size
);
14674 trees_out
sec (to
, this, table
, table
.section
);
14676 unsigned index_lwm
= counts
[MSC_entities
];
14678 /* Determine entity numbers, mark for writing. */
14679 dump (dumper::CLUSTER
) && dump ("Cluster members:") && (dump
.indent (), true);
14680 for (unsigned ix
= 0; ix
!= size
; ix
++)
14682 depset
*b
= scc
[ix
];
14684 switch (b
->get_entity_kind ())
14687 gcc_unreachable ();
14689 case depset::EK_BINDING
:
14691 dump (dumper::CLUSTER
)
14692 && dump ("[%u]=%s %P", ix
, b
->entity_kind_name (),
14693 b
->get_entity (), b
->get_name ());
14694 depset
*ns_dep
= b
->deps
[0];
14695 gcc_checking_assert (ns_dep
->get_entity_kind ()
14696 == depset::EK_NAMESPACE
14697 && ns_dep
->get_entity () == b
->get_entity ());
14698 for (unsigned jx
= b
->deps
.length (); --jx
;)
14700 depset
*dep
= b
->deps
[jx
];
14701 // We could be declaring something that is also a
14703 gcc_checking_assert (dep
->is_import ()
14704 || TREE_VISITED (dep
->get_entity ())
14705 || (dep
->get_entity_kind ()
14706 == depset::EK_USING
));
14711 case depset::EK_DECL
:
14712 case depset::EK_SPECIALIZATION
:
14713 case depset::EK_PARTIAL
:
14714 b
->cluster
= counts
[MSC_entities
]++;
14715 sec
.mark_declaration (b
->get_entity (), b
->has_defn ());
14718 case depset::EK_USING
:
14719 gcc_checking_assert (!b
->is_import ()
14720 && !b
->is_unreached ());
14721 dump (dumper::CLUSTER
)
14722 && dump ("[%u]=%s %s %N", ix
, b
->entity_kind_name (),
14723 b
->has_defn () ? "definition" : "declaration",
14728 dump (dumper::CLUSTER
) && (dump
.outdent (), true);
14730 /* Ensure every out-of-cluster decl is referenced before we start
14731 streaming. We must do both imports *and* earlier clusters,
14732 because the latter could reach into the former and cause a
14734 sec
.set_importing (+1);
14735 for (unsigned ix
= 0; ix
!= size
; ix
++)
14737 depset
*b
= scc
[ix
];
14738 for (unsigned jx
= (b
->get_entity_kind () == depset::EK_BINDING
14739 || b
->is_special ()) ? 1 : 0;
14740 jx
!= b
->deps
.length (); jx
++)
14742 depset
*dep
= b
->deps
[jx
];
14744 if (dep
->is_binding ())
14746 for (unsigned ix
= dep
->deps
.length (); --ix
;)
14748 depset
*bind
= dep
->deps
[ix
];
14749 if (bind
->get_entity_kind () == depset::EK_USING
)
14750 bind
= bind
->deps
[1];
14752 intercluster_seed (sec
, index_lwm
, bind
);
14754 /* Also check the namespace itself. */
14755 dep
= dep
->deps
[0];
14758 intercluster_seed (sec
, index_lwm
, dep
);
14761 sec
.tree_node (NULL_TREE
);
14762 /* We're done importing now. */
14763 sec
.set_importing (-1);
14765 /* Write non-definitions. */
14766 for (unsigned ix
= 0; ix
!= size
; ix
++)
14768 depset
*b
= scc
[ix
];
14769 tree decl
= b
->get_entity ();
14770 switch (b
->get_entity_kind ())
14773 gcc_unreachable ();
14776 case depset::EK_BINDING
:
14778 gcc_assert (TREE_CODE (decl
) == NAMESPACE_DECL
);
14779 dump () && dump ("Depset:%u binding %C:%P", ix
, TREE_CODE (decl
),
14780 decl
, b
->get_name ());
14782 sec
.tree_node (decl
);
14783 sec
.tree_node (b
->get_name ());
14785 /* Write in reverse order, so reading will see the exports
14786 first, thus building the overload chain will be
14788 for (unsigned jx
= b
->deps
.length (); --jx
;)
14790 depset
*dep
= b
->deps
[jx
];
14791 tree bound
= dep
->get_entity ();
14792 unsigned flags
= 0;
14793 if (dep
->get_entity_kind () == depset::EK_USING
)
14796 bound
= OVL_FUNCTION (bound
);
14797 if (!(TREE_CODE (bound
) == CONST_DECL
14798 && UNSCOPED_ENUM_P (TREE_TYPE (bound
))
14799 && decl
== TYPE_NAME (TREE_TYPE (bound
))))
14801 /* An unscope enumerator in its enumeration's
14802 scope is not a using. */
14803 flags
|= cbf_using
;
14804 if (OVL_USING_P (ovl
))
14805 flags
|= cbf_wrapped
;
14807 if (OVL_EXPORT_P (ovl
))
14808 flags
|= cbf_export
;
14812 /* An implicit typedef must be at one. */
14813 gcc_assert (!DECL_IMPLICIT_TYPEDEF_P (bound
) || jx
== 1);
14814 if (dep
->is_hidden ())
14815 flags
|= cbf_hidden
;
14816 else if (DECL_MODULE_EXPORT_P (STRIP_TEMPLATE (bound
)))
14817 flags
|= cbf_export
;
14820 gcc_checking_assert (DECL_P (bound
));
14823 sec
.tree_node (bound
);
14826 /* Terminate the list. */
14831 case depset::EK_USING
:
14832 dump () && dump ("Depset:%u %s %C:%N", ix
, b
->entity_kind_name (),
14833 TREE_CODE (decl
), decl
);
14836 case depset::EK_SPECIALIZATION
:
14837 case depset::EK_PARTIAL
:
14838 case depset::EK_DECL
:
14839 dump () && dump ("Depset:%u %s entity:%u %C:%N", ix
,
14840 b
->entity_kind_name (), b
->cluster
,
14841 TREE_CODE (decl
), decl
);
14844 sec
.tree_node (decl
);
14846 dump () && dump ("Wrote declaration entity:%u %C:%N",
14847 b
->cluster
, TREE_CODE (decl
), decl
);
14852 depset
*namer
= NULL
;
14854 /* Write out definitions */
14855 for (unsigned ix
= 0; ix
!= size
; ix
++)
14857 depset
*b
= scc
[ix
];
14858 tree decl
= b
->get_entity ();
14859 switch (b
->get_entity_kind ())
14864 case depset::EK_SPECIALIZATION
:
14865 case depset::EK_PARTIAL
:
14866 case depset::EK_DECL
:
14870 if (b
->has_defn ())
14873 sec
.tree_node (decl
);
14874 dump () && dump ("Writing definition %N", decl
);
14875 sec
.write_definition (decl
);
14877 if (!namer
->has_defn ())
14884 /* We don't find the section by name. Use depset's decl's name for
14885 human friendliness. */
14887 tree naming_decl
= NULL_TREE
;
14890 naming_decl
= namer
->get_entity ();
14891 if (namer
->get_entity_kind () == depset::EK_USING
)
14892 /* This unfortunately names the section from the target of the
14893 using decl. But the name is only a guide, so Do Not Care. */
14894 naming_decl
= OVL_FUNCTION (naming_decl
);
14895 if (DECL_IMPLICIT_TYPEDEF_P (naming_decl
))
14896 /* Lose any anonymousness. */
14897 naming_decl
= TYPE_NAME (TREE_TYPE (naming_decl
));
14898 name
= to
->qualified_name (naming_decl
, namer
->has_defn ());
14901 unsigned bytes
= sec
.pos
;
14902 unsigned snum
= sec
.end (to
, name
, crc_ptr
);
14904 for (unsigned ix
= size
; ix
--;)
14905 gcc_checking_assert (scc
[ix
]->section
== snum
);
14908 dump () && dump ("Wrote section:%u named-by:%N", table
.section
, naming_decl
);
14913 /* Read a cluster from section SNUM. */
14916 module_state::read_cluster (unsigned snum
)
14918 trees_in
sec (this);
14920 if (!sec
.begin (loc
, from (), snum
))
14923 dump () && dump ("Reading section:%u", snum
);
14926 /* We care about structural equality. */
14927 comparing_dependent_aliases
++;
14929 /* First seed the imports. */
14930 while (tree import
= sec
.tree_node ())
14931 dump (dumper::CLUSTER
) && dump ("Seeded import %N", import
);
14933 while (!sec
.get_overrun () && sec
.more_p ())
14935 unsigned ct
= sec
.u ();
14939 sec
.set_overrun ();
14943 /* A set of namespace bindings. */
14945 tree ns
= sec
.tree_node ();
14946 tree name
= sec
.tree_node ();
14947 tree decls
= NULL_TREE
;
14948 tree visible
= NULL_TREE
;
14949 tree type
= NULL_TREE
;
14950 bool dedup
= false;
14952 /* We rely on the bindings being in the reverse order of
14953 the resulting overload set. */
14956 int flags
= sec
.i ();
14960 if ((flags
& cbf_hidden
)
14961 && (flags
& (cbf_using
| cbf_export
)))
14962 sec
.set_overrun ();
14964 tree decl
= sec
.tree_node ();
14965 if (sec
.get_overrun ())
14968 if (decls
&& TREE_CODE (decl
) == TYPE_DECL
)
14971 if (type
|| !DECL_IMPLICIT_TYPEDEF_P (decl
))
14972 sec
.set_overrun ();
14978 || (flags
& (cbf_hidden
| cbf_wrapped
))
14979 || DECL_FUNCTION_TEMPLATE_P (decl
))
14981 decls
= ovl_make (decl
, decls
);
14982 if (flags
& cbf_using
)
14985 OVL_USING_P (decls
) = true;
14986 if (flags
& cbf_export
)
14987 OVL_EXPORT_P (decls
) = true;
14990 if (flags
& cbf_hidden
)
14991 OVL_HIDDEN_P (decls
) = true;
14993 OVL_DEDUP_P (decls
) = true;
14998 if (flags
& cbf_export
14999 || (!(flags
& cbf_hidden
)
15000 && (is_module () || is_partition ())))
15006 sec
.set_overrun ();
15008 if (sec
.get_overrun ())
15011 dump () && dump ("Binding of %P", ns
, name
);
15012 if (!set_module_binding (ns
, name
, mod
,
15014 : is_module () || is_partition () ? 1
15016 decls
, type
, visible
))
15017 sec
.set_overrun ();
15024 tree decl
= sec
.tree_node ();
15025 dump () && dump ("Read declaration of %N", decl
);
15031 tree decl
= sec
.tree_node ();
15032 dump () && dump ("Reading definition of %N", decl
);
15033 sec
.read_definition (decl
);
15039 /* When lazy loading is in effect, we can be in the middle of
15040 parsing or instantiating a function. Save it away.
15041 push_function_context does too much work. */
15042 tree old_cfd
= current_function_decl
;
15043 struct function
*old_cfun
= cfun
;
15044 while (tree decl
= sec
.post_process ())
15046 bool abstract
= false;
15047 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
15050 decl
= DECL_TEMPLATE_RESULT (decl
);
15053 current_function_decl
= decl
;
15054 allocate_struct_function (decl
, abstract
);
15055 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
15056 cfun
->language
->base
.x_stmt_tree
.stmts_are_full_exprs_p
= 1;
15060 else if (DECL_ABSTRACT_P (decl
))
15061 vec_safe_push (post_load_decls
, decl
);
15064 bool aggr
= aggregate_value_p (DECL_RESULT (decl
), decl
);
15065 #ifdef PCC_STATIC_STRUCT_RETURN
15066 cfun
->returns_pcc_struct
= aggr
;
15068 cfun
->returns_struct
= aggr
;
15070 if (DECL_COMDAT (decl
))
15071 // FIXME: Comdat grouping?
15072 comdat_linkage (decl
);
15073 note_vague_linkage_fn (decl
);
15074 cgraph_node::finalize_function (decl
, true);
15078 /* Look, function.cc's interface to cfun does too much for us, we
15079 just need to restore the old value. I do not want to go
15080 redesigning that API right now. */
15083 current_function_decl
= old_cfd
;
15084 comparing_dependent_aliases
--;
15087 dump () && dump ("Read section:%u", snum
);
15091 if (!sec
.end (from ()))
15098 module_state::write_namespace (bytes_out
&sec
, depset
*dep
)
15100 unsigned ns_num
= dep
->cluster
;
15101 unsigned ns_import
= 0;
15103 if (dep
->is_import ())
15104 ns_import
= dep
->section
;
15105 else if (dep
->get_entity () != global_namespace
)
15113 module_state::read_namespace (bytes_in
&sec
)
15115 unsigned ns_import
= sec
.u ();
15116 unsigned ns_num
= sec
.u ();
15117 tree ns
= NULL_TREE
;
15119 if (ns_import
|| ns_num
)
15124 if (unsigned origin
= slurp
->remap_module (ns_import
))
15126 module_state
*from
= (*modules
)[origin
];
15127 if (ns_num
< from
->entity_num
)
15129 binding_slot
&slot
= (*entity_ary
)[from
->entity_lwm
+ ns_num
];
15131 if (!slot
.is_lazy ())
15136 sec
.set_overrun ();
15139 ns
= global_namespace
;
15144 /* SPACES is a sorted vector of namespaces. Write out the namespaces
15145 to MOD_SNAME_PFX.nms section. */
15148 module_state::write_namespaces (elf_out
*to
, vec
<depset
*> spaces
,
15149 unsigned num
, unsigned *crc_p
)
15151 dump () && dump ("Writing namespaces");
15154 bytes_out
sec (to
);
15157 for (unsigned ix
= 0; ix
!= num
; ix
++)
15159 depset
*b
= spaces
[ix
];
15160 tree ns
= b
->get_entity ();
15162 gcc_checking_assert (TREE_CODE (ns
) == NAMESPACE_DECL
);
15163 /* P1815 may have something to say about this. */
15164 gcc_checking_assert (TREE_PUBLIC (ns
));
15166 unsigned flags
= 0;
15167 if (TREE_PUBLIC (ns
))
15169 if (DECL_NAMESPACE_INLINE_P (ns
))
15171 if (DECL_MODULE_PURVIEW_P (ns
))
15173 if (DECL_MODULE_EXPORT_P (ns
))
15176 dump () && dump ("Writing namespace:%u %N%s%s%s%s",
15178 flags
& 1 ? ", public" : "",
15179 flags
& 2 ? ", inline" : "",
15180 flags
& 4 ? ", purview" : "",
15181 flags
& 8 ? ", export" : "");
15182 sec
.u (b
->cluster
);
15183 sec
.u (to
->name (DECL_NAME (ns
)));
15184 write_namespace (sec
, b
->deps
[0]);
15187 write_location (sec
, DECL_SOURCE_LOCATION (ns
));
15190 sec
.end (to
, to
->name (MOD_SNAME_PFX
".nms"), crc_p
);
15194 /* Read the namespace hierarchy from MOD_SNAME_PFX.namespace. Fill in
15195 SPACES from that data. */
15198 module_state::read_namespaces (unsigned num
)
15202 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".nms"))
15205 dump () && dump ("Reading namespaces");
15208 for (unsigned ix
= 0; ix
!= num
; ix
++)
15210 unsigned entity_index
= sec
.u ();
15211 unsigned name
= sec
.u ();
15213 tree parent
= read_namespace (sec
);
15215 /* See comment in write_namespace about why not bits. */
15216 unsigned flags
= sec
.u ();
15217 location_t src_loc
= read_location (sec
);
15219 if (entity_index
>= entity_num
15221 || (flags
& 0xc) == 0x8)
15222 sec
.set_overrun ();
15223 if (sec
.get_overrun ())
15226 tree id
= name
? get_identifier (from ()->name (name
)) : NULL_TREE
;
15228 dump () && dump ("Read namespace:%u %P%s%s%s%s",
15229 entity_index
, parent
, id
,
15230 flags
& 1 ? ", public" : "",
15231 flags
& 2 ? ", inline" : "",
15232 flags
& 4 ? ", purview" : "",
15233 flags
& 8 ? ", export" : "");
15234 bool visible_p
= ((flags
& 8)
15237 && (is_partition () || is_module ())));
15238 tree inner
= add_imported_namespace (parent
, id
, src_loc
, mod
,
15239 bool (flags
& 2), visible_p
);
15242 sec
.set_overrun ();
15246 if (is_partition ())
15249 DECL_MODULE_PURVIEW_P (inner
) = true;
15251 DECL_MODULE_EXPORT_P (inner
) = true;
15254 /* Install the namespace. */
15255 (*entity_ary
)[entity_lwm
+ entity_index
] = inner
;
15256 if (DECL_MODULE_IMPORT_P (inner
))
15259 unsigned *slot
= &entity_map
->get_or_insert
15260 (DECL_UID (inner
), &existed
);
15262 /* If it existed, it should match. */
15263 gcc_checking_assert (inner
== (*entity_ary
)[*slot
]);
15265 *slot
= entity_lwm
+ entity_index
;
15269 if (!sec
.end (from ()))
15274 /* Write the binding TABLE to MOD_SNAME_PFX.bnd */
15277 module_state::write_bindings (elf_out
*to
, vec
<depset
*> sccs
, unsigned *crc_p
)
15279 dump () && dump ("Writing binding table");
15283 bytes_out
sec (to
);
15286 for (unsigned ix
= 0; ix
!= sccs
.length (); ix
++)
15288 depset
*b
= sccs
[ix
];
15289 if (b
->is_binding ())
15291 tree ns
= b
->get_entity ();
15292 dump () && dump ("Bindings %P section:%u", ns
, b
->get_name (),
15294 sec
.u (to
->name (b
->get_name ()));
15295 write_namespace (sec
, b
->deps
[0]);
15296 sec
.u (b
->section
);
15301 sec
.end (to
, to
->name (MOD_SNAME_PFX
".bnd"), crc_p
);
15307 /* Read the binding table from MOD_SNAME_PFX.bind. */
15310 module_state::read_bindings (unsigned num
, unsigned lwm
, unsigned hwm
)
15314 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".bnd"))
15317 dump () && dump ("Reading binding table");
15319 for (; !sec
.get_overrun () && num
--;)
15321 const char *name
= from ()->name (sec
.u ());
15322 tree ns
= read_namespace (sec
);
15323 unsigned snum
= sec
.u ();
15325 if (!ns
|| !name
|| (snum
- lwm
) >= (hwm
- lwm
))
15326 sec
.set_overrun ();
15327 if (!sec
.get_overrun ())
15329 tree id
= get_identifier (name
);
15330 dump () && dump ("Bindings %P section:%u", ns
, id
, snum
);
15331 if (mod
&& !import_module_binding (ns
, id
, mod
, snum
))
15337 if (!sec
.end (from ()))
15342 /* Write the entity table to MOD_SNAME_PFX.ent
15344 Each entry is a section number. */
15347 module_state::write_entities (elf_out
*to
, vec
<depset
*> depsets
,
15348 unsigned count
, unsigned *crc_p
)
15350 dump () && dump ("Writing entities");
15353 bytes_out
sec (to
);
15356 unsigned current
= 0;
15357 for (unsigned ix
= 0; ix
< depsets
.length (); ix
++)
15359 depset
*d
= depsets
[ix
];
15361 switch (d
->get_entity_kind ())
15366 case depset::EK_NAMESPACE
:
15367 if (!d
->is_import () && d
->get_entity () != global_namespace
)
15369 gcc_checking_assert (d
->cluster
== current
);
15375 case depset::EK_DECL
:
15376 case depset::EK_SPECIALIZATION
:
15377 case depset::EK_PARTIAL
:
15378 gcc_checking_assert (!d
->is_unreached ()
15379 && !d
->is_import ()
15380 && d
->cluster
== current
15383 sec
.u (d
->section
);
15387 gcc_assert (count
== current
);
15388 sec
.end (to
, to
->name (MOD_SNAME_PFX
".ent"), crc_p
);
15393 module_state::read_entities (unsigned count
, unsigned lwm
, unsigned hwm
)
15395 trees_in
sec (this);
15397 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".ent"))
15400 dump () && dump ("Reading entities");
15403 for (binding_slot
*slot
= entity_ary
->begin () + entity_lwm
; count
--; slot
++)
15405 unsigned snum
= sec
.u ();
15406 if (snum
&& (snum
- lwm
) >= (hwm
- lwm
))
15407 sec
.set_overrun ();
15408 if (sec
.get_overrun ())
15412 slot
->set_lazy (snum
<< 2);
15416 if (!sec
.end (from ()))
15421 /* Write the pending table to MOD_SNAME_PFX.pnd
15423 The pending table holds information about clusters that need to be
15424 loaded because they contain information about something that is not
15425 found by namespace-scope lookup.
15427 The three cases are:
15429 (a) Template (maybe-partial) specializations that we have
15430 instantiated or defined. When an importer needs to instantiate
15431 that template, they /must have/ the partial, explicit & extern
15432 specializations available. If they have the other specializations
15433 available, they'll have less work to do. Thus, when we're about to
15434 instantiate FOO, we have to be able to ask 'are there any
15435 specialization of FOO in our imports?'.
15437 (b) (Maybe-implicit) member functions definitions. A class could
15438 be defined in one header, and an inline member defined in a
15439 different header (this occurs in the STL). Similarly, like the
15440 specialization case, an implicit member function could have been
15441 'instantiated' in one module, and it'd be nice to not have to
15442 reinstantiate it in another.
15444 (c) A member classes completed elsewhere. A member class could be
15445 declared in one header and defined in another. We need to know to
15446 load the class definition before looking in it. This turns out to
15447 be a specific case of #b, so we can treat these the same. But it
15448 does highlight an issue -- there could be an intermediate import
15449 between the outermost containing namespace-scope class and the
15450 innermost being-defined member class. This is actually possible
15451 with all of these cases, so be aware -- we're not just talking of
15452 one level of import to get to the innermost namespace.
15454 This gets complicated fast, it took me multiple attempts to even
15455 get something remotely working. Partially because I focussed on
15456 optimizing what I think turns out to be a smaller problem, given
15457 the known need to do the more general case *anyway*. I document
15458 the smaller problem, because it does appear to be the natural way
15459 to do it. It's trap!
15463 Let's refer to the primary template or the containing class as the
15464 KEY. And the specialization or member as the PENDING-ENTITY. (To
15465 avoid having to say those mouthfuls all the time.)
15467 In either case, we have an entity and we need some way of mapping
15468 that to a set of entities that need to be loaded before we can
15469 proceed with whatever processing of the entity we were going to do.
15471 We need to link the key to the pending-entity in some way. Given a
15472 key, tell me the pending-entities I need to have loaded. However
15473 we tie the key to the pending-entity must not rely on the key being
15474 loaded -- that'd defeat the lazy loading scheme.
15476 As the key will be an import in we know its entity number (either
15477 because we imported it, or we're writing it out too). Thus we can
15478 generate a map of key-indices to pending-entities. The
15479 pending-entity indices will be into our span of the entity table,
15480 and thus allow them to be lazily loaded. The key index will be
15481 into another slot of the entity table. Notice that this checking
15482 could be expensive, we don't want to iterate over a bunch of
15483 pending-entity indices (across multiple imports), every time we're
15484 about do to the thing with the key. We need to quickly determine
15485 'definitely nothing needed'.
15487 That's almost good enough, except that key indices are not unique
15488 in a couple of cases :( Specifically the Global Module or a module
15489 partition can result in multiple modules assigning an entity index
15490 for the key. The decl-merging on loading will detect that so we
15491 only have one Key loaded, and in the entity hash it'll indicate the
15492 entity index of first load. Which might be different to how we
15493 know it. Notice this is restricted to GM entities or this-module
15494 entities. Foreign imports cannot have this.
15496 We can simply resolve this in the direction of how this module
15497 referred to the key to how the importer knows it. Look in the
15498 entity table slot that we nominate, maybe lazy load it, and then
15499 lookup the resultant entity in the entity hash to learn how the
15502 But we need to go in the other direction :( Given the key, find all
15503 the index-aliases of that key. We can partially solve that by
15504 adding an alias hash table. Whenever we load a merged decl, add or
15505 augment a mapping from the entity (or its entity-index) to the
15506 newly-discovered index. Then when we look for pending entities of
15507 a key, we also iterate over this aliases this mapping provides.
15509 But that requires the alias to be loaded. And that's not
15512 *** THE SIMPLER WAY
15514 The remaining fixed thing we have is the innermost namespace
15515 containing the ultimate namespace-scope container of the key and
15516 the name of that container (which might be the key itself). I.e. a
15517 namespace-decl/identifier/module tuple. Let's call this the
15518 top-key. We'll discover that the module is not important here,
15519 because of cross-module possibilities mentioned in case #c above.
15520 We can't markup namespace-binding slots. The best we can do is
15521 mark the binding vector with 'there's something here', and have
15522 another map from namespace/identifier pairs to a vector of pending
15525 Maintain a pending-entity map. This is keyed by top-key, and
15526 maps to a vector of pending-entity indices. On the binding vector
15527 have flags saying whether the pending-name-entity map has contents.
15528 (We might want to further extend the key to be GM-vs-Partition and
15529 specialization-vs-member, but let's not get ahead of ourselves.)
15531 For every key-like entity, find the outermost namespace-scope
15532 name. Use that to lookup in the pending-entity map and then make
15533 sure the specified entities are loaded.
15535 An optimization might be to have a flag in each key-entity saying
15536 that its top key might be in the entity table. It's not clear to
15537 me how to set that flag cheaply -- cheaper than just looking.
15539 FIXME: It'd be nice to have a bit in decls to tell us whether to
15540 even try this. We can have a 'already done' flag, that we set when
15541 we've done KLASS's lazy pendings. When we import a module that
15542 registers pendings on the same top-key as KLASS we need to clear
15543 the flag. A recursive walk of the top-key clearing the bit will
15544 suffice. Plus we only need to recurse on classes that have the bit
15545 set. (That means we need to set the bit on parents of KLASS here,
15546 don't forget.) However, first: correctness, second: efficiency. */
15549 module_state::write_pendings (elf_out
*to
, vec
<depset
*> depsets
,
15550 depset::hash
&table
, unsigned *crc_p
)
15552 dump () && dump ("Writing pending-entities");
15555 trees_out
sec (to
, this, table
);
15558 unsigned count
= 0;
15559 tree cache_ns
= NULL_TREE
;
15560 tree cache_id
= NULL_TREE
;
15561 unsigned cache_section
= ~0;
15562 for (unsigned ix
= 0; ix
< depsets
.length (); ix
++)
15564 depset
*d
= depsets
[ix
];
15566 if (d
->is_binding ())
15569 if (d
->is_import ())
15572 if (!(d
->get_entity_kind () == depset::EK_SPECIALIZATION
15573 || d
->get_entity_kind () == depset::EK_PARTIAL
15574 || (d
->get_entity_kind () == depset::EK_DECL
&& d
->is_member ())))
15577 tree key_decl
= nullptr;
15578 tree key_ns
= find_pending_key (d
->get_entity (), &key_decl
);
15579 tree key_name
= DECL_NAME (key_decl
);
15581 if (IDENTIFIER_ANON_P (key_name
))
15583 gcc_checking_assert (IDENTIFIER_LAMBDA_P (key_name
));
15584 if (tree attached
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (key_decl
)))
15585 key_name
= DECL_NAME (attached
);
15588 /* There's nothing to attach it to. Must
15589 always reinstantiate. */
15591 && dump ("Unattached lambda %N[%u] section:%u",
15592 d
->get_entity_kind () == depset::EK_DECL
15593 ? "Member" : "Specialization", d
->get_entity (),
15594 d
->cluster
, d
->section
);
15599 char const *also
= "";
15600 if (d
->section
== cache_section
15601 && key_ns
== cache_ns
15602 && key_name
== cache_id
)
15603 /* Same section & key as previous, no need to repeat ourselves. */
15608 cache_id
= key_name
;
15609 cache_section
= d
->section
;
15610 gcc_checking_assert (table
.find_dependency (cache_ns
));
15611 sec
.tree_node (cache_ns
);
15612 sec
.tree_node (cache_id
);
15613 sec
.u (d
->cluster
);
15616 dump () && dump ("Pending %s %N entity:%u section:%u %skeyed to %P",
15617 d
->get_entity_kind () == depset::EK_DECL
15618 ? "member" : "specialization", d
->get_entity (),
15619 d
->cluster
, cache_section
, also
, cache_ns
, cache_id
);
15621 sec
.end (to
, to
->name (MOD_SNAME_PFX
".pnd"), crc_p
);
15628 module_state::read_pendings (unsigned count
)
15630 trees_in
sec (this);
15632 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".pnd"))
15635 dump () && dump ("Reading %u pendings", count
);
15638 for (unsigned ix
= 0; ix
!= count
; ix
++)
15643 key
.ns
= sec
.tree_node ();
15644 key
.id
= sec
.tree_node ();
15647 if (!key
.ns
|| !key
.id
15648 || !(TREE_CODE (key
.ns
) == NAMESPACE_DECL
15649 && !DECL_NAMESPACE_ALIAS (key
.ns
))
15650 || !identifier_p (key
.id
)
15651 || index
>= entity_num
)
15652 sec
.set_overrun ();
15654 if (sec
.get_overrun ())
15657 dump () && dump ("Pending:%u keyed to %P", index
, key
.ns
, key
.id
);
15659 index
+= entity_lwm
;
15660 auto &vec
= pending_table
->get_or_insert (key
);
15661 vec
.safe_push (index
);
15665 if (!sec
.end (from ()))
15670 /* Read & write locations. */
15674 LK_IMPORT_ORDINARY
,
15680 static const module_state
*
15681 module_for_ordinary_loc (location_t loc
)
15684 unsigned len
= ool
->length () - pos
;
15688 unsigned half
= len
/ 2;
15689 module_state
*probe
= (*ool
)[pos
+ half
];
15690 if (loc
< probe
->ordinary_locs
.first
)
15692 else if (loc
< probe
->ordinary_locs
.first
+ probe
->ordinary_locs
.second
)
15697 len
= len
- (half
+ 1);
15704 static const module_state
*
15705 module_for_macro_loc (location_t loc
)
15708 unsigned len
= modules
->length () - pos
;
15712 unsigned half
= len
/ 2;
15713 module_state
*probe
= (*modules
)[pos
+ half
];
15714 if (loc
< probe
->macro_locs
.first
)
15717 len
= len
- (half
+ 1);
15719 else if (loc
>= probe
->macro_locs
.first
+ probe
->macro_locs
.second
)
15729 module_state::imported_from () const
15731 location_t from
= loc
;
15732 line_map_ordinary
const *fmap
15733 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
15735 if (MAP_MODULE_P (fmap
))
15736 from
= linemap_included_from (fmap
);
15741 /* Note that LOC will need writing. This allows us to prune locations
15742 that are not needed. */
15745 module_state::note_location (location_t loc
)
15747 bool added
= false;
15748 if (!macro_loc_table
&& !ord_loc_table
)
15750 else if (loc
< RESERVED_LOCATION_COUNT
)
15752 else if (IS_ADHOC_LOC (loc
))
15754 location_t locus
= get_location_from_adhoc_loc (line_table
, loc
);
15755 note_location (locus
);
15756 source_range range
= get_range_from_loc (line_table
, loc
);
15757 if (range
.m_start
!= locus
)
15758 note_location (range
.m_start
);
15759 note_location (range
.m_finish
);
15761 else if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
))
15763 if (spans
.macro (loc
))
15765 const line_map
*map
= linemap_lookup (line_table
, loc
);
15766 const line_map_macro
*mac_map
= linemap_check_macro (map
);
15767 hashval_t hv
= macro_loc_traits::hash (mac_map
);
15768 macro_loc_info
*slot
15769 = macro_loc_table
->find_slot_with_hash (mac_map
, hv
, INSERT
);
15772 slot
->src
= mac_map
;
15774 // Expansion locations could themselves be from a
15775 // macro, we need to note them all.
15776 note_location (mac_map
->expansion
);
15777 gcc_checking_assert (mac_map
->n_tokens
);
15778 location_t tloc
= UNKNOWN_LOCATION
;
15779 for (unsigned ix
= mac_map
->n_tokens
* 2; ix
--;)
15780 if (mac_map
->macro_locations
[ix
] != tloc
)
15782 tloc
= mac_map
->macro_locations
[ix
];
15783 note_location (tloc
);
15789 else if (IS_ORDINARY_LOC (loc
))
15791 if (spans
.ordinary (loc
))
15793 const line_map
*map
= linemap_lookup (line_table
, loc
);
15794 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
15796 lkup
.src
= ord_map
;
15797 lkup
.span
= 1 << ord_map
->m_column_and_range_bits
;
15798 lkup
.offset
= (loc
- MAP_START_LOCATION (ord_map
)) & ~(lkup
.span
- 1);
15800 ord_loc_info
*slot
= (ord_loc_table
->find_slot_with_hash
15801 (lkup
, ord_loc_traits::hash (lkup
), INSERT
));
15810 gcc_unreachable ();
15814 /* If we're not streaming, record that we need location LOC.
15815 Otherwise stream it. */
15818 module_state::write_location (bytes_out
&sec
, location_t loc
)
15820 if (!sec
.streaming_p ())
15822 note_location (loc
);
15826 if (loc
< RESERVED_LOCATION_COUNT
)
15828 dump (dumper::LOCATION
) && dump ("Reserved location %u", unsigned (loc
));
15829 sec
.u (LK_RESERVED
+ loc
);
15831 else if (IS_ADHOC_LOC (loc
))
15833 dump (dumper::LOCATION
) && dump ("Adhoc location");
15835 location_t locus
= get_location_from_adhoc_loc (line_table
, loc
);
15836 write_location (sec
, locus
);
15837 source_range range
= get_range_from_loc (line_table
, loc
);
15838 if (range
.m_start
== locus
)
15840 range
.m_start
= UNKNOWN_LOCATION
;
15841 write_location (sec
, range
.m_start
);
15842 write_location (sec
, range
.m_finish
);
15843 unsigned discriminator
= get_discriminator_from_adhoc_loc (line_table
, loc
);
15844 sec
.u (discriminator
);
15846 else if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
))
15848 const macro_loc_info
*info
= nullptr;
15849 unsigned offset
= 0;
15850 if (unsigned hwm
= macro_loc_remap
->length ())
15852 info
= macro_loc_remap
->begin ();
15855 unsigned mid
= hwm
/ 2;
15856 if (MAP_START_LOCATION (info
[mid
].src
) <= loc
)
15864 offset
= loc
- MAP_START_LOCATION (info
->src
);
15865 if (offset
> info
->src
->n_tokens
)
15869 gcc_checking_assert (bool (info
) == bool (spans
.macro (loc
)));
15873 offset
+= info
->remap
;
15876 dump (dumper::LOCATION
)
15877 && dump ("Macro location %u output %u", loc
, offset
);
15879 else if (const module_state
*import
= module_for_macro_loc (loc
))
15881 unsigned off
= loc
- import
->macro_locs
.first
;
15882 sec
.u (LK_IMPORT_MACRO
);
15883 sec
.u (import
->remap
);
15885 dump (dumper::LOCATION
)
15886 && dump ("Imported macro location %u output %u:%u",
15887 loc
, import
->remap
, off
);
15890 gcc_unreachable ();
15892 else if (IS_ORDINARY_LOC (loc
))
15894 const ord_loc_info
*info
= nullptr;
15895 unsigned offset
= 0;
15896 if (unsigned hwm
= ord_loc_remap
->length ())
15898 info
= ord_loc_remap
->begin ();
15901 unsigned mid
= hwm
/ 2;
15902 if (MAP_START_LOCATION (info
[mid
].src
) + info
[mid
].offset
<= loc
)
15910 offset
= loc
- MAP_START_LOCATION (info
->src
) - info
->offset
;
15911 if (offset
> info
->span
)
15915 gcc_checking_assert (bool (info
) == bool (spans
.ordinary (loc
)));
15919 offset
+= info
->remap
;
15920 sec
.u (LK_ORDINARY
);
15923 dump (dumper::LOCATION
)
15924 && dump ("Ordinary location %u output %u", loc
, offset
);
15926 else if (const module_state
*import
= module_for_ordinary_loc (loc
))
15928 unsigned off
= loc
- import
->ordinary_locs
.first
;
15929 sec
.u (LK_IMPORT_ORDINARY
);
15930 sec
.u (import
->remap
);
15932 dump (dumper::LOCATION
)
15933 && dump ("Imported ordinary location %u output %u:%u",
15934 import
->remap
, import
->remap
, off
);
15937 gcc_unreachable ();
15940 gcc_unreachable ();
15944 module_state::read_location (bytes_in
&sec
) const
15946 location_t locus
= UNKNOWN_LOCATION
;
15947 unsigned kind
= sec
.u ();
15952 if (kind
< LK_RESERVED
+ RESERVED_LOCATION_COUNT
)
15953 locus
= location_t (kind
- LK_RESERVED
);
15955 sec
.set_overrun ();
15956 dump (dumper::LOCATION
)
15957 && dump ("Reserved location %u", unsigned (locus
));
15963 dump (dumper::LOCATION
) && dump ("Adhoc location");
15964 locus
= read_location (sec
);
15965 source_range range
;
15966 range
.m_start
= read_location (sec
);
15967 if (range
.m_start
== UNKNOWN_LOCATION
)
15968 range
.m_start
= locus
;
15969 range
.m_finish
= read_location (sec
);
15970 unsigned discriminator
= sec
.u ();
15971 if (locus
!= loc
&& range
.m_start
!= loc
&& range
.m_finish
!= loc
)
15972 locus
= get_combined_adhoc_loc (line_table
, locus
, range
, NULL
, discriminator
);
15978 unsigned off
= sec
.u ();
15980 if (macro_locs
.second
)
15982 if (off
< macro_locs
.second
)
15983 locus
= off
+ macro_locs
.first
;
15985 sec
.set_overrun ();
15989 dump (dumper::LOCATION
)
15990 && dump ("Macro %u becoming %u", off
, locus
);
15996 unsigned off
= sec
.u ();
15997 if (ordinary_locs
.second
)
15999 if (off
< ordinary_locs
.second
)
16000 locus
= off
+ ordinary_locs
.first
;
16002 sec
.set_overrun ();
16007 dump (dumper::LOCATION
)
16008 && dump ("Ordinary location %u becoming %u", off
, locus
);
16012 case LK_IMPORT_MACRO
:
16013 case LK_IMPORT_ORDINARY
:
16015 unsigned mod
= sec
.u ();
16016 unsigned off
= sec
.u ();
16017 const module_state
*import
= NULL
;
16019 if (!mod
&& !slurp
->remap
)
16020 /* This is an early read of a partition location during the
16021 read of our ordinary location map. */
16025 mod
= slurp
->remap_module (mod
);
16027 sec
.set_overrun ();
16029 import
= (*modules
)[mod
];
16034 if (kind
== LK_IMPORT_MACRO
)
16036 if (!import
->macro_locs
.second
)
16037 locus
= import
->loc
;
16038 else if (off
< import
->macro_locs
.second
)
16039 locus
= off
+ import
->macro_locs
.first
;
16041 sec
.set_overrun ();
16045 if (!import
->ordinary_locs
.second
)
16046 locus
= import
->loc
;
16047 else if (off
< import
->ordinary_locs
.second
)
16048 locus
= import
->ordinary_locs
.first
+ off
;
16050 sec
.set_overrun ();
16060 /* Allocate hash tables to record needed locations. */
16063 module_state::write_init_maps ()
16065 macro_loc_table
= new hash_table
<macro_loc_traits
> (EXPERIMENT (1, 400));
16066 ord_loc_table
= new hash_table
<ord_loc_traits
> (EXPERIMENT (1, 400));
16069 /* Prepare the span adjustments. We prune unneeded locations -- at
16070 this point every needed location must have been seen by
16074 module_state::write_prepare_maps (module_state_config
*cfg
, bool has_partitions
)
16076 dump () && dump ("Preparing locations");
16079 dump () && dump ("Reserved locations [%u,%u) macro [%u,%u)",
16080 spans
[loc_spans::SPAN_RESERVED
].ordinary
.first
,
16081 spans
[loc_spans::SPAN_RESERVED
].ordinary
.second
,
16082 spans
[loc_spans::SPAN_RESERVED
].macro
.first
,
16083 spans
[loc_spans::SPAN_RESERVED
].macro
.second
);
16085 range_t info
{0, 0};
16087 // Sort the noted lines.
16088 vec_alloc (ord_loc_remap
, ord_loc_table
->size ());
16089 for (auto iter
= ord_loc_table
->begin (), end
= ord_loc_table
->end ();
16090 iter
!= end
; ++iter
)
16091 ord_loc_remap
->quick_push (*iter
);
16092 ord_loc_remap
->qsort (&ord_loc_info::compare
);
16094 // Note included-from maps.
16095 bool added
= false;
16096 const line_map_ordinary
*current
= nullptr;
16097 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16098 iter
!= end
; ++iter
)
16099 if (iter
->src
!= current
)
16101 current
= iter
->src
;
16102 for (auto probe
= current
;
16103 auto from
= linemap_included_from (probe
);
16104 probe
= linemap_check_ordinary (linemap_lookup (line_table
, from
)))
16106 if (has_partitions
)
16108 // Partition locations need to elide their module map
16111 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
16112 if (MAP_MODULE_P (probe
))
16113 from
= linemap_included_from (probe
);
16116 if (!note_location (from
))
16123 // Reconstruct the line array as we added items to the hash table.
16124 vec_free (ord_loc_remap
);
16125 vec_alloc (ord_loc_remap
, ord_loc_table
->size ());
16126 for (auto iter
= ord_loc_table
->begin (), end
= ord_loc_table
->end ();
16127 iter
!= end
; ++iter
)
16128 ord_loc_remap
->quick_push (*iter
);
16129 ord_loc_remap
->qsort (&ord_loc_info::compare
);
16131 delete ord_loc_table
;
16132 ord_loc_table
= nullptr;
16134 // Merge (sufficiently) adjacent spans, and calculate remapping.
16135 constexpr unsigned adjacency
= 2; // Allow 2 missing lines.
16136 auto begin
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16138 unsigned offset
= 0, range_bits
= 0;
16139 ord_loc_info
*base
= nullptr;
16140 for (auto iter
= begin
; iter
!= end
; ++iter
)
16142 if (base
&& iter
->src
== base
->src
)
16144 if (base
->offset
+ base
->span
+
16145 ((adjacency
<< base
->src
->m_column_and_range_bits
)
16146 // If there are few c&r bits, allow further separation.
16147 | (adjacency
<< 4))
16151 offset
-= base
->span
;
16152 base
->span
= iter
->offset
+ iter
->span
- base
->offset
;
16153 offset
+= base
->span
;
16157 else if (range_bits
< iter
->src
->m_range_bits
)
16158 range_bits
= iter
->src
->m_range_bits
;
16160 offset
+= ((1u << iter
->src
->m_range_bits
) - 1);
16161 offset
&= ~((1u << iter
->src
->m_range_bits
) - 1);
16162 iter
->remap
= offset
;
16163 offset
+= iter
->span
;
16167 ord_loc_remap
->truncate (dst
- begin
);
16169 info
.first
= ord_loc_remap
->length ();
16170 cfg
->ordinary_locs
= offset
;
16171 cfg
->loc_range_bits
= range_bits
;
16172 dump () && dump ("Ordinary maps:%u locs:%u range_bits:%u",
16173 info
.first
, cfg
->ordinary_locs
,
16174 cfg
->loc_range_bits
);
16176 // Remap the macro locations.
16177 vec_alloc (macro_loc_remap
, macro_loc_table
->size ());
16178 for (auto iter
= macro_loc_table
->begin (), end
= macro_loc_table
->end ();
16179 iter
!= end
; ++iter
)
16180 macro_loc_remap
->quick_push (*iter
);
16181 delete macro_loc_table
;
16182 macro_loc_table
= nullptr;
16184 macro_loc_remap
->qsort (¯o_loc_info::compare
);
16186 for (auto iter
= macro_loc_remap
->begin (), end
= macro_loc_remap
->end ();
16187 iter
!= end
; ++iter
)
16189 auto mac
= iter
->src
;
16190 iter
->remap
= offset
;
16191 offset
+= mac
->n_tokens
;
16193 info
.second
= macro_loc_remap
->length ();
16194 cfg
->macro_locs
= offset
;
16196 dump () && dump ("Macro maps:%u locs:%u", info
.second
, cfg
->macro_locs
);
16200 // If we have no ordinary locs, we must also have no macro locs.
16201 gcc_checking_assert (cfg
->ordinary_locs
|| !cfg
->macro_locs
);
16207 module_state::read_prepare_maps (const module_state_config
*cfg
)
16209 location_t ordinary
= line_table
->highest_location
+ 1;
16210 ordinary
+= cfg
->ordinary_locs
;
16212 location_t macro
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
16213 macro
-= cfg
->macro_locs
;
16215 if (ordinary
< LINE_MAP_MAX_LOCATION_WITH_COLS
16216 && macro
>= LINE_MAP_MAX_LOCATION
)
16217 /* OK, we have enough locations. */
16220 ordinary_locs
.first
= ordinary_locs
.second
= 0;
16221 macro_locs
.first
= macro_locs
.second
= 0;
16223 static bool informed
= false;
16226 /* Just give the notice once. */
16228 inform (loc
, "unable to represent further imported source locations");
16234 /* Write & read the location maps. Not called if there are no
16238 module_state::write_ordinary_maps (elf_out
*to
, range_t
&info
,
16239 bool has_partitions
, unsigned *crc_p
)
16241 dump () && dump ("Writing ordinary location maps");
16244 vec
<const char *> filenames
;
16245 filenames
.create (20);
16247 /* Determine the unique filenames. */
16248 const line_map_ordinary
*current
= nullptr;
16249 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16250 iter
!= end
; ++iter
)
16251 if (iter
->src
!= current
)
16253 current
= iter
->src
;
16254 const char *fname
= ORDINARY_MAP_FILE_NAME (iter
->src
);
16256 /* We should never find a module linemap in an interval. */
16257 gcc_checking_assert (!MAP_MODULE_P (iter
->src
));
16259 /* We expect very few filenames, so just an array.
16260 (Not true when headers are still in play :() */
16261 for (unsigned jx
= filenames
.length (); jx
--;)
16263 const char *name
= filenames
[jx
];
16264 if (0 == strcmp (name
, fname
))
16266 /* Reset the linemap's name, because for things like
16267 preprocessed input we could have multiple instances
16268 of the same name, and we'd rather not percolate
16270 const_cast<line_map_ordinary
*> (iter
->src
)->to_file
= name
;
16276 filenames
.safe_push (fname
);
16279 bytes_out
sec (to
);
16282 /* Write the filenames. */
16283 unsigned len
= filenames
.length ();
16285 dump () && dump ("%u source file names", len
);
16286 for (unsigned ix
= 0; ix
!= len
; ix
++)
16288 const char *fname
= filenames
[ix
];
16289 dump (dumper::LOCATION
) && dump ("Source file[%u]=%s", ix
, fname
);
16293 sec
.u (info
.first
); /* Num maps. */
16294 const ord_loc_info
*base
= nullptr;
16295 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16296 iter
!= end
; ++iter
)
16298 dump (dumper::LOCATION
)
16299 && dump ("Span:%u ordinary [%u+%u,+%u)->[%u,+%u)",
16300 iter
- ord_loc_remap
->begin (),
16301 MAP_START_LOCATION (iter
->src
), iter
->offset
, iter
->span
,
16302 iter
->remap
, iter
->span
);
16304 if (!base
|| iter
->src
!= base
->src
)
16306 sec
.u (iter
->offset
- base
->offset
);
16309 sec
.u (iter
->src
->sysp
);
16310 sec
.u (iter
->src
->m_range_bits
);
16311 sec
.u (iter
->src
->m_column_and_range_bits
- iter
->src
->m_range_bits
);
16313 const char *fname
= ORDINARY_MAP_FILE_NAME (iter
->src
);
16314 for (unsigned ix
= 0; ix
!= filenames
.length (); ix
++)
16315 if (filenames
[ix
] == fname
)
16320 unsigned line
= ORDINARY_MAP_STARTING_LINE_NUMBER (iter
->src
);
16321 line
+= iter
->offset
>> iter
->src
->m_column_and_range_bits
;
16324 sec
.u (iter
->remap
);
16327 /* Write the included from location, which means reading it
16328 while reading in the ordinary maps. So we'd better not
16329 be getting ahead of ourselves. */
16330 location_t from
= linemap_included_from (iter
->src
);
16331 gcc_checking_assert (from
< MAP_START_LOCATION (iter
->src
));
16332 if (from
!= UNKNOWN_LOCATION
&& has_partitions
)
16334 /* A partition's span will have a from pointing at a
16335 MODULE_INC. Find that map's from. */
16336 line_map_ordinary
const *fmap
16337 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
16338 if (MAP_MODULE_P (fmap
))
16339 from
= linemap_included_from (fmap
);
16341 write_location (sec
, from
);
16345 filenames
.release ();
16347 sec
.end (to
, to
->name (MOD_SNAME_PFX
".olm"), crc_p
);
16352 module_state::write_macro_maps (elf_out
*to
, range_t
&info
, unsigned *crc_p
)
16354 dump () && dump ("Writing macro location maps");
16357 bytes_out
sec (to
);
16360 dump () && dump ("Macro maps:%u", info
.second
);
16361 sec
.u (info
.second
);
16363 unsigned macro_num
= 0;
16364 for (auto iter
= macro_loc_remap
->end (), begin
= macro_loc_remap
->begin ();
16367 auto mac
= iter
->src
;
16368 sec
.u (iter
->remap
);
16369 sec
.u (mac
->n_tokens
);
16370 sec
.cpp_node (mac
->macro
);
16371 write_location (sec
, mac
->expansion
);
16372 const location_t
*locs
= mac
->macro_locations
;
16373 /* There are lots of identical runs. */
16374 location_t prev
= UNKNOWN_LOCATION
;
16375 unsigned count
= 0;
16377 for (unsigned jx
= mac
->n_tokens
* 2; jx
--;)
16379 location_t tok_loc
= locs
[jx
];
16380 if (tok_loc
== prev
)
16389 write_location (sec
, tok_loc
);
16392 dump (dumper::LOCATION
)
16393 && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)->%u",
16394 macro_num
, identifier (mac
->macro
),
16395 runs
, mac
->n_tokens
,
16396 MAP_START_LOCATION (mac
),
16397 MAP_START_LOCATION (mac
) + mac
->n_tokens
,
16401 gcc_assert (macro_num
== info
.second
);
16403 sec
.end (to
, to
->name (MOD_SNAME_PFX
".mlm"), crc_p
);
16408 module_state::read_ordinary_maps (unsigned num_ord_locs
, unsigned range_bits
)
16412 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".olm"))
16414 dump () && dump ("Reading ordinary location maps");
16417 /* Read the filename table. */
16418 unsigned len
= sec
.u ();
16419 dump () && dump ("%u source file names", len
);
16420 vec
<const char *> filenames
;
16421 filenames
.create (len
);
16422 for (unsigned ix
= 0; ix
!= len
; ix
++)
16425 const char *buf
= sec
.str (&l
);
16426 char *fname
= XNEWVEC (char, l
+ 1);
16427 memcpy (fname
, buf
, l
+ 1);
16428 dump (dumper::LOCATION
) && dump ("Source file[%u]=%s", ix
, fname
);
16429 /* We leak these names into the line-map table. But it
16430 doesn't own them. */
16431 filenames
.quick_push (fname
);
16434 unsigned num_ordinary
= sec
.u ();
16435 dump () && dump ("Ordinary maps:%u, range_bits:%u", num_ordinary
, range_bits
);
16437 location_t offset
= line_table
->highest_location
+ 1;
16438 offset
+= ((1u << range_bits
) - 1);
16439 offset
&= ~((1u << range_bits
) - 1);
16440 ordinary_locs
.first
= offset
;
16442 bool propagated
= spans
.maybe_propagate (this, offset
);
16443 line_map_ordinary
*maps
= static_cast<line_map_ordinary
*>
16444 (line_map_new_raw (line_table
, false, num_ordinary
));
16446 const line_map_ordinary
*base
= nullptr;
16447 for (unsigned ix
= 0; ix
!= num_ordinary
&& !sec
.get_overrun (); ix
++)
16449 line_map_ordinary
*map
= &maps
[ix
];
16451 unsigned offset
= sec
.u ();
16454 map
->reason
= LC_RENAME
;
16455 map
->sysp
= sec
.u ();
16456 map
->m_range_bits
= sec
.u ();
16457 map
->m_column_and_range_bits
= sec
.u () + map
->m_range_bits
;
16458 unsigned fnum
= sec
.u ();
16459 map
->to_file
= (fnum
< filenames
.length () ? filenames
[fnum
] : "");
16460 map
->to_line
= sec
.u ();
16466 map
->to_line
+= offset
>> map
->m_column_and_range_bits
;
16468 unsigned remap
= sec
.u ();
16469 map
->start_location
= remap
+ ordinary_locs
.first
;
16472 /* Root the outermost map at our location. */
16473 ordinary_locs
.second
= remap
;
16474 location_t from
= read_location (sec
);
16475 map
->included_from
= from
!= UNKNOWN_LOCATION
? from
: loc
;
16479 ordinary_locs
.second
= num_ord_locs
;
16480 /* highest_location is the one handed out, not the next one to
16482 line_table
->highest_location
= ordinary_locs
.first
+ ordinary_locs
.second
- 1;
16484 if (line_table
->highest_location
>= LINE_MAP_MAX_LOCATION_WITH_COLS
)
16485 /* We shouldn't run out of locations, as we checked before
16487 sec
.set_overrun ();
16488 dump () && dump ("Ordinary location [%u,+%u)",
16489 ordinary_locs
.first
, ordinary_locs
.second
);
16494 filenames
.release ();
16497 if (!sec
.end (from ()))
16504 module_state::read_macro_maps (unsigned num_macro_locs
)
16508 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".mlm"))
16510 dump () && dump ("Reading macro location maps");
16513 unsigned num_macros
= sec
.u ();
16514 dump () && dump ("Macro maps:%u locs:%u", num_macros
, num_macro_locs
);
16516 bool propagated
= spans
.maybe_propagate (this,
16517 line_table
->highest_location
+ 1);
16519 location_t offset
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
16520 macro_locs
.second
= num_macro_locs
;
16521 macro_locs
.first
= offset
- num_macro_locs
;
16523 dump () && dump ("Macro loc delta %d", offset
);
16524 dump () && dump ("Macro locations [%u,%u)",
16525 macro_locs
.first
, macro_locs
.second
);
16527 for (unsigned ix
= 0; ix
!= num_macros
&& !sec
.get_overrun (); ix
++)
16529 unsigned offset
= sec
.u ();
16530 unsigned n_tokens
= sec
.u ();
16531 cpp_hashnode
*node
= sec
.cpp_node ();
16532 location_t exp_loc
= read_location (sec
);
16534 const line_map_macro
*macro
16535 = linemap_enter_macro (line_table
, node
, exp_loc
, n_tokens
);
16537 /* We shouldn't run out of locations, as we checked that we
16538 had enough before starting. */
16540 gcc_checking_assert (MAP_START_LOCATION (macro
)
16541 == offset
+ macro_locs
.first
);
16543 location_t
*locs
= macro
->macro_locations
;
16544 location_t tok_loc
= UNKNOWN_LOCATION
;
16545 unsigned count
= sec
.u ();
16547 for (unsigned jx
= macro
->n_tokens
* 2; jx
-- && !sec
.get_overrun ();)
16549 while (!count
-- && !sec
.get_overrun ())
16552 tok_loc
= read_location (sec
);
16555 locs
[jx
] = tok_loc
;
16558 sec
.set_overrun ();
16559 dump (dumper::LOCATION
)
16560 && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)",
16561 ix
, identifier (node
), runs
, n_tokens
,
16562 MAP_START_LOCATION (macro
),
16563 MAP_START_LOCATION (macro
) + n_tokens
);
16566 dump () && dump ("Macro location lwm:%u", macro_locs
.first
);
16571 if (!sec
.end (from ()))
16577 /* Serialize the definition of MACRO. */
16580 module_state::write_define (bytes_out
&sec
, const cpp_macro
*macro
)
16582 sec
.u (macro
->count
);
16584 sec
.b (macro
->fun_like
);
16585 sec
.b (macro
->variadic
);
16586 sec
.b (macro
->syshdr
);
16589 write_location (sec
, macro
->line
);
16590 if (macro
->fun_like
)
16592 sec
.u (macro
->paramc
);
16593 const cpp_hashnode
*const *parms
= macro
->parm
.params
;
16594 for (unsigned ix
= 0; ix
!= macro
->paramc
; ix
++)
16595 sec
.cpp_node (parms
[ix
]);
16599 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
16601 const cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16602 write_location (sec
, token
->src_loc
);
16603 sec
.u (token
->type
);
16604 sec
.u (token
->flags
);
16605 switch (cpp_token_val_index (token
))
16608 gcc_unreachable ();
16610 case CPP_TOKEN_FLD_ARG_NO
:
16611 /* An argument reference. */
16612 sec
.u (token
->val
.macro_arg
.arg_no
);
16613 sec
.cpp_node (token
->val
.macro_arg
.spelling
);
16616 case CPP_TOKEN_FLD_NODE
:
16617 /* An identifier. */
16618 sec
.cpp_node (token
->val
.node
.node
);
16619 if (token
->val
.node
.spelling
== token
->val
.node
.node
)
16620 /* The spelling will usually be the same. so optimize
16624 sec
.cpp_node (token
->val
.node
.spelling
);
16627 case CPP_TOKEN_FLD_NONE
:
16630 case CPP_TOKEN_FLD_STR
:
16631 /* A string, number or comment. Not always NUL terminated,
16632 we stream out in a single contatenation with embedded
16633 NULs as that's a safe default. */
16634 len
+= token
->val
.str
.len
+ 1;
16635 sec
.u (token
->val
.str
.len
);
16638 case CPP_TOKEN_FLD_SOURCE
:
16639 case CPP_TOKEN_FLD_TOKEN_NO
:
16640 case CPP_TOKEN_FLD_PRAGMA
:
16641 /* These do not occur inside a macro itself. */
16642 gcc_unreachable ();
16648 char *ptr
= reinterpret_cast<char *> (sec
.buf (len
));
16650 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
16652 const cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16653 if (cpp_token_val_index (token
) == CPP_TOKEN_FLD_STR
)
16655 memcpy (ptr
+ len
, token
->val
.str
.text
,
16656 token
->val
.str
.len
);
16657 len
+= token
->val
.str
.len
;
16664 /* Read a macro definition. */
16667 module_state::read_define (bytes_in
&sec
, cpp_reader
*reader
) const
16669 unsigned count
= sec
.u ();
16670 /* We rely on knowing cpp_reader's hash table is ident_hash, and
16671 its subobject allocator is stringpool_ggc_alloc and that is just
16672 a wrapper for ggc_alloc_atomic. */
16674 = (cpp_macro
*)ggc_alloc_atomic (sizeof (cpp_macro
)
16675 + sizeof (cpp_token
) * (count
- !!count
));
16676 memset (macro
, 0, sizeof (cpp_macro
) + sizeof (cpp_token
) * (count
- !!count
));
16678 macro
->count
= count
;
16679 macro
->kind
= cmk_macro
;
16680 macro
->imported_p
= true;
16682 macro
->fun_like
= sec
.b ();
16683 macro
->variadic
= sec
.b ();
16684 macro
->syshdr
= sec
.b ();
16687 macro
->line
= read_location (sec
);
16689 if (macro
->fun_like
)
16691 unsigned paramc
= sec
.u ();
16692 cpp_hashnode
**params
16693 = (cpp_hashnode
**)ggc_alloc_atomic (sizeof (cpp_hashnode
*) * paramc
);
16694 macro
->paramc
= paramc
;
16695 macro
->parm
.params
= params
;
16696 for (unsigned ix
= 0; ix
!= paramc
; ix
++)
16697 params
[ix
] = sec
.cpp_node ();
16701 for (unsigned ix
= 0; ix
!= count
&& !sec
.get_overrun (); ix
++)
16703 cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16704 token
->src_loc
= read_location (sec
);
16705 token
->type
= cpp_ttype (sec
.u ());
16706 token
->flags
= sec
.u ();
16707 switch (cpp_token_val_index (token
))
16710 sec
.set_overrun ();
16713 case CPP_TOKEN_FLD_ARG_NO
:
16714 /* An argument reference. */
16716 unsigned arg_no
= sec
.u ();
16717 if (arg_no
- 1 >= macro
->paramc
)
16718 sec
.set_overrun ();
16719 token
->val
.macro_arg
.arg_no
= arg_no
;
16720 token
->val
.macro_arg
.spelling
= sec
.cpp_node ();
16724 case CPP_TOKEN_FLD_NODE
:
16725 /* An identifier. */
16726 token
->val
.node
.node
= sec
.cpp_node ();
16727 token
->val
.node
.spelling
= sec
.cpp_node ();
16728 if (!token
->val
.node
.spelling
)
16729 token
->val
.node
.spelling
= token
->val
.node
.node
;
16732 case CPP_TOKEN_FLD_NONE
:
16735 case CPP_TOKEN_FLD_STR
:
16736 /* A string, number or comment. */
16737 token
->val
.str
.len
= sec
.u ();
16738 len
+= token
->val
.str
.len
+ 1;
16744 if (const char *ptr
= reinterpret_cast<const char *> (sec
.buf (len
)))
16746 /* There should be a final NUL. */
16748 sec
.set_overrun ();
16749 /* cpp_alloc_token_string will add a final NUL. */
16750 const unsigned char *buf
16751 = cpp_alloc_token_string (reader
, (const unsigned char *)ptr
, len
- 1);
16753 for (unsigned ix
= 0; ix
!= count
&& !sec
.get_overrun (); ix
++)
16755 cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16756 if (cpp_token_val_index (token
) == CPP_TOKEN_FLD_STR
)
16758 token
->val
.str
.text
= buf
+ len
;
16759 len
+= token
->val
.str
.len
;
16761 sec
.set_overrun ();
16766 if (sec
.get_overrun ())
16771 /* Exported macro data. */
16772 struct GTY(()) macro_export
{
16774 location_t undef_loc
;
16777 :def (NULL
), undef_loc (UNKNOWN_LOCATION
)
16782 /* Imported macro data. */
16783 class macro_import
{
16786 #if defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8
16789 /* We need to ensure we don't use the LSB for representation, as
16790 that's the union discriminator below. */
16793 #if !(defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8)
16806 /* Not a regular ctor, because we put it in a union, and that's
16807 not allowed in C++ 98. */
16808 static slot
ctor (unsigned module
, unsigned defness
)
16810 gcc_checking_assert (defness
);
16812 s
.bits
= defness
| (module
<< L_MODULE_SHIFT
);
16818 unsigned get_defness () const
16820 return bits
& L_BOTH
;
16822 unsigned get_module () const
16824 return bits
>> L_MODULE_SHIFT
;
16826 void become_undef ()
16828 bits
&= ~unsigned (L_DEF
);
16829 bits
|= unsigned (L_UNDEF
);
16834 typedef vec
<slot
, va_heap
, vl_embed
> ary_t
;
16836 /* Discriminated by bits 0|1 != 0. The expected case is that
16837 there will be exactly one slot per macro, hence the effort of
16850 bool single_p () const
16852 return u
.single
.bits
& slot::L_BOTH
;
16854 bool occupied_p () const
16856 return u
.ary
!= NULL
;
16860 unsigned length () const
16862 gcc_checking_assert (occupied_p ());
16863 return single_p () ? 1 : u
.ary
->length ();
16865 slot
&operator[] (unsigned ix
)
16867 gcc_checking_assert (occupied_p ());
16870 gcc_checking_assert (!ix
);
16874 return (*u
.ary
)[ix
];
16879 slot
&append (unsigned module
, unsigned defness
);
16882 /* O is a new import to append to the list for. If we're an empty
16883 set, initialize us. */
16885 macro_import::slot
&
16886 macro_import::append (unsigned module
, unsigned defness
)
16888 if (!occupied_p ())
16890 u
.single
= slot::ctor (module
, defness
);
16895 bool single
= single_p ();
16896 ary_t
*m
= single
? NULL
: u
.ary
;
16897 vec_safe_reserve (m
, 1 + single
);
16899 m
->quick_push (u
.single
);
16901 return *u
.ary
->quick_push (slot::ctor (module
, defness
));
16905 /* We're going to export something. Make sure the first import slot
16908 macro_import::slot
&
16909 macro_import::exported ()
16911 if (occupied_p () && !(*this)[0].get_module ())
16913 slot
&res
= (*this)[0];
16914 res
.bits
|= slot::L_DEF
;
16918 slot
*a
= &append (0, slot::L_DEF
);
16921 slot
&f
= (*this)[0];
16928 /* The import (&exported) macros. cpp_hasnode's deferred field
16929 indexes this array (offset by 1, so zero means 'not present'. */
16931 static vec
<macro_import
, va_heap
, vl_embed
> *macro_imports
;
16933 /* The exported macros. A macro_import slot's zeroth element's offset
16934 indexes this array. If the zeroth slot is not for module zero,
16935 there is no export. */
16937 static GTY(()) vec
<macro_export
, va_gc
> *macro_exports
;
16939 /* The reachable set of header imports from this TU. */
16941 static GTY(()) bitmap headers
;
16943 /* Get the (possibly empty) macro imports for NODE. */
16945 static macro_import
&
16946 get_macro_imports (cpp_hashnode
*node
)
16948 if (node
->deferred
)
16949 return (*macro_imports
)[node
->deferred
- 1];
16951 vec_safe_reserve (macro_imports
, 1);
16952 node
->deferred
= macro_imports
->length () + 1;
16953 return *vec_safe_push (macro_imports
, macro_import ());
16956 /* Get the macro export for export EXP of NODE. */
16958 static macro_export
&
16959 get_macro_export (macro_import::slot
&slot
)
16961 if (slot
.offset
>= 0)
16962 return (*macro_exports
)[slot
.offset
];
16964 vec_safe_reserve (macro_exports
, 1);
16965 slot
.offset
= macro_exports
->length ();
16966 return *macro_exports
->quick_push (macro_export ());
16969 /* If NODE is an exportable macro, add it to the export set. */
16972 maybe_add_macro (cpp_reader
*, cpp_hashnode
*node
, void *data_
)
16974 bool exporting
= false;
16976 if (cpp_user_macro_p (node
))
16977 if (cpp_macro
*macro
= node
->value
.macro
)
16978 /* Ignore imported, builtins, command line and forced header macros. */
16979 if (!macro
->imported_p
16980 && !macro
->lazy
&& macro
->line
>= spans
.main_start ())
16982 gcc_checking_assert (macro
->kind
== cmk_macro
);
16983 /* I don't want to deal with this corner case, that I suspect is
16984 a devil's advocate reading of the standard. */
16985 gcc_checking_assert (!macro
->extra_tokens
);
16987 macro_import::slot
&slot
= get_macro_imports (node
).exported ();
16988 macro_export
&exp
= get_macro_export (slot
);
16993 if (!exporting
&& node
->deferred
)
16995 macro_import
&imports
= (*macro_imports
)[node
->deferred
- 1];
16996 macro_import::slot
&slot
= imports
[0];
16997 if (!slot
.get_module ())
16999 gcc_checking_assert (slot
.get_defness ());
17005 static_cast<vec
<cpp_hashnode
*> *> (data_
)->safe_push (node
);
17007 return 1; /* Don't stop. */
17010 /* Order cpp_hashnodes A_ and B_ by their exported macro locations. */
17013 macro_loc_cmp (const void *a_
, const void *b_
)
17015 const cpp_hashnode
*node_a
= *(const cpp_hashnode
*const *)a_
;
17016 macro_import
&import_a
= (*macro_imports
)[node_a
->deferred
- 1];
17017 const macro_export
&export_a
= (*macro_exports
)[import_a
[0].offset
];
17018 location_t loc_a
= export_a
.def
? export_a
.def
->line
: export_a
.undef_loc
;
17020 const cpp_hashnode
*node_b
= *(const cpp_hashnode
*const *)b_
;
17021 macro_import
&import_b
= (*macro_imports
)[node_b
->deferred
- 1];
17022 const macro_export
&export_b
= (*macro_exports
)[import_b
[0].offset
];
17023 location_t loc_b
= export_b
.def
? export_b
.def
->line
: export_b
.undef_loc
;
17027 else if (loc_a
> loc_b
)
17033 /* Gather the macro definitions and undefinitions that we will need to
17036 vec
<cpp_hashnode
*> *
17037 module_state::prepare_macros (cpp_reader
*reader
)
17039 vec
<cpp_hashnode
*> *macros
;
17040 vec_alloc (macros
, 100);
17042 cpp_forall_identifiers (reader
, maybe_add_macro
, macros
);
17044 dump (dumper::MACRO
) && dump ("No more than %u macros", macros
->length ());
17046 macros
->qsort (macro_loc_cmp
);
17048 // Note the locations.
17049 for (unsigned ix
= macros
->length (); ix
--;)
17051 cpp_hashnode
*node
= (*macros
)[ix
];
17052 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17053 macro_export
&mac
= (*macro_exports
)[slot
.offset
];
17055 if (IDENTIFIER_KEYWORD_P (identifier (node
)))
17058 if (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17059 note_location (mac
.undef_loc
);
17062 note_location (mac
.def
->line
);
17063 for (unsigned ix
= 0; ix
!= mac
.def
->count
; ix
++)
17064 note_location (mac
.def
->exp
.tokens
[ix
].src_loc
);
17071 /* Write out the exported defines. This is two sections, one
17072 containing the definitions, the other a table of node names. */
17075 module_state::write_macros (elf_out
*to
, vec
<cpp_hashnode
*> *macros
,
17078 dump () && dump ("Writing macros");
17081 /* Write the defs */
17082 bytes_out
sec (to
);
17085 unsigned count
= 0;
17086 for (unsigned ix
= macros
->length (); ix
--;)
17088 cpp_hashnode
*node
= (*macros
)[ix
];
17089 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17090 gcc_assert (!slot
.get_module () && slot
.get_defness ());
17092 macro_export
&mac
= (*macro_exports
)[slot
.offset
];
17093 gcc_assert (!!(slot
.get_defness () & macro_import::slot::L_UNDEF
)
17094 == (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17095 && !!(slot
.get_defness () & macro_import::slot::L_DEF
)
17096 == (mac
.def
!= NULL
));
17098 if (IDENTIFIER_KEYWORD_P (identifier (node
)))
17100 warning_at (mac
.def
->line
, 0,
17101 "not exporting %<#define %E%> as it is a keyword",
17102 identifier (node
));
17108 slot
.offset
= sec
.pos
;
17109 dump (dumper::MACRO
)
17110 && dump ("Writing macro %s%s%s %I at %u",
17111 slot
.get_defness () & macro_import::slot::L_UNDEF
17113 slot
.get_defness () == macro_import::slot::L_BOTH
17115 slot
.get_defness () & macro_import::slot::L_DEF
17117 identifier (node
), slot
.offset
);
17118 if (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17119 write_location (sec
, mac
.undef_loc
);
17121 write_define (sec
, mac
.def
);
17124 // We may have ended on a tokenless macro with a very short
17125 // location, that will cause problems reading its bit flags.
17127 sec
.end (to
, to
->name (MOD_SNAME_PFX
".def"), crc_p
);
17131 /* Write the table. */
17132 bytes_out
sec (to
);
17136 for (unsigned ix
= macros
->length (); ix
--;)
17138 const cpp_hashnode
*node
= (*macros
)[ix
];
17139 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17143 sec
.cpp_node (node
);
17144 sec
.u (slot
.get_defness ());
17145 sec
.u (slot
.offset
);
17148 sec
.end (to
, to
->name (MOD_SNAME_PFX
".mac"), crc_p
);
17156 module_state::read_macros ()
17158 /* Get the def section. */
17159 if (!slurp
->macro_defs
.begin (loc
, from (), MOD_SNAME_PFX
".def"))
17162 /* Get the tbl section, if there are defs. */
17163 if (slurp
->macro_defs
.more_p ()
17164 && !slurp
->macro_tbl
.begin (loc
, from (), MOD_SNAME_PFX
".mac"))
17170 /* Install the macro name table. */
17173 module_state::install_macros ()
17175 bytes_in
&sec
= slurp
->macro_tbl
;
17179 dump () && dump ("Reading macro table %M", this);
17182 unsigned count
= sec
.u ();
17183 dump () && dump ("%u macros", count
);
17186 cpp_hashnode
*node
= sec
.cpp_node ();
17187 macro_import
&imp
= get_macro_imports (node
);
17188 unsigned flags
= sec
.u () & macro_import::slot::L_BOTH
;
17190 sec
.set_overrun ();
17192 if (sec
.get_overrun ())
17195 macro_import::slot
&slot
= imp
.append (mod
, flags
);
17196 slot
.offset
= sec
.u ();
17198 dump (dumper::MACRO
)
17199 && dump ("Read %s macro %s%s%s %I at %u",
17200 imp
.length () > 1 ? "add" : "new",
17201 flags
& macro_import::slot::L_UNDEF
? "#undef" : "",
17202 flags
== macro_import::slot::L_BOTH
? " & " : "",
17203 flags
& macro_import::slot::L_DEF
? "#define" : "",
17204 identifier (node
), slot
.offset
);
17206 /* We'll leak an imported definition's TOKEN_FLD_STR's data
17207 here. But that only happens when we've had to resolve the
17208 deferred macro before this import -- why are you doing
17210 if (cpp_macro
*cur
= cpp_set_deferred_macro (node
))
17211 if (!cur
->imported_p
)
17213 macro_import::slot
&slot
= imp
.exported ();
17214 macro_export
&exp
= get_macro_export (slot
);
17216 dump (dumper::MACRO
)
17217 && dump ("Saving current #define %I", identifier (node
));
17221 /* We're now done with the table. */
17222 elf_in::release (slurp
->from
, sec
);
17227 /* Import the transitive macros. */
17230 module_state::import_macros ()
17232 bitmap_ior_into (headers
, slurp
->headers
);
17234 bitmap_iterator bititer
;
17236 EXECUTE_IF_SET_IN_BITMAP (slurp
->headers
, 0, bitnum
, bititer
)
17237 (*modules
)[bitnum
]->install_macros ();
17240 /* NODE is being undefined at LOC. Record it in the export table, if
17244 module_state::undef_macro (cpp_reader
*, location_t loc
, cpp_hashnode
*node
)
17246 if (!node
->deferred
)
17247 /* The macro is not imported, so our undef is irrelevant. */
17250 unsigned n
= dump
.push (NULL
);
17252 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1].exported ();
17253 macro_export
&exp
= get_macro_export (slot
);
17255 exp
.undef_loc
= loc
;
17256 slot
.become_undef ();
17259 dump (dumper::MACRO
) && dump ("Recording macro #undef %I", identifier (node
));
17264 /* NODE is a deferred macro node. Determine the definition and return
17265 it, with NULL if undefined. May issue diagnostics.
17267 This can leak memory, when merging declarations -- the string
17268 contents (TOKEN_FLD_STR) of each definition are allocated in
17269 unreclaimable cpp objstack. Only one will win. However, I do not
17270 expect this to be common -- mostly macros have a single point of
17271 definition. Perhaps we could restore the objstack to its position
17272 after the first imported definition (if that wins)? The macros
17273 themselves are GC'd. */
17276 module_state::deferred_macro (cpp_reader
*reader
, location_t loc
,
17277 cpp_hashnode
*node
)
17279 macro_import
&imports
= (*macro_imports
)[node
->deferred
- 1];
17281 unsigned n
= dump
.push (NULL
);
17282 dump (dumper::MACRO
) && dump ("Deferred macro %I", identifier (node
));
17284 bitmap
visible (BITMAP_GGC_ALLOC ());
17286 if (!((imports
[0].get_defness () & macro_import::slot::L_UNDEF
)
17287 && !imports
[0].get_module ()))
17289 /* Calculate the set of visible header imports. */
17290 bitmap_copy (visible
, headers
);
17291 for (unsigned ix
= imports
.length (); ix
--;)
17293 const macro_import::slot
&slot
= imports
[ix
];
17294 unsigned mod
= slot
.get_module ();
17295 if ((slot
.get_defness () & macro_import::slot::L_UNDEF
)
17296 && bitmap_bit_p (visible
, mod
))
17298 bitmap arg
= mod
? (*modules
)[mod
]->slurp
->headers
: headers
;
17299 bitmap_and_compl_into (visible
, arg
);
17300 bitmap_set_bit (visible
, mod
);
17304 bitmap_set_bit (visible
, 0);
17306 /* Now find the macros that are still visible. */
17307 bool failed
= false;
17308 cpp_macro
*def
= NULL
;
17309 vec
<macro_export
> defs
;
17310 defs
.create (imports
.length ());
17311 for (unsigned ix
= imports
.length (); ix
--;)
17313 const macro_import::slot
&slot
= imports
[ix
];
17314 unsigned mod
= slot
.get_module ();
17315 if (bitmap_bit_p (visible
, mod
))
17317 macro_export
*pushed
= NULL
;
17320 const module_state
*imp
= (*modules
)[mod
];
17321 bytes_in
&sec
= imp
->slurp
->macro_defs
;
17322 if (!sec
.get_overrun ())
17324 dump (dumper::MACRO
)
17325 && dump ("Reading macro %s%s%s %I module %M at %u",
17326 slot
.get_defness () & macro_import::slot::L_UNDEF
17328 slot
.get_defness () == macro_import::slot::L_BOTH
17330 slot
.get_defness () & macro_import::slot::L_DEF
17332 identifier (node
), imp
, slot
.offset
);
17333 sec
.random_access (slot
.offset
);
17336 if (slot
.get_defness () & macro_import::slot::L_UNDEF
)
17337 exp
.undef_loc
= imp
->read_location (sec
);
17338 if (slot
.get_defness () & macro_import::slot::L_DEF
)
17339 exp
.def
= imp
->read_define (sec
, reader
);
17340 if (sec
.get_overrun ())
17341 error_at (loc
, "macro definitions of %qE corrupted",
17344 pushed
= defs
.quick_push (exp
);
17348 pushed
= defs
.quick_push ((*macro_exports
)[slot
.offset
]);
17349 if (pushed
&& pushed
->def
)
17353 else if (cpp_compare_macros (def
, pushed
->def
))
17361 /* If LOC is the first loc, this is the end of file check, which
17363 if (loc
== MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0)))
17364 warning_at (loc
, OPT_Winvalid_imported_macros
,
17365 "inconsistent imported macro definition %qE",
17366 identifier (node
));
17368 error_at (loc
, "inconsistent imported macro definition %qE",
17369 identifier (node
));
17370 for (unsigned ix
= defs
.length (); ix
--;)
17372 macro_export
&exp
= defs
[ix
];
17374 inform (exp
.undef_loc
, "%<#undef %E%>", identifier (node
));
17376 inform (exp
.def
->line
, "%<#define %s%>",
17377 cpp_macro_definition (reader
, node
, exp
.def
));
17389 /* Stream the static aggregates. Sadly some headers (ahem:
17390 iostream) contain static vars, and rely on them to run global
17393 module_state::write_inits (elf_out
*to
, depset::hash
&table
, unsigned *crc_ptr
)
17395 if (!static_aggregates
&& !tls_aggregates
)
17398 dump () && dump ("Writing initializers");
17401 static_aggregates
= nreverse (static_aggregates
);
17402 tls_aggregates
= nreverse (tls_aggregates
);
17404 unsigned count
= 0;
17405 trees_out
sec (to
, this, table
, ~0u);
17408 tree list
= static_aggregates
;
17409 for (int passes
= 0; passes
!= 2; passes
++)
17411 for (tree init
= list
; init
; init
= TREE_CHAIN (init
), count
++)
17412 if (TREE_LANG_FLAG_0 (init
))
17414 tree decl
= TREE_VALUE (init
);
17416 dump ("Initializer:%u for %N", count
, decl
);
17417 sec
.tree_node (decl
);
17420 list
= tls_aggregates
;
17423 sec
.end (to
, to
->name (MOD_SNAME_PFX
".ini"), crc_ptr
);
17429 /* We have to defer some post-load processing until we've completed
17430 reading, because they can cause more reading. */
17433 post_load_processing ()
17435 /* We mustn't cause a GC, our caller should have arranged for that
17437 gcc_checking_assert (function_depth
);
17439 if (!post_load_decls
)
17442 tree old_cfd
= current_function_decl
;
17443 struct function
*old_cfun
= cfun
;
17444 while (post_load_decls
->length ())
17446 tree decl
= post_load_decls
->pop ();
17448 dump () && dump ("Post-load processing of %N", decl
);
17450 gcc_checking_assert (DECL_ABSTRACT_P (decl
));
17451 /* Cloning can cause loading -- specifically operator delete for
17452 the deleting dtor. */
17453 maybe_clone_body (decl
);
17457 current_function_decl
= old_cfd
;
17461 module_state::read_inits (unsigned count
)
17463 trees_in
sec (this);
17464 if (!sec
.begin (loc
, from (), from ()->find (MOD_SNAME_PFX
".ini")))
17466 dump () && dump ("Reading %u initializers", count
);
17470 for (unsigned ix
= 0; ix
!= count
; ix
++)
17472 /* Merely referencing the decl causes its initializer to be read
17473 and added to the correct list. */
17474 tree decl
= sec
.tree_node ();
17476 if (sec
.get_overrun ())
17479 dump ("Initializer:%u for %N", count
, decl
);
17482 post_load_processing ();
17484 if (!sec
.end (from ()))
17490 module_state::write_counts (elf_out
*to
, unsigned counts
[MSC_HWM
],
17493 bytes_out
cfg (to
);
17497 for (unsigned ix
= MSC_HWM
; ix
--;)
17498 cfg
.u (counts
[ix
]);
17502 dump ("Cluster sections are [%u,%u)",
17503 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]);
17504 dump ("Bindings %u", counts
[MSC_bindings
]);
17505 dump ("Pendings %u", counts
[MSC_pendings
]);
17506 dump ("Entities %u", counts
[MSC_entities
]);
17507 dump ("Namespaces %u", counts
[MSC_namespaces
]);
17508 dump ("Macros %u", counts
[MSC_macros
]);
17509 dump ("Initializers %u", counts
[MSC_inits
]);
17512 cfg
.end (to
, to
->name (MOD_SNAME_PFX
".cnt"), crc_ptr
);
17516 module_state::read_counts (unsigned counts
[MSC_HWM
])
17520 if (!cfg
.begin (loc
, from (), MOD_SNAME_PFX
".cnt"))
17523 for (unsigned ix
= MSC_HWM
; ix
--;)
17524 counts
[ix
] = cfg
.u ();
17528 dump ("Declaration sections are [%u,%u)",
17529 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]);
17530 dump ("Bindings %u", counts
[MSC_bindings
]);
17531 dump ("Pendings %u", counts
[MSC_pendings
]);
17532 dump ("Entities %u", counts
[MSC_entities
]);
17533 dump ("Namespaces %u", counts
[MSC_namespaces
]);
17534 dump ("Macros %u", counts
[MSC_macros
]);
17535 dump ("Initializers %u", counts
[MSC_inits
]);
17538 return cfg
.end (from ());
17541 /* Tool configuration: MOD_SNAME_PFX .config
17543 This is data that confirms current state (or fails). */
17546 module_state::write_config (elf_out
*to
, module_state_config
&config
,
17547 unsigned inner_crc
)
17549 bytes_out
cfg (to
);
17553 /* Write version and inner crc as u32 values, for easier
17554 debug inspection. */
17555 dump () && dump ("Writing version=%V, inner_crc=%x",
17556 MODULE_VERSION
, inner_crc
);
17557 cfg
.u32 (unsigned (MODULE_VERSION
));
17558 cfg
.u32 (inner_crc
);
17560 cfg
.u (to
->name (is_header () ? "" : get_flatname ()));
17562 /* Configuration. */
17563 dump () && dump ("Writing target='%s', host='%s'",
17564 TARGET_MACHINE
, HOST_MACHINE
);
17565 unsigned target
= to
->name (TARGET_MACHINE
);
17566 unsigned host
= (!strcmp (TARGET_MACHINE
, HOST_MACHINE
)
17567 ? target
: to
->name (HOST_MACHINE
));
17571 cfg
.str (config
.dialect_str
);
17572 cfg
.u (extensions
);
17574 /* Global tree information. We write the globals crc separately,
17575 rather than mix it directly into the overall crc, as it is used
17576 to ensure data match between instances of the compiler, not
17577 integrity of the file. */
17578 dump () && dump ("Writing globals=%u, crc=%x",
17579 fixed_trees
->length (), global_crc
);
17580 cfg
.u (fixed_trees
->length ());
17581 cfg
.u32 (global_crc
);
17583 if (is_partition ())
17584 cfg
.u (is_interface ());
17586 cfg
.u (config
.num_imports
);
17587 cfg
.u (config
.num_partitions
);
17588 cfg
.u (config
.num_entities
);
17590 cfg
.u (config
.ordinary_locs
);
17591 cfg
.u (config
.macro_locs
);
17592 cfg
.u (config
.loc_range_bits
);
17594 cfg
.u (config
.active_init
);
17596 /* Now generate CRC, we'll have incorporated the inner CRC because
17597 of its serialization above. */
17598 cfg
.end (to
, to
->name (MOD_SNAME_PFX
".cfg"), &crc
);
17599 dump () && dump ("Writing CRC=%x", crc
);
17603 module_state::note_cmi_name ()
17605 if (!cmi_noted_p
&& filename
)
17607 cmi_noted_p
= true;
17608 inform (loc
, "compiled module file is %qs",
17609 maybe_add_cmi_prefix (filename
));
17614 module_state::read_config (module_state_config
&config
)
17618 if (!cfg
.begin (loc
, from (), MOD_SNAME_PFX
".cfg"))
17621 /* Check version. */
17622 unsigned my_ver
= MODULE_VERSION
;
17623 unsigned their_ver
= cfg
.u32 ();
17624 dump () && dump (my_ver
== their_ver
? "Version %V"
17625 : "Expecting %V found %V", my_ver
, their_ver
);
17626 if (their_ver
!= my_ver
)
17628 /* The compiler versions differ. Close enough? */
17629 verstr_t my_string
, their_string
;
17631 version2string (my_ver
, my_string
);
17632 version2string (their_ver
, their_string
);
17634 /* Reject when either is non-experimental or when experimental
17635 major versions differ. */
17636 bool reject_p
= ((!IS_EXPERIMENTAL (my_ver
)
17637 || !IS_EXPERIMENTAL (their_ver
)
17638 || MODULE_MAJOR (my_ver
) != MODULE_MAJOR (their_ver
))
17639 /* The 'I know what I'm doing' switch. */
17640 && !flag_module_version_ignore
);
17641 bool inform_p
= true;
17644 cfg
.set_overrun ();
17645 error_at (loc
, "compiled module is %sversion %s",
17646 IS_EXPERIMENTAL (their_ver
) ? "experimental " : "",
17650 inform_p
= warning_at (loc
, 0, "compiled module is %sversion %s",
17651 IS_EXPERIMENTAL (their_ver
) ? "experimental " : "",
17656 inform (loc
, "compiler is %sversion %s%s%s",
17657 IS_EXPERIMENTAL (my_ver
) ? "experimental " : "",
17659 reject_p
? "" : flag_module_version_ignore
17660 ? ", be it on your own head!" : ", close enough?",
17661 reject_p
? "" : " \xc2\xaf\\_(\xe3\x83\x84)_/\xc2\xaf");
17669 /* We wrote the inner crc merely to merge it, so simply read it
17670 back and forget it. */
17673 /* Check module name. */
17675 const char *their_name
= from ()->name (cfg
.u ());
17676 const char *our_name
= "";
17679 our_name
= get_flatname ();
17681 /* Header units can be aliased, so name checking is
17683 if (0 != strcmp (their_name
, our_name
))
17686 their_name
[0] && our_name
[0] ? G_("module %qs found")
17688 ? G_("header module expected, module %qs found")
17689 : G_("module %qs expected, header module found"),
17690 their_name
[0] ? their_name
: our_name
);
17691 cfg
.set_overrun ();
17696 /* Check the CRC after the above sanity checks, so that the user is
17699 unsigned e_crc
= crc
;
17700 crc
= cfg
.get_crc ();
17701 dump () && dump ("Reading CRC=%x", crc
);
17702 if (!is_direct () && crc
!= e_crc
)
17704 error_at (loc
, "module %qs CRC mismatch", get_flatname ());
17705 cfg
.set_overrun ();
17710 /* Check target & host. */
17712 const char *their_target
= from ()->name (cfg
.u ());
17713 const char *their_host
= from ()->name (cfg
.u ());
17714 dump () && dump ("Read target='%s', host='%s'", their_target
, their_host
);
17715 if (strcmp (their_target
, TARGET_MACHINE
)
17716 || strcmp (their_host
, HOST_MACHINE
))
17718 error_at (loc
, "target & host is %qs:%qs, expected %qs:%qs",
17719 their_target
, TARGET_MACHINE
, their_host
, HOST_MACHINE
);
17720 cfg
.set_overrun ();
17725 /* Check compilation dialect. This must match. */
17727 const char *their_dialect
= cfg
.str ();
17728 if (strcmp (their_dialect
, config
.dialect_str
))
17730 error_at (loc
, "language dialect differs %qs, expected %qs",
17731 their_dialect
, config
.dialect_str
);
17732 cfg
.set_overrun ();
17737 /* Check for extensions. If they set any, we must have them set
17740 unsigned ext
= cfg
.u ();
17741 unsigned allowed
= (flag_openmp
? SE_OPENMP
: 0);
17743 if (unsigned bad
= ext
& ~allowed
)
17745 if (bad
& SE_OPENMP
)
17746 error_at (loc
, "module contains OpenMP, use %<-fopenmp%> to enable");
17747 cfg
.set_overrun ();
17753 /* Check global trees. */
17755 unsigned their_fixed_length
= cfg
.u ();
17756 unsigned their_fixed_crc
= cfg
.u32 ();
17757 dump () && dump ("Read globals=%u, crc=%x",
17758 their_fixed_length
, their_fixed_crc
);
17759 if (!flag_preprocess_only
17760 && (their_fixed_length
!= fixed_trees
->length ()
17761 || their_fixed_crc
!= global_crc
))
17763 error_at (loc
, "fixed tree mismatch");
17764 cfg
.set_overrun ();
17769 /* All non-partitions are interfaces. */
17770 interface_p
= !is_partition () || cfg
.u ();
17772 config
.num_imports
= cfg
.u ();
17773 config
.num_partitions
= cfg
.u ();
17774 config
.num_entities
= cfg
.u ();
17776 config
.ordinary_locs
= cfg
.u ();
17777 config
.macro_locs
= cfg
.u ();
17778 config
.loc_range_bits
= cfg
.u ();
17780 config
.active_init
= cfg
.u ();
17783 return cfg
.end (from ());
17786 /* Comparator for ordering the Ordered Ordinary Location array. */
17789 ool_cmp (const void *a_
, const void *b_
)
17791 auto *a
= *static_cast<const module_state
*const *> (a_
);
17792 auto *b
= *static_cast<const module_state
*const *> (b_
);
17795 else if (a
->ordinary_locs
.first
< b
->ordinary_locs
.first
)
17801 /* Use ELROND format to record the following sections:
17802 qualified-names : binding value(s)
17803 MOD_SNAME_PFX.README : human readable, strings
17804 MOD_SNAME_PFX.ENV : environment strings, strings
17805 MOD_SNAME_PFX.nms : namespace hierarchy
17806 MOD_SNAME_PFX.bnd : binding table
17807 MOD_SNAME_PFX.spc : specialization table
17808 MOD_SNAME_PFX.imp : import table
17809 MOD_SNAME_PFX.ent : entity table
17810 MOD_SNAME_PFX.prt : partitions table
17811 MOD_SNAME_PFX.olm : ordinary line maps
17812 MOD_SNAME_PFX.mlm : macro line maps
17813 MOD_SNAME_PFX.def : macro definitions
17814 MOD_SNAME_PFX.mac : macro index
17815 MOD_SNAME_PFX.ini : inits
17816 MOD_SNAME_PFX.cnt : counts
17817 MOD_SNAME_PFX.cfg : config data
17821 module_state::write_begin (elf_out
*to
, cpp_reader
*reader
,
17822 module_state_config
&config
, unsigned &crc
)
17824 /* Figure out remapped module numbers, which might elide
17826 bitmap partitions
= NULL
;
17827 if (!is_header () && !is_partition ())
17828 partitions
= BITMAP_GGC_ALLOC ();
17829 write_init_maps ();
17831 unsigned mod_hwm
= 1;
17832 for (unsigned ix
= 1; ix
!= modules
->length (); ix
++)
17834 module_state
*imp
= (*modules
)[ix
];
17836 /* Promote any non-partition direct import from a partition, unless
17837 we're a partition. */
17838 if (!is_partition () && !imp
->is_partition ()
17839 && imp
->is_partition_direct ())
17840 imp
->directness
= MD_PURVIEW_DIRECT
;
17842 /* Write any import that is not a partition, unless we're a
17844 if (!partitions
|| !imp
->is_partition ())
17845 imp
->remap
= mod_hwm
++;
17848 dump () && dump ("Partition %M %u", imp
, ix
);
17849 bitmap_set_bit (partitions
, ix
);
17851 /* All interface partitions must be exported. */
17852 if (imp
->is_interface () && !bitmap_bit_p (exports
, imp
->mod
))
17854 error_at (imp
->loc
, "interface partition is not exported");
17855 bitmap_set_bit (exports
, imp
->mod
);
17858 /* All the partition entities should have been loaded when
17859 loading the partition. */
17861 for (unsigned jx
= 0; jx
!= imp
->entity_num
; jx
++)
17863 binding_slot
*slot
= &(*entity_ary
)[imp
->entity_lwm
+ jx
];
17864 gcc_checking_assert (!slot
->is_lazy ());
17868 if (imp
->is_direct () && (imp
->remap
|| imp
->is_partition ()))
17869 note_location (imp
->imported_from ());
17872 if (partitions
&& bitmap_empty_p (partitions
))
17873 /* No partitions present. */
17874 partitions
= nullptr;
17876 /* Find the set of decls we must write out. */
17877 depset::hash
table (DECL_NAMESPACE_BINDINGS (global_namespace
)->size () * 8);
17878 /* Add the specializations before the writables, so that we can
17879 detect injected friend specializations. */
17880 table
.add_specializations (true);
17881 table
.add_specializations (false);
17882 if (partial_specializations
)
17884 table
.add_partial_entities (partial_specializations
);
17885 partial_specializations
= NULL
;
17887 table
.add_namespace_entities (global_namespace
, partitions
);
17890 table
.add_class_entities (class_members
);
17891 class_members
= NULL
;
17894 /* Now join everything up. */
17895 table
.find_dependencies (this);
17897 if (!table
.finalize_dependencies ())
17904 /* We're done verifying at-most once reading, reset to verify
17905 at-most once writing. */
17906 note_defs
= note_defs_table_t::create_ggc (1000);
17909 /* Determine Strongy Connected Components. */
17910 vec
<depset
*> sccs
= table
.connect ();
17912 vec_alloc (ool
, modules
->length ());
17913 for (unsigned ix
= modules
->length (); --ix
;)
17915 auto *import
= (*modules
)[ix
];
17916 if (import
->loadedness
> ML_NONE
17917 && !(partitions
&& bitmap_bit_p (partitions
, import
->mod
)))
17918 ool
->quick_push (import
);
17920 ool
->qsort (ool_cmp
);
17922 vec
<cpp_hashnode
*> *macros
= nullptr;
17924 macros
= prepare_macros (reader
);
17926 config
.num_imports
= mod_hwm
;
17927 config
.num_partitions
= modules
->length () - mod_hwm
;
17928 auto map_info
= write_prepare_maps (&config
, bool (config
.num_partitions
));
17929 unsigned counts
[MSC_HWM
];
17930 memset (counts
, 0, sizeof (counts
));
17932 /* depset::cluster is the cluster number,
17933 depset::section is unspecified scratch value.
17935 The following loops make use of the tarjan property that
17936 dependencies will be earlier in the SCCS array. */
17938 /* This first loop determines the number of depsets in each SCC, and
17939 also the number of namespaces we're dealing with. During the
17940 loop, the meaning of a couple of depset fields now change:
17942 depset::cluster -> size_of cluster, if first of cluster & !namespace
17943 depset::section -> section number of cluster (if !namespace). */
17945 unsigned n_spaces
= 0;
17946 counts
[MSC_sec_lwm
] = counts
[MSC_sec_hwm
] = to
->get_section_limit ();
17947 for (unsigned size
, ix
= 0; ix
< sccs
.length (); ix
+= size
)
17949 depset
**base
= &sccs
[ix
];
17951 if (base
[0]->get_entity_kind () == depset::EK_NAMESPACE
)
17958 /* Count the members in this cluster. */
17959 for (size
= 1; ix
+ size
< sccs
.length (); size
++)
17960 if (base
[size
]->cluster
!= base
[0]->cluster
)
17963 for (unsigned jx
= 0; jx
!= size
; jx
++)
17965 /* Set the section number. */
17966 base
[jx
]->cluster
= ~(~0u >> 1); /* A bad value. */
17967 base
[jx
]->section
= counts
[MSC_sec_hwm
];
17970 /* Save the size in the first member's cluster slot. */
17971 base
[0]->cluster
= size
;
17973 counts
[MSC_sec_hwm
]++;
17977 /* Write the clusters. Namespace decls are put in the spaces array.
17978 The meaning of depset::cluster changes to provide the
17979 unnamed-decl count of the depset's decl (and remains zero for
17980 non-decls and non-unnamed). */
17981 unsigned bytes
= 0;
17982 vec
<depset
*> spaces
;
17983 spaces
.create (n_spaces
);
17985 for (unsigned size
, ix
= 0; ix
< sccs
.length (); ix
+= size
)
17987 depset
**base
= &sccs
[ix
];
17989 if (base
[0]->get_entity_kind () == depset::EK_NAMESPACE
)
17991 tree decl
= base
[0]->get_entity ();
17992 if (decl
== global_namespace
)
17993 base
[0]->cluster
= 0;
17994 else if (!base
[0]->is_import ())
17996 base
[0]->cluster
= counts
[MSC_entities
]++;
17997 spaces
.quick_push (base
[0]);
17998 counts
[MSC_namespaces
]++;
18001 /* Add it to the entity map, such that we can tell it is
18004 unsigned *slot
= &entity_map
->get_or_insert
18005 (DECL_UID (decl
), &existed
);
18007 /* It must have come from a partition. */
18008 gcc_checking_assert
18009 (import_entity_module (*slot
)->is_partition ());
18010 *slot
= ~base
[0]->cluster
;
18012 dump (dumper::CLUSTER
) && dump ("Cluster namespace %N", decl
);
18018 size
= base
[0]->cluster
;
18020 /* Cluster is now used to number entities. */
18021 base
[0]->cluster
= ~(~0u >> 1); /* A bad value. */
18023 sort_cluster (&table
, base
, size
);
18025 /* Record the section for consistency checking during stream
18026 out -- we don't want to start writing decls in different
18028 table
.section
= base
[0]->section
;
18029 bytes
+= write_cluster (to
, base
, size
, table
, counts
, &crc
);
18034 /* depset::cluster - entity number (on entities)
18035 depset::section - cluster number */
18036 /* We'd better have written as many sections and found as many
18037 namespaces as we predicted. */
18038 gcc_assert (counts
[MSC_sec_hwm
] == to
->get_section_limit ()
18039 && spaces
.length () == counts
[MSC_namespaces
]);
18041 /* Write the entitites. None happens if we contain namespaces or
18043 config
.num_entities
= counts
[MSC_entities
];
18044 if (counts
[MSC_entities
])
18045 write_entities (to
, sccs
, counts
[MSC_entities
], &crc
);
18047 /* Write the namespaces. */
18048 if (counts
[MSC_namespaces
])
18049 write_namespaces (to
, spaces
, counts
[MSC_namespaces
], &crc
);
18051 /* Write the bindings themselves. */
18052 counts
[MSC_bindings
] = write_bindings (to
, sccs
, &crc
);
18054 /* Write the unnamed. */
18055 counts
[MSC_pendings
] = write_pendings (to
, sccs
, table
, &crc
);
18057 /* Write the import table. */
18058 if (config
.num_imports
> 1)
18059 write_imports (to
, &crc
);
18061 /* Write elided partition table. */
18062 if (config
.num_partitions
)
18063 write_partitions (to
, config
.num_partitions
, &crc
);
18065 /* Write the line maps. */
18066 if (config
.ordinary_locs
)
18067 write_ordinary_maps (to
, map_info
, bool (config
.num_partitions
), &crc
);
18068 if (config
.macro_locs
)
18069 write_macro_maps (to
, map_info
, &crc
);
18073 counts
[MSC_macros
] = write_macros (to
, macros
, &crc
);
18074 counts
[MSC_inits
] = write_inits (to
, table
, &crc
);
18078 unsigned clusters
= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18079 dump () && dump ("Wrote %u clusters, average %u bytes/cluster",
18080 clusters
, (bytes
+ clusters
/ 2) / (clusters
+ !clusters
));
18081 trees_out::instrument ();
18083 write_counts (to
, counts
, &crc
);
18088 vec_free (macro_loc_remap
);
18089 vec_free (ord_loc_remap
);
18092 // FIXME:QOI: Have a command line switch to control more detailed
18093 // information (which might leak data you do not want to leak).
18094 // Perhaps (some of) the write_readme contents should also be
18100 // Finish module writing after we've emitted all dynamic initializers.
18103 module_state::write_end (elf_out
*to
, cpp_reader
*reader
,
18104 module_state_config
&config
, unsigned &crc
)
18106 /* And finish up. */
18107 write_config (to
, config
, crc
);
18109 /* Human-readable info. */
18110 write_readme (to
, reader
, config
.dialect_str
);
18112 dump () && dump ("Wrote %u sections", to
->get_section_limit ());
18115 /* Initial read of a CMI. Checks config, loads up imports and line
18119 module_state::read_initial (cpp_reader
*reader
)
18121 module_state_config config
;
18124 if (ok
&& !from ()->begin (loc
))
18127 if (ok
&& !read_config (config
))
18130 bool have_locs
= ok
&& read_prepare_maps (&config
);
18132 /* Ordinary maps before the imports. */
18133 if (!(have_locs
&& config
.ordinary_locs
))
18134 ordinary_locs
.first
= line_table
->highest_location
+ 1;
18135 else if (!read_ordinary_maps (config
.ordinary_locs
, config
.loc_range_bits
))
18138 /* Allocate the REMAP vector. */
18139 slurp
->alloc_remap (config
.num_imports
);
18143 /* Read the import table. Decrement current to stop this CMI
18144 from being evicted during the import. */
18146 if (config
.num_imports
> 1 && !read_imports (reader
, line_table
))
18151 /* Read the elided partition table, if we're the primary partition. */
18152 if (ok
&& config
.num_partitions
&& is_module ()
18153 && !read_partitions (config
.num_partitions
))
18156 /* Determine the module's number. */
18157 gcc_checking_assert (mod
== MODULE_UNKNOWN
);
18158 gcc_checking_assert (this != (*modules
)[0]);
18161 /* Allocate space in the entities array now -- that array must be
18162 monotonically in step with the modules array. */
18163 entity_lwm
= vec_safe_length (entity_ary
);
18164 entity_num
= config
.num_entities
;
18165 gcc_checking_assert (modules
->length () == 1
18166 || modules
->last ()->entity_lwm
<= entity_lwm
);
18167 vec_safe_reserve (entity_ary
, config
.num_entities
);
18170 slot
.u
.binding
= NULL_TREE
;
18171 for (unsigned count
= config
.num_entities
; count
--;)
18172 entity_ary
->quick_push (slot
);
18175 /* We'll run out of other resources before we run out of module
18177 mod
= modules
->length ();
18178 vec_safe_push (modules
, this);
18180 /* We always import and export ourselves. */
18181 bitmap_set_bit (imports
, mod
);
18182 bitmap_set_bit (exports
, mod
);
18185 (*slurp
->remap
)[0] = mod
<< 1;
18186 dump () && dump ("Assigning %M module number %u", this, mod
);
18188 /* We should not have been frozen during the importing done by
18190 gcc_assert (!from ()->is_frozen ());
18192 /* Macro maps after the imports. */
18193 if (!(ok
&& have_locs
&& config
.macro_locs
))
18194 macro_locs
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
18195 else if (!read_macro_maps (config
.macro_locs
))
18198 /* Note whether there's an active initializer. */
18199 active_init_p
= !is_header () && bool (config
.active_init
);
18201 gcc_assert (slurp
->current
== ~0u);
18205 /* Read a preprocessor state. */
18208 module_state::read_preprocessor (bool outermost
)
18210 gcc_checking_assert (is_header () && slurp
18211 && slurp
->remap_module (0) == mod
);
18213 if (loadedness
== ML_PREPROCESSOR
)
18214 return !(from () && from ()->get_error ());
18218 /* Read direct header imports. */
18219 unsigned len
= slurp
->remap
->length ();
18220 for (unsigned ix
= 1; ok
&& ix
!= len
; ix
++)
18222 unsigned map
= (*slurp
->remap
)[ix
];
18225 module_state
*import
= (*modules
)[map
>> 1];
18226 if (import
->is_header ())
18228 ok
= import
->read_preprocessor (false);
18229 bitmap_ior_into (slurp
->headers
, import
->slurp
->headers
);
18234 /* Record as a direct header. */
18236 bitmap_set_bit (slurp
->headers
, mod
);
18238 if (ok
&& !read_macros ())
18241 loadedness
= ML_PREPROCESSOR
;
18242 announce ("macros");
18244 if (flag_preprocess_only
)
18245 /* We're done with the string table. */
18246 from ()->release ();
18248 return check_read (outermost
, ok
);
18251 /* Read language state. */
18254 module_state::read_language (bool outermost
)
18256 gcc_checking_assert (!lazy_snum
);
18258 if (loadedness
== ML_LANGUAGE
)
18259 return !(slurp
&& from () && from ()->get_error ());
18261 gcc_checking_assert (slurp
&& slurp
->current
== ~0u
18262 && slurp
->remap_module (0) == mod
);
18266 /* Read direct imports. */
18267 unsigned len
= slurp
->remap
->length ();
18268 for (unsigned ix
= 1; ok
&& ix
!= len
; ix
++)
18270 unsigned map
= (*slurp
->remap
)[ix
];
18273 module_state
*import
= (*modules
)[map
>> 1];
18274 if (!import
->read_language (false))
18279 unsigned counts
[MSC_HWM
];
18281 if (ok
&& !read_counts (counts
))
18284 function_depth
++; /* Prevent unexpected GCs. */
18286 if (ok
&& counts
[MSC_entities
] != entity_num
)
18288 if (ok
&& counts
[MSC_entities
]
18289 && !read_entities (counts
[MSC_entities
],
18290 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]))
18293 /* Read the namespace hierarchy. */
18294 if (ok
&& counts
[MSC_namespaces
]
18295 && !read_namespaces (counts
[MSC_namespaces
]))
18298 if (ok
&& !read_bindings (counts
[MSC_bindings
],
18299 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]))
18303 if (ok
&& counts
[MSC_pendings
] && !read_pendings (counts
[MSC_pendings
]))
18308 slurp
->remaining
= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18309 available_clusters
+= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18312 if (!flag_module_lazy
18313 || (is_partition ()
18314 && module_interface_p ()
18315 && !module_partition_p ()))
18317 /* Read the sections in forward order, so that dependencies are read
18318 first. See note about tarjan_connect. */
18323 unsigned hwm
= counts
[MSC_sec_hwm
];
18324 for (unsigned ix
= counts
[MSC_sec_lwm
]; ok
&& ix
!= hwm
; ix
++)
18325 if (!load_section (ix
, NULL
))
18331 post_load_processing ();
18335 if (ok
&& CHECKING_P
)
18336 for (unsigned ix
= 0; ix
!= entity_num
; ix
++)
18337 gcc_assert (!(*entity_ary
)[ix
+ entity_lwm
].is_lazy ());
18340 // If the import is a header-unit, we need to register initializers
18341 // of any static objects it contains (looking at you _Ioinit).
18342 // Notice, the ordering of these initializers will be that of a
18343 // dynamic initializer at this point in the current TU. (Other
18344 // instances of these objects in other TUs will be initialized as
18345 // part of that TU's global initializers.)
18346 if (ok
&& counts
[MSC_inits
] && !read_inits (counts
[MSC_inits
]))
18351 announce (flag_module_lazy
? "lazy" : "imported");
18352 loadedness
= ML_LANGUAGE
;
18354 gcc_assert (slurp
->current
== ~0u);
18356 /* We're done with the string table. */
18357 from ()->release ();
18359 return check_read (outermost
, ok
);
18363 module_state::maybe_defrost ()
18366 if (from ()->is_frozen ())
18368 if (lazy_open
>= lazy_limit
)
18370 dump () && dump ("Defrosting '%s'", filename
);
18371 ok
= from ()->defrost (maybe_add_cmi_prefix (filename
));
18378 /* Load section SNUM, dealing with laziness. It doesn't matter if we
18379 have multiple concurrent loads, because we do not use TREE_VISITED
18380 when reading back in. */
18383 module_state::load_section (unsigned snum
, binding_slot
*mslot
)
18385 if (from ()->get_error ())
18388 if (snum
>= slurp
->current
)
18389 from ()->set_error (elf::E_BAD_LAZY
);
18390 else if (maybe_defrost ())
18392 unsigned old_current
= slurp
->current
;
18393 slurp
->current
= snum
;
18394 slurp
->lru
= 0; /* Do not swap out. */
18395 slurp
->remaining
--;
18396 read_cluster (snum
);
18397 slurp
->lru
= ++lazy_lru
;
18398 slurp
->current
= old_current
;
18401 if (mslot
&& mslot
->is_lazy ())
18403 /* Oops, the section didn't set this slot. */
18404 from ()->set_error (elf::E_BAD_DATA
);
18405 *mslot
= NULL_TREE
;
18408 bool ok
= !from ()->get_error ();
18411 error_at (loc
, "failed to read compiled module cluster %u: %s",
18412 snum
, from ()->get_error (filename
));
18416 maybe_completed_reading ();
18422 module_state::maybe_completed_reading ()
18424 if (loadedness
== ML_LANGUAGE
&& slurp
->current
== ~0u && !slurp
->remaining
)
18427 /* We no longer need the macros, all tokenizing has been done. */
18428 slurp
->release_macros ();
18436 /* After a reading operation, make sure things are still ok. If not,
18437 emit an error and clean up. */
18440 module_state::check_read (bool outermost
, bool ok
)
18442 gcc_checking_assert (!outermost
|| slurp
->current
== ~0u);
18445 from ()->set_error ();
18447 if (int e
= from ()->get_error ())
18449 error_at (loc
, "failed to read compiled module: %s",
18450 from ()->get_error (filename
));
18459 inform (loc
, "consider using %<-fno-module-lazy%>,"
18460 " increasing %<-param-lazy-modules=%u%> value,"
18461 " or increasing the per-process file descriptor limit",
18462 param_lazy_modules
);
18463 else if (e
== ENOENT
)
18464 inform (loc
, "imports must be built before being imported");
18467 fatal_error (loc
, "returning to the gate for a mechanical issue");
18472 maybe_completed_reading ();
18477 /* Return the IDENTIFIER_NODE naming module IX. This is the name
18481 module_name (unsigned ix
, bool header_ok
)
18485 module_state
*imp
= (*modules
)[ix
];
18487 if (ix
&& !imp
->name
)
18490 if (header_ok
|| !imp
->is_header ())
18491 return imp
->get_flatname ();
18497 /* Return the bitmap describing what modules are imported. Remember,
18498 we always import ourselves. */
18501 get_import_bitmap ()
18503 return (*modules
)[0]->imports
;
18506 /* Return the visible imports and path of instantiation for an
18507 instantiation at TINST. If TINST is nullptr, we're not in an
18508 instantiation, and thus will return the visible imports of the
18509 current TU (and NULL *PATH_MAP_P). We cache the information on
18510 the tinst level itself. */
18513 path_of_instantiation (tinst_level
*tinst
, bitmap
*path_map_p
)
18515 gcc_checking_assert (modules_p ());
18519 /* Not inside an instantiation, just the regular case. */
18520 *path_map_p
= nullptr;
18521 return get_import_bitmap ();
18527 bitmap visible
= path_of_instantiation (tinst
->next
, path_map_p
);
18528 bitmap path_map
= *path_map_p
;
18532 path_map
= BITMAP_GGC_ALLOC ();
18533 bitmap_set_bit (path_map
, 0);
18536 tree decl
= tinst
->tldcl
;
18537 if (TREE_CODE (decl
) == TREE_LIST
)
18538 decl
= TREE_PURPOSE (decl
);
18540 decl
= TYPE_NAME (decl
);
18542 if (unsigned mod
= get_originating_module (decl
))
18543 if (!bitmap_bit_p (path_map
, mod
))
18545 /* This is brand new information! */
18546 bitmap new_path
= BITMAP_GGC_ALLOC ();
18547 bitmap_copy (new_path
, path_map
);
18548 bitmap_set_bit (new_path
, mod
);
18549 path_map
= new_path
;
18551 bitmap imports
= (*modules
)[mod
]->imports
;
18552 if (bitmap_intersect_compl_p (imports
, visible
))
18554 /* IMPORTS contains additional modules to VISIBLE. */
18555 bitmap new_visible
= BITMAP_GGC_ALLOC ();
18557 bitmap_ior (new_visible
, visible
, imports
);
18558 visible
= new_visible
;
18562 tinst
->path
= path_map
;
18563 tinst
->visible
= visible
;
18566 *path_map_p
= tinst
->path
;
18567 return tinst
->visible
;
18570 /* Return the bitmap describing what modules are visible along the
18571 path of instantiation. If we're not an instantiation, this will be
18572 the visible imports of the TU. *PATH_MAP_P is filled in with the
18573 modules owning the instantiation path -- we see the module-linkage
18574 entities of those modules. */
18577 visible_instantiation_path (bitmap
*path_map_p
)
18582 return path_of_instantiation (current_instantiation (), path_map_p
);
18585 /* We've just directly imported IMPORT. Update our import/export
18586 bitmaps. IS_EXPORT is true if we're reexporting the OTHER. */
18589 module_state::set_import (module_state
const *import
, bool is_export
)
18591 gcc_checking_assert (this != import
);
18593 /* We see IMPORT's exports (which includes IMPORT). If IMPORT is
18594 the primary interface or a partition we'll see its imports. */
18595 bitmap_ior_into (imports
, import
->is_module () || import
->is_partition ()
18596 ? import
->imports
: import
->exports
);
18599 /* We'll export OTHER's exports. */
18600 bitmap_ior_into (exports
, import
->exports
);
18603 /* Return the declaring entity of DECL. That is the decl determining
18604 how to decorate DECL with module information. Returns NULL_TREE if
18605 it's the global module. */
18608 get_originating_module_decl (tree decl
)
18610 /* An enumeration constant. */
18611 if (TREE_CODE (decl
) == CONST_DECL
18612 && DECL_CONTEXT (decl
)
18613 && (TREE_CODE (DECL_CONTEXT (decl
)) == ENUMERAL_TYPE
))
18614 decl
= TYPE_NAME (DECL_CONTEXT (decl
));
18615 else if (TREE_CODE (decl
) == FIELD_DECL
18616 || TREE_CODE (decl
) == USING_DECL
)
18618 decl
= DECL_CONTEXT (decl
);
18619 if (TREE_CODE (decl
) != FUNCTION_DECL
)
18620 decl
= TYPE_NAME (decl
);
18623 gcc_checking_assert (TREE_CODE (decl
) == TEMPLATE_DECL
18624 || TREE_CODE (decl
) == FUNCTION_DECL
18625 || TREE_CODE (decl
) == TYPE_DECL
18626 || TREE_CODE (decl
) == VAR_DECL
18627 || TREE_CODE (decl
) == CONCEPT_DECL
18628 || TREE_CODE (decl
) == NAMESPACE_DECL
);
18632 /* Uninstantiated template friends are owned by the befriending
18633 class -- not their context. */
18634 if (TREE_CODE (decl
) == TEMPLATE_DECL
18635 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
18636 decl
= TYPE_NAME (DECL_CHAIN (decl
));
18639 if (tree ti
= node_template_info (decl
, use
))
18641 decl
= TI_TEMPLATE (ti
);
18642 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18644 /* A friend template specialization. */
18645 gcc_checking_assert (OVL_P (decl
));
18646 return global_namespace
;
18651 tree ctx
= CP_DECL_CONTEXT (decl
);
18652 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
18657 ctx
= TYPE_NAME (ctx
);
18660 /* Some kind of internal type. */
18661 gcc_checking_assert (DECL_ARTIFICIAL (decl
));
18662 return global_namespace
;
18673 get_originating_module (tree decl
, bool for_mangle
)
18675 tree owner
= get_originating_module_decl (decl
);
18676 tree not_tmpl
= STRIP_TEMPLATE (owner
);
18678 if (!DECL_LANG_SPECIFIC (not_tmpl
))
18679 return for_mangle
? -1 : 0;
18681 if (for_mangle
&& !DECL_MODULE_ATTACH_P (not_tmpl
))
18684 int mod
= !DECL_MODULE_IMPORT_P (not_tmpl
) ? 0 : get_importing_module (owner
);
18685 gcc_checking_assert (!for_mangle
|| !(*modules
)[mod
]->is_header ());
18690 get_importing_module (tree decl
, bool flexible
)
18692 unsigned index
= import_entity_index (decl
, flexible
);
18693 if (index
== ~(~0u >> 1))
18695 module_state
*module
= import_entity_module (index
);
18697 return module
->mod
;
18700 /* Is it permissible to redeclare DECL. */
18703 module_may_redeclare (tree decl
)
18707 tree ctx
= CP_DECL_CONTEXT (decl
);
18708 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
18709 // Found the namespace-scope decl.
18711 if (!CLASS_TYPE_P (ctx
))
18712 // We've met a non-class scope. Such a thing is not
18713 // reopenable, so we must be ok.
18715 decl
= TYPE_NAME (ctx
);
18718 tree not_tmpl
= STRIP_TEMPLATE (decl
);
18721 if (node_template_info (not_tmpl
, use_tpl
) && use_tpl
)
18722 // Specializations of any kind can be redeclared anywhere.
18723 // FIXME: Should we be checking this in more places on the scope chain?
18726 if (!DECL_LANG_SPECIFIC (not_tmpl
) || !DECL_MODULE_ATTACH_P (not_tmpl
))
18727 // Decl is attached to global module. Current scope needs to be too.
18728 return !module_attach_p ();
18730 module_state
*me
= (*modules
)[0];
18731 module_state
*them
= me
;
18733 if (DECL_LANG_SPECIFIC (not_tmpl
) && DECL_MODULE_IMPORT_P (not_tmpl
))
18735 /* We can be given the TEMPLATE_RESULT. We want the
18738 if (tree ti
= node_template_info (decl
, use_tpl
))
18740 tree tmpl
= TI_TEMPLATE (ti
);
18743 /* A partial specialization. Find that specialization's
18745 for (tree list
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
18746 list
; list
= TREE_CHAIN (list
))
18747 if (DECL_TEMPLATE_RESULT (TREE_VALUE (list
)) == decl
)
18749 decl
= TREE_VALUE (list
);
18753 else if (DECL_TEMPLATE_RESULT (tmpl
) == decl
)
18756 unsigned index
= import_entity_index (decl
);
18757 them
= import_entity_module (index
);
18760 // Decl is attached to named module. Current scope needs to be
18761 // attaching to the same module.
18762 if (!module_attach_p ())
18765 // Both attached to named module.
18769 return me
&& get_primary (them
) == get_primary (me
);
18772 /* DECL is being created by this TU. Record it came from here. We
18773 record module purview, so we can see if partial or explicit
18774 specialization needs to be written out, even though its purviewness
18775 comes from the most general template. */
18778 set_instantiating_module (tree decl
)
18780 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
18782 || TREE_CODE (decl
) == TYPE_DECL
18783 || TREE_CODE (decl
) == CONCEPT_DECL
18784 || TREE_CODE (decl
) == TEMPLATE_DECL
18785 || (TREE_CODE (decl
) == NAMESPACE_DECL
18786 && DECL_NAMESPACE_ALIAS (decl
)));
18791 decl
= STRIP_TEMPLATE (decl
);
18793 if (!DECL_LANG_SPECIFIC (decl
) && module_purview_p ())
18794 retrofit_lang_decl (decl
);
18796 if (DECL_LANG_SPECIFIC (decl
))
18798 DECL_MODULE_PURVIEW_P (decl
) = module_purview_p ();
18799 /* If this was imported, we'll still be in the entity_hash. */
18800 DECL_MODULE_IMPORT_P (decl
) = false;
18804 /* If DECL is a class member, whose class is not defined in this TU
18805 (it was imported), remember this decl. */
18808 set_defining_module (tree decl
)
18810 gcc_checking_assert (!DECL_LANG_SPECIFIC (decl
)
18811 || !DECL_MODULE_IMPORT_P (decl
));
18813 if (module_has_cmi_p ())
18815 tree ctx
= DECL_CONTEXT (decl
);
18817 && (TREE_CODE (ctx
) == RECORD_TYPE
|| TREE_CODE (ctx
) == UNION_TYPE
)
18818 && DECL_LANG_SPECIFIC (TYPE_NAME (ctx
))
18819 && DECL_MODULE_IMPORT_P (TYPE_NAME (ctx
)))
18821 /* This entity's context is from an import. We may need to
18822 record this entity to make sure we emit it in the CMI.
18823 Template specializations are in the template hash tables,
18824 so we don't need to record them here as well. */
18826 tree ti
= node_template_info (decl
, use_tpl
);
18831 gcc_checking_assert (!use_tpl
);
18832 /* Get to the TEMPLATE_DECL. */
18833 decl
= TI_TEMPLATE (ti
);
18836 /* Record it on the class_members list. */
18837 vec_safe_push (class_members
, decl
);
18840 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
18841 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18842 /* This is a partial or explicit specialization. */
18843 vec_safe_push (partial_specializations
, decl
);
18848 set_originating_module (tree decl
, bool friend_p ATTRIBUTE_UNUSED
)
18850 set_instantiating_module (decl
);
18852 if (!DECL_NAMESPACE_SCOPE_P (decl
))
18855 gcc_checking_assert (friend_p
|| decl
== get_originating_module_decl (decl
));
18857 if (module_attach_p ())
18859 retrofit_lang_decl (decl
);
18860 DECL_MODULE_ATTACH_P (decl
) = true;
18863 if (!module_exporting_p ())
18866 // FIXME: Check ill-formed linkage
18867 DECL_MODULE_EXPORT_P (decl
) = true;
18870 /* DECL is keyed to CTX for odr purposes. */
18873 maybe_key_decl (tree ctx
, tree decl
)
18878 // FIXME: For now just deal with lambdas attached to var decls.
18879 // This might be sufficient?
18880 if (TREE_CODE (ctx
) != VAR_DECL
)
18883 gcc_checking_assert (DECL_NAMESPACE_SCOPE_P (ctx
));
18886 keyed_table
= new keyed_map_t (EXPERIMENT (1, 400));
18888 auto &vec
= keyed_table
->get_or_insert (ctx
);
18889 if (!vec
.length ())
18891 retrofit_lang_decl (ctx
);
18892 DECL_MODULE_KEYED_DECLS_P (ctx
) = true;
18894 vec
.safe_push (decl
);
18897 /* Create the flat name string. It is simplest to have it handy. */
18900 module_state::set_flatname ()
18902 gcc_checking_assert (!flatname
);
18905 auto_vec
<tree
,5> ids
;
18907 char const *primary
= NULL
;
18908 size_t pfx_len
= 0;
18910 for (module_state
*probe
= this;
18912 probe
= probe
->parent
)
18913 if (is_partition () && !probe
->is_partition ())
18915 primary
= probe
->get_flatname ();
18916 pfx_len
= strlen (primary
);
18921 ids
.safe_push (probe
->name
);
18922 len
+= IDENTIFIER_LENGTH (probe
->name
) + 1;
18925 char *flat
= XNEWVEC (char, pfx_len
+ len
+ is_partition ());
18930 memcpy (flat
, primary
, pfx_len
);
18935 for (unsigned len
= 0; ids
.length ();)
18939 tree elt
= ids
.pop ();
18940 unsigned l
= IDENTIFIER_LENGTH (elt
);
18941 memcpy (flat
+ len
, IDENTIFIER_POINTER (elt
), l
+ 1);
18945 else if (is_header ())
18946 flatname
= TREE_STRING_POINTER (name
);
18948 flatname
= IDENTIFIER_POINTER (name
);
18951 /* Read the CMI file for a module. */
18954 module_state::do_import (cpp_reader
*reader
, bool outermost
)
18956 gcc_assert (global_namespace
== current_scope () && loadedness
== ML_NONE
);
18958 loc
= linemap_module_loc (line_table
, loc
, get_flatname ());
18960 if (lazy_open
>= lazy_limit
)
18967 const char *file
= maybe_add_cmi_prefix (filename
);
18968 dump () && dump ("CMI is %s", file
);
18969 if (note_module_cmi_yes
|| inform_cmi_p
)
18970 inform (loc
, "reading CMI %qs", file
);
18971 fd
= open (file
, O_RDONLY
| O_CLOEXEC
| O_BINARY
);
18975 gcc_checking_assert (!slurp
);
18976 slurp
= new slurping (new elf_in (fd
, e
));
18979 if (!from ()->get_error ())
18981 announce ("importing");
18982 loadedness
= ML_CONFIG
;
18984 ok
= read_initial (reader
);
18985 slurp
->lru
= ++lazy_lru
;
18988 gcc_assert (slurp
->current
== ~0u);
18990 return check_read (outermost
, ok
);
18993 /* Attempt to increase the file descriptor limit. */
18996 try_increase_lazy (unsigned want
)
18998 gcc_checking_assert (lazy_open
>= lazy_limit
);
19000 /* If we're increasing, saturate at hard limit. */
19001 if (want
> lazy_hard_limit
&& lazy_limit
< lazy_hard_limit
)
19002 want
= lazy_hard_limit
;
19005 if ((!lazy_limit
|| !param_lazy_modules
)
19007 && want
<= lazy_hard_limit
)
19009 struct rlimit rlimit
;
19010 rlimit
.rlim_cur
= want
+ LAZY_HEADROOM
;
19011 rlimit
.rlim_max
= lazy_hard_limit
+ LAZY_HEADROOM
;
19012 if (!setrlimit (RLIMIT_NOFILE
, &rlimit
))
19017 return lazy_open
< lazy_limit
;
19020 /* Pick a victim module to freeze its reader. */
19023 module_state::freeze_an_elf ()
19025 if (try_increase_lazy (lazy_open
* 2))
19028 module_state
*victim
= NULL
;
19029 for (unsigned ix
= modules
->length (); ix
--;)
19031 module_state
*candidate
= (*modules
)[ix
];
19032 if (candidate
&& candidate
->slurp
&& candidate
->slurp
->lru
19033 && candidate
->from ()->is_freezable ()
19034 && (!victim
|| victim
->slurp
->lru
> candidate
->slurp
->lru
))
19035 victim
= candidate
;
19040 dump () && dump ("Freezing '%s'", victim
->filename
);
19041 if (victim
->slurp
->macro_defs
.size
)
19042 /* Save the macro definitions to a buffer. */
19043 victim
->from ()->preserve (victim
->slurp
->macro_defs
);
19044 if (victim
->slurp
->macro_tbl
.size
)
19045 /* Save the macro definitions to a buffer. */
19046 victim
->from ()->preserve (victim
->slurp
->macro_tbl
);
19047 victim
->from ()->freeze ();
19051 dump () && dump ("No module available for freezing");
19054 /* Load the lazy slot *MSLOT, INDEX'th slot of the module. */
19057 module_state::lazy_load (unsigned index
, binding_slot
*mslot
)
19059 unsigned n
= dump
.push (this);
19061 gcc_checking_assert (function_depth
);
19063 unsigned cookie
= mslot
->get_lazy ();
19064 unsigned snum
= cookie
>> 2;
19065 dump () && dump ("Loading entity %M[%u] section:%u", this, index
, snum
);
19067 bool ok
= load_section (snum
, mslot
);
19074 /* Load MOD's binding for NS::ID into *MSLOT. *MSLOT contains the
19075 lazy cookie. OUTER is true if this is the outermost lazy, (used
19076 for diagnostics). */
19079 lazy_load_binding (unsigned mod
, tree ns
, tree id
, binding_slot
*mslot
)
19081 int count
= errorcount
+ warningcount
;
19083 timevar_start (TV_MODULE_IMPORT
);
19085 /* Make sure lazy loading from a template context behaves as if
19086 from a non-template context. */
19087 processing_template_decl_sentinel ptds
;
19089 /* Stop GC happening, even in outermost loads (because our caller
19090 could well be building up a lookup set). */
19093 gcc_checking_assert (mod
);
19094 module_state
*module
= (*modules
)[mod
];
19095 unsigned n
= dump
.push (module
);
19097 unsigned snum
= mslot
->get_lazy ();
19098 dump () && dump ("Lazily binding %P@%N section:%u", ns
, id
,
19099 module
->name
, snum
);
19101 bool ok
= !recursive_lazy (snum
);
19104 ok
= module
->load_section (snum
, mslot
);
19106 post_load_processing ();
19113 timevar_stop (TV_MODULE_IMPORT
);
19116 fatal_error (input_location
,
19117 module
->is_header ()
19118 ? G_("failed to load binding %<%E%s%E%>")
19119 : G_("failed to load binding %<%E%s%E@%s%>"),
19120 ns
, &"::"[ns
== global_namespace
? 2 : 0], id
,
19121 module
->get_flatname ());
19123 if (count
!= errorcount
+ warningcount
)
19124 inform (input_location
,
19125 module
->is_header ()
19126 ? G_("during load of binding %<%E%s%E%>")
19127 : G_("during load of binding %<%E%s%E@%s%>"),
19128 ns
, &"::"[ns
== global_namespace
? 2 : 0], id
,
19129 module
->get_flatname ());
19132 /* Load any pending entities keyed to the top-key of DECL. */
19135 lazy_load_pendings (tree decl
)
19137 /* Make sure lazy loading from a template context behaves as if
19138 from a non-template context. */
19139 processing_template_decl_sentinel ptds
;
19143 key
.ns
= find_pending_key (decl
, &key_decl
);
19144 key
.id
= DECL_NAME (key_decl
);
19146 auto *pending_vec
= pending_table
? pending_table
->get (key
) : nullptr;
19150 int count
= errorcount
+ warningcount
;
19152 timevar_start (TV_MODULE_IMPORT
);
19153 bool ok
= !recursive_lazy ();
19156 function_depth
++; /* Prevent GC */
19157 unsigned n
= dump
.push (NULL
);
19158 dump () && dump ("Reading %u pending entities keyed to %P",
19159 pending_vec
->length (), key
.ns
, key
.id
);
19160 for (unsigned ix
= pending_vec
->length (); ix
--;)
19162 unsigned index
= (*pending_vec
)[ix
];
19163 binding_slot
*slot
= &(*entity_ary
)[index
];
19165 if (slot
->is_lazy ())
19167 module_state
*import
= import_entity_module (index
);
19168 if (!import
->lazy_load (index
- import
->entity_lwm
, slot
))
19173 module_state
*import
= import_entity_module (index
);
19174 dump () && dump ("Entity %M[%u] already loaded",
19175 import
, index
- import
->entity_lwm
);
19179 pending_table
->remove (key
);
19182 post_load_processing ();
19186 timevar_stop (TV_MODULE_IMPORT
);
19189 fatal_error (input_location
, "failed to load pendings for %<%E%s%E%>",
19190 key
.ns
, &"::"[key
.ns
== global_namespace
? 2 : 0], key
.id
);
19192 if (count
!= errorcount
+ warningcount
)
19193 inform (input_location
, "during load of pendings for %<%E%s%E%>",
19194 key
.ns
, &"::"[key
.ns
== global_namespace
? 2 : 0], key
.id
);
19198 direct_import (module_state
*import
, cpp_reader
*reader
)
19200 timevar_start (TV_MODULE_IMPORT
);
19201 unsigned n
= dump
.push (import
);
19203 gcc_checking_assert (import
->is_direct () && import
->has_location ());
19204 if (import
->loadedness
== ML_NONE
)
19205 if (!import
->do_import (reader
, true))
19206 gcc_unreachable ();
19208 if (import
->loadedness
< ML_LANGUAGE
)
19211 keyed_table
= new keyed_map_t (EXPERIMENT (1, 400));
19212 import
->read_language (true);
19215 (*modules
)[0]->set_import (import
, import
->exported_p
);
19218 timevar_stop (TV_MODULE_IMPORT
);
19221 /* Import module IMPORT. */
19224 import_module (module_state
*import
, location_t from_loc
, bool exporting_p
,
19225 tree
, cpp_reader
*reader
)
19227 if (!import
->check_not_purview (from_loc
))
19230 if (!import
->is_header () && current_lang_depth ())
19231 /* Only header units should appear inside language
19232 specifications. The std doesn't specify this, but I think
19233 that's an error in resolving US 033, because language linkage
19234 is also our escape clause to getting things into the global
19235 module, so we don't want to confuse things by having to think
19236 about whether 'extern "C++" { import foo; }' puts foo's
19237 contents into the global module all of a sudden. */
19238 warning (0, "import of named module %qs inside language-linkage block",
19239 import
->get_flatname ());
19241 if (exporting_p
|| module_exporting_p ())
19242 import
->exported_p
= true;
19244 if (import
->loadedness
!= ML_NONE
)
19246 from_loc
= ordinary_loc_of (line_table
, from_loc
);
19247 linemap_module_reparent (line_table
, import
->loc
, from_loc
);
19249 gcc_checking_assert (!import
->module_p
);
19250 gcc_checking_assert (import
->is_direct () && import
->has_location ());
19252 direct_import (import
, reader
);
19255 /* Declare the name of the current module to be NAME. EXPORTING_p is
19256 true if this TU is the exporting module unit. */
19259 declare_module (module_state
*module
, location_t from_loc
, bool exporting_p
,
19260 tree
, cpp_reader
*reader
)
19262 gcc_assert (global_namespace
== current_scope ());
19264 module_state
*current
= (*modules
)[0];
19265 if (module_purview_p () || module
->loadedness
> ML_CONFIG
)
19267 error_at (from_loc
, module_purview_p ()
19268 ? G_("module already declared")
19269 : G_("module already imported"));
19270 if (module_purview_p ())
19272 inform (module
->loc
, module_purview_p ()
19273 ? G_("module %qs declared here")
19274 : G_("module %qs imported here"),
19275 module
->get_flatname ());
19279 gcc_checking_assert (module
->module_p
);
19280 gcc_checking_assert (module
->is_direct () && module
->has_location ());
19282 /* Yer a module, 'arry. */
19283 module_kind
= module
->is_header () ? MK_HEADER
: MK_NAMED
| MK_ATTACH
;
19285 // Even in header units, we consider the decls to be purview
19286 module_kind
|= MK_PURVIEW
;
19288 if (module
->is_partition ())
19289 module_kind
|= MK_PARTITION
;
19292 module
->interface_p
= true;
19293 module_kind
|= MK_INTERFACE
;
19296 if (module_has_cmi_p ())
19298 /* Copy the importing information we may have already done. We
19299 do not need to separate out the imports that only happen in
19300 the GMF, inspite of what the literal wording of the std
19301 might imply. See p2191, the core list had a discussion
19302 where the module implementors agreed that the GMF of a named
19303 module is invisible to importers. */
19304 module
->imports
= current
->imports
;
19307 (*modules
)[0] = module
;
19311 module
->interface_p
= true;
19312 current
->parent
= module
; /* So mangler knows module identity. */
19313 direct_import (module
, reader
);
19317 /* Return true IFF we must emit a module global initializer function
19318 (which will be called by importers' init code). */
19321 module_global_init_needed ()
19323 return module_has_cmi_p () && !header_module_p ();
19326 /* Calculate which, if any, import initializers need calling. */
19329 module_determine_import_inits ()
19331 if (!modules
|| header_module_p ())
19334 /* Prune active_init_p. We need the same bitmap allocation
19335 scheme as for the imports member. */
19336 function_depth
++; /* Disable GC. */
19337 bitmap
covered_imports (BITMAP_GGC_ALLOC ());
19341 /* Because indirect imports are before their direct import, and
19342 we're scanning the array backwards, we only need one pass! */
19343 for (unsigned ix
= modules
->length (); --ix
;)
19345 module_state
*import
= (*modules
)[ix
];
19347 if (!import
->active_init_p
)
19349 else if (bitmap_bit_p (covered_imports
, ix
))
19350 import
->active_init_p
= false;
19353 /* Everything this imports is therefore handled by its
19354 initializer, so doesn't need initializing by us. */
19355 bitmap_ior_into (covered_imports
, import
->imports
);
19364 /* Emit calls to each direct import's global initializer. Including
19365 direct imports of directly imported header units. The initializers
19366 of (static) entities in header units will be called by their
19367 importing modules (for the instance contained within that), or by
19368 the current TU (for the instances we've brought in). Of course
19369 such header unit behaviour is evil, but iostream went through that
19370 door some time ago. */
19373 module_add_import_initializers ()
19375 if (!modules
|| header_module_p ())
19378 tree fntype
= build_function_type (void_type_node
, void_list_node
);
19379 releasing_vec args
; // There are no args
19381 for (unsigned ix
= modules
->length (); --ix
;)
19383 module_state
*import
= (*modules
)[ix
];
19384 if (import
->active_init_p
)
19386 tree name
= mangle_module_global_init (ix
);
19387 tree fndecl
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
19389 DECL_CONTEXT (fndecl
) = FROB_CONTEXT (global_namespace
);
19390 SET_DECL_ASSEMBLER_NAME (fndecl
, name
);
19391 TREE_PUBLIC (fndecl
) = true;
19392 determine_visibility (fndecl
);
19394 tree call
= cp_build_function_call_vec (fndecl
, &args
,
19395 tf_warning_or_error
);
19396 finish_expr_stmt (call
);
19401 /* NAME & LEN are a preprocessed header name, possibly including the
19402 surrounding "" or <> characters. Return the raw string name of the
19403 module to which it refers. This will be an absolute path, or begin
19404 with ./, so it is immediately distinguishable from a (non-header
19405 unit) module name. If READER is non-null, ask the preprocessor to
19406 locate the header to which it refers using the appropriate include
19407 path. Note that we do never do \ processing of the string, as that
19408 matches the preprocessor's behaviour. */
19410 static const char *
19411 canonicalize_header_name (cpp_reader
*reader
, location_t loc
, bool unquoted
,
19412 const char *str
, size_t &len_r
)
19414 size_t len
= len_r
;
19415 static char *buf
= 0;
19416 static size_t alloc
= 0;
19420 gcc_checking_assert (len
>= 2
19421 && ((reader
&& str
[0] == '<' && str
[len
-1] == '>')
19422 || (str
[0] == '"' && str
[len
-1] == '"')));
19429 gcc_assert (!unquoted
);
19434 buf
= XRESIZEVEC (char, buf
, alloc
);
19436 memcpy (buf
, str
, len
);
19439 if (const char *hdr
19440 = cpp_probe_header_unit (reader
, buf
, str
[-1] == '<', loc
))
19442 len
= strlen (hdr
);
19449 if (!(str
[0] == '.' ? IS_DIR_SEPARATOR (str
[1]) : IS_ABSOLUTE_PATH (str
)))
19452 if (len
+ 3 > alloc
)
19455 buf
= XRESIZEVEC (char, buf
, alloc
);
19459 buf
[1] = DIR_SEPARATOR
;
19460 memmove (buf
+ 2, str
, len
);
19470 /* Set the CMI name from a cody packet. Issue an error if
19473 void module_state::set_filename (const Cody::Packet
&packet
)
19475 gcc_checking_assert (!filename
);
19476 if (packet
.GetCode () == Cody::Client::PC_PATHNAME
)
19477 filename
= xstrdup (packet
.GetString ().c_str ());
19480 gcc_checking_assert (packet
.GetCode () == Cody::Client::PC_ERROR
);
19481 error_at (loc
, "unknown Compiled Module Interface: %s",
19482 packet
.GetString ().c_str ());
19486 /* Figure out whether to treat HEADER as an include or an import. */
19489 maybe_translate_include (cpp_reader
*reader
, line_maps
*lmaps
, location_t loc
,
19495 cpp_get_callbacks (reader
)->translate_include
= NULL
;
19499 if (!spans
.init_p ())
19500 /* Before the main file, don't divert. */
19505 dump () && dump ("Checking include translation '%s'", path
);
19506 auto *mapper
= get_mapper (cpp_main_loc (reader
));
19508 size_t len
= strlen (path
);
19509 path
= canonicalize_header_name (NULL
, loc
, true, path
, len
);
19510 auto packet
= mapper
->IncludeTranslate (path
, Cody::Flags::None
, len
);
19512 if (packet
.GetCode () == Cody::Client::PC_BOOL
)
19513 xlate
= -int (packet
.GetInteger ());
19514 else if (packet
.GetCode () == Cody::Client::PC_PATHNAME
)
19516 /* Record the CMI name for when we do the import. */
19517 module_state
*import
= get_module (build_string (len
, path
));
19518 import
->set_filename (packet
);
19523 gcc_checking_assert (packet
.GetCode () == Cody::Client::PC_ERROR
);
19524 error_at (loc
, "cannot determine %<#include%> translation of %s: %s",
19525 path
, packet
.GetString ().c_str ());
19529 if (note_include_translate_yes
&& xlate
> 1)
19531 else if (note_include_translate_no
&& xlate
== 0)
19533 else if (note_includes
)
19534 /* We do not expect the note_includes vector to be large, so O(N)
19536 for (unsigned ix
= note_includes
->length (); !note
&& ix
--;)
19537 if (!strcmp ((*note_includes
)[ix
], path
))
19542 ? G_("include %qs translated to import")
19543 : G_("include %qs processed textually") , path
);
19545 dump () && dump (xlate
? "Translating include to import"
19546 : "Keeping include as include");
19552 /* Create the translation text. */
19553 loc
= ordinary_loc_of (lmaps
, loc
);
19554 const line_map_ordinary
*map
19555 = linemap_check_ordinary (linemap_lookup (lmaps
, loc
));
19556 unsigned col
= SOURCE_COLUMN (map
, loc
);
19557 col
-= (col
!= 0); /* Columns are 1-based. */
19559 unsigned alloc
= len
+ col
+ 60;
19560 char *res
= XNEWVEC (char, alloc
);
19562 strcpy (res
, "__import");
19563 unsigned actual
= 8;
19566 /* Pad out so the filename appears at the same position. */
19567 memset (res
+ actual
, ' ', col
- actual
);
19570 /* No need to encode characters, that's not how header names are
19572 actual
+= snprintf (res
+ actual
, alloc
- actual
,
19573 "\"%s\" [[__translated]];\n", path
);
19574 gcc_checking_assert (actual
< alloc
);
19576 /* cpplib will delete the buffer. */
19581 begin_header_unit (cpp_reader
*reader
)
19583 /* Set the module header name from the main_input_filename. */
19584 const char *main
= main_input_filename
;
19585 size_t len
= strlen (main
);
19586 main
= canonicalize_header_name (NULL
, 0, true, main
, len
);
19587 module_state
*module
= get_module (build_string (len
, main
));
19589 preprocess_module (module
, cpp_main_loc (reader
), false, false, true, reader
);
19592 /* We've just properly entered the main source file. I.e. after the
19593 command line, builtins and forced headers. Record the line map and
19594 location of this map. Note we may be called more than once. The
19595 first call sticks. */
19598 module_begin_main_file (cpp_reader
*reader
, line_maps
*lmaps
,
19599 const line_map_ordinary
*map
)
19601 gcc_checking_assert (lmaps
== line_table
);
19602 if (modules_p () && !spans
.init_p ())
19604 unsigned n
= dump
.push (NULL
);
19605 spans
.init (lmaps
, map
);
19607 if (flag_header_unit
&& !cpp_get_options (reader
)->preprocessed
)
19609 /* Tell the preprocessor this is an include file. */
19610 cpp_retrofit_as_include (reader
);
19611 begin_header_unit (reader
);
19616 /* Process the pending_import queue, making sure we know the
19620 name_pending_imports (cpp_reader
*reader
)
19622 auto *mapper
= get_mapper (cpp_main_loc (reader
));
19624 if (!vec_safe_length (pending_imports
))
19625 /* Not doing anything. */
19628 timevar_start (TV_MODULE_MAPPER
);
19630 auto n
= dump
.push (NULL
);
19631 dump () && dump ("Resolving direct import names");
19632 bool want_deps
= (bool (mapper
->get_flags () & Cody::Flags::NameOnly
)
19633 || cpp_get_deps (reader
));
19636 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19638 module_state
*module
= (*pending_imports
)[ix
];
19639 gcc_checking_assert (module
->is_direct ());
19640 if (!module
->filename
&& !module
->visited_p
)
19642 bool export_p
= (module
->module_p
19643 && (module
->is_partition () || module
->exported_p
));
19645 Cody::Flags flags
= Cody::Flags::None
;
19646 if (flag_preprocess_only
19647 && !(module
->is_header () && !export_p
))
19651 flags
= Cody::Flags::NameOnly
;
19660 mapper
->ModuleExport (module
->get_flatname (), flags
);
19662 mapper
->ModuleImport (module
->get_flatname (), flags
);
19663 module
->visited_p
= true;
19669 auto response
= mapper
->Uncork ();
19670 auto r_iter
= response
.begin ();
19671 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19673 module_state
*module
= (*pending_imports
)[ix
];
19674 if (module
->visited_p
)
19676 module
->visited_p
= false;
19677 gcc_checking_assert (!module
->filename
);
19679 module
->set_filename (*r_iter
);
19687 timevar_stop (TV_MODULE_MAPPER
);
19690 /* We've just lexed a module-specific control line for MODULE. Mark
19691 the module as a direct import, and possibly load up its macro
19692 state. Returns the primary module, if this is a module
19694 /* Perhaps we should offer a preprocessing mode where we read the
19695 directives from the header unit, rather than require the header's
19699 preprocess_module (module_state
*module
, location_t from_loc
,
19700 bool in_purview
, bool is_import
, bool is_export
,
19701 cpp_reader
*reader
)
19706 /* It's already been mentioned, so ignore its module-ness. */
19710 /* Record it is the module. */
19711 module
->module_p
= true;
19714 module
->exported_p
= true;
19715 module
->interface_p
= true;
19720 if (module
->directness
< MD_DIRECT
+ in_purview
)
19722 /* Mark as a direct import. */
19723 module
->directness
= module_directness (MD_DIRECT
+ in_purview
);
19725 /* Set the location to be most informative for users. */
19726 from_loc
= ordinary_loc_of (line_table
, from_loc
);
19727 if (module
->loadedness
!= ML_NONE
)
19728 linemap_module_reparent (line_table
, module
->loc
, from_loc
);
19731 module
->loc
= from_loc
;
19732 if (!module
->flatname
)
19733 module
->set_flatname ();
19737 auto desired
= ML_CONFIG
;
19739 && module
->is_header ()
19740 && (!cpp_get_options (reader
)->preprocessed
19741 || cpp_get_options (reader
)->directives_only
))
19742 /* We need preprocessor state now. */
19743 desired
= ML_PREPROCESSOR
;
19745 if (!is_import
|| module
->loadedness
< desired
)
19747 vec_safe_push (pending_imports
, module
);
19749 if (desired
== ML_PREPROCESSOR
)
19751 unsigned n
= dump
.push (NULL
);
19753 dump () && dump ("Reading %M preprocessor state", module
);
19754 name_pending_imports (reader
);
19756 /* Preserve the state of the line-map. */
19757 unsigned pre_hwm
= LINEMAPS_ORDINARY_USED (line_table
);
19759 /* We only need to close the span, if we're going to emit a
19760 CMI. But that's a little tricky -- our token scanner
19761 needs to be smarter -- and this isn't much state.
19762 Remember, we've not parsed anything at this point, so
19763 our module state flags are inadequate. */
19764 spans
.maybe_init ();
19767 timevar_start (TV_MODULE_IMPORT
);
19769 /* Load the config of each pending import -- we must assign
19770 module numbers monotonically. */
19771 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19773 auto *import
= (*pending_imports
)[ix
];
19774 if (!(import
->module_p
19775 && (import
->is_partition () || import
->exported_p
))
19776 && import
->loadedness
== ML_NONE
19777 && (import
->is_header () || !flag_preprocess_only
))
19779 unsigned n
= dump
.push (import
);
19780 import
->do_import (reader
, true);
19784 vec_free (pending_imports
);
19786 /* Restore the line-map state. */
19787 spans
.open (linemap_module_restore (line_table
, pre_hwm
));
19789 /* Now read the preprocessor state of this particular
19791 if (module
->loadedness
== ML_CONFIG
19792 && module
->read_preprocessor (true))
19793 module
->import_macros ();
19795 timevar_stop (TV_MODULE_IMPORT
);
19801 return is_import
? NULL
: get_primary (module
);
19804 /* We've completed phase-4 translation. Emit any dependency
19805 information for the not-yet-loaded direct imports, and fill in
19806 their file names. We'll have already loaded up the direct header
19810 preprocessed_module (cpp_reader
*reader
)
19812 unsigned n
= dump
.push (NULL
);
19814 dump () && dump ("Completed phase-4 (tokenization) processing");
19816 name_pending_imports (reader
);
19817 vec_free (pending_imports
);
19819 spans
.maybe_init ();
19822 using iterator
= hash_table
<module_state_hash
>::iterator
;
19823 if (mkdeps
*deps
= cpp_get_deps (reader
))
19825 /* Walk the module hash, informing the dependency machinery. */
19826 iterator end
= modules_hash
->end ();
19827 for (iterator iter
= modules_hash
->begin (); iter
!= end
; ++iter
)
19829 module_state
*module
= *iter
;
19831 if (module
->is_direct ())
19833 if (module
->is_module ()
19834 && (module
->is_interface () || module
->is_partition ()))
19835 deps_add_module_target (deps
, module
->get_flatname (),
19836 maybe_add_cmi_prefix (module
->filename
),
19837 module
->is_header (),
19838 module
->is_exported ());
19840 deps_add_module_dep (deps
, module
->get_flatname ());
19845 if (flag_header_unit
&& !flag_preprocess_only
)
19847 /* Find the main module -- remember, it's not yet in the module
19849 iterator end
= modules_hash
->end ();
19850 for (iterator iter
= modules_hash
->begin (); iter
!= end
; ++iter
)
19852 module_state
*module
= *iter
;
19853 if (module
->is_module ())
19855 declare_module (module
, cpp_main_loc (reader
), true, NULL
, reader
);
19856 module_kind
|= MK_EXPORTING
;
19865 /* VAL is a global tree, add it to the global vec if it is
19866 interesting. Add some of its targets, if they too are
19867 interesting. We do not add identifiers, as they can be re-found
19868 via the identifier hash table. There is a cost to the number of
19872 maybe_add_global (tree val
, unsigned &crc
)
19876 if (val
&& !(identifier_p (val
) || TREE_VISITED (val
)))
19878 TREE_VISITED (val
) = true;
19879 crc
= crc32_unsigned (crc
, fixed_trees
->length ());
19880 vec_safe_push (fixed_trees
, val
);
19883 if (CODE_CONTAINS_STRUCT (TREE_CODE (val
), TS_TYPED
))
19884 v
+= maybe_add_global (TREE_TYPE (val
), crc
);
19885 if (CODE_CONTAINS_STRUCT (TREE_CODE (val
), TS_TYPE_COMMON
))
19886 v
+= maybe_add_global (TYPE_NAME (val
), crc
);
19892 /* Initialize module state. Create the hash table, determine the
19893 global trees. Create the module for current TU. */
19896 init_modules (cpp_reader
*reader
)
19898 /* PCH should not be reachable because of lang-specs, but the
19899 user could have overriden that. */
19901 fatal_error (input_location
,
19902 "C++ modules are incompatible with precompiled headers");
19904 if (cpp_get_options (reader
)->traditional
)
19905 fatal_error (input_location
,
19906 "C++ modules are incompatible with traditional preprocessing");
19908 if (flag_preprocess_only
)
19910 cpp_options
*cpp_opts
= cpp_get_options (reader
);
19912 || (cpp_opts
->deps
.style
!= DEPS_NONE
19913 && !cpp_opts
->deps
.need_preprocessor_output
))
19915 warning (0, flag_dump_macros
== 'M'
19916 ? G_("macro debug output may be incomplete with modules")
19917 : G_("module dependencies require preprocessing"));
19918 if (cpp_opts
->deps
.style
!= DEPS_NONE
)
19919 inform (input_location
, "you should use the %<-%s%> option",
19920 cpp_opts
->deps
.style
== DEPS_SYSTEM
? "MD" : "MMD");
19924 /* :: is always exported. */
19925 DECL_MODULE_EXPORT_P (global_namespace
) = true;
19927 modules_hash
= hash_table
<module_state_hash
>::create_ggc (31);
19928 vec_safe_reserve (modules
, 20);
19930 /* Create module for current TU. */
19931 module_state
*current
19932 = new (ggc_alloc
<module_state
> ()) module_state (NULL_TREE
, NULL
, false);
19934 bitmap_set_bit (current
->imports
, 0);
19935 modules
->quick_push (current
);
19937 gcc_checking_assert (!fixed_trees
);
19939 headers
= BITMAP_GGC_ALLOC ();
19942 /* Canonicalize header names. */
19943 for (unsigned ix
= 0; ix
!= note_includes
->length (); ix
++)
19945 const char *hdr
= (*note_includes
)[ix
];
19946 size_t len
= strlen (hdr
);
19948 bool system
= hdr
[0] == '<';
19949 bool user
= hdr
[0] == '"';
19950 bool delimed
= system
|| user
;
19952 if (len
<= (delimed
? 2 : 0)
19953 || (delimed
&& hdr
[len
-1] != (system
? '>' : '"')))
19954 error ("invalid header name %qs", hdr
);
19956 hdr
= canonicalize_header_name (delimed
? reader
: NULL
,
19957 0, !delimed
, hdr
, len
);
19958 char *path
= XNEWVEC (char, len
+ 1);
19959 memcpy (path
, hdr
, len
);
19962 (*note_includes
)[ix
] = path
;
19966 /* Canonicalize & mark module names. */
19967 for (unsigned ix
= 0; ix
!= note_cmis
->length (); ix
++)
19969 const char *name
= (*note_cmis
)[ix
];
19970 size_t len
= strlen (name
);
19972 bool is_system
= name
[0] == '<';
19973 bool is_user
= name
[0] == '"';
19974 bool is_pathname
= false;
19975 if (!(is_system
|| is_user
))
19976 for (unsigned ix
= len
; !is_pathname
&& ix
--;)
19977 is_pathname
= IS_DIR_SEPARATOR (name
[ix
]);
19978 if (is_system
|| is_user
|| is_pathname
)
19980 if (len
<= (is_pathname
? 0 : 2)
19981 || (!is_pathname
&& name
[len
-1] != (is_system
? '>' : '"')))
19983 error ("invalid header name %qs", name
);
19987 name
= canonicalize_header_name (is_pathname
? nullptr : reader
,
19988 0, is_pathname
, name
, len
);
19990 if (auto module
= get_module (name
))
19991 module
->inform_cmi_p
= 1;
19993 error ("invalid module name %qs", name
);
19998 /* Determine lazy handle bound. */
20000 unsigned limit
= 1000;
20002 struct rlimit rlimit
;
20003 if (!getrlimit (RLIMIT_NOFILE
, &rlimit
))
20005 lazy_hard_limit
= (rlimit
.rlim_max
< 1000000
20006 ? unsigned (rlimit
.rlim_max
) : 1000000);
20007 lazy_hard_limit
= (lazy_hard_limit
> LAZY_HEADROOM
20008 ? lazy_hard_limit
- LAZY_HEADROOM
: 0);
20009 if (rlimit
.rlim_cur
< limit
)
20010 limit
= unsigned (rlimit
.rlim_cur
);
20013 limit
= limit
> LAZY_HEADROOM
? limit
- LAZY_HEADROOM
: 1;
20015 if (unsigned parm
= param_lazy_modules
)
20017 if (parm
<= limit
|| !lazy_hard_limit
|| !try_increase_lazy (parm
))
20021 lazy_limit
= limit
;
20027 version2string (MODULE_VERSION
, ver
);
20028 dump ("Source: %s", main_input_filename
);
20029 dump ("Compiler: %s", version_string
);
20030 dump ("Modules: %s", ver
);
20031 dump ("Checking: %s",
20034 #elif ENABLE_ASSERT_CHECKING
20040 dump ("Compiled by: "
20042 "GCC %d.%d, %s", __GNUC__
, __GNUC_MINOR__
,
20043 #ifdef __OPTIMIZE__
20052 dump ("Reading: %s", MAPPED_READING
? "mmap" : "fileio");
20053 dump ("Writing: %s", MAPPED_WRITING
? "mmap" : "fileio");
20054 dump ("Lazy limit: %u", lazy_limit
);
20055 dump ("Lazy hard limit: %u", lazy_hard_limit
);
20059 /* Construct the global tree array. This is an array of unique
20060 global trees (& types). Do this now, rather than lazily, as
20061 some global trees are lazily created and we don't want that to
20062 mess with our syndrome of fixed trees. */
20064 vec_alloc (fixed_trees
, 200);
20066 dump () && dump ("+Creating globals");
20067 /* Insert the TRANSLATION_UNIT_DECL. */
20068 TREE_VISITED (DECL_CONTEXT (global_namespace
)) = true;
20069 fixed_trees
->quick_push (DECL_CONTEXT (global_namespace
));
20070 for (unsigned jx
= 0; global_tree_arys
[jx
].first
; jx
++)
20072 const tree
*ptr
= global_tree_arys
[jx
].first
;
20073 unsigned limit
= global_tree_arys
[jx
].second
;
20075 for (unsigned ix
= 0; ix
!= limit
; ix
++, ptr
++)
20077 !(ix
& 31) && dump ("") && dump ("+\t%u:%u:", jx
, ix
);
20078 unsigned v
= maybe_add_global (*ptr
, crc
);
20079 dump () && dump ("+%u", v
);
20082 global_crc
= crc32_unsigned (crc
, fixed_trees
->length ());
20083 dump ("") && dump ("Created %u unique globals, crc=%x",
20084 fixed_trees
->length (), global_crc
);
20085 for (unsigned ix
= fixed_trees
->length (); ix
--;)
20086 TREE_VISITED ((*fixed_trees
)[ix
]) = false;
20090 if (!flag_module_lazy
)
20091 /* Get the mapper now, if we're not being lazy. */
20092 get_mapper (cpp_main_loc (reader
));
20094 if (!flag_preprocess_only
)
20096 pending_table
= new pending_map_t (EXPERIMENT (1, 400));
20097 entity_map
= new entity_map_t (EXPERIMENT (1, 400));
20098 vec_safe_reserve (entity_ary
, EXPERIMENT (1, 400));
20102 note_defs
= note_defs_table_t::create_ggc (1000);
20105 if (flag_header_unit
&& cpp_get_options (reader
)->preprocessed
)
20106 begin_header_unit (reader
);
20108 /* Collect here to make sure things are tagged correctly (when
20109 aggressively GC'd). */
20113 /* If NODE is a deferred macro, load it. */
20116 load_macros (cpp_reader
*reader
, cpp_hashnode
*node
, void *)
20118 location_t main_loc
20119 = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0));
20121 if (cpp_user_macro_p (node
)
20122 && !node
->value
.macro
)
20124 cpp_macro
*macro
= cpp_get_deferred_macro (reader
, node
, main_loc
);
20125 dump () && dump ("Loaded macro #%s %I",
20126 macro
? "define" : "undef", identifier (node
));
20132 /* At the end of tokenizing, we no longer need the macro tables of
20133 imports. But the user might have requested some checking. */
20136 maybe_check_all_macros (cpp_reader
*reader
)
20138 if (!warn_imported_macros
)
20141 /* Force loading of any remaining deferred macros. This will
20142 produce diagnostics if they are ill-formed. */
20143 unsigned n
= dump
.push (NULL
);
20144 cpp_forall_identifiers (reader
, load_macros
, NULL
);
20148 // State propagated from finish_module_processing to fini_modules
20150 struct module_processing_cookie
20153 module_state_config config
;
20159 module_processing_cookie (char *cmi
, char *tmp
, int fd
, int e
)
20160 : out (fd
, e
), cmi_name (cmi
), tmp_name (tmp
), crc (0), began (false)
20163 ~module_processing_cookie ()
20165 XDELETEVEC (tmp_name
);
20166 XDELETEVEC (cmi_name
);
20170 /* Write the CMI, if we're a module interface. */
20173 finish_module_processing (cpp_reader
*reader
)
20175 module_processing_cookie
*cookie
= nullptr;
20177 if (header_module_p ())
20178 module_kind
&= ~MK_EXPORTING
;
20180 if (!modules
|| !(*modules
)[0]->name
)
20182 if (flag_module_only
)
20183 warning (0, "%<-fmodule-only%> used for non-interface");
20185 else if (!flag_syntax_only
)
20190 timevar_start (TV_MODULE_EXPORT
);
20192 /* Force a valid but empty line map at the end. This simplifies
20193 the line table preparation and writing logic. */
20194 linemap_add (line_table
, LC_ENTER
, false, "", 0);
20196 /* We write to a tmpname, and then atomically rename. */
20197 char *cmi_name
= NULL
;
20198 char *tmp_name
= NULL
;
20199 module_state
*state
= (*modules
)[0];
20201 unsigned n
= dump
.push (state
);
20202 state
->announce ("creating");
20203 if (state
->filename
)
20206 cmi_name
= xstrdup (maybe_add_cmi_prefix (state
->filename
, &len
));
20207 tmp_name
= XNEWVEC (char, len
+ 3);
20208 memcpy (tmp_name
, cmi_name
, len
);
20209 strcpy (&tmp_name
[len
], "~");
20212 for (unsigned again
= 2; ; again
--)
20214 fd
= open (tmp_name
,
20215 O_RDWR
| O_CREAT
| O_TRUNC
| O_CLOEXEC
| O_BINARY
,
20216 S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IWGRP
|S_IROTH
|S_IWOTH
);
20218 if (fd
>= 0 || !again
|| e
!= ENOENT
)
20220 create_dirs (tmp_name
);
20222 if (note_module_cmi_yes
|| state
->inform_cmi_p
)
20223 inform (state
->loc
, "writing CMI %qs", cmi_name
);
20224 dump () && dump ("CMI is %s", cmi_name
);
20227 cookie
= new module_processing_cookie (cmi_name
, tmp_name
, fd
, e
);
20230 warning_at (state
->loc
, 0, "not writing module %qs due to errors",
20231 state
->get_flatname ());
20232 else if (cookie
->out
.begin ())
20234 cookie
->began
= true;
20235 auto loc
= input_location
;
20236 /* So crashes finger-point the module decl. */
20237 input_location
= state
->loc
;
20238 state
->write_begin (&cookie
->out
, reader
, cookie
->config
, cookie
->crc
);
20239 input_location
= loc
;
20243 timevar_stop (TV_MODULE_EXPORT
);
20250 unsigned n
= dump
.push (NULL
);
20251 dump () && dump ("Imported %u modules", modules
->length () - 1);
20252 dump () && dump ("Containing %u clusters", available_clusters
);
20253 dump () && dump ("Loaded %u clusters (%u%%)", loaded_clusters
,
20254 (loaded_clusters
* 100 + available_clusters
/ 2) /
20255 (available_clusters
+ !available_clusters
));
20262 // Do the final emission of a module. At this point we know whether
20263 // the module static initializer is a NOP or not.
20266 late_finish_module (cpp_reader
*reader
, module_processing_cookie
*cookie
,
20267 bool init_fn_non_empty
)
20269 timevar_start (TV_MODULE_EXPORT
);
20271 module_state
*state
= (*modules
)[0];
20272 unsigned n
= dump
.push (state
);
20273 state
->announce ("finishing");
20275 cookie
->config
.active_init
= init_fn_non_empty
;
20277 state
->write_end (&cookie
->out
, reader
, cookie
->config
, cookie
->crc
);
20279 if (cookie
->out
.end () && cookie
->cmi_name
)
20281 /* Some OS's do not replace NEWNAME if it already exists.
20282 This'll have a race condition in erroneous concurrent
20284 unlink (cookie
->cmi_name
);
20285 if (rename (cookie
->tmp_name
, cookie
->cmi_name
))
20287 dump () && dump ("Rename ('%s','%s') errno=%u",
20288 cookie
->tmp_name
, cookie
->cmi_name
, errno
);
20289 cookie
->out
.set_error (errno
);
20293 if (cookie
->out
.get_error () && cookie
->began
)
20295 error_at (state
->loc
, "failed to write compiled module: %s",
20296 cookie
->out
.get_error (state
->filename
));
20297 state
->note_cmi_name ();
20302 auto *mapper
= get_mapper (cpp_main_loc (reader
));
20303 mapper
->ModuleCompiled (state
->get_flatname ());
20305 else if (cookie
->cmi_name
)
20307 /* We failed, attempt to erase all evidence we even tried. */
20308 unlink (cookie
->tmp_name
);
20309 unlink (cookie
->cmi_name
);
20314 timevar_stop (TV_MODULE_EXPORT
);
20318 fini_modules (cpp_reader
*reader
, void *cookie
, bool has_inits
)
20321 late_finish_module (reader
,
20322 static_cast<module_processing_cookie
*> (cookie
),
20325 /* We're done with the macro tables now. */
20326 vec_free (macro_exports
);
20327 vec_free (macro_imports
);
20330 /* We're now done with everything but the module names. */
20331 set_cmi_repo (NULL
);
20334 timevar_start (TV_MODULE_MAPPER
);
20335 module_client::close_module_client (0, mapper
);
20337 timevar_stop (TV_MODULE_MAPPER
);
20339 module_state_config::release ();
20346 for (unsigned ix
= modules
->length (); --ix
;)
20347 if (module_state
*state
= (*modules
)[ix
])
20350 /* No need to lookup modules anymore. */
20351 modules_hash
= NULL
;
20353 /* Or entity array. We still need the entity map to find import numbers. */
20354 vec_free (entity_ary
);
20357 /* Or remember any pending entities. */
20358 delete pending_table
;
20359 pending_table
= NULL
;
20361 /* Or any keys -- Let it go! */
20362 delete keyed_table
;
20363 keyed_table
= NULL
;
20365 /* Allow a GC, we've possibly made much data unreachable. */
20369 /* If CODE is a module option, handle it & return true. Otherwise
20370 return false. For unknown reasons I cannot get the option
20371 generation machinery to set fmodule-mapper or -fmodule-header to
20372 make a string type option variable. */
20375 handle_module_option (unsigned code
, const char *str
, int)
20377 auto hdr
= CMS_header
;
20379 switch (opt_code (code
))
20381 case OPT_fmodule_mapper_
:
20382 module_mapper_name
= str
;
20385 case OPT_fmodule_header_
:
20387 if (!strcmp (str
, "user"))
20389 else if (!strcmp (str
, "system"))
20392 error ("unknown header kind %qs", str
);
20396 case OPT_fmodule_header
:
20397 flag_header_unit
= hdr
;
20401 case OPT_flang_info_include_translate_
:
20402 vec_safe_push (note_includes
, str
);
20405 case OPT_flang_info_module_cmi_
:
20406 vec_safe_push (note_cmis
, str
);
20414 /* Set preprocessor callbacks and options for modules. */
20417 module_preprocess_options (cpp_reader
*reader
)
20419 gcc_checking_assert (!lang_hooks
.preprocess_undef
);
20422 auto *cb
= cpp_get_callbacks (reader
);
20424 cb
->translate_include
= maybe_translate_include
;
20425 cb
->user_deferred_macro
= module_state::deferred_macro
;
20426 if (flag_header_unit
)
20428 /* If the preprocessor hook is already in use, that
20429 implementation will call the undef langhook. */
20431 lang_hooks
.preprocess_undef
= module_state::undef_macro
;
20433 cb
->undef
= module_state::undef_macro
;
20435 auto *opt
= cpp_get_options (reader
);
20436 opt
->module_directives
= true;
20437 opt
->main_search
= cpp_main_search (flag_header_unit
);
20441 #include "gt-cp-module.h"