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
, class mkdeps
*deps
);
3973 inline module_client
*get_mapper (location_t loc
, class mkdeps
*deps
)
3977 res
= make_mapper (loc
, deps
);
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
));
5164 state
->extensions
|= SE_OPENMP
;
5165 u (OMP_CLAUSE_CODE (t
));
5169 str (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
5173 u (VECTOR_CST_LOG2_NPATTERNS (t
));
5174 u (VECTOR_CST_NELTS_PER_PATTERN (t
));
5178 u (BINFO_N_BASE_BINFOS (t
));
5182 u (TREE_VEC_LENGTH (t
));
5187 gcc_unreachable (); /* Not supported in C++. */
5190 case IDENTIFIER_NODE
:
5192 case TARGET_MEM_REF
:
5193 case TRANSLATION_UNIT_DECL
:
5194 /* We shouldn't meet these. */
5200 /* Start tree read. Allocate the receiving node. */
5203 trees_in::start (unsigned code
)
5213 if (code
>= MAX_TREE_CODES
)
5219 else if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5221 unsigned ops
= u ();
5222 t
= build_vl_exp (tree_code (code
), ops
);
5225 t
= make_node (tree_code (code
));
5232 t
= make_int_cst (n
, e
);
5238 if (!(state
->extensions
& SE_OPENMP
))
5241 unsigned omp_code
= u ();
5242 t
= build_omp_clause (UNKNOWN_LOCATION
, omp_clause_code (omp_code
));
5249 const char *chars
= str (&l
);
5250 t
= build_string (l
, chars
);
5256 unsigned log2_npats
= u ();
5257 unsigned elts_per
= u ();
5258 t
= make_vector (log2_npats
, elts_per
);
5263 t
= make_tree_binfo (u ());
5267 t
= make_tree_vec (u ());
5271 case IDENTIFIER_NODE
:
5274 case TARGET_MEM_REF
:
5275 case TRANSLATION_UNIT_DECL
:
5282 /* The structure streamers access the raw fields, because the
5283 alternative, of using the accessor macros can require using
5284 different accessors for the same underlying field, depending on the
5285 tree code. That's both confusing and annoying. */
5287 /* Read & write the core boolean flags. */
5290 trees_out::core_bools (tree t
)
5292 #define WB(X) (b (X))
5293 tree_code code
= TREE_CODE (t
);
5295 WB (t
->base
.side_effects_flag
);
5296 WB (t
->base
.constant_flag
);
5297 WB (t
->base
.addressable_flag
);
5298 WB (t
->base
.volatile_flag
);
5299 WB (t
->base
.readonly_flag
);
5300 /* base.asm_written_flag is a property of the current TU's use of
5302 WB (t
->base
.nowarning_flag
);
5303 /* base.visited read as zero (it's set for writer, because that's
5304 how we mark nodes). */
5305 /* base.used_flag is not streamed. Readers may set TREE_USED of
5307 WB (t
->base
.nothrow_flag
);
5308 WB (t
->base
.static_flag
);
5309 if (TREE_CODE_CLASS (code
) != tcc_type
)
5310 /* This is TYPE_CACHED_VALUES_P for types. */
5311 WB (t
->base
.public_flag
);
5312 WB (t
->base
.private_flag
);
5313 WB (t
->base
.protected_flag
);
5314 WB (t
->base
.deprecated_flag
);
5315 WB (t
->base
.default_def_flag
);
5322 case TARGET_MEM_REF
:
5324 /* These use different base.u fields. */
5328 WB (t
->base
.u
.bits
.lang_flag_0
);
5329 bool flag_1
= t
->base
.u
.bits
.lang_flag_1
;
5332 else if (code
== TEMPLATE_INFO
)
5333 /* This is TI_PENDING_TEMPLATE_FLAG, not relevant to reader. */
5335 else if (code
== VAR_DECL
)
5337 /* This is DECL_INITIALIZED_P. */
5338 if (TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
5339 /* We'll set this when reading the definition. */
5343 WB (t
->base
.u
.bits
.lang_flag_2
);
5344 WB (t
->base
.u
.bits
.lang_flag_3
);
5345 WB (t
->base
.u
.bits
.lang_flag_4
);
5346 WB (t
->base
.u
.bits
.lang_flag_5
);
5347 WB (t
->base
.u
.bits
.lang_flag_6
);
5348 WB (t
->base
.u
.bits
.saturating_flag
);
5349 WB (t
->base
.u
.bits
.unsigned_flag
);
5350 WB (t
->base
.u
.bits
.packed_flag
);
5351 WB (t
->base
.u
.bits
.user_align
);
5352 WB (t
->base
.u
.bits
.nameless_flag
);
5353 WB (t
->base
.u
.bits
.atomic_flag
);
5357 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5359 WB (t
->type_common
.no_force_blk_flag
);
5360 WB (t
->type_common
.needs_constructing_flag
);
5361 WB (t
->type_common
.transparent_aggr_flag
);
5362 WB (t
->type_common
.restrict_flag
);
5363 WB (t
->type_common
.string_flag
);
5364 WB (t
->type_common
.lang_flag_0
);
5365 WB (t
->type_common
.lang_flag_1
);
5366 WB (t
->type_common
.lang_flag_2
);
5367 WB (t
->type_common
.lang_flag_3
);
5368 WB (t
->type_common
.lang_flag_4
);
5369 WB (t
->type_common
.lang_flag_5
);
5370 WB (t
->type_common
.lang_flag_6
);
5371 WB (t
->type_common
.typeless_storage
);
5374 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5376 WB (t
->decl_common
.nonlocal_flag
);
5377 WB (t
->decl_common
.virtual_flag
);
5378 WB (t
->decl_common
.ignored_flag
);
5379 WB (t
->decl_common
.abstract_flag
);
5380 WB (t
->decl_common
.artificial_flag
);
5381 WB (t
->decl_common
.preserve_flag
);
5382 WB (t
->decl_common
.debug_expr_is_from
);
5383 WB (t
->decl_common
.lang_flag_0
);
5384 WB (t
->decl_common
.lang_flag_1
);
5385 WB (t
->decl_common
.lang_flag_2
);
5386 WB (t
->decl_common
.lang_flag_3
);
5387 WB (t
->decl_common
.lang_flag_4
);
5388 WB (t
->decl_common
.lang_flag_5
);
5389 WB (t
->decl_common
.lang_flag_6
);
5390 WB (t
->decl_common
.lang_flag_7
);
5391 WB (t
->decl_common
.lang_flag_8
);
5392 WB (t
->decl_common
.decl_flag_0
);
5395 /* DECL_EXTERNAL -> decl_flag_1
5396 == it is defined elsewhere
5397 DECL_NOT_REALLY_EXTERN -> base.not_really_extern
5398 == that was a lie, it is here */
5400 bool is_external
= t
->decl_common
.decl_flag_1
;
5402 /* decl_flag_1 is DECL_EXTERNAL. Things we emit here, might
5403 well be external from the POV of an importer. */
5404 // FIXME: Do we need to know if this is a TEMPLATE_RESULT --
5405 // a flag from the caller?
5413 && !(TREE_STATIC (t
)
5414 && DECL_FUNCTION_SCOPE_P (t
)
5415 && DECL_DECLARED_INLINE_P (DECL_CONTEXT (t
)))
5416 && !DECL_VAR_DECLARED_INLINE_P (t
))
5422 && !DECL_DECLARED_INLINE_P (t
))
5429 WB (t
->decl_common
.decl_flag_2
);
5430 WB (t
->decl_common
.decl_flag_3
);
5431 WB (t
->decl_common
.not_gimple_reg_flag
);
5432 WB (t
->decl_common
.decl_by_reference_flag
);
5433 WB (t
->decl_common
.decl_read_flag
);
5434 WB (t
->decl_common
.decl_nonshareable_flag
);
5435 WB (t
->decl_common
.decl_not_flexarray
);
5438 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
5440 WB (t
->decl_with_vis
.defer_output
);
5441 WB (t
->decl_with_vis
.hard_register
);
5442 WB (t
->decl_with_vis
.common_flag
);
5443 WB (t
->decl_with_vis
.in_text_section
);
5444 WB (t
->decl_with_vis
.in_constant_pool
);
5445 WB (t
->decl_with_vis
.dllimport_flag
);
5446 WB (t
->decl_with_vis
.weak_flag
);
5447 WB (t
->decl_with_vis
.seen_in_bind_expr
);
5448 WB (t
->decl_with_vis
.comdat_flag
);
5449 WB (t
->decl_with_vis
.visibility_specified
);
5450 WB (t
->decl_with_vis
.init_priority_p
);
5451 WB (t
->decl_with_vis
.shadowed_for_var_p
);
5452 WB (t
->decl_with_vis
.cxx_constructor
);
5453 WB (t
->decl_with_vis
.cxx_destructor
);
5454 WB (t
->decl_with_vis
.final
);
5455 WB (t
->decl_with_vis
.regdecl_flag
);
5458 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
5460 WB (t
->function_decl
.static_ctor_flag
);
5461 WB (t
->function_decl
.static_dtor_flag
);
5462 WB (t
->function_decl
.uninlinable
);
5463 WB (t
->function_decl
.possibly_inlined
);
5464 WB (t
->function_decl
.novops_flag
);
5465 WB (t
->function_decl
.returns_twice_flag
);
5466 WB (t
->function_decl
.malloc_flag
);
5467 WB (t
->function_decl
.declared_inline_flag
);
5468 WB (t
->function_decl
.no_inline_warning_flag
);
5469 WB (t
->function_decl
.no_instrument_function_entry_exit
);
5470 WB (t
->function_decl
.no_limit_stack
);
5471 WB (t
->function_decl
.disregard_inline_limits
);
5472 WB (t
->function_decl
.pure_flag
);
5473 WB (t
->function_decl
.looping_const_or_pure_flag
);
5475 WB (t
->function_decl
.has_debug_args_flag
);
5476 WB (t
->function_decl
.versioned_function
);
5478 /* decl_type is a (misnamed) 2 bit discriminator. */
5479 unsigned kind
= t
->function_decl
.decl_type
;
5480 WB ((kind
>> 0) & 1);
5481 WB ((kind
>> 1) & 1);
5487 trees_in::core_bools (tree t
)
5489 #define RB(X) ((X) = b ())
5490 tree_code code
= TREE_CODE (t
);
5492 RB (t
->base
.side_effects_flag
);
5493 RB (t
->base
.constant_flag
);
5494 RB (t
->base
.addressable_flag
);
5495 RB (t
->base
.volatile_flag
);
5496 RB (t
->base
.readonly_flag
);
5497 /* base.asm_written_flag is not streamed. */
5498 RB (t
->base
.nowarning_flag
);
5499 /* base.visited is not streamed. */
5500 /* base.used_flag is not streamed. */
5501 RB (t
->base
.nothrow_flag
);
5502 RB (t
->base
.static_flag
);
5503 if (TREE_CODE_CLASS (code
) != tcc_type
)
5504 RB (t
->base
.public_flag
);
5505 RB (t
->base
.private_flag
);
5506 RB (t
->base
.protected_flag
);
5507 RB (t
->base
.deprecated_flag
);
5508 RB (t
->base
.default_def_flag
);
5515 case TARGET_MEM_REF
:
5517 /* These use different base.u fields. */
5521 RB (t
->base
.u
.bits
.lang_flag_0
);
5522 RB (t
->base
.u
.bits
.lang_flag_1
);
5523 RB (t
->base
.u
.bits
.lang_flag_2
);
5524 RB (t
->base
.u
.bits
.lang_flag_3
);
5525 RB (t
->base
.u
.bits
.lang_flag_4
);
5526 RB (t
->base
.u
.bits
.lang_flag_5
);
5527 RB (t
->base
.u
.bits
.lang_flag_6
);
5528 RB (t
->base
.u
.bits
.saturating_flag
);
5529 RB (t
->base
.u
.bits
.unsigned_flag
);
5530 RB (t
->base
.u
.bits
.packed_flag
);
5531 RB (t
->base
.u
.bits
.user_align
);
5532 RB (t
->base
.u
.bits
.nameless_flag
);
5533 RB (t
->base
.u
.bits
.atomic_flag
);
5537 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5539 RB (t
->type_common
.no_force_blk_flag
);
5540 RB (t
->type_common
.needs_constructing_flag
);
5541 RB (t
->type_common
.transparent_aggr_flag
);
5542 RB (t
->type_common
.restrict_flag
);
5543 RB (t
->type_common
.string_flag
);
5544 RB (t
->type_common
.lang_flag_0
);
5545 RB (t
->type_common
.lang_flag_1
);
5546 RB (t
->type_common
.lang_flag_2
);
5547 RB (t
->type_common
.lang_flag_3
);
5548 RB (t
->type_common
.lang_flag_4
);
5549 RB (t
->type_common
.lang_flag_5
);
5550 RB (t
->type_common
.lang_flag_6
);
5551 RB (t
->type_common
.typeless_storage
);
5554 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5556 RB (t
->decl_common
.nonlocal_flag
);
5557 RB (t
->decl_common
.virtual_flag
);
5558 RB (t
->decl_common
.ignored_flag
);
5559 RB (t
->decl_common
.abstract_flag
);
5560 RB (t
->decl_common
.artificial_flag
);
5561 RB (t
->decl_common
.preserve_flag
);
5562 RB (t
->decl_common
.debug_expr_is_from
);
5563 RB (t
->decl_common
.lang_flag_0
);
5564 RB (t
->decl_common
.lang_flag_1
);
5565 RB (t
->decl_common
.lang_flag_2
);
5566 RB (t
->decl_common
.lang_flag_3
);
5567 RB (t
->decl_common
.lang_flag_4
);
5568 RB (t
->decl_common
.lang_flag_5
);
5569 RB (t
->decl_common
.lang_flag_6
);
5570 RB (t
->decl_common
.lang_flag_7
);
5571 RB (t
->decl_common
.lang_flag_8
);
5572 RB (t
->decl_common
.decl_flag_0
);
5573 RB (t
->decl_common
.decl_flag_1
);
5574 RB (t
->decl_common
.decl_flag_2
);
5575 RB (t
->decl_common
.decl_flag_3
);
5576 RB (t
->decl_common
.not_gimple_reg_flag
);
5577 RB (t
->decl_common
.decl_by_reference_flag
);
5578 RB (t
->decl_common
.decl_read_flag
);
5579 RB (t
->decl_common
.decl_nonshareable_flag
);
5580 RB (t
->decl_common
.decl_not_flexarray
);
5583 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
5585 RB (t
->decl_with_vis
.defer_output
);
5586 RB (t
->decl_with_vis
.hard_register
);
5587 RB (t
->decl_with_vis
.common_flag
);
5588 RB (t
->decl_with_vis
.in_text_section
);
5589 RB (t
->decl_with_vis
.in_constant_pool
);
5590 RB (t
->decl_with_vis
.dllimport_flag
);
5591 RB (t
->decl_with_vis
.weak_flag
);
5592 RB (t
->decl_with_vis
.seen_in_bind_expr
);
5593 RB (t
->decl_with_vis
.comdat_flag
);
5594 RB (t
->decl_with_vis
.visibility_specified
);
5595 RB (t
->decl_with_vis
.init_priority_p
);
5596 RB (t
->decl_with_vis
.shadowed_for_var_p
);
5597 RB (t
->decl_with_vis
.cxx_constructor
);
5598 RB (t
->decl_with_vis
.cxx_destructor
);
5599 RB (t
->decl_with_vis
.final
);
5600 RB (t
->decl_with_vis
.regdecl_flag
);
5603 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
5605 RB (t
->function_decl
.static_ctor_flag
);
5606 RB (t
->function_decl
.static_dtor_flag
);
5607 RB (t
->function_decl
.uninlinable
);
5608 RB (t
->function_decl
.possibly_inlined
);
5609 RB (t
->function_decl
.novops_flag
);
5610 RB (t
->function_decl
.returns_twice_flag
);
5611 RB (t
->function_decl
.malloc_flag
);
5612 RB (t
->function_decl
.declared_inline_flag
);
5613 RB (t
->function_decl
.no_inline_warning_flag
);
5614 RB (t
->function_decl
.no_instrument_function_entry_exit
);
5615 RB (t
->function_decl
.no_limit_stack
);
5616 RB (t
->function_decl
.disregard_inline_limits
);
5617 RB (t
->function_decl
.pure_flag
);
5618 RB (t
->function_decl
.looping_const_or_pure_flag
);
5620 RB (t
->function_decl
.has_debug_args_flag
);
5621 RB (t
->function_decl
.versioned_function
);
5623 /* decl_type is a (misnamed) 2 bit discriminator. */
5625 kind
|= unsigned (b ()) << 0;
5626 kind
|= unsigned (b ()) << 1;
5627 t
->function_decl
.decl_type
= function_decl_type (kind
);
5630 return !get_overrun ();
5634 trees_out::lang_decl_bools (tree t
)
5636 #define WB(X) (b (X))
5637 const struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
5639 WB (lang
->u
.base
.language
== lang_cplusplus
);
5640 WB ((lang
->u
.base
.use_template
>> 0) & 1);
5641 WB ((lang
->u
.base
.use_template
>> 1) & 1);
5642 /* Do not write lang->u.base.not_really_extern, importer will set
5643 when reading the definition (if any). */
5644 WB (lang
->u
.base
.initialized_in_class
);
5645 WB (lang
->u
.base
.threadprivate_or_deleted_p
);
5646 /* Do not write lang->u.base.anticipated_p, it is a property of the
5648 WB (lang
->u
.base
.friend_or_tls
);
5649 WB (lang
->u
.base
.unknown_bound_p
);
5650 /* Do not write lang->u.base.odr_used, importer will recalculate if
5651 they do ODR use this decl. */
5652 WB (lang
->u
.base
.concept_p
);
5653 WB (lang
->u
.base
.var_declared_inline_p
);
5654 WB (lang
->u
.base
.dependent_init_p
);
5655 /* When building a header unit, everthing is marked as purview, (so
5656 we know which decls to write). But when we import them we do not
5657 want to mark them as in module purview. */
5658 WB (lang
->u
.base
.module_purview_p
&& !header_module_p ());
5659 WB (lang
->u
.base
.module_attach_p
);
5660 if (VAR_OR_FUNCTION_DECL_P (t
))
5661 WB (lang
->u
.base
.module_keyed_decls_p
);
5662 switch (lang
->u
.base
.selector
)
5667 case lds_fn
: /* lang_decl_fn. */
5668 WB (lang
->u
.fn
.global_ctor_p
);
5669 WB (lang
->u
.fn
.global_dtor_p
);
5670 WB (lang
->u
.fn
.static_function
);
5671 WB (lang
->u
.fn
.pure_virtual
);
5672 WB (lang
->u
.fn
.defaulted_p
);
5673 WB (lang
->u
.fn
.has_in_charge_parm_p
);
5674 WB (lang
->u
.fn
.has_vtt_parm_p
);
5675 /* There shouldn't be a pending inline at this point. */
5676 gcc_assert (!lang
->u
.fn
.pending_inline_p
);
5677 WB (lang
->u
.fn
.nonconverting
);
5678 WB (lang
->u
.fn
.thunk_p
);
5679 WB (lang
->u
.fn
.this_thunk_p
);
5680 /* Do not stream lang->u.hidden_friend_p, it is a property of
5682 WB (lang
->u
.fn
.omp_declare_reduction_p
);
5683 WB (lang
->u
.fn
.has_dependent_explicit_spec_p
);
5684 WB (lang
->u
.fn
.immediate_fn_p
);
5685 WB (lang
->u
.fn
.maybe_deleted
);
5688 case lds_decomp
: /* lang_decl_decomp. */
5692 case lds_min
: /* lang_decl_min. */
5697 case lds_ns
: /* lang_decl_ns. */
5701 case lds_parm
: /* lang_decl_parm. */
5709 trees_in::lang_decl_bools (tree t
)
5711 #define RB(X) ((X) = b ())
5712 struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
5714 lang
->u
.base
.language
= b () ? lang_cplusplus
: lang_c
;
5718 lang
->u
.base
.use_template
= v
;
5719 /* lang->u.base.not_really_extern is not streamed. */
5720 RB (lang
->u
.base
.initialized_in_class
);
5721 RB (lang
->u
.base
.threadprivate_or_deleted_p
);
5722 /* lang->u.base.anticipated_p is not streamed. */
5723 RB (lang
->u
.base
.friend_or_tls
);
5724 RB (lang
->u
.base
.unknown_bound_p
);
5725 /* lang->u.base.odr_used is not streamed. */
5726 RB (lang
->u
.base
.concept_p
);
5727 RB (lang
->u
.base
.var_declared_inline_p
);
5728 RB (lang
->u
.base
.dependent_init_p
);
5729 RB (lang
->u
.base
.module_purview_p
);
5730 RB (lang
->u
.base
.module_attach_p
);
5731 if (VAR_OR_FUNCTION_DECL_P (t
))
5732 RB (lang
->u
.base
.module_keyed_decls_p
);
5733 switch (lang
->u
.base
.selector
)
5738 case lds_fn
: /* lang_decl_fn. */
5739 RB (lang
->u
.fn
.global_ctor_p
);
5740 RB (lang
->u
.fn
.global_dtor_p
);
5741 RB (lang
->u
.fn
.static_function
);
5742 RB (lang
->u
.fn
.pure_virtual
);
5743 RB (lang
->u
.fn
.defaulted_p
);
5744 RB (lang
->u
.fn
.has_in_charge_parm_p
);
5745 RB (lang
->u
.fn
.has_vtt_parm_p
);
5746 RB (lang
->u
.fn
.nonconverting
);
5747 RB (lang
->u
.fn
.thunk_p
);
5748 RB (lang
->u
.fn
.this_thunk_p
);
5749 /* lang->u.fn.hidden_friend_p is not streamed. */
5750 RB (lang
->u
.fn
.omp_declare_reduction_p
);
5751 RB (lang
->u
.fn
.has_dependent_explicit_spec_p
);
5752 RB (lang
->u
.fn
.immediate_fn_p
);
5753 RB (lang
->u
.fn
.maybe_deleted
);
5756 case lds_decomp
: /* lang_decl_decomp. */
5760 case lds_min
: /* lang_decl_min. */
5765 case lds_ns
: /* lang_decl_ns. */
5769 case lds_parm
: /* lang_decl_parm. */
5774 return !get_overrun ();
5778 trees_out::lang_type_bools (tree t
)
5780 #define WB(X) (b (X))
5781 const struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
5783 WB (lang
->has_type_conversion
);
5784 WB (lang
->has_copy_ctor
);
5785 WB (lang
->has_default_ctor
);
5786 WB (lang
->const_needs_init
);
5787 WB (lang
->ref_needs_init
);
5788 WB (lang
->has_const_copy_assign
);
5789 WB ((lang
->use_template
>> 0) & 1);
5790 WB ((lang
->use_template
>> 1) & 1);
5792 WB (lang
->has_mutable
);
5793 WB (lang
->com_interface
);
5794 WB (lang
->non_pod_class
);
5795 WB (lang
->nearly_empty_p
);
5796 WB (lang
->user_align
);
5797 WB (lang
->has_copy_assign
);
5799 WB (lang
->has_array_new
);
5801 WB ((lang
->gets_delete
>> 0) & 1);
5802 WB ((lang
->gets_delete
>> 1) & 1);
5803 // Interfaceness is recalculated upon reading. May have to revisit?
5804 // How do dllexport and dllimport interact across a module?
5805 // lang->interface_only
5806 // lang->interface_unknown
5807 WB (lang
->contains_empty_class_p
);
5808 WB (lang
->anon_aggr
);
5809 WB (lang
->non_zero_init
);
5812 WB (lang
->vec_new_uses_cookie
);
5813 WB (lang
->declared_class
);
5814 WB (lang
->diamond_shaped
);
5815 WB (lang
->repeated_base
);
5816 gcc_assert (!lang
->being_defined
);
5817 // lang->debug_requested
5818 WB (lang
->fields_readonly
);
5819 WB (lang
->ptrmemfunc_flag
);
5821 WB (lang
->lazy_default_ctor
);
5822 WB (lang
->lazy_copy_ctor
);
5823 WB (lang
->lazy_copy_assign
);
5824 WB (lang
->lazy_destructor
);
5825 WB (lang
->has_const_copy_ctor
);
5826 WB (lang
->has_complex_copy_ctor
);
5827 WB (lang
->has_complex_copy_assign
);
5828 WB (lang
->non_aggregate
);
5830 WB (lang
->has_complex_dflt
);
5831 WB (lang
->has_list_ctor
);
5832 WB (lang
->non_std_layout
);
5833 WB (lang
->is_literal
);
5834 WB (lang
->lazy_move_ctor
);
5835 WB (lang
->lazy_move_assign
);
5836 WB (lang
->has_complex_move_ctor
);
5837 WB (lang
->has_complex_move_assign
);
5839 WB (lang
->has_constexpr_ctor
);
5840 WB (lang
->unique_obj_representations
);
5841 WB (lang
->unique_obj_representations_set
);
5846 trees_in::lang_type_bools (tree t
)
5848 #define RB(X) ((X) = b ())
5849 struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
5851 RB (lang
->has_type_conversion
);
5852 RB (lang
->has_copy_ctor
);
5853 RB (lang
->has_default_ctor
);
5854 RB (lang
->const_needs_init
);
5855 RB (lang
->ref_needs_init
);
5856 RB (lang
->has_const_copy_assign
);
5860 lang
->use_template
= v
;
5862 RB (lang
->has_mutable
);
5863 RB (lang
->com_interface
);
5864 RB (lang
->non_pod_class
);
5865 RB (lang
->nearly_empty_p
);
5866 RB (lang
->user_align
);
5867 RB (lang
->has_copy_assign
);
5869 RB (lang
->has_array_new
);
5873 lang
->gets_delete
= v
;
5874 // lang->interface_only
5875 // lang->interface_unknown
5876 lang
->interface_unknown
= true; // Redetermine interface
5877 RB (lang
->contains_empty_class_p
);
5878 RB (lang
->anon_aggr
);
5879 RB (lang
->non_zero_init
);
5882 RB (lang
->vec_new_uses_cookie
);
5883 RB (lang
->declared_class
);
5884 RB (lang
->diamond_shaped
);
5885 RB (lang
->repeated_base
);
5886 gcc_assert (!lang
->being_defined
);
5887 gcc_assert (!lang
->debug_requested
);
5888 RB (lang
->fields_readonly
);
5889 RB (lang
->ptrmemfunc_flag
);
5891 RB (lang
->lazy_default_ctor
);
5892 RB (lang
->lazy_copy_ctor
);
5893 RB (lang
->lazy_copy_assign
);
5894 RB (lang
->lazy_destructor
);
5895 RB (lang
->has_const_copy_ctor
);
5896 RB (lang
->has_complex_copy_ctor
);
5897 RB (lang
->has_complex_copy_assign
);
5898 RB (lang
->non_aggregate
);
5900 RB (lang
->has_complex_dflt
);
5901 RB (lang
->has_list_ctor
);
5902 RB (lang
->non_std_layout
);
5903 RB (lang
->is_literal
);
5904 RB (lang
->lazy_move_ctor
);
5905 RB (lang
->lazy_move_assign
);
5906 RB (lang
->has_complex_move_ctor
);
5907 RB (lang
->has_complex_move_assign
);
5909 RB (lang
->has_constexpr_ctor
);
5910 RB (lang
->unique_obj_representations
);
5911 RB (lang
->unique_obj_representations_set
);
5913 return !get_overrun ();
5916 /* Read & write the core values and pointers. */
5919 trees_out::core_vals (tree t
)
5921 #define WU(X) (u (X))
5922 #define WT(X) (tree_node (X))
5923 tree_code code
= TREE_CODE (t
);
5925 /* First by shape of the tree. */
5927 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
5929 /* Write this early, for better log information. */
5930 WT (t
->decl_minimal
.name
);
5931 if (!DECL_TEMPLATE_PARM_P (t
))
5932 WT (t
->decl_minimal
.context
);
5935 state
->write_location (*this, t
->decl_minimal
.locus
);
5938 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
5940 /* The only types we write also have TYPE_NON_COMMON. */
5941 gcc_checking_assert (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
));
5943 /* We only stream the main variant. */
5944 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
5946 /* Stream the name & context first, for better log information */
5947 WT (t
->type_common
.name
);
5948 WT (t
->type_common
.context
);
5950 /* By construction we want to make sure we have the canonical
5951 and main variants already in the type table, so emit them
5953 WT (t
->type_common
.main_variant
);
5955 tree canonical
= t
->type_common
.canonical
;
5956 if (canonical
&& DECL_TEMPLATE_PARM_P (TYPE_NAME (t
)))
5957 /* We do not want to wander into different templates.
5958 Reconstructed on stream in. */
5962 /* type_common.next_variant is internally manipulated. */
5963 /* type_common.pointer_to, type_common.reference_to. */
5967 WU (t
->type_common
.precision
);
5968 WU (t
->type_common
.contains_placeholder_bits
);
5969 WU (t
->type_common
.mode
);
5970 WU (t
->type_common
.align
);
5973 if (!RECORD_OR_UNION_CODE_P (code
))
5975 WT (t
->type_common
.size
);
5976 WT (t
->type_common
.size_unit
);
5978 WT (t
->type_common
.attributes
);
5980 WT (t
->type_common
.common
.chain
); /* TYPE_STUB_DECL. */
5983 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
5987 WU (t
->decl_common
.mode
);
5988 WU (t
->decl_common
.off_align
);
5989 WU (t
->decl_common
.align
);
5992 /* For templates these hold instantiation (partial and/or
5993 specialization) information. */
5994 if (code
!= TEMPLATE_DECL
)
5996 WT (t
->decl_common
.size
);
5997 WT (t
->decl_common
.size_unit
);
6000 WT (t
->decl_common
.attributes
);
6001 // FIXME: Does this introduce cross-decl links? For instance
6002 // from instantiation to the template. If so, we'll need more
6003 // deduplication logic. I think we'll need to walk the blocks
6004 // of the owning function_decl's abstract origin in tandem, to
6005 // generate the locating data needed?
6006 WT (t
->decl_common
.abstract_origin
);
6009 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
6011 WT (t
->decl_with_vis
.assembler_name
);
6013 WU (t
->decl_with_vis
.visibility
);
6016 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
6018 if (code
== ENUMERAL_TYPE
)
6020 /* These fields get set even for opaque enums that lack a
6021 definition, so we stream them directly for each ENUMERAL_TYPE.
6022 We stream TYPE_VALUES as part of the definition. */
6023 WT (t
->type_non_common
.maxval
);
6024 WT (t
->type_non_common
.minval
);
6026 /* Records and unions hold FIELDS, VFIELD & BINFO on these
6028 else if (!RECORD_OR_UNION_CODE_P (code
))
6030 // FIXME: These are from tpl_parm_value's 'type' writing.
6031 // Perhaps it should just be doing them directly?
6032 gcc_checking_assert (code
== TEMPLATE_TYPE_PARM
6033 || code
== TEMPLATE_TEMPLATE_PARM
6034 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
);
6035 gcc_checking_assert (!TYPE_CACHED_VALUES_P (t
));
6036 WT (t
->type_non_common
.values
);
6037 WT (t
->type_non_common
.maxval
);
6038 WT (t
->type_non_common
.minval
);
6041 WT (t
->type_non_common
.lang_1
);
6044 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
6047 state
->write_location (*this, t
->exp
.locus
);
6049 /* Walk in forward order, as (for instance) REQUIRES_EXPR has a
6050 bunch of unscoped parms on its first operand. It's safer to
6051 create those in order. */
6052 bool vl
= TREE_CODE_CLASS (code
) == tcc_vl_exp
;
6053 for (unsigned limit
= (vl
? VL_EXP_OPERAND_LENGTH (t
)
6054 : TREE_OPERAND_LENGTH (t
)),
6055 ix
= unsigned (vl
); ix
!= limit
; ix
++)
6056 WT (TREE_OPERAND (t
, ix
));
6059 /* The CODE_CONTAINS tables were inaccurate when I started. */
6060 gcc_checking_assert (TREE_CODE_CLASS (code
) != tcc_expression
6061 && TREE_CODE_CLASS (code
) != tcc_binary
6062 && TREE_CODE_CLASS (code
) != tcc_unary
6063 && TREE_CODE_CLASS (code
) != tcc_reference
6064 && TREE_CODE_CLASS (code
) != tcc_comparison
6065 && TREE_CODE_CLASS (code
) != tcc_statement
6066 && TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6068 /* Then by CODE. Special cases and/or 1:1 tree shape
6075 case ARGUMENT_PACK_SELECT
: /* Transient during instantiation. */
6076 case DEFERRED_PARSE
: /* Expanded upon completion of
6078 case IDENTIFIER_NODE
: /* Streamed specially. */
6079 case BINDING_VECTOR
: /* Only in namespace-scope symbol
6082 case TRANSLATION_UNIT_DECL
: /* There is only one, it is a
6084 case USERDEF_LITERAL
: /* Expanded during parsing. */
6085 gcc_unreachable (); /* Should never meet. */
6089 WT (TREE_REALPART (t
));
6090 WT (TREE_IMAGPART (t
));
6094 gcc_unreachable (); /* Not supported in C++. */
6099 unsigned num
= TREE_INT_CST_EXT_NUNITS (t
);
6100 for (unsigned ix
= 0; ix
!= num
; ix
++)
6101 wu (TREE_INT_CST_ELT (t
, ix
));
6106 gcc_unreachable (); /* Not supported in C++. */
6110 buf (TREE_REAL_CST_PTR (t
), sizeof (real_value
));
6114 /* Streamed during start. */
6118 for (unsigned ix
= vector_cst_encoded_nelts (t
); ix
--;)
6119 WT (VECTOR_CST_ENCODED_ELT (t
, ix
));
6124 if (DECL_CONTEXT (t
)
6125 && TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
6131 if (DECL_HAS_VALUE_EXPR_P (t
))
6132 WT (DECL_VALUE_EXPR (t
));
6137 WT (t
->decl_common
.initial
);
6141 WT (t
->field_decl
.offset
);
6142 WT (t
->field_decl
.bit_field_type
);
6143 WT (t
->field_decl
.qualifier
); /* bitfield unit. */
6144 WT (t
->field_decl
.bit_offset
);
6145 WT (t
->field_decl
.fcontext
);
6146 WT (t
->decl_common
.initial
);
6152 WU (t
->label_decl
.label_decl_uid
);
6153 WU (t
->label_decl
.eh_landing_pad_nr
);
6160 /* Builtins can be streamed by value when a header declares
6162 WU (DECL_BUILT_IN_CLASS (t
));
6163 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
6164 WU (DECL_UNCHECKED_FUNCTION_CODE (t
));
6167 WT (t
->function_decl
.personality
);
6168 WT (t
->function_decl
.function_specific_target
);
6169 WT (t
->function_decl
.function_specific_optimization
);
6170 WT (t
->function_decl
.vindex
);
6172 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
6173 WT (lookup_explicit_specifier (t
));
6177 /* USING_DECL_DECLS */
6178 WT (t
->decl_common
.initial
);
6182 /* USING_DECL: USING_DECL_SCOPE */
6183 /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6184 WT (t
->decl_non_common
.result
);
6187 /* Miscellaneous common nodes. */
6191 state
->write_location (*this, t
->block
.locus
);
6192 state
->write_location (*this, t
->block
.end_locus
);
6195 /* DECL_LOCAL_DECL_P decls are first encountered here and
6196 streamed by value. */
6197 chained_decls (t
->block
.vars
);
6198 /* nonlocalized_vars is a middle-end thing. */
6199 WT (t
->block
.subblocks
);
6200 WT (t
->block
.supercontext
);
6201 // FIXME: As for decl's abstract_origin, does this introduce crosslinks?
6202 WT (t
->block
.abstract_origin
);
6203 /* fragment_origin, fragment_chain are middle-end things. */
6204 WT (t
->block
.chain
);
6205 /* nonlocalized_vars, block_num & die are middle endy/debug
6215 // This must be streamed /after/ we've streamed the type,
6216 // because it can directly refer to elements of the type. Eg,
6217 // FIELD_DECLs of a RECORD_TYPE.
6222 /* The ompcode is serialized in start. */
6224 WU (t
->omp_clause
.subcode
.map_kind
);
6226 state
->write_location (*this, t
->omp_clause
.locus
);
6228 unsigned len
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)];
6229 for (unsigned ix
= 0; ix
!= len
; ix
++)
6230 WT (t
->omp_clause
.ops
[ix
]);
6234 case STATEMENT_LIST
:
6235 for (tree stmt
: tsi_range (t
))
6241 case OPTIMIZATION_NODE
:
6242 case TARGET_OPTION_NODE
:
6243 // FIXME: Our representation for these two nodes is a cache of
6244 // the resulting set of options. Not a record of the options
6245 // that got changed by a particular attribute or pragma. Should
6246 // we record that, or should we record the diff from the command
6247 // line options? The latter seems the right behaviour, but is
6248 // (a) harder, and I guess could introduce strangeness if the
6249 // importer has set some incompatible set of optimization flags?
6255 WT (t
->binfo
.common
.chain
);
6256 WT (t
->binfo
.offset
);
6257 WT (t
->binfo
.inheritance
);
6258 WT (t
->binfo
.vptr_field
);
6260 WT (t
->binfo
.vtable
);
6261 WT (t
->binfo
.virtuals
);
6262 WT (t
->binfo
.vtt_subvtt
);
6263 WT (t
->binfo
.vtt_vptr
);
6265 tree_vec (BINFO_BASE_ACCESSES (t
));
6266 unsigned num
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
6267 for (unsigned ix
= 0; ix
!= num
; ix
++)
6268 WT (BINFO_BASE_BINFO (t
, ix
));
6273 WT (t
->list
.purpose
);
6275 WT (t
->list
.common
.chain
);
6279 for (unsigned ix
= TREE_VEC_LENGTH (t
); ix
--;)
6280 WT (TREE_VEC_ELT (t
, ix
));
6281 /* We stash NON_DEFAULT_TEMPLATE_ARGS_COUNT on TREE_CHAIN! */
6282 gcc_checking_assert (!t
->type_common
.common
.chain
6283 || (TREE_CODE (t
->type_common
.common
.chain
)
6285 WT (t
->type_common
.common
.chain
);
6288 /* C++-specific nodes ... */
6290 WT (((lang_tree_node
*)t
)->baselink
.binfo
);
6291 WT (((lang_tree_node
*)t
)->baselink
.functions
);
6292 WT (((lang_tree_node
*)t
)->baselink
.access_binfo
);
6295 case CONSTRAINT_INFO
:
6296 WT (((lang_tree_node
*)t
)->constraint_info
.template_reqs
);
6297 WT (((lang_tree_node
*)t
)->constraint_info
.declarator_reqs
);
6298 WT (((lang_tree_node
*)t
)->constraint_info
.associated_constr
);
6301 case DEFERRED_NOEXCEPT
:
6302 WT (((lang_tree_node
*)t
)->deferred_noexcept
.pattern
);
6303 WT (((lang_tree_node
*)t
)->deferred_noexcept
.args
);
6307 WT (((lang_tree_node
*)t
)->lambda_expression
.capture_list
);
6308 WT (((lang_tree_node
*)t
)->lambda_expression
.this_capture
);
6309 WT (((lang_tree_node
*)t
)->lambda_expression
.extra_scope
);
6310 /* pending_proxies is a parse-time thing. */
6311 gcc_assert (!((lang_tree_node
*)t
)->lambda_expression
.pending_proxies
);
6313 state
->write_location
6314 (*this, ((lang_tree_node
*)t
)->lambda_expression
.locus
);
6317 WU (((lang_tree_node
*)t
)->lambda_expression
.default_capture_mode
);
6318 WU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_scope
);
6319 WU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_sig
);
6324 WT (((lang_tree_node
*)t
)->overload
.function
);
6325 WT (t
->common
.chain
);
6329 WT (((lang_tree_node
*)t
)->ptrmem
.member
);
6333 WT (((lang_tree_node
*)t
)->static_assertion
.condition
);
6334 WT (((lang_tree_node
*)t
)->static_assertion
.message
);
6336 state
->write_location
6337 (*this, ((lang_tree_node
*)t
)->static_assertion
.location
);
6341 /* Streamed with the template_decl node itself. */
6343 (TREE_VISITED (((lang_tree_node
*)t
)->template_decl
.arguments
));
6345 (TREE_VISITED (((lang_tree_node
*)t
)->template_decl
.result
)
6346 || dep_hash
->find_dependency (t
)->is_alias_tmpl_inst ());
6347 if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t
))
6348 WT (DECL_CHAIN (t
));
6353 WT (((lang_tree_node
*)t
)->template_info
.tmpl
);
6354 WT (((lang_tree_node
*)t
)->template_info
.args
);
6355 WT (((lang_tree_node
*)t
)->template_info
.partial
);
6357 const auto *ac
= (((lang_tree_node
*)t
)
6358 ->template_info
.deferred_access_checks
);
6359 unsigned len
= vec_safe_length (ac
);
6364 for (unsigned ix
= 0; ix
!= len
; ix
++)
6366 const auto &m
= (*ac
)[ix
];
6371 state
->write_location (*this, m
.loc
);
6377 case TEMPLATE_PARM_INDEX
:
6380 WU (((lang_tree_node
*)t
)->tpi
.index
);
6381 WU (((lang_tree_node
*)t
)->tpi
.level
);
6382 WU (((lang_tree_node
*)t
)->tpi
.orig_level
);
6384 WT (((lang_tree_node
*)t
)->tpi
.decl
);
6385 /* TEMPLATE_PARM_DESCENDANTS (AKA TREE_CHAIN) is an internal
6386 cache, do not stream. */
6390 WT (((lang_tree_node
*)t
)->trait_expression
.type1
);
6391 WT (((lang_tree_node
*)t
)->trait_expression
.type2
);
6393 WU (((lang_tree_node
*)t
)->trait_expression
.kind
);
6397 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
6399 /* We want to stream the type of a expression-like nodes /after/
6400 we've streamed the operands. The type often contains (bits
6401 of the) types of the operands, and with things like decltype
6402 and noexcept in play, we really want to stream the decls
6403 defining the type before we try and stream the type on its
6404 own. Otherwise we can find ourselves trying to read in a
6405 decl, when we're already partially reading in a component of
6406 its type. And that's bad. */
6407 tree type
= t
->typed
.type
;
6416 /* We fill in the template's type separately. */
6421 if (DECL_ORIGINAL_TYPE (t
) && t
== TYPE_NAME (type
))
6422 /* This is a typedef. We set its type separately. */
6427 if (type
&& !ENUM_FIXED_UNDERLYING_TYPE_P (t
))
6429 /* Type is a restricted range integer type derived from the
6430 integer_types. Find the right one. */
6431 prec
= TYPE_PRECISION (type
);
6432 tree name
= DECL_NAME (TYPE_NAME (type
));
6434 for (unsigned itk
= itk_none
; itk
--;)
6435 if (integer_types
[itk
]
6436 && DECL_NAME (TYPE_NAME (integer_types
[itk
])) == name
)
6438 type
= integer_types
[itk
];
6441 gcc_assert (type
!= t
->typed
.type
);
6447 if (prec
&& streaming_p ())
6451 if (TREE_CODE (t
) == CONSTRUCTOR
)
6453 unsigned len
= vec_safe_length (t
->constructor
.elts
);
6457 for (unsigned ix
= 0; ix
!= len
; ix
++)
6459 const constructor_elt
&elt
= (*t
->constructor
.elts
)[ix
];
6470 // Streaming in a reference to a decl can cause that decl to be
6471 // TREE_USED, which is the mark_used behaviour we need most of the
6472 // time. The trees_in::unused can be incremented to inhibit this,
6473 // which is at least needed for vtables.
6476 trees_in::core_vals (tree t
)
6478 #define RU(X) ((X) = u ())
6479 #define RUC(T,X) ((X) = T (u ()))
6480 #define RT(X) ((X) = tree_node ())
6481 #define RTU(X) ((X) = tree_node (true))
6482 tree_code code
= TREE_CODE (t
);
6484 /* First by tree shape. */
6485 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
6487 RT (t
->decl_minimal
.name
);
6488 if (!DECL_TEMPLATE_PARM_P (t
))
6489 RT (t
->decl_minimal
.context
);
6491 /* Don't zap the locus just yet, we don't record it correctly
6492 and thus lose all location information. */
6493 t
->decl_minimal
.locus
= state
->read_location (*this);
6496 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
6498 RT (t
->type_common
.name
);
6499 RT (t
->type_common
.context
);
6501 RT (t
->type_common
.main_variant
);
6502 RT (t
->type_common
.canonical
);
6504 /* type_common.next_variant is internally manipulated. */
6505 /* type_common.pointer_to, type_common.reference_to. */
6507 RU (t
->type_common
.precision
);
6508 RU (t
->type_common
.contains_placeholder_bits
);
6509 RUC (machine_mode
, t
->type_common
.mode
);
6510 RU (t
->type_common
.align
);
6512 if (!RECORD_OR_UNION_CODE_P (code
))
6514 RT (t
->type_common
.size
);
6515 RT (t
->type_common
.size_unit
);
6517 RT (t
->type_common
.attributes
);
6519 RT (t
->type_common
.common
.chain
); /* TYPE_STUB_DECL. */
6522 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
6524 RUC (machine_mode
, t
->decl_common
.mode
);
6525 RU (t
->decl_common
.off_align
);
6526 RU (t
->decl_common
.align
);
6528 if (code
!= TEMPLATE_DECL
)
6530 RT (t
->decl_common
.size
);
6531 RT (t
->decl_common
.size_unit
);
6534 RT (t
->decl_common
.attributes
);
6535 RT (t
->decl_common
.abstract_origin
);
6538 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
6540 RT (t
->decl_with_vis
.assembler_name
);
6541 RUC (symbol_visibility
, t
->decl_with_vis
.visibility
);
6544 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
6546 if (code
== ENUMERAL_TYPE
)
6548 /* These fields get set even for opaque enums that lack a
6549 definition, so we stream them directly for each ENUMERAL_TYPE.
6550 We stream TYPE_VALUES as part of the definition. */
6551 RT (t
->type_non_common
.maxval
);
6552 RT (t
->type_non_common
.minval
);
6554 /* Records and unions hold FIELDS, VFIELD & BINFO on these
6556 else if (!RECORD_OR_UNION_CODE_P (code
))
6558 /* This is not clobbering TYPE_CACHED_VALUES, because this
6559 is a type that doesn't have any. */
6560 gcc_checking_assert (!TYPE_CACHED_VALUES_P (t
));
6561 RT (t
->type_non_common
.values
);
6562 RT (t
->type_non_common
.maxval
);
6563 RT (t
->type_non_common
.minval
);
6566 RT (t
->type_non_common
.lang_1
);
6569 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
6571 t
->exp
.locus
= state
->read_location (*this);
6573 bool vl
= TREE_CODE_CLASS (code
) == tcc_vl_exp
;
6574 for (unsigned limit
= (vl
? VL_EXP_OPERAND_LENGTH (t
)
6575 : TREE_OPERAND_LENGTH (t
)),
6576 ix
= unsigned (vl
); ix
!= limit
; ix
++)
6577 RTU (TREE_OPERAND (t
, ix
));
6580 /* Then by CODE. Special cases and/or 1:1 tree shape
6587 case ARGUMENT_PACK_SELECT
:
6588 case DEFERRED_PARSE
:
6589 case IDENTIFIER_NODE
:
6590 case BINDING_VECTOR
:
6592 case TRANSLATION_UNIT_DECL
:
6593 case USERDEF_LITERAL
:
6594 return false; /* Should never meet. */
6598 RT (TREE_REALPART (t
));
6599 RT (TREE_IMAGPART (t
));
6603 /* Not suported in C++. */
6608 unsigned num
= TREE_INT_CST_EXT_NUNITS (t
);
6609 for (unsigned ix
= 0; ix
!= num
; ix
++)
6610 TREE_INT_CST_ELT (t
, ix
) = wu ();
6615 /* Not suported in C++. */
6619 if (const void *bytes
= buf (sizeof (real_value
)))
6620 memcpy (TREE_REAL_CST_PTR (t
), bytes
, sizeof (real_value
));
6624 /* Streamed during start. */
6628 for (unsigned ix
= vector_cst_encoded_nelts (t
); ix
--;)
6629 RT (VECTOR_CST_ENCODED_ELT (t
, ix
));
6634 if (DECL_CONTEXT (t
)
6635 && TREE_CODE (DECL_CONTEXT (t
)) != FUNCTION_DECL
)
6641 if (DECL_HAS_VALUE_EXPR_P (t
))
6643 /* The DECL_VALUE hash table is a cache, thus if we're
6644 reading a duplicate (which we end up discarding), the
6645 value expr will also be cleaned up at the next gc. */
6646 tree val
= tree_node ();
6647 SET_DECL_VALUE_EXPR (t
, val
);
6653 RT (t
->decl_common
.initial
);
6657 RT (t
->field_decl
.offset
);
6658 RT (t
->field_decl
.bit_field_type
);
6659 RT (t
->field_decl
.qualifier
);
6660 RT (t
->field_decl
.bit_offset
);
6661 RT (t
->field_decl
.fcontext
);
6662 RT (t
->decl_common
.initial
);
6666 RU (t
->label_decl
.label_decl_uid
);
6667 RU (t
->label_decl
.eh_landing_pad_nr
);
6672 unsigned bltin
= u ();
6673 t
->function_decl
.built_in_class
= built_in_class (bltin
);
6674 if (bltin
!= NOT_BUILT_IN
)
6677 DECL_UNCHECKED_FUNCTION_CODE (t
) = built_in_function (bltin
);
6680 RT (t
->function_decl
.personality
);
6681 RT (t
->function_decl
.function_specific_target
);
6682 RT (t
->function_decl
.function_specific_optimization
);
6683 RT (t
->function_decl
.vindex
);
6685 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
6689 store_explicit_specifier (t
, spec
);
6695 /* USING_DECL_DECLS */
6696 RT (t
->decl_common
.initial
);
6700 /* USING_DECL: USING_DECL_SCOPE */
6701 /* TYPE_DECL: DECL_ORIGINAL_TYPE */
6702 RT (t
->decl_non_common
.result
);
6705 /* Miscellaneous common nodes. */
6707 t
->block
.locus
= state
->read_location (*this);
6708 t
->block
.end_locus
= state
->read_location (*this);
6709 t
->block
.vars
= chained_decls ();
6710 /* nonlocalized_vars is middle-end. */
6711 RT (t
->block
.subblocks
);
6712 RT (t
->block
.supercontext
);
6713 RT (t
->block
.abstract_origin
);
6714 /* fragment_origin, fragment_chain are middle-end. */
6715 RT (t
->block
.chain
);
6716 /* nonlocalized_vars, block_num, die are middle endy/debug
6721 RUC (internal_fn
, t
->base
.u
.ifn
);
6725 // Streamed after the node's type.
6730 RU (t
->omp_clause
.subcode
.map_kind
);
6731 t
->omp_clause
.locus
= state
->read_location (*this);
6733 unsigned len
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)];
6734 for (unsigned ix
= 0; ix
!= len
; ix
++)
6735 RT (t
->omp_clause
.ops
[ix
]);
6739 case STATEMENT_LIST
:
6741 tree_stmt_iterator iter
= tsi_start (t
);
6742 for (tree stmt
; RT (stmt
);)
6743 tsi_link_after (&iter
, stmt
, TSI_CONTINUE_LINKING
);
6747 case OPTIMIZATION_NODE
:
6748 case TARGET_OPTION_NODE
:
6749 /* Not yet implemented, see trees_out::core_vals. */
6754 RT (t
->binfo
.common
.chain
);
6755 RT (t
->binfo
.offset
);
6756 RT (t
->binfo
.inheritance
);
6757 RT (t
->binfo
.vptr_field
);
6759 /* Do not mark the vtables as USED in the address expressions
6762 RT (t
->binfo
.vtable
);
6763 RT (t
->binfo
.virtuals
);
6764 RT (t
->binfo
.vtt_subvtt
);
6765 RT (t
->binfo
.vtt_vptr
);
6768 BINFO_BASE_ACCESSES (t
) = tree_vec ();
6769 if (!get_overrun ())
6771 unsigned num
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
6772 for (unsigned ix
= 0; ix
!= num
; ix
++)
6773 BINFO_BASE_APPEND (t
, tree_node ());
6778 RT (t
->list
.purpose
);
6780 RT (t
->list
.common
.chain
);
6784 for (unsigned ix
= TREE_VEC_LENGTH (t
); ix
--;)
6785 RT (TREE_VEC_ELT (t
, ix
));
6786 RT (t
->type_common
.common
.chain
);
6789 /* C++-specific nodes ... */
6791 RT (((lang_tree_node
*)t
)->baselink
.binfo
);
6792 RTU (((lang_tree_node
*)t
)->baselink
.functions
);
6793 RT (((lang_tree_node
*)t
)->baselink
.access_binfo
);
6796 case CONSTRAINT_INFO
:
6797 RT (((lang_tree_node
*)t
)->constraint_info
.template_reqs
);
6798 RT (((lang_tree_node
*)t
)->constraint_info
.declarator_reqs
);
6799 RT (((lang_tree_node
*)t
)->constraint_info
.associated_constr
);
6802 case DEFERRED_NOEXCEPT
:
6803 RT (((lang_tree_node
*)t
)->deferred_noexcept
.pattern
);
6804 RT (((lang_tree_node
*)t
)->deferred_noexcept
.args
);
6808 RT (((lang_tree_node
*)t
)->lambda_expression
.capture_list
);
6809 RT (((lang_tree_node
*)t
)->lambda_expression
.this_capture
);
6810 RT (((lang_tree_node
*)t
)->lambda_expression
.extra_scope
);
6811 /* lambda_expression.pending_proxies is NULL */
6812 ((lang_tree_node
*)t
)->lambda_expression
.locus
6813 = state
->read_location (*this);
6814 RUC (cp_lambda_default_capture_mode_type
,
6815 ((lang_tree_node
*)t
)->lambda_expression
.default_capture_mode
);
6816 RU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_scope
);
6817 RU (((lang_tree_node
*)t
)->lambda_expression
.discriminator_sig
);
6821 RT (((lang_tree_node
*)t
)->overload
.function
);
6822 RT (t
->common
.chain
);
6826 RT (((lang_tree_node
*)t
)->ptrmem
.member
);
6830 RT (((lang_tree_node
*)t
)->static_assertion
.condition
);
6831 RT (((lang_tree_node
*)t
)->static_assertion
.message
);
6832 ((lang_tree_node
*)t
)->static_assertion
.location
6833 = state
->read_location (*this);
6837 /* Streamed when reading the raw template decl itself. */
6838 gcc_assert (((lang_tree_node
*)t
)->template_decl
.arguments
);
6839 gcc_assert (((lang_tree_node
*)t
)->template_decl
.result
);
6840 if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t
))
6841 RT (DECL_CHAIN (t
));
6845 RT (((lang_tree_node
*)t
)->template_info
.tmpl
);
6846 RT (((lang_tree_node
*)t
)->template_info
.args
);
6847 RT (((lang_tree_node
*)t
)->template_info
.partial
);
6848 if (unsigned len
= u ())
6850 auto &ac
= (((lang_tree_node
*)t
)
6851 ->template_info
.deferred_access_checks
);
6852 vec_alloc (ac
, len
);
6853 for (unsigned ix
= 0; ix
!= len
; ix
++)
6855 deferred_access_check m
;
6860 m
.loc
= state
->read_location (*this);
6866 case TEMPLATE_PARM_INDEX
:
6867 RU (((lang_tree_node
*)t
)->tpi
.index
);
6868 RU (((lang_tree_node
*)t
)->tpi
.level
);
6869 RU (((lang_tree_node
*)t
)->tpi
.orig_level
);
6870 RT (((lang_tree_node
*)t
)->tpi
.decl
);
6874 RT (((lang_tree_node
*)t
)->trait_expression
.type1
);
6875 RT (((lang_tree_node
*)t
)->trait_expression
.type2
);
6876 RUC (cp_trait_kind
, ((lang_tree_node
*)t
)->trait_expression
.kind
);
6880 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
6882 tree type
= tree_node ();
6884 if (type
&& code
== ENUMERAL_TYPE
&& !ENUM_FIXED_UNDERLYING_TYPE_P (t
))
6886 unsigned precision
= u ();
6888 type
= build_distinct_type_copy (type
);
6889 TYPE_PRECISION (type
) = precision
;
6890 set_min_and_max_values_for_integral_type (type
, precision
,
6894 if (code
!= TEMPLATE_DECL
)
6895 t
->typed
.type
= type
;
6898 if (TREE_CODE (t
) == CONSTRUCTOR
)
6899 if (unsigned len
= u ())
6901 vec_alloc (t
->constructor
.elts
, len
);
6902 for (unsigned ix
= 0; ix
!= len
; ix
++)
6904 constructor_elt elt
;
6908 t
->constructor
.elts
->quick_push (elt
);
6915 return !get_overrun ();
6919 trees_out::lang_decl_vals (tree t
)
6921 const struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
6922 #define WU(X) (u (X))
6923 #define WT(X) (tree_node (X))
6924 /* Module index already written. */
6925 switch (lang
->u
.base
.selector
)
6930 case lds_fn
: /* lang_decl_fn. */
6933 if (DECL_NAME (t
) && IDENTIFIER_OVL_OP_P (DECL_NAME (t
)))
6934 WU (lang
->u
.fn
.ovl_op_code
);
6937 if (DECL_CLASS_SCOPE_P (t
))
6938 WT (lang
->u
.fn
.context
);
6940 if (lang
->u
.fn
.thunk_p
)
6942 /* The thunked-to function. */
6943 WT (lang
->u
.fn
.befriending_classes
);
6945 wi (lang
->u
.fn
.u5
.fixed_offset
);
6948 WT (lang
->u
.fn
.u5
.cloned_function
);
6950 if (FNDECL_USED_AUTO (t
))
6951 WT (lang
->u
.fn
.u
.saved_auto_return_type
);
6955 case lds_decomp
: /* lang_decl_decomp. */
6956 WT (lang
->u
.decomp
.base
);
6959 case lds_min
: /* lang_decl_min. */
6961 WT (lang
->u
.min
.template_info
);
6963 tree access
= lang
->u
.min
.access
;
6965 /* DECL_ACCESS needs to be maintained by the definition of the
6966 (derived) class that changes the access. The other users
6967 of DECL_ACCESS need to write it here. */
6968 if (!DECL_THUNK_P (t
)
6969 && (DECL_CONTEXT (t
) && TYPE_P (DECL_CONTEXT (t
))))
6976 case lds_ns
: /* lang_decl_ns. */
6979 case lds_parm
: /* lang_decl_parm. */
6982 WU (lang
->u
.parm
.level
);
6983 WU (lang
->u
.parm
.index
);
6992 trees_in::lang_decl_vals (tree t
)
6994 struct lang_decl
*lang
= DECL_LANG_SPECIFIC (t
);
6995 #define RU(X) ((X) = u ())
6996 #define RT(X) ((X) = tree_node ())
6998 /* Module index already read. */
6999 switch (lang
->u
.base
.selector
)
7004 case lds_fn
: /* lang_decl_fn. */
7005 if (DECL_NAME (t
) && IDENTIFIER_OVL_OP_P (DECL_NAME (t
)))
7007 unsigned code
= u ();
7009 /* Check consistency. */
7010 if (code
>= OVL_OP_MAX
7011 || (ovl_op_info
[IDENTIFIER_ASSIGN_OP_P (DECL_NAME (t
))][code
]
7012 .ovl_op_code
) == OVL_OP_ERROR_MARK
)
7015 lang
->u
.fn
.ovl_op_code
= code
;
7018 if (DECL_CLASS_SCOPE_P (t
))
7019 RT (lang
->u
.fn
.context
);
7021 if (lang
->u
.fn
.thunk_p
)
7023 RT (lang
->u
.fn
.befriending_classes
);
7024 lang
->u
.fn
.u5
.fixed_offset
= wi ();
7027 RT (lang
->u
.fn
.u5
.cloned_function
);
7029 if (FNDECL_USED_AUTO (t
))
7030 RT (lang
->u
.fn
.u
.saved_auto_return_type
);
7033 case lds_decomp
: /* lang_decl_decomp. */
7034 RT (lang
->u
.decomp
.base
);
7037 case lds_min
: /* lang_decl_min. */
7039 RT (lang
->u
.min
.template_info
);
7040 RT (lang
->u
.min
.access
);
7043 case lds_ns
: /* lang_decl_ns. */
7046 case lds_parm
: /* lang_decl_parm. */
7047 RU (lang
->u
.parm
.level
);
7048 RU (lang
->u
.parm
.index
);
7053 return !get_overrun ();
7056 /* Most of the value contents of lang_type is streamed in
7060 trees_out::lang_type_vals (tree t
)
7062 const struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
7063 #define WU(X) (u (X))
7064 #define WT(X) (tree_node (X))
7072 trees_in::lang_type_vals (tree t
)
7074 struct lang_type
*lang
= TYPE_LANG_SPECIFIC (t
);
7075 #define RU(X) ((X) = u ())
7076 #define RT(X) ((X) = tree_node ())
7080 return !get_overrun ();
7083 /* Write out the bools of T, including information about any
7084 LANG_SPECIFIC information. Including allocation of any lang
7088 trees_out::tree_node_bools (tree t
)
7090 gcc_checking_assert (streaming_p ());
7092 /* We should never stream a namespace. */
7093 gcc_checking_assert (TREE_CODE (t
) != NAMESPACE_DECL
7094 || DECL_NAMESPACE_ALIAS (t
));
7098 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7100 case tcc_declaration
:
7102 bool specific
= DECL_LANG_SPECIFIC (t
) != NULL
;
7104 if (specific
&& VAR_P (t
))
7105 b (DECL_DECOMPOSITION_P (t
));
7107 lang_decl_bools (t
);
7113 bool specific
= (TYPE_MAIN_VARIANT (t
) == t
7114 && TYPE_LANG_SPECIFIC (t
) != NULL
);
7115 gcc_assert (TYPE_LANG_SPECIFIC (t
)
7116 == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t
)));
7120 lang_type_bools (t
);
7132 trees_in::tree_node_bools (tree t
)
7134 bool ok
= core_bools (t
);
7137 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7139 case tcc_declaration
:
7142 bool decomp
= VAR_P (t
) && b ();
7144 ok
= maybe_add_lang_decl_raw (t
, decomp
);
7146 ok
= lang_decl_bools (t
);
7153 ok
= maybe_add_lang_type_raw (t
);
7155 ok
= lang_type_bools (t
);
7164 if (!ok
|| get_overrun ())
7171 /* Write out the lang-specifc vals of node T. */
7174 trees_out::lang_vals (tree t
)
7176 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7178 case tcc_declaration
:
7179 if (DECL_LANG_SPECIFIC (t
))
7184 if (TYPE_MAIN_VARIANT (t
) == t
&& TYPE_LANG_SPECIFIC (t
))
7194 trees_in::lang_vals (tree t
)
7198 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
7200 case tcc_declaration
:
7201 if (DECL_LANG_SPECIFIC (t
))
7202 ok
= lang_decl_vals (t
);
7206 if (TYPE_LANG_SPECIFIC (t
))
7207 ok
= lang_type_vals (t
);
7209 TYPE_LANG_SPECIFIC (t
) = TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t
));
7219 /* Write out the value fields of node T. */
7222 trees_out::tree_node_vals (tree t
)
7229 trees_in::tree_node_vals (tree t
)
7231 bool ok
= core_vals (t
);
7239 /* If T is a back reference, fixed reference or NULL, write out its
7240 code and return WK_none. Otherwise return WK_value if we must write
7241 by value, or WK_normal otherwise. */
7244 trees_out::ref_node (tree t
)
7250 /* NULL_TREE -> tt_null. */
7257 if (!TREE_VISITED (t
))
7260 /* An already-visited tree. It must be in the map. */
7261 int val
= get_tag (t
);
7263 if (val
== tag_value
)
7264 /* An entry we should walk into. */
7269 if (val
<= tag_backref
)
7271 /* Back reference -> -ve number */
7276 else if (val
>= tag_fixed
)
7278 /* Fixed reference -> tt_fixed */
7281 i (tt_fixed
), u (val
);
7289 && dump ("Wrote %s:%d %C:%N%S", kind
, val
, TREE_CODE (t
), t
, t
);
7295 trees_in::back_ref (int tag
)
7297 tree res
= NULL_TREE
;
7299 if (tag
< 0 && unsigned (~tag
) < back_refs
.length ())
7300 res
= back_refs
[~tag
];
7303 /* Checking TREE_CODE is a dereference, so we know this is not a
7304 wild pointer. Checking the code provides evidence we've not
7305 corrupted something. */
7306 || TREE_CODE (res
) >= MAX_TREE_CODES
)
7309 dump (dumper::TREE
) && dump ("Read backref:%d found %C:%N%S", tag
,
7310 TREE_CODE (res
), res
, res
);
7315 trees_out::add_indirect_tpl_parms (tree parms
)
7318 for (; parms
; parms
= TREE_CHAIN (parms
), len
++)
7320 if (TREE_VISITED (parms
))
7323 int tag
= insert (parms
);
7326 && dump ("Indirect:%d template's parameter %u %C:%N",
7327 tag
, len
, TREE_CODE (parms
), parms
);
7337 trees_in::add_indirect_tpl_parms (tree parms
)
7339 unsigned len
= u ();
7340 for (unsigned ix
= 0; ix
!= len
; parms
= TREE_CHAIN (parms
), ix
++)
7342 int tag
= insert (parms
);
7344 && dump ("Indirect:%d template's parameter %u %C:%N",
7345 tag
, ix
, TREE_CODE (parms
), parms
);
7351 /* We've just found DECL by name. Insert nodes that come with it, but
7352 cannot be found by name, so we'll not accidentally walk into them. */
7355 trees_out::add_indirects (tree decl
)
7359 // FIXME:OPTIMIZATION We'll eventually want default fn parms of
7360 // templates and perhaps default template parms too. The former can
7361 // be referenced from instantiations (as they are lazily
7362 // instantiated). Also (deferred?) exception specifications of
7363 // templates. See the note about PARM_DECLs in trees_out::decl_node.
7365 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7367 count
+= add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl
));
7369 inner
= DECL_TEMPLATE_RESULT (decl
);
7370 int tag
= insert (inner
);
7373 && dump ("Indirect:%d template's result %C:%N",
7374 tag
, TREE_CODE (inner
), inner
);
7378 if (TREE_CODE (inner
) == TYPE_DECL
)
7380 /* Make sure the type is in the map too. Otherwise we get
7381 different RECORD_TYPEs for the same type, and things go
7383 tree type
= TREE_TYPE (inner
);
7384 gcc_checking_assert (DECL_ORIGINAL_TYPE (inner
)
7385 || TYPE_NAME (type
) == inner
);
7386 int tag
= insert (type
);
7388 dump (dumper::TREE
) && dump ("Indirect:%d decl's type %C:%N", tag
,
7389 TREE_CODE (type
), type
);
7396 dump (dumper::TREE
) && dump ("Inserted %u indirects", count
);
7401 trees_in::add_indirects (tree decl
)
7406 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7408 count
+= add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl
));
7410 inner
= DECL_TEMPLATE_RESULT (decl
);
7411 int tag
= insert (inner
);
7413 && dump ("Indirect:%d templates's result %C:%N", tag
,
7414 TREE_CODE (inner
), inner
);
7418 if (TREE_CODE (inner
) == TYPE_DECL
)
7420 tree type
= TREE_TYPE (inner
);
7421 gcc_checking_assert (DECL_ORIGINAL_TYPE (inner
)
7422 || TYPE_NAME (type
) == inner
);
7423 int tag
= insert (type
);
7425 && dump ("Indirect:%d decl's type %C:%N", tag
, TREE_CODE (type
), type
);
7429 dump (dumper::TREE
) && dump ("Inserted %u indirects", count
);
7430 return count
== u ();
7433 /* Stream a template parameter. There are 4.5 kinds of parameter:
7434 a) Template - TEMPLATE_DECL->TYPE_DECL->TEMPLATE_TEMPLATE_PARM
7435 TEMPLATE_TYPE_PARM_INDEX TPI
7436 b) Type - TYPE_DECL->TEMPLATE_TYPE_PARM TEMPLATE_TYPE_PARM_INDEX TPI
7437 c.1) NonTYPE - PARM_DECL DECL_INITIAL TPI We meet this first
7438 c.2) NonTYPE - CONST_DECL DECL_INITIAL Same TPI
7439 d) BoundTemplate - TYPE_DECL->BOUND_TEMPLATE_TEMPLATE_PARM
7440 TEMPLATE_TYPE_PARM_INDEX->TPI
7441 TEMPLATE_TEMPLATE_PARM_INFO->TEMPLATE_INFO
7443 All of these point to a TEMPLATE_PARM_INDEX, and #B also has a TEMPLATE_INFO
7447 trees_out::tpl_parm_value (tree parm
)
7449 gcc_checking_assert (DECL_P (parm
) && DECL_TEMPLATE_PARM_P (parm
));
7451 int parm_tag
= insert (parm
);
7455 dump (dumper::TREE
) && dump ("Writing template parm:%d %C:%N",
7456 parm_tag
, TREE_CODE (parm
), parm
);
7458 tree_node_bools (parm
);
7462 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7464 inner
= DECL_TEMPLATE_RESULT (inner
);
7465 int inner_tag
= insert (inner
);
7468 dump (dumper::TREE
) && dump ("Writing inner template parm:%d %C:%N",
7469 inner_tag
, TREE_CODE (inner
), inner
);
7471 tree_node_bools (inner
);
7475 tree type
= NULL_TREE
;
7476 if (TREE_CODE (inner
) == TYPE_DECL
)
7478 type
= TREE_TYPE (inner
);
7479 int type_tag
= insert (type
);
7482 dump (dumper::TREE
) && dump ("Writing template parm type:%d %C:%N",
7483 type_tag
, TREE_CODE (type
), type
);
7485 tree_node_bools (type
);
7491 /* This is a template-template parameter. */
7492 unsigned tpl_levels
= 0;
7493 tpl_header (parm
, &tpl_levels
);
7494 tpl_parms_fini (parm
, tpl_levels
);
7497 tree_node_vals (parm
);
7499 tree_node_vals (inner
);
7502 tree_node_vals (type
);
7503 if (DECL_NAME (inner
) == auto_identifier
7504 || DECL_NAME (inner
) == decltype_auto_identifier
)
7506 /* Placeholder auto. */
7507 tree_node (DECL_INITIAL (inner
));
7508 tree_node (DECL_SIZE_UNIT (inner
));
7513 dump (dumper::TREE
) && dump ("Wrote template parm:%d %C:%N",
7514 parm_tag
, TREE_CODE (parm
), parm
);
7518 trees_in::tpl_parm_value ()
7520 tree parm
= start ();
7521 if (!parm
|| !tree_node_bools (parm
))
7524 int parm_tag
= insert (parm
);
7525 dump (dumper::TREE
) && dump ("Reading template parm:%d %C:%N",
7526 parm_tag
, TREE_CODE (parm
), parm
);
7529 if (TREE_CODE (inner
) == TEMPLATE_DECL
)
7532 if (!inner
|| !tree_node_bools (inner
))
7534 int inner_tag
= insert (inner
);
7535 dump (dumper::TREE
) && dump ("Reading inner template parm:%d %C:%N",
7536 inner_tag
, TREE_CODE (inner
), inner
);
7537 DECL_TEMPLATE_RESULT (parm
) = inner
;
7540 tree type
= NULL_TREE
;
7541 if (TREE_CODE (inner
) == TYPE_DECL
)
7544 if (!type
|| !tree_node_bools (type
))
7546 int type_tag
= insert (type
);
7547 dump (dumper::TREE
) && dump ("Reading template parm type:%d %C:%N",
7548 type_tag
, TREE_CODE (type
), type
);
7550 TREE_TYPE (inner
) = TREE_TYPE (parm
) = type
;
7551 TYPE_NAME (type
) = parm
;
7556 /* A template template parameter. */
7557 unsigned tpl_levels
= 0;
7558 tpl_header (parm
, &tpl_levels
);
7559 tpl_parms_fini (parm
, tpl_levels
);
7562 tree_node_vals (parm
);
7564 tree_node_vals (inner
);
7567 tree_node_vals (type
);
7568 if (DECL_NAME (inner
) == auto_identifier
7569 || DECL_NAME (inner
) == decltype_auto_identifier
)
7571 /* Placeholder auto. */
7572 DECL_INITIAL (inner
) = tree_node ();
7573 DECL_SIZE_UNIT (inner
) = tree_node ();
7575 if (TYPE_CANONICAL (type
))
7577 gcc_checking_assert (TYPE_CANONICAL (type
) == type
);
7578 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
7582 dump (dumper::TREE
) && dump ("Read template parm:%d %C:%N",
7583 parm_tag
, TREE_CODE (parm
), parm
);
7589 trees_out::install_entity (tree decl
, depset
*dep
)
7591 gcc_checking_assert (streaming_p ());
7593 /* Write the entity index, so we can insert it as soon as we
7594 know this is new. */
7595 u (dep
? dep
->cluster
+ 1 : 0);
7596 if (CHECKING_P
&& dep
)
7598 /* Add it to the entity map, such that we can tell it is
7601 unsigned *slot
= &entity_map
->get_or_insert
7602 (DECL_UID (decl
), &existed
);
7604 /* If it existed, it should match. */
7605 gcc_checking_assert (decl
== (*entity_ary
)[*slot
]);
7606 *slot
= ~dep
->cluster
;
7611 trees_in::install_entity (tree decl
)
7613 unsigned entity_index
= u ();
7617 if (entity_index
> state
->entity_num
)
7623 /* Insert the real decl into the entity ary. */
7624 unsigned ident
= state
->entity_lwm
+ entity_index
- 1;
7625 (*entity_ary
)[ident
] = decl
;
7627 /* And into the entity map, if it's not already there. */
7628 tree not_tmpl
= STRIP_TEMPLATE (decl
);
7629 if (!DECL_LANG_SPECIFIC (not_tmpl
)
7630 || !DECL_MODULE_ENTITY_P (not_tmpl
))
7632 retrofit_lang_decl (not_tmpl
);
7633 DECL_MODULE_ENTITY_P (not_tmpl
) = true;
7635 /* Insert into the entity hash (it cannot already be there). */
7637 unsigned &slot
= entity_map
->get_or_insert (DECL_UID (decl
), &existed
);
7638 gcc_checking_assert (!existed
);
7645 static bool has_definition (tree decl
);
7647 /* DECL is a decl node that must be written by value. DEP is the
7651 trees_out::decl_value (tree decl
, depset
*dep
)
7653 /* We should not be writing clones or template parms. */
7654 gcc_checking_assert (DECL_P (decl
)
7655 && !DECL_CLONED_FUNCTION_P (decl
)
7656 && !DECL_TEMPLATE_PARM_P (decl
));
7658 /* We should never be writing non-typedef ptrmemfuncs by value. */
7659 gcc_checking_assert (TREE_CODE (decl
) != TYPE_DECL
7660 || DECL_ORIGINAL_TYPE (decl
)
7661 || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)));
7663 merge_kind mk
= get_merge_kind (decl
, dep
);
7667 /* Never start in the middle of a template. */
7669 if (tree ti
= node_template_info (decl
, use_tpl
))
7670 gcc_checking_assert (TREE_CODE (TI_TEMPLATE (ti
)) == OVERLOAD
7671 || TREE_CODE (TI_TEMPLATE (ti
)) == FIELD_DECL
7672 || (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
))
7678 /* A new node -> tt_decl. */
7684 if (mk
!= MK_unique
)
7686 if (!(mk
& MK_template_mask
) && !state
->is_header ())
7688 /* Tell the importer whether this is a global module entity,
7689 or a module entity. This bool merges into the next block
7690 of bools. Sneaky. */
7691 tree o
= get_originating_module_decl (decl
);
7692 bool is_attached
= false;
7694 tree not_tmpl
= STRIP_TEMPLATE (o
);
7695 if (DECL_LANG_SPECIFIC (not_tmpl
)
7696 && DECL_MODULE_ATTACH_P (not_tmpl
))
7701 b (dep
&& dep
->has_defn ());
7703 tree_node_bools (decl
);
7706 int tag
= insert (decl
, WK_value
);
7709 && dump ("Writing %s:%d %C:%N%S", merge_kind_name
[mk
], tag
,
7710 TREE_CODE (decl
), decl
, decl
);
7714 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7716 inner
= DECL_TEMPLATE_RESULT (decl
);
7717 inner_tag
= insert (inner
, WK_value
);
7721 int code
= TREE_CODE (inner
);
7723 start (inner
, true);
7724 tree_node_bools (inner
);
7726 && dump ("Writing %s:%d %C:%N%S", merge_kind_name
[mk
], inner_tag
,
7727 TREE_CODE (inner
), inner
, inner
);
7731 tree type
= NULL_TREE
;
7733 tree stub_decl
= NULL_TREE
;
7735 if (TREE_CODE (inner
) == TYPE_DECL
)
7737 type
= TREE_TYPE (inner
);
7738 bool has_type
= (type
== TYPE_MAIN_VARIANT (type
)
7739 && TYPE_NAME (type
) == inner
);
7742 u (has_type
? TREE_CODE (type
) : 0);
7746 type_tag
= insert (type
, WK_value
);
7750 tree_node_bools (type
);
7752 && dump ("Writing type:%d %C:%N", type_tag
,
7753 TREE_CODE (type
), type
);
7756 stub_decl
= TYPE_STUB_DECL (type
);
7757 bool has_stub
= inner
!= stub_decl
;
7759 u (has_stub
? TREE_CODE (stub_decl
) : 0);
7762 stub_tag
= insert (stub_decl
);
7765 start (stub_decl
, true);
7766 tree_node_bools (stub_decl
);
7768 && dump ("Writing stub_decl:%d %C:%N", stub_tag
,
7769 TREE_CODE (stub_decl
), stub_decl
);
7773 stub_decl
= NULL_TREE
;
7776 /* Regular typedef. */
7780 /* Stream the container, we want it correctly canonicalized before
7781 we start emitting keys for this decl. */
7782 tree container
= decl_container (decl
);
7784 unsigned tpl_levels
= 0;
7786 tpl_header (decl
, &tpl_levels
);
7787 if (TREE_CODE (inner
) == FUNCTION_DECL
)
7788 fn_parms_init (inner
);
7790 /* Now write out the merging information, and then really
7791 install the tag values. */
7792 key_mergeable (tag
, mk
, decl
, inner
, container
, dep
);
7795 dump (dumper::MERGE
)
7796 && dump ("Wrote:%d's %s merge key %C:%N", tag
,
7797 merge_kind_name
[mk
], TREE_CODE (decl
), decl
);
7799 if (TREE_CODE (inner
) == FUNCTION_DECL
)
7800 fn_parms_fini (inner
);
7802 if (!is_key_order ())
7803 tree_node_vals (decl
);
7807 if (!is_key_order ())
7808 tree_node_vals (inner
);
7809 tpl_parms_fini (decl
, tpl_levels
);
7812 if (type
&& !is_key_order ())
7814 tree_node_vals (type
);
7816 tree_node_vals (stub_decl
);
7819 if (!is_key_order ())
7821 if (mk
& MK_template_mask
7823 || mk
== MK_friend_spec
)
7825 if (mk
!= MK_partial
)
7827 // FIXME: We should make use of the merge-key by
7828 // exposing it outside of key_mergeable. But this gets
7830 auto *entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
7833 u (get_mergeable_specialization_flags (entry
->tmpl
, decl
));
7834 tree_node (entry
->tmpl
);
7835 tree_node (entry
->args
);
7839 tree ti
= get_template_info (inner
);
7840 tree_node (TI_TEMPLATE (ti
));
7841 tree_node (TI_ARGS (ti
));
7844 tree_node (get_constraints (decl
));
7849 /* Do not stray outside this section. */
7850 gcc_checking_assert (!dep
|| dep
->section
== dep_hash
->section
);
7852 /* Write the entity index, so we can insert it as soon as we
7853 know this is new. */
7854 install_entity (decl
, dep
);
7857 if (VAR_OR_FUNCTION_DECL_P (inner
)
7858 && DECL_LANG_SPECIFIC (inner
)
7859 && DECL_MODULE_KEYED_DECLS_P (inner
)
7860 && !is_key_order ())
7862 /* Stream the keyed entities. */
7863 auto *attach_vec
= keyed_table
->get (inner
);
7864 unsigned num
= attach_vec
->length ();
7867 for (unsigned ix
= 0; ix
!= num
; ix
++)
7869 tree attached
= (*attach_vec
)[ix
];
7870 tree_node (attached
);
7872 dump (dumper::MERGE
)
7873 && dump ("Written %d[%u] attached decl %N", tag
, ix
, attached
);
7877 bool is_typedef
= false;
7878 if (!type
&& TREE_CODE (inner
) == TYPE_DECL
)
7880 tree t
= TREE_TYPE (inner
);
7881 unsigned tdef_flags
= 0;
7882 if (DECL_ORIGINAL_TYPE (inner
)
7883 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
7886 if (TYPE_STRUCTURAL_EQUALITY_P (t
)
7887 && TYPE_DEPENDENT_P_VALID (t
)
7888 && TYPE_DEPENDENT_P (t
))
7896 /* A typedef type. */
7897 int type_tag
= insert (t
);
7900 && dump ("Cloned:%d %s %C:%N", type_tag
,
7901 tdef_flags
& 2 ? "depalias" : "typedef",
7908 if (streaming_p () && DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
))
7911 = (DECL_CHAIN (decl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
7912 bool needs_vtt_parm_p
7913 = (cloned_p
&& CLASSTYPE_VBASECLASSES (DECL_CONTEXT (decl
)));
7914 bool omit_inherited_parms_p
7915 = (cloned_p
&& DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
7916 && base_ctor_omit_inherited_parms (decl
));
7917 unsigned flags
= (int (cloned_p
) << 0
7918 | int (needs_vtt_parm_p
) << 1
7919 | int (omit_inherited_parms_p
) << 2);
7921 dump (dumper::TREE
) && dump ("CDTOR %N is %scloned",
7922 decl
, cloned_p
? "" : "not ");
7926 dump (dumper::TREE
) && dump ("Written decl:%d %C:%N", tag
,
7927 TREE_CODE (decl
), decl
);
7929 if (NAMESPACE_SCOPE_P (inner
))
7930 gcc_checking_assert (!dep
== (VAR_OR_FUNCTION_DECL_P (inner
)
7931 && DECL_LOCAL_DECL_P (inner
)));
7932 else if ((TREE_CODE (inner
) == TYPE_DECL
7934 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
7935 || TREE_CODE (inner
) == FUNCTION_DECL
)
7937 bool write_defn
= !dep
&& has_definition (decl
);
7941 write_definition (decl
);
7946 trees_in::decl_value ()
7949 bool is_attached
= false;
7950 bool has_defn
= false;
7951 unsigned mk_u
= u ();
7952 if (mk_u
>= MK_hwm
|| !merge_kind_name
[mk_u
])
7958 unsigned saved_unused
= unused
;
7961 merge_kind mk
= merge_kind (mk_u
);
7963 tree decl
= start ();
7966 if (mk
!= MK_unique
)
7968 if (!(mk
& MK_template_mask
) && !state
->is_header ())
7969 /* See note in trees_out about where this bool is sequenced. */
7975 if (!tree_node_bools (decl
))
7979 /* Insert into map. */
7980 tag
= insert (decl
);
7983 && dump ("Reading:%d %C", tag
, TREE_CODE (decl
));
7987 if (decl
&& TREE_CODE (decl
) == TEMPLATE_DECL
)
7990 inner
= start (code
);
7991 if (inner
&& tree_node_bools (inner
))
7992 DECL_TEMPLATE_RESULT (decl
) = inner
;
7996 inner_tag
= insert (inner
);
7999 && dump ("Reading:%d %C", inner_tag
, TREE_CODE (inner
));
8002 tree type
= NULL_TREE
;
8004 tree stub_decl
= NULL_TREE
;
8006 if (decl
&& TREE_CODE (inner
) == TYPE_DECL
)
8008 if (unsigned type_code
= u ())
8010 type
= start (type_code
);
8011 if (type
&& tree_node_bools (type
))
8013 TREE_TYPE (inner
) = type
;
8014 TYPE_NAME (type
) = inner
;
8019 type_tag
= insert (type
);
8022 && dump ("Reading type:%d %C", type_tag
, TREE_CODE (type
));
8024 if (unsigned stub_code
= u ())
8026 stub_decl
= start (stub_code
);
8027 if (stub_decl
&& tree_node_bools (stub_decl
))
8029 TREE_TYPE (stub_decl
) = type
;
8030 TYPE_STUB_DECL (type
) = stub_decl
;
8035 stub_tag
= insert (stub_decl
);
8038 && dump ("Reading stub_decl:%d %C", stub_tag
,
8039 TREE_CODE (stub_decl
));
8048 back_refs
[~inner_tag
] = NULL_TREE
;
8050 back_refs
[~type_tag
] = NULL_TREE
;
8052 back_refs
[~stub_tag
] = NULL_TREE
;
8054 back_refs
[~tag
] = NULL_TREE
;
8057 unused
= saved_unused
;
8061 /* Read the container, to ensure it's already been streamed in. */
8062 tree container
= decl_container ();
8063 unsigned tpl_levels
= 0;
8065 /* Figure out if this decl is already known about. */
8069 if (!tpl_header (decl
, &tpl_levels
))
8071 if (TREE_CODE (inner
) == FUNCTION_DECL
)
8072 parm_tag
= fn_parms_init (inner
);
8074 tree existing
= key_mergeable (tag
, mk
, decl
, inner
, type
, container
,
8076 tree existing_inner
= existing
;
8079 if (existing
== error_mark_node
)
8082 if (TREE_CODE (STRIP_TEMPLATE (existing
)) == TYPE_DECL
)
8084 tree etype
= TREE_TYPE (existing
);
8085 if (TYPE_LANG_SPECIFIC (etype
)
8086 && COMPLETE_TYPE_P (etype
)
8087 && !CLASSTYPE_MEMBER_VEC (etype
))
8088 /* Give it a member vec, we're likely gonna be looking
8090 set_class_bindings (etype
, -1);
8093 /* Install the existing decl into the back ref array. */
8094 register_duplicate (decl
, existing
);
8095 back_refs
[~tag
] = existing
;
8098 existing_inner
= DECL_TEMPLATE_RESULT (existing
);
8099 back_refs
[~inner_tag
] = existing_inner
;
8104 tree existing_type
= TREE_TYPE (existing
);
8105 back_refs
[~type_tag
] = existing_type
;
8107 back_refs
[~stub_tag
] = TYPE_STUB_DECL (existing_type
);
8112 fn_parms_fini (parm_tag
, inner
, existing_inner
, has_defn
);
8114 if (!tree_node_vals (decl
))
8119 gcc_checking_assert (DECL_TEMPLATE_RESULT (decl
) == inner
);
8121 if (!tree_node_vals (inner
))
8124 if (!tpl_parms_fini (decl
, tpl_levels
))
8128 if (type
&& (!tree_node_vals (type
)
8129 || (stub_decl
&& !tree_node_vals (stub_decl
))))
8133 unsigned spec_flags
= 0;
8134 if (mk
& MK_template_mask
8136 || mk
== MK_friend_spec
)
8138 if (mk
== MK_partial
)
8143 spec
.tmpl
= tree_node ();
8144 spec
.args
= tree_node ();
8146 /* Hold constraints on the spec field, for a short while. */
8147 spec
.spec
= tree_node ();
8149 dump (dumper::TREE
) && dump ("Read:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8151 existing
= back_refs
[~tag
];
8152 bool installed
= install_entity (existing
);
8153 bool is_new
= existing
== decl
;
8155 if (VAR_OR_FUNCTION_DECL_P (inner
)
8156 && DECL_LANG_SPECIFIC (inner
)
8157 && DECL_MODULE_KEYED_DECLS_P (inner
))
8159 /* Read and maybe install the attached entities. */
8161 auto &set
= keyed_table
->get_or_insert (STRIP_TEMPLATE (existing
),
8163 unsigned num
= u ();
8164 if (is_new
== existed
)
8168 for (unsigned ix
= 0; !get_overrun () && ix
!= num
; ix
++)
8170 tree attached
= tree_node ();
8171 dump (dumper::MERGE
)
8172 && dump ("Read %d[%u] %s attached decl %N", tag
, ix
,
8173 is_new
? "new" : "matched", attached
);
8175 set
.quick_push (attached
);
8176 else if (set
[ix
] != attached
)
8181 /* Regular typedefs will have a NULL TREE_TYPE at this point. */
8182 unsigned tdef_flags
= 0;
8183 bool is_typedef
= false;
8184 if (!type
&& TREE_CODE (inner
) == TYPE_DECL
)
8193 /* A newly discovered node. */
8194 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
8195 /* Mark this identifier as naming a virtual function --
8196 lookup_overrides relies on this optimization. */
8197 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = true;
8201 /* Mark the entity as imported. */
8202 retrofit_lang_decl (inner
);
8203 DECL_MODULE_IMPORT_P (inner
) = true;
8207 set_constraints (decl
, spec
.spec
);
8209 if (TREE_CODE (decl
) == INTEGER_CST
&& !TREE_OVERFLOW (decl
))
8211 decl
= cache_integer_cst (decl
, true);
8212 back_refs
[~tag
] = decl
;
8217 /* Frob it to be ready for cloning. */
8218 TREE_TYPE (inner
) = DECL_ORIGINAL_TYPE (inner
);
8219 DECL_ORIGINAL_TYPE (inner
) = NULL_TREE
;
8220 set_underlying_type (inner
);
8223 /* Match instantiate_alias_template's handling. */
8224 tree type
= TREE_TYPE (inner
);
8225 TYPE_DEPENDENT_P (type
) = true;
8226 TYPE_DEPENDENT_P_VALID (type
) = true;
8227 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8232 /* Set the TEMPLATE_DECL's type. */
8233 TREE_TYPE (decl
) = TREE_TYPE (inner
);
8235 /* Add to specialization tables now that constraints etc are
8237 if (mk
== MK_partial
)
8239 bool is_type
= TREE_CODE (inner
) == TYPE_DECL
;
8240 spec
.spec
= is_type
? type
: inner
;
8241 add_mergeable_specialization (!is_type
, false,
8242 &spec
, decl
, spec_flags
);
8244 else if (mk
& MK_template_mask
)
8246 bool is_type
= !(mk
& MK_tmpl_decl_mask
);
8247 spec
.spec
= is_type
? type
: mk
& MK_tmpl_tmpl_mask
? inner
: decl
;
8248 add_mergeable_specialization (!is_type
,
8249 !is_type
&& mk
& MK_tmpl_alias_mask
,
8250 &spec
, decl
, spec_flags
);
8253 if (NAMESPACE_SCOPE_P (decl
)
8254 && (mk
== MK_named
|| mk
== MK_unique
8255 || mk
== MK_enum
|| mk
== MK_friend_spec
)
8256 && !(VAR_OR_FUNCTION_DECL_P (decl
) && DECL_LOCAL_DECL_P (decl
)))
8257 add_module_namespace_decl (CP_DECL_CONTEXT (decl
), decl
);
8259 if (DECL_ARTIFICIAL (decl
)
8260 && TREE_CODE (decl
) == FUNCTION_DECL
8261 && !DECL_TEMPLATE_INFO (decl
)
8262 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
8263 && TYPE_SIZE (DECL_CONTEXT (decl
))
8264 && !DECL_THUNK_P (decl
))
8265 /* A new implicit member function, when the class is
8266 complete. This means the importee declared it, and
8267 we must now add it to the class. Note that implicit
8268 member fns of template instantiations do not themselves
8269 look like templates. */
8270 if (!install_implicit_member (inner
))
8275 /* DECL is the to-be-discarded decl. Its internal pointers will
8276 be to the EXISTING's structure. Frob it to point to its
8277 own other structures, so loading its definition will alter
8278 it, and not the existing decl. */
8279 dump (dumper::MERGE
) && dump ("Deduping %N", existing
);
8282 DECL_TEMPLATE_RESULT (decl
) = inner
;
8286 /* Point at the to-be-discarded type & decl. */
8287 TYPE_NAME (type
) = inner
;
8288 TREE_TYPE (inner
) = type
;
8290 TYPE_STUB_DECL (type
) = stub_decl
? stub_decl
: inner
;
8292 TREE_TYPE (stub_decl
) = type
;
8296 /* Set the TEMPLATE_DECL's type. */
8297 TREE_TYPE (decl
) = TREE_TYPE (inner
);
8299 if (!is_matching_decl (existing
, decl
, is_typedef
))
8300 unmatched_duplicate (existing
);
8302 if (TREE_CODE (inner
) == FUNCTION_DECL
)
8304 tree e_inner
= STRIP_TEMPLATE (existing
);
8305 for (auto parm
= DECL_ARGUMENTS (inner
);
8306 parm
; parm
= DECL_CHAIN (parm
))
8307 DECL_CONTEXT (parm
) = e_inner
;
8310 /* And our result is the existing node. */
8314 if (mk
== MK_friend_spec
)
8316 tree e
= match_mergeable_specialization (true, &spec
);
8320 add_mergeable_specialization (true, false, &spec
, decl
, spec_flags
);
8322 else if (e
!= existing
)
8328 /* Insert the type into the array now. */
8329 tag
= insert (TREE_TYPE (decl
));
8331 && dump ("Cloned:%d typedef %C:%N",
8332 tag
, TREE_CODE (TREE_TYPE (decl
)), TREE_TYPE (decl
));
8335 unused
= saved_unused
;
8337 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
))
8339 unsigned flags
= u ();
8343 bool cloned_p
= flags
& 1;
8344 dump (dumper::TREE
) && dump ("CDTOR %N is %scloned",
8345 decl
, cloned_p
? "" : "not ");
8347 build_cdtor_clones (decl
, flags
& 2, flags
& 4,
8348 /* Update the member vec, if there is
8349 one (we're in a different cluster
8350 to the class defn). */
8351 CLASSTYPE_MEMBER_VEC (DECL_CONTEXT (decl
)));
8355 if (!NAMESPACE_SCOPE_P (inner
)
8356 && ((TREE_CODE (inner
) == TYPE_DECL
8358 && TYPE_NAME (TREE_TYPE (inner
)) == inner
)
8359 || TREE_CODE (inner
) == FUNCTION_DECL
)
8361 read_definition (decl
);
8366 /* DECL is an unnameable member of CTX. Return a suitable identifying
8370 get_field_ident (tree ctx
, tree decl
)
8372 gcc_checking_assert (TREE_CODE (decl
) == USING_DECL
8373 || !DECL_NAME (decl
)
8374 || IDENTIFIER_ANON_P (DECL_NAME (decl
)));
8377 for (tree fields
= TYPE_FIELDS (ctx
);
8378 fields
; fields
= DECL_CHAIN (fields
))
8383 if (DECL_CONTEXT (fields
) == ctx
8384 && (TREE_CODE (fields
) == USING_DECL
8385 || (TREE_CODE (fields
) == FIELD_DECL
8386 && (!DECL_NAME (fields
)
8387 || IDENTIFIER_ANON_P (DECL_NAME (fields
))))))
8388 /* Count this field. */
8395 lookup_field_ident (tree ctx
, unsigned ix
)
8397 for (tree fields
= TYPE_FIELDS (ctx
);
8398 fields
; fields
= DECL_CHAIN (fields
))
8399 if (DECL_CONTEXT (fields
) == ctx
8400 && (TREE_CODE (fields
) == USING_DECL
8401 || (TREE_CODE (fields
) == FIELD_DECL
8402 && (!DECL_NAME (fields
)
8403 || IDENTIFIER_ANON_P (DECL_NAME (fields
))))))
8410 /* Reference DECL. REF indicates the walk kind we are performing.
8411 Return true if we should write this decl by value. */
8414 trees_out::decl_node (tree decl
, walk_kind ref
)
8416 gcc_checking_assert (DECL_P (decl
) && !DECL_TEMPLATE_PARM_P (decl
)
8417 && DECL_CONTEXT (decl
));
8419 if (ref
== WK_value
)
8421 depset
*dep
= dep_hash
->find_dependency (decl
);
8422 decl_value (decl
, dep
);
8426 switch (TREE_CODE (decl
))
8432 gcc_checking_assert (!DECL_LOCAL_DECL_P (decl
));
8436 /* Unlike PARM_DECLs, RESULT_DECLs are only generated and
8437 referenced when we're inside the function itself. */
8444 tree_node (DECL_CONTEXT (decl
));
8447 /* That must have put this in the map. */
8448 walk_kind ref
= ref_node (decl
);
8450 // FIXME:OPTIMIZATION We can wander into bits of the
8451 // template this was instantiated from. For instance
8452 // deferred noexcept and default parms. Currently we'll
8453 // end up cloning those bits of tree. It would be nice
8454 // to reference those specific nodes. I think putting
8455 // those things in the map when we reference their
8456 // template by name. See the note in add_indirects.
8460 && dump ("Wrote %s reference %N",
8461 TREE_CODE (decl
) == PARM_DECL
? "parameter" : "result",
8468 /* This describes a USING_DECL to the ME's debug machinery. It
8469 originates from the fortran FE, and has nothing to do with
8478 /* If I end up cloning enum decls, implementing C++20 using
8479 E::v, this will need tweaking. */
8482 tree ctx
= DECL_CONTEXT (decl
);
8483 gcc_checking_assert (TREE_CODE (ctx
) == ENUMERAL_TYPE
);
8485 tree_node (DECL_NAME (decl
));
8487 int tag
= insert (decl
);
8490 && dump ("Wrote enum decl:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8496 if (TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8505 tree ctx
= DECL_CONTEXT (decl
);
8508 tree name
= NULL_TREE
;
8510 if (TREE_CODE (decl
) == USING_DECL
)
8514 name
= DECL_NAME (decl
);
8515 if (name
&& IDENTIFIER_ANON_P (name
))
8520 if (!name
&& streaming_p ())
8522 unsigned ix
= get_field_ident (ctx
, decl
);
8526 int tag
= insert (decl
);
8529 && dump ("Wrote member:%d %C:%N", tag
, TREE_CODE (decl
), decl
);
8535 gcc_checking_assert (!DECL_LOCAL_DECL_P (decl
));
8536 if (DECL_VTABLE_OR_VTT_P (decl
))
8538 /* VTT or VTABLE, they are all on the vtables list. */
8539 tree ctx
= CP_DECL_CONTEXT (decl
);
8540 tree vtable
= CLASSTYPE_VTABLES (ctx
);
8541 for (unsigned ix
= 0; ; vtable
= DECL_CHAIN (vtable
), ix
++)
8544 gcc_checking_assert (DECL_VIRTUAL_P (decl
));
8550 && dump ("Writing vtable %N[%u]", ctx
, ix
);
8558 if (DECL_TINFO_P (decl
))
8561 /* A typeinfo, tt_tinfo_typedef or tt_tinfo_var. */
8562 bool is_var
= VAR_P (decl
);
8563 tree type
= TREE_TYPE (decl
);
8564 unsigned ix
= get_pseudo_tinfo_index (type
);
8567 i (is_var
? tt_tinfo_var
: tt_tinfo_typedef
);
8573 /* We also need the type it is for and mangled name, so
8574 the reader doesn't need to complete the type (which
8575 would break section ordering). The type it is for is
8576 stashed on the name's TREE_TYPE. */
8577 tree name
= DECL_NAME (decl
);
8579 type
= TREE_TYPE (name
);
8583 int tag
= insert (decl
);
8586 && dump ("Wrote tinfo_%s:%d %u %N", is_var
? "var" : "type",
8591 tag
= insert (type
);
8594 && dump ("Wrote tinfo_type:%d %u %N", tag
, ix
, type
);
8599 if (DECL_NTTP_OBJECT_P (decl
))
8601 /* A NTTP parm object. */
8604 tree_node (tparm_object_argument (decl
));
8605 tree_node (DECL_NAME (decl
));
8606 int tag
= insert (decl
);
8609 && dump ("Wrote nttp object:%d %N", tag
, DECL_NAME (decl
));
8616 if (DECL_TINFO_P (decl
))
8621 if (DECL_THUNK_P (decl
))
8623 /* Thunks are similar to binfos -- write the thunked-to decl and
8624 then thunk-specific key info. */
8628 i (THUNK_FIXED_OFFSET (decl
));
8632 while (DECL_THUNK_P (target
))
8633 target
= THUNK_TARGET (target
);
8635 tree_node (THUNK_VIRTUAL_OFFSET (decl
));
8636 int tag
= insert (decl
);
8639 && dump ("Wrote:%d thunk %N to %N", tag
, DECL_NAME (decl
), target
);
8643 if (DECL_CLONED_FUNCTION_P (decl
))
8645 tree target
= get_clone_target (decl
);
8650 tree_node (DECL_NAME (decl
));
8651 if (DECL_VIRTUAL_P (decl
))
8652 tree_node (DECL_VINDEX (decl
));
8653 int tag
= insert (decl
);
8656 && dump ("Wrote:%d clone %N of %N", tag
, DECL_NAME (decl
), target
);
8660 /* Everything left should be a thing that is in the entity table.
8661 Mostly things that can be defined outside of their (original
8662 declaration) context. */
8663 gcc_checking_assert (TREE_CODE (decl
) == TEMPLATE_DECL
8665 || TREE_CODE (decl
) == FUNCTION_DECL
8666 || TREE_CODE (decl
) == TYPE_DECL
8667 || TREE_CODE (decl
) == USING_DECL
8668 || TREE_CODE (decl
) == CONCEPT_DECL
8669 || TREE_CODE (decl
) == NAMESPACE_DECL
);
8672 tree ti
= node_template_info (decl
, use_tpl
);
8673 tree tpl
= NULL_TREE
;
8675 /* If this is the TEMPLATE_DECL_RESULT of a TEMPLATE_DECL, get the
8676 TEMPLATE_DECL. Note TI_TEMPLATE is not a TEMPLATE_DECL for
8677 (some) friends, so we need to check that. */
8678 // FIXME: Should local friend template specializations be by value?
8679 // They don't get idents so we'll never know they're imported, but I
8680 // think we can only reach them from the TU that defines the
8681 // befriending class?
8682 if (ti
&& TREE_CODE (TI_TEMPLATE (ti
)) == TEMPLATE_DECL
8683 && DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
)) == decl
)
8685 tpl
= TI_TEMPLATE (ti
);
8691 && dump ("Writing implicit template %C:%N%S",
8692 TREE_CODE (tpl
), tpl
, tpl
);
8696 /* Streaming TPL caused us to visit DECL and maybe its type. */
8697 gcc_checking_assert (TREE_VISITED (decl
));
8698 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
8699 gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl
)));
8703 tree ctx
= CP_DECL_CONTEXT (decl
);
8706 dep
= dep_hash
->find_dependency (decl
);
8707 else if (TREE_CODE (ctx
) != FUNCTION_DECL
8708 || TREE_CODE (decl
) == TEMPLATE_DECL
8709 || (dep_hash
->sneakoscope
&& DECL_IMPLICIT_TYPEDEF_P (decl
))
8710 || (DECL_LANG_SPECIFIC (decl
)
8711 && DECL_MODULE_IMPORT_P (decl
)))
8713 auto kind
= (TREE_CODE (decl
) == NAMESPACE_DECL
8714 && !DECL_NAMESPACE_ALIAS (decl
)
8715 ? depset::EK_NAMESPACE
: depset::EK_DECL
);
8716 dep
= dep_hash
->add_dependency (decl
, kind
);
8721 /* Some internal entity of context. Do by value. */
8722 decl_value (decl
, NULL
);
8726 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
8728 /* The DECL_TEMPLATE_RESULT of a partial specialization.
8729 Write the partial specialization's template. */
8730 depset
*redirect
= dep
->deps
[0];
8731 gcc_checking_assert (redirect
->get_entity_kind () == depset::EK_PARTIAL
);
8732 tpl
= redirect
->get_entity ();
8733 goto partial_template
;
8738 /* Locate the entity. */
8739 unsigned index
= dep
->cluster
;
8740 unsigned import
= 0;
8742 if (dep
->is_import ())
8743 import
= dep
->section
;
8744 else if (CHECKING_P
)
8745 /* It should be what we put there. */
8746 gcc_checking_assert (index
== ~import_entity_index (decl
));
8749 gcc_assert (!import
|| importedness
>= 0);
8756 int tag
= insert (decl
);
8757 if (streaming_p () && dump (dumper::TREE
))
8759 char const *kind
= "import";
8760 module_state
*from
= (*modules
)[0];
8761 if (dep
->is_import ())
8762 /* Rediscover the unremapped index. */
8763 from
= import_entity_module (import_entity_index (decl
));
8766 tree o
= get_originating_module_decl (decl
);
8767 o
= STRIP_TEMPLATE (o
);
8768 kind
= (DECL_LANG_SPECIFIC (o
) && DECL_MODULE_PURVIEW_P (o
)
8769 ? "purview" : "GMF");
8771 dump ("Wrote %s:%d %C:%N@%M", kind
,
8772 tag
, TREE_CODE (decl
), decl
, from
);
8775 add_indirects (decl
);
8781 trees_out::type_node (tree type
)
8783 gcc_assert (TYPE_P (type
));
8785 tree root
= (TYPE_NAME (type
)
8786 ? TREE_TYPE (TYPE_NAME (type
)) : TYPE_MAIN_VARIANT (type
));
8791 i (tt_variant_type
);
8796 if (TREE_CODE (type
) == FUNCTION_TYPE
8797 || TREE_CODE (type
) == METHOD_TYPE
)
8799 int quals
= type_memfn_quals (type
);
8800 int rquals
= type_memfn_rqual (type
);
8801 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
8802 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
8804 if (raises
!= TYPE_RAISES_EXCEPTIONS (root
)
8805 || rquals
!= type_memfn_rqual (root
)
8806 || quals
!= type_memfn_quals (root
)
8807 || late
!= TYPE_HAS_LATE_RETURN_TYPE (root
))
8808 flags
= rquals
| (int (late
) << 2) | (quals
<< 3);
8812 if (TYPE_USER_ALIGN (type
))
8813 flags
= TYPE_ALIGN_RAW (type
);
8821 else if (TREE_CODE (type
) == FUNCTION_TYPE
8822 || TREE_CODE (type
) == METHOD_TYPE
)
8824 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
8825 if (raises
== TYPE_RAISES_EXCEPTIONS (root
))
8826 raises
= error_mark_node
;
8830 tree_node (TYPE_ATTRIBUTES (type
));
8835 int rquals
= cp_type_quals (root
);
8836 int quals
= cp_type_quals (type
);
8837 if (quals
== rquals
)
8842 if (ref_node (type
) != WK_none
)
8844 int tag
= insert (type
);
8849 && dump ("Wrote:%d variant type %C", tag
, TREE_CODE (type
));
8855 if (tree name
= TYPE_NAME (type
))
8856 if ((TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
))
8857 || DECL_TEMPLATE_PARM_P (name
)
8858 || TREE_CODE (type
) == RECORD_TYPE
8859 || TREE_CODE (type
) == UNION_TYPE
8860 || TREE_CODE (type
) == ENUMERAL_TYPE
)
8862 /* We can meet template parms that we didn't meet in the
8863 tpl_parms walk, because we're referring to a derived type
8864 that was previously constructed from equivalent template
8868 i (tt_typedef_type
);
8870 && dump ("Writing %stypedef %C:%N",
8871 DECL_IMPLICIT_TYPEDEF_P (name
) ? "implicit " : "",
8872 TREE_CODE (name
), name
);
8876 dump (dumper::TREE
) && dump ("Wrote typedef %C:%N%S",
8877 TREE_CODE (name
), name
, name
);
8878 gcc_checking_assert (TREE_VISITED (type
));
8882 if (TYPE_PTRMEMFUNC_P (type
))
8884 /* This is a distinct type node, masquerading as a structure. */
8885 tree fn_type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
8888 tree_node (fn_type
);
8889 int tag
= insert (type
);
8891 dump (dumper::TREE
) && dump ("Written:%d ptrmem type", tag
);
8897 u (tt_derived_type
);
8898 u (TREE_CODE (type
));
8901 tree_node (TREE_TYPE (type
));
8902 switch (TREE_CODE (type
))
8905 /* We should never meet a type here that is indescribable in
8906 terms of other types. */
8910 tree_node (TYPE_DOMAIN (type
));
8912 /* Dependent arrays are constructed with TYPE_DEPENENT_P
8914 u (TYPE_DEPENDENT_P (type
));
8918 /* No additional data. */
8922 /* A non-standard boolean type. */
8924 u (TYPE_PRECISION (type
));
8928 if (TREE_TYPE (type
))
8930 /* A range type (representing an array domain). */
8931 tree_node (TYPE_MIN_VALUE (type
));
8932 tree_node (TYPE_MAX_VALUE (type
));
8936 /* A new integral type (representing a bitfield). */
8939 unsigned prec
= TYPE_PRECISION (type
);
8940 bool unsigned_p
= TYPE_UNSIGNED (type
);
8942 u ((prec
<< 1) | unsigned_p
);
8950 gcc_checking_assert (type_memfn_rqual (type
) == REF_QUAL_NONE
);
8952 tree arg_types
= TYPE_ARG_TYPES (type
);
8953 if (TREE_CODE (type
) == METHOD_TYPE
)
8955 tree_node (TREE_TYPE (TREE_VALUE (arg_types
)));
8956 arg_types
= TREE_CHAIN (arg_types
);
8958 tree_node (arg_types
);
8963 tree_node (TYPE_OFFSET_BASETYPE (type
));
8967 /* No additional data. */
8970 case REFERENCE_TYPE
:
8972 u (TYPE_REF_IS_RVALUE (type
));
8977 case DEPENDENT_OPERATOR_TYPE
:
8978 tree_node (TYPE_VALUES_RAW (type
));
8979 if (TREE_CODE (type
) == DECLTYPE_TYPE
)
8980 /* We stash a whole bunch of things into decltype's
8983 tree_node_bools (type
);
8987 tree_node (TRAIT_TYPE_KIND_RAW (type
));
8988 tree_node (TRAIT_TYPE_TYPE1 (type
));
8989 tree_node (TRAIT_TYPE_TYPE2 (type
));
8992 case TYPE_ARGUMENT_PACK
:
8993 /* No additional data. */
8996 case TYPE_PACK_EXPANSION
:
8998 u (PACK_EXPANSION_LOCAL_P (type
));
8999 tree_node (PACK_EXPANSION_PARAMETER_PACKS (type
));
9000 tree_node (PACK_EXPANSION_EXTRA_ARGS (type
));
9005 tree_node (TYPE_CONTEXT (type
));
9006 tree_node (DECL_NAME (TYPE_NAME (type
)));
9007 tree_node (TYPENAME_TYPE_FULLNAME (type
));
9010 enum tag_types tag_type
= none_type
;
9011 if (TYPENAME_IS_ENUM_P (type
))
9012 tag_type
= enum_type
;
9013 else if (TYPENAME_IS_CLASS_P (type
))
9014 tag_type
= class_type
;
9020 case UNBOUND_CLASS_TEMPLATE
:
9022 tree decl
= TYPE_NAME (type
);
9023 tree_node (DECL_CONTEXT (decl
));
9024 tree_node (DECL_NAME (decl
));
9025 tree_node (DECL_TEMPLATE_PARMS (decl
));
9032 poly_uint64 nunits
= TYPE_VECTOR_SUBPARTS (type
);
9033 /* to_constant asserts that only coeff[0] is of interest. */
9034 wu (static_cast<unsigned HOST_WIDE_INT
> (nunits
.to_constant ()));
9039 /* We may have met the type during emitting the above. */
9040 if (ref_node (type
) != WK_none
)
9042 int tag
= insert (type
);
9047 && dump ("Wrote:%d derived type %C", tag
, TREE_CODE (type
));
9054 /* T is (mostly*) a non-mergeable node that must be written by value.
9055 The mergeable case is a BINFO, which are as-if DECLSs. */
9058 trees_out::tree_value (tree t
)
9060 /* We should never be writing a type by value. tree_type should
9061 have streamed it, or we're going via its TYPE_DECL. */
9062 gcc_checking_assert (!TYPE_P (t
));
9065 /* No template, type, var or function, except anonymous
9066 non-context vars. */
9067 gcc_checking_assert ((TREE_CODE (t
) != TEMPLATE_DECL
9068 && TREE_CODE (t
) != TYPE_DECL
9069 && (TREE_CODE (t
) != VAR_DECL
9070 || (!DECL_NAME (t
) && !DECL_CONTEXT (t
)))
9071 && TREE_CODE (t
) != FUNCTION_DECL
));
9075 /* A new node -> tt_node. */
9079 tree_node_bools (t
);
9082 if (TREE_CODE (t
) == TREE_BINFO
)
9083 /* Binfos are decl-like and need merging information. */
9084 binfo_mergeable (t
);
9086 int tag
= insert (t
, WK_value
);
9089 && dump ("Writing tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9094 dump (dumper::TREE
) && dump ("Written tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9098 trees_in::tree_value ()
9101 if (!t
|| !tree_node_bools (t
))
9105 if (TREE_CODE (t
) == TREE_BINFO
)
9108 unsigned ix
= binfo_mergeable (&type
);
9109 if (TYPE_BINFO (type
))
9111 /* We already have a definition, this must be a duplicate. */
9112 dump (dumper::MERGE
)
9113 && dump ("Deduping binfo %N[%u]", type
, ix
);
9114 existing
= TYPE_BINFO (type
);
9115 while (existing
&& ix
--)
9116 existing
= TREE_CHAIN (existing
);
9118 register_duplicate (t
, existing
);
9120 /* Error, mismatch -- diagnose in read_class_def's
9126 /* Insert into map. */
9127 int tag
= insert (existing
);
9129 && dump ("Reading tree:%d %C", tag
, TREE_CODE (t
));
9131 if (!tree_node_vals (t
))
9133 back_refs
[~tag
] = NULL_TREE
;
9139 dump (dumper::TREE
) && dump ("Read tree:%d %C:%N", tag
, TREE_CODE (t
), t
);
9141 if (TREE_CODE (existing
) == INTEGER_CST
&& !TREE_OVERFLOW (existing
))
9143 existing
= cache_integer_cst (t
, true);
9144 back_refs
[~tag
] = existing
;
9150 /* Stream out tree node T. We automatically create local back
9151 references, which is essentially a single pass lisp
9152 self-referential structure pretty-printer. */
9155 trees_out::tree_node (tree t
)
9158 walk_kind ref
= ref_node (t
);
9162 if (ref
!= WK_normal
)
9165 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
9167 /* An identifier node -> tt_id, tt_conv_id, tt_anon_id, tt_lambda_id. */
9169 if (IDENTIFIER_ANON_P (t
))
9170 code
= IDENTIFIER_LAMBDA_P (t
) ? tt_lambda_id
: tt_anon_id
;
9171 else if (IDENTIFIER_CONV_OP_P (t
))
9177 if (code
== tt_conv_id
)
9179 tree type
= TREE_TYPE (t
);
9180 gcc_checking_assert (type
|| t
== conv_op_identifier
);
9183 else if (code
== tt_id
&& streaming_p ())
9184 str (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
9186 int tag
= insert (t
);
9189 /* We know the ordering of the 4 id tags. */
9190 static const char *const kinds
[] =
9191 {"", "conv_op ", "anon ", "lambda "};
9193 && dump ("Written:%d %sidentifier:%N", tag
,
9194 kinds
[code
- tt_id
],
9195 code
== tt_conv_id
? TREE_TYPE (t
) : t
);
9200 if (TREE_CODE (t
) == TREE_BINFO
)
9202 /* A BINFO -> tt_binfo.
9203 We must do this by reference. We stream the binfo tree
9204 itself when streaming its owning RECORD_TYPE. That we got
9205 here means the dominating type is not in this SCC. */
9208 binfo_mergeable (t
);
9209 gcc_checking_assert (!TREE_VISITED (t
));
9210 int tag
= insert (t
);
9212 dump (dumper::TREE
) && dump ("Inserting binfo:%d %N", tag
, t
);
9216 if (TREE_CODE (t
) == INTEGER_CST
9217 && !TREE_OVERFLOW (t
)
9218 && TREE_CODE (TREE_TYPE (t
)) == ENUMERAL_TYPE
)
9220 /* An integral constant of enumeral type. See if it matches one
9221 of the enumeration values. */
9222 for (tree values
= TYPE_VALUES (TREE_TYPE (t
));
9223 values
; values
= TREE_CHAIN (values
))
9225 tree decl
= TREE_VALUE (values
);
9226 if (tree_int_cst_equal (DECL_INITIAL (decl
), t
))
9231 dump (dumper::TREE
) && dump ("Written enum value %N", decl
);
9235 /* It didn't match. We'll write it a an explicit INTEGER_CST
9247 if (DECL_TEMPLATE_PARM_P (t
))
9253 if (!DECL_CONTEXT (t
))
9255 /* There are a few cases of decls with no context. We'll write
9256 these by value, but first assert they are cases we expect. */
9257 gcc_checking_assert (ref
== WK_normal
);
9258 switch (TREE_CODE (t
))
9260 default: gcc_unreachable ();
9263 /* CASE_LABEL_EXPRs contain uncontexted LABEL_DECLs. */
9264 gcc_checking_assert (!DECL_NAME (t
));
9268 /* AGGR_INIT_EXPRs cons up anonymous uncontexted VAR_DECLs. */
9269 gcc_checking_assert (!DECL_NAME (t
)
9270 && DECL_ARTIFICIAL (t
));
9274 /* REQUIRES_EXPRs have a tree list of uncontexted
9275 PARM_DECLS. It'd be nice if they had a
9276 distinguishing flag to double check. */
9284 if (DECL_P (t
) && !decl_node (t
, ref
))
9287 /* Otherwise by value */
9292 /* And, breath out. */
9296 /* Stream in a tree node. */
9299 trees_in::tree_node (bool is_use
)
9306 tree res
= NULL_TREE
;
9310 /* backref, pull it out of the map. */
9311 res
= back_ref (tag
);
9319 /* A fixed ref, find it in the fixed_ref array. */
9321 unsigned fix
= u ();
9322 if (fix
< (*fixed_trees
).length ())
9324 res
= (*fixed_trees
)[fix
];
9325 dump (dumper::TREE
) && dump ("Read fixed:%u %C:%N%S", fix
,
9326 TREE_CODE (res
), res
, res
);
9336 tree fn
= tree_node ();
9337 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
9341 && dump ("Read %s reference %N",
9342 TREE_CODE (res
) == PARM_DECL
? "parameter" : "result",
9348 /* A new node. Stream it in. */
9349 res
= tree_value ();
9353 /* A new decl. Stream it in. */
9354 res
= decl_value ();
9358 /* A template parameter. Stream it in. */
9359 res
= tpl_parm_value ();
9363 /* An identifier node. */
9366 const char *chars
= str (&l
);
9367 res
= get_identifier_with_length (chars
, l
);
9368 int tag
= insert (res
);
9370 && dump ("Read identifier:%d %N", tag
, res
);
9375 /* A conversion operator. Get the type and recreate the
9378 tree type
= tree_node ();
9379 if (!get_overrun ())
9381 res
= type
? make_conv_op_name (type
) : conv_op_identifier
;
9382 int tag
= insert (res
);
9384 && dump ("Created conv_op:%d %S for %N", tag
, res
, type
);
9391 /* An anonymous or lambda id. */
9393 res
= make_anon_name ();
9394 if (tag
== tt_lambda_id
)
9395 IDENTIFIER_LAMBDA_P (res
) = true;
9396 int tag
= insert (res
);
9398 && dump ("Read %s identifier:%d %N",
9399 IDENTIFIER_LAMBDA_P (res
) ? "lambda" : "anon", tag
, res
);
9403 case tt_typedef_type
:
9408 && dump ("Read %stypedef %C:%N",
9409 DECL_IMPLICIT_TYPEDEF_P (res
) ? "implicit " : "",
9410 TREE_CODE (res
), res
);
9411 res
= TREE_TYPE (res
);
9415 case tt_derived_type
:
9416 /* A type derived from some other type. */
9418 enum tree_code code
= tree_code (u ());
9429 tree domain
= tree_node ();
9431 if (!get_overrun ())
9432 res
= build_cplus_array_type (res
, domain
, dep
);
9437 if (!get_overrun ())
9438 res
= build_complex_type (res
);
9443 unsigned precision
= u ();
9444 if (!get_overrun ())
9445 res
= build_nonstandard_boolean_type (precision
);
9452 /* A range type (representing an array domain). */
9453 tree min
= tree_node ();
9454 tree max
= tree_node ();
9456 if (!get_overrun ())
9457 res
= build_range_type (res
, min
, max
);
9461 /* A new integral type (representing a bitfield). */
9462 unsigned enc
= u ();
9463 if (!get_overrun ())
9464 res
= build_nonstandard_integer_type (enc
>> 1, enc
& 1);
9471 tree klass
= code
== METHOD_TYPE
? tree_node () : NULL_TREE
;
9472 tree args
= tree_node ();
9473 if (!get_overrun ())
9476 res
= build_method_type_directly (klass
, res
, args
);
9478 res
= build_function_type (res
, args
);
9485 tree base
= tree_node ();
9486 if (!get_overrun ())
9487 res
= build_offset_type (base
, res
);
9492 if (!get_overrun ())
9493 res
= build_pointer_type (res
);
9496 case REFERENCE_TYPE
:
9498 bool rval
= bool (u ());
9499 if (!get_overrun ())
9500 res
= cp_build_reference_type (res
, rval
);
9506 case DEPENDENT_OPERATOR_TYPE
:
9508 tree expr
= tree_node ();
9509 if (!get_overrun ())
9511 res
= cxx_make_type (code
);
9512 TYPE_VALUES_RAW (res
) = expr
;
9513 if (code
== DECLTYPE_TYPE
)
9514 tree_node_bools (res
);
9515 SET_TYPE_STRUCTURAL_EQUALITY (res
);
9522 tree kind
= tree_node ();
9523 tree type1
= tree_node ();
9524 tree type2
= tree_node ();
9525 if (!get_overrun ())
9527 res
= cxx_make_type (TRAIT_TYPE
);
9528 TRAIT_TYPE_KIND_RAW (res
) = kind
;
9529 TRAIT_TYPE_TYPE1 (res
) = type1
;
9530 TRAIT_TYPE_TYPE2 (res
) = type2
;
9531 SET_TYPE_STRUCTURAL_EQUALITY (res
);
9536 case TYPE_ARGUMENT_PACK
:
9537 if (!get_overrun ())
9539 tree pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9540 ARGUMENT_PACK_ARGS (pack
) = res
;
9545 case TYPE_PACK_EXPANSION
:
9548 tree param_packs
= tree_node ();
9549 tree extra_args
= tree_node ();
9550 if (!get_overrun ())
9552 tree expn
= cxx_make_type (TYPE_PACK_EXPANSION
);
9553 SET_TYPE_STRUCTURAL_EQUALITY (expn
);
9554 PACK_EXPANSION_PATTERN (expn
) = res
;
9555 PACK_EXPANSION_PARAMETER_PACKS (expn
) = param_packs
;
9556 PACK_EXPANSION_EXTRA_ARGS (expn
) = extra_args
;
9557 PACK_EXPANSION_LOCAL_P (expn
) = local
;
9565 tree ctx
= tree_node ();
9566 tree name
= tree_node ();
9567 tree fullname
= tree_node ();
9568 enum tag_types tag_type
= tag_types (u ());
9570 if (!get_overrun ())
9571 res
= build_typename_type (ctx
, name
, fullname
, tag_type
);
9575 case UNBOUND_CLASS_TEMPLATE
:
9577 tree ctx
= tree_node ();
9578 tree name
= tree_node ();
9579 tree parms
= tree_node ();
9581 if (!get_overrun ())
9582 res
= make_unbound_class_template_raw (ctx
, name
, parms
);
9588 unsigned HOST_WIDE_INT nunits
= wu ();
9589 if (!get_overrun ())
9590 res
= build_vector_type (res
, static_cast<poly_int64
> (nunits
));
9601 && dump ("Created:%d derived type %C", tag
, code
);
9604 res
= back_ref (tag
);
9608 case tt_variant_type
:
9609 /* Variant of some type. */
9617 else if (TREE_CODE (res
) == FUNCTION_TYPE
9618 || TREE_CODE (res
) == METHOD_TYPE
)
9620 cp_ref_qualifier rqual
= cp_ref_qualifier (flags
& 3);
9621 bool late
= (flags
>> 2) & 1;
9622 cp_cv_quals quals
= cp_cv_quals (flags
>> 3);
9624 tree raises
= tree_node ();
9625 if (raises
== error_mark_node
)
9626 raises
= TYPE_RAISES_EXCEPTIONS (res
);
9628 res
= build_cp_fntype_variant (res
, rqual
, raises
, late
);
9629 if (TREE_CODE (res
) == FUNCTION_TYPE
)
9630 res
= apply_memfn_quals (res
, quals
, rqual
);
9634 res
= build_aligned_type (res
, (1u << flags
) >> 1);
9635 TYPE_USER_ALIGN (res
) = true;
9638 if (tree attribs
= tree_node ())
9639 res
= cp_build_type_attribute_variant (res
, attribs
);
9642 if (quals
>= 0 && !get_overrun ())
9643 res
= cp_build_qualified_type (res
, quals
);
9651 && dump ("Created:%d variant type %C", tag
, TREE_CODE (res
));
9654 res
= back_ref (tag
);
9659 case tt_tinfo_typedef
:
9660 /* A tinfo var or typedef. */
9662 bool is_var
= tag
== tt_tinfo_var
;
9664 tree type
= NULL_TREE
;
9668 tree name
= tree_node ();
9669 type
= tree_node ();
9671 if (!get_overrun ())
9672 res
= get_tinfo_decl_direct (type
, name
, int (ix
));
9676 if (!get_overrun ())
9678 type
= get_pseudo_tinfo_type (ix
);
9679 res
= TYPE_NAME (type
);
9684 int tag
= insert (res
);
9686 && dump ("Created tinfo_%s:%d %S:%u for %N",
9687 is_var
? "var" : "decl", tag
, res
, ix
, type
);
9690 tag
= insert (type
);
9692 && dump ("Created tinfo_type:%d %u %N", tag
, ix
, type
);
9698 case tt_ptrmem_type
:
9699 /* A pointer to member function. */
9701 tree type
= tree_node ();
9702 if (type
&& TREE_CODE (type
) == POINTER_TYPE
9703 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
9705 res
= build_ptrmemfunc_type (type
);
9706 int tag
= insert (res
);
9707 dump (dumper::TREE
) && dump ("Created:%d ptrmem type", tag
);
9715 /* An NTTP object. */
9717 tree init
= tree_node ();
9718 tree name
= tree_node ();
9719 if (!get_overrun ())
9721 res
= get_template_parm_object (init
, name
);
9722 int tag
= insert (res
);
9724 && dump ("Created nttp object:%d %N", tag
, name
);
9730 /* An enum const value. */
9732 if (tree decl
= tree_node ())
9734 dump (dumper::TREE
) && dump ("Read enum value %N", decl
);
9735 res
= DECL_INITIAL (decl
);
9746 tree ctx
= tree_node ();
9747 tree name
= tree_node ();
9750 && TREE_CODE (ctx
) == ENUMERAL_TYPE
)
9751 res
= find_enum_member (ctx
, name
);
9757 int tag
= insert (res
);
9759 && dump ("Read enum decl:%d %C:%N", tag
, TREE_CODE (res
), res
);
9764 case tt_data_member
:
9765 /* A data member. */
9767 tree ctx
= tree_node ();
9768 tree name
= tree_node ();
9771 && RECORD_OR_UNION_TYPE_P (ctx
))
9774 res
= lookup_class_binding (ctx
, name
);
9776 res
= lookup_field_ident (ctx
, u ());
9779 || TREE_CODE (res
) != FIELD_DECL
9780 || DECL_CONTEXT (res
) != ctx
)
9788 int tag
= insert (res
);
9790 && dump ("Read member:%d %C:%N", tag
, TREE_CODE (res
), res
);
9796 /* A BINFO. Walk the tree of the dominating type. */
9799 unsigned ix
= binfo_mergeable (&type
);
9802 res
= TYPE_BINFO (type
);
9803 for (; ix
&& res
; res
= TREE_CHAIN (res
))
9812 /* Insert binfo into backreferences. */
9814 dump (dumper::TREE
) && dump ("Read binfo:%d %N", tag
, res
);
9821 tree ctx
= tree_node ();
9822 dump (dumper::TREE
) && dump ("Reading vtable %N[%u]", ctx
, ix
);
9823 if (TREE_CODE (ctx
) == RECORD_TYPE
&& TYPE_LANG_SPECIFIC (ctx
))
9824 for (res
= CLASSTYPE_VTABLES (ctx
); res
; res
= DECL_CHAIN (res
))
9835 tree target
= tree_node ();
9836 tree virt
= tree_node ();
9838 for (tree thunk
= DECL_THUNKS (target
);
9839 thunk
; thunk
= DECL_CHAIN (thunk
))
9840 if (THUNK_FIXED_OFFSET (thunk
) == fixed
9841 && !THUNK_VIRTUAL_OFFSET (thunk
) == !virt
9843 || tree_int_cst_equal (virt
, THUNK_VIRTUAL_OFFSET (thunk
))))
9849 int tag
= insert (res
);
9852 && dump ("Read:%d thunk %N to %N", tag
, DECL_NAME (res
), target
);
9860 tree target
= tree_node ();
9861 tree name
= tree_node ();
9863 if (DECL_P (target
) && DECL_MAYBE_IN_CHARGE_CDTOR_P (target
))
9866 FOR_EVERY_CLONE (clone
, target
)
9867 if (DECL_NAME (clone
) == name
)
9874 /* A clone might have a different vtable entry. */
9875 if (res
&& DECL_VIRTUAL_P (res
))
9876 DECL_VINDEX (res
) = tree_node ();
9880 int tag
= insert (res
);
9883 && dump ("Read:%d clone %N of %N", tag
, DECL_NAME (res
), target
);
9890 /* Index into the entity table. Perhaps not loaded yet! */
9892 unsigned origin
= state
->slurp
->remap_module (u ());
9893 unsigned ident
= u ();
9894 module_state
*from
= (*modules
)[origin
];
9896 if (!origin
|| ident
>= from
->entity_num
)
9898 if (!get_overrun ())
9900 binding_slot
*slot
= &(*entity_ary
)[from
->entity_lwm
+ ident
];
9901 if (slot
->is_lazy ())
9902 if (!from
->lazy_load (ident
, slot
))
9909 const char *kind
= (origin
!= state
->mod
? "Imported" : "Named");
9910 int tag
= insert (res
);
9912 && dump ("%s:%d %C:%N@%M", kind
, tag
, TREE_CODE (res
),
9913 res
, (*modules
)[origin
]);
9915 if (!add_indirects (res
))
9926 if (tree tpl
= tree_node ())
9928 res
= DECL_TEMPLATE_RESULT (tpl
);
9930 && dump ("Read template %C:%N", TREE_CODE (res
), res
);
9935 if (is_use
&& !unused
&& res
&& DECL_P (res
) && !TREE_USED (res
))
9937 /* Mark decl used as mark_used does -- we cannot call
9938 mark_used in the middle of streaming, we only need a subset
9939 of its functionality. */
9940 TREE_USED (res
) = true;
9942 /* And for structured bindings also the underlying decl. */
9943 if (DECL_DECOMPOSITION_P (res
) && DECL_DECOMP_BASE (res
))
9944 TREE_USED (DECL_DECOMP_BASE (res
)) = true;
9946 if (DECL_CLONED_FUNCTION_P (res
))
9947 TREE_USED (DECL_CLONED_FUNCTION (res
)) = true;
9955 trees_out::tpl_parms (tree parms
, unsigned &tpl_levels
)
9960 if (TREE_VISITED (parms
))
9966 tpl_parms (TREE_CHAIN (parms
), tpl_levels
);
9968 tree vec
= TREE_VALUE (parms
);
9969 unsigned len
= TREE_VEC_LENGTH (vec
);
9971 int tag
= insert (parms
);
9976 && dump ("Writing template parms:%d level:%N length:%d",
9977 tag
, TREE_PURPOSE (parms
), len
);
9979 tree_node (TREE_PURPOSE (parms
));
9981 for (unsigned ix
= 0; ix
!= len
; ix
++)
9983 tree parm
= TREE_VEC_ELT (vec
, ix
);
9984 tree decl
= TREE_VALUE (parm
);
9986 gcc_checking_assert (DECL_TEMPLATE_PARM_P (decl
));
9988 switch (TREE_CODE (decl
))
9990 default: gcc_unreachable ();
9993 gcc_assert ((TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TEMPLATE_PARM
)
9994 && (TREE_CODE (DECL_TEMPLATE_RESULT (decl
)) == TYPE_DECL
)
9995 && (TYPE_NAME (TREE_TYPE (decl
)) == decl
));
9999 gcc_assert ((TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TYPE_PARM
)
10000 && (TYPE_NAME (TREE_TYPE (decl
)) == decl
));
10004 gcc_assert ((TREE_CODE (DECL_INITIAL (decl
)) == TEMPLATE_PARM_INDEX
)
10005 && (TREE_CODE (TEMPLATE_PARM_DECL (DECL_INITIAL (decl
)))
10007 && (DECL_TEMPLATE_PARM_P
10008 (TEMPLATE_PARM_DECL (DECL_INITIAL (decl
)))));
10013 tree_node (TEMPLATE_PARM_CONSTRAINTS (parm
));
10020 trees_in::tpl_parms (unsigned &tpl_levels
)
10022 tree parms
= NULL_TREE
;
10024 while (int len
= i ())
10028 parms
= back_ref (len
);
10033 parms
= tree_cons (NULL_TREE
, NULL_TREE
, parms
);
10034 int tag
= insert (parms
);
10035 TREE_PURPOSE (parms
) = tree_node ();
10037 dump (dumper::TREE
)
10038 && dump ("Reading template parms:%d level:%N length:%d",
10039 tag
, TREE_PURPOSE (parms
), len
);
10041 tree vec
= make_tree_vec (len
);
10042 for (int ix
= 0; ix
!= len
; ix
++)
10044 tree decl
= tree_node ();
10048 tree parm
= build_tree_list (NULL
, decl
);
10049 TEMPLATE_PARM_CONSTRAINTS (parm
) = tree_node ();
10051 TREE_VEC_ELT (vec
, ix
) = parm
;
10054 TREE_VALUE (parms
) = vec
;
10062 trees_out::tpl_parms_fini (tree tmpl
, unsigned tpl_levels
)
10064 for (tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
10065 tpl_levels
--; parms
= TREE_CHAIN (parms
))
10067 tree vec
= TREE_VALUE (parms
);
10069 tree_node (TREE_TYPE (vec
));
10070 for (unsigned ix
= TREE_VEC_LENGTH (vec
); ix
--;)
10072 tree parm
= TREE_VEC_ELT (vec
, ix
);
10073 tree dflt
= TREE_PURPOSE (parm
);
10076 if (streaming_p ())
10078 tree decl
= TREE_VALUE (parm
);
10079 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10081 tree ctx
= DECL_CONTEXT (decl
);
10082 tree inner
= DECL_TEMPLATE_RESULT (decl
);
10083 tree tpi
= (TREE_CODE (inner
) == TYPE_DECL
10084 ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl
))
10085 : DECL_INITIAL (inner
));
10086 bool original
= (TEMPLATE_PARM_LEVEL (tpi
)
10087 == TEMPLATE_PARM_ORIG_LEVEL (tpi
));
10088 /* Original template template parms have a context
10089 of their owning template. Reduced ones do not. */
10090 gcc_checking_assert (original
? ctx
== tmpl
: !ctx
);
10098 trees_in::tpl_parms_fini (tree tmpl
, unsigned tpl_levels
)
10100 for (tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
10101 tpl_levels
--; parms
= TREE_CHAIN (parms
))
10103 tree vec
= TREE_VALUE (parms
);
10105 TREE_TYPE (vec
) = tree_node ();
10106 for (unsigned ix
= TREE_VEC_LENGTH (vec
); ix
--;)
10108 tree parm
= TREE_VEC_ELT (vec
, ix
);
10109 tree dflt
= tree_node ();
10110 if (get_overrun ())
10112 TREE_PURPOSE (parm
) = dflt
;
10114 tree decl
= TREE_VALUE (parm
);
10115 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10117 tree inner
= DECL_TEMPLATE_RESULT (decl
);
10118 tree tpi
= (TREE_CODE (inner
) == TYPE_DECL
10119 ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl
))
10120 : DECL_INITIAL (inner
));
10121 bool original
= (TEMPLATE_PARM_LEVEL (tpi
)
10122 == TEMPLATE_PARM_ORIG_LEVEL (tpi
));
10123 /* Original template template parms have a context
10124 of their owning template. Reduced ones do not. */
10126 DECL_CONTEXT (decl
) = tmpl
;
10133 /* PARMS is a LIST, one node per level.
10134 TREE_VALUE is a TREE_VEC of parm info for that level.
10135 each ELT is a TREE_LIST
10136 TREE_VALUE is PARM_DECL, TYPE_DECL or TEMPLATE_DECL
10137 TREE_PURPOSE is the default value. */
10140 trees_out::tpl_header (tree tpl
, unsigned *tpl_levels
)
10142 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
10143 tpl_parms (parms
, *tpl_levels
);
10146 if (streaming_p ())
10150 tree_node (TEMPLATE_PARMS_CONSTRAINTS (parms
));
10154 trees_in::tpl_header (tree tpl
, unsigned *tpl_levels
)
10156 tree parms
= tpl_parms (*tpl_levels
);
10160 DECL_TEMPLATE_PARMS (tpl
) = parms
;
10163 TEMPLATE_PARMS_CONSTRAINTS (parms
) = tree_node ();
10168 /* Stream skeleton parm nodes, with their flags, type & parm indices.
10169 All the parms will have consecutive tags. */
10172 trees_out::fn_parms_init (tree fn
)
10174 /* First init them. */
10175 int base_tag
= ref_num
- 1;
10177 for (tree parm
= DECL_ARGUMENTS (fn
);
10178 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10180 if (streaming_p ())
10183 tree_node_bools (parm
);
10185 int tag
= insert (parm
);
10186 gcc_checking_assert (base_tag
- ix
== tag
);
10188 /* Mark the end. */
10189 if (streaming_p ())
10192 /* Now stream their contents. */
10194 for (tree parm
= DECL_ARGUMENTS (fn
);
10195 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10197 if (streaming_p ())
10198 dump (dumper::TREE
)
10199 && dump ("Writing parm:%d %u (%N) of %N",
10200 base_tag
- ix
, ix
, parm
, fn
);
10201 tree_node_vals (parm
);
10204 if (!streaming_p ())
10206 /* We must walk contract attrs so the dependency graph is complete. */
10207 for (tree contract
= DECL_CONTRACTS (fn
);
10209 contract
= CONTRACT_CHAIN (contract
))
10210 tree_node (contract
);
10213 /* Write a reference to contracts pre/post functions, if any, to avoid
10214 regenerating them in importers. */
10215 tree_node (DECL_PRE_FN (fn
));
10216 tree_node (DECL_POST_FN (fn
));
10219 /* Build skeleton parm nodes, read their flags, type & parm indices. */
10222 trees_in::fn_parms_init (tree fn
)
10224 int base_tag
= ~(int)back_refs
.length ();
10226 tree
*parm_ptr
= &DECL_ARGUMENTS (fn
);
10228 for (; int code
= u (); ix
++)
10230 tree parm
= start (code
);
10231 if (!tree_node_bools (parm
))
10234 int tag
= insert (parm
);
10235 gcc_checking_assert (base_tag
- ix
== tag
);
10237 parm_ptr
= &DECL_CHAIN (parm
);
10241 for (tree parm
= DECL_ARGUMENTS (fn
);
10242 parm
; parm
= DECL_CHAIN (parm
), ix
++)
10244 dump (dumper::TREE
)
10245 && dump ("Reading parm:%d %u (%N) of %N",
10246 base_tag
- ix
, ix
, parm
, fn
);
10247 if (!tree_node_vals (parm
))
10251 /* Reload references to contract functions, if any. */
10252 tree pre_fn
= tree_node ();
10253 tree post_fn
= tree_node ();
10254 set_contract_functions (fn
, pre_fn
, post_fn
);
10259 /* Read the remaining parm node data. Replace with existing (if
10260 non-null) in the map. */
10263 trees_in::fn_parms_fini (int tag
, tree fn
, tree existing
, bool is_defn
)
10265 tree existing_parm
= existing
? DECL_ARGUMENTS (existing
) : NULL_TREE
;
10266 tree parms
= DECL_ARGUMENTS (fn
);
10268 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
), ix
++)
10272 if (is_defn
&& !DECL_SAVED_TREE (existing
))
10274 /* If we're about to become the definition, set the
10275 names of the parms from us. */
10276 DECL_NAME (existing_parm
) = DECL_NAME (parm
);
10277 DECL_SOURCE_LOCATION (existing_parm
) = DECL_SOURCE_LOCATION (parm
);
10280 back_refs
[~tag
] = existing_parm
;
10281 existing_parm
= DECL_CHAIN (existing_parm
);
10287 /* DEP is the depset of some decl we're streaming by value. Determine
10288 the merging behaviour. */
10291 trees_out::get_merge_kind (tree decl
, depset
*dep
)
10295 if (VAR_OR_FUNCTION_DECL_P (decl
))
10297 /* Any var or function with template info should have DEP. */
10298 gcc_checking_assert (!DECL_LANG_SPECIFIC (decl
)
10299 || !DECL_TEMPLATE_INFO (decl
));
10300 if (DECL_LOCAL_DECL_P (decl
))
10304 /* Either unique, or some member of a class that cannot have an
10305 out-of-class definition. For instance a FIELD_DECL. */
10306 tree ctx
= CP_DECL_CONTEXT (decl
);
10307 if (TREE_CODE (ctx
) == FUNCTION_DECL
)
10309 /* USING_DECLs and NAMESPACE_DECLs cannot have DECL_TEMPLATE_INFO --
10310 this isn't permitting them to have one. */
10311 gcc_checking_assert (TREE_CODE (decl
) == USING_DECL
10312 || TREE_CODE (decl
) == NAMESPACE_DECL
10313 || !DECL_LANG_SPECIFIC (decl
)
10314 || !DECL_TEMPLATE_INFO (decl
));
10319 if (TREE_CODE (decl
) == TEMPLATE_DECL
10320 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10321 return MK_local_friend
;
10323 gcc_checking_assert (TYPE_P (ctx
));
10324 if (TREE_CODE (decl
) == USING_DECL
)
10327 if (TREE_CODE (decl
) == FIELD_DECL
)
10329 if (DECL_NAME (decl
))
10331 /* Anonymous FIELD_DECLs have a NULL name. */
10332 gcc_checking_assert (!IDENTIFIER_ANON_P (DECL_NAME (decl
)));
10336 if (!DECL_NAME (decl
)
10337 && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
10338 && !DECL_BIT_FIELD_REPRESENTATIVE (decl
))
10340 /* The underlying storage unit for a bitfield. We do not
10341 need to dedup it, because it's only reachable through
10342 the bitfields it represents. And those are deduped. */
10343 // FIXME: Is that assertion correct -- do we ever fish it
10344 // out and put it in an expr?
10345 gcc_checking_assert ((TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
10346 ? TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
10347 : TREE_CODE (TREE_TYPE (decl
)))
10355 if (TREE_CODE (decl
) == CONST_DECL
)
10358 if (TREE_CODE (decl
) == VAR_DECL
10359 && DECL_VTABLE_OR_VTT_P (decl
))
10362 if (DECL_THUNK_P (decl
))
10363 /* Thunks are unique-enough, because they're only referenced
10364 from the vtable. And that's either new (so we want the
10365 thunks), or it's a duplicate (so it will be dropped). */
10368 /* There should be no other cases. */
10369 gcc_unreachable ();
10372 gcc_checking_assert (TREE_CODE (decl
) != FIELD_DECL
10373 && TREE_CODE (decl
) != USING_DECL
10374 && TREE_CODE (decl
) != CONST_DECL
);
10376 if (is_key_order ())
10378 /* When doing the mergeablilty graph, there's an indirection to
10379 the actual depset. */
10380 gcc_assert (dep
->is_special ());
10381 dep
= dep
->deps
[0];
10384 gcc_checking_assert (decl
== dep
->get_entity ());
10386 merge_kind mk
= MK_named
;
10387 switch (dep
->get_entity_kind ())
10390 gcc_unreachable ();
10392 case depset::EK_PARTIAL
:
10396 case depset::EK_DECL
:
10398 tree ctx
= CP_DECL_CONTEXT (decl
);
10400 switch (TREE_CODE (ctx
))
10403 gcc_unreachable ();
10405 case FUNCTION_DECL
:
10406 // FIXME: This can occur for (a) voldemorty TYPE_DECLS
10407 // (which are returned from a function), or (b)
10408 // block-scope class definitions in template functions.
10409 // These are as unique as the containing function. While
10410 // on read-back we can discover if the CTX was a
10411 // duplicate, we don't have a mechanism to get from the
10412 // existing CTX to the existing version of this decl.
10413 gcc_checking_assert
10414 (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl
)));
10421 if (DECL_NAME (decl
) == as_base_identifier
)
10423 else if (IDENTIFIER_ANON_P (DECL_NAME (decl
)))
10427 case NAMESPACE_DECL
:
10428 if (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl
))
10429 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
10431 = LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
10432 (TREE_TYPE (decl
))))
10433 if (TREE_CODE (scope
) == VAR_DECL
10434 && DECL_MODULE_KEYED_DECLS_P (scope
))
10440 if (TREE_CODE (decl
) == TEMPLATE_DECL
10441 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10442 mk
= MK_local_friend
;
10443 else if (IDENTIFIER_ANON_P (DECL_NAME (decl
)))
10445 if (DECL_IMPLICIT_TYPEDEF_P (decl
)
10446 && UNSCOPED_ENUM_P (TREE_TYPE (decl
))
10447 && TYPE_VALUES (TREE_TYPE (decl
)))
10448 /* Keyed by first enum value, and underlying type. */
10451 /* No way to merge it, it is an ODR land-mine. */
10458 case depset::EK_SPECIALIZATION
:
10460 gcc_checking_assert (dep
->is_special ());
10462 if (TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
10463 /* An block-scope classes of templates are themselves
10465 gcc_checking_assert (DECL_IMPLICIT_TYPEDEF_P (decl
));
10467 if (dep
->is_friend_spec ())
10468 mk
= MK_friend_spec
;
10469 else if (dep
->is_type_spec ())
10471 else if (dep
->is_alias ())
10472 mk
= MK_alias_spec
;
10476 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10478 spec_entry
*entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
10479 if (TREE_CODE (entry
->spec
) != TEMPLATE_DECL
)
10480 mk
= merge_kind (mk
| MK_tmpl_tmpl_mask
);
10490 /* The container of DECL -- not necessarily its context! */
10493 trees_out::decl_container (tree decl
)
10496 tree tpl
= NULL_TREE
;
10497 if (tree template_info
= node_template_info (decl
, use_tpl
))
10498 tpl
= TI_TEMPLATE (template_info
);
10502 /* Stream the template we're instantiated from. */
10505 tree container
= NULL_TREE
;
10506 if (TREE_CODE (decl
) == TEMPLATE_DECL
10507 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
10508 container
= DECL_CHAIN (decl
);
10510 container
= CP_DECL_CONTEXT (decl
);
10512 if (TYPE_P (container
))
10513 container
= TYPE_NAME (container
);
10515 tree_node (container
);
10521 trees_in::decl_container ()
10523 /* The maybe-template. */
10524 (void)tree_node ();
10526 tree container
= tree_node ();
10531 /* Write out key information about a mergeable DEP. Does not write
10532 the contents of DEP itself. The context has already been
10533 written. The container has already been streamed. */
10536 trees_out::key_mergeable (int tag
, merge_kind mk
, tree decl
, tree inner
,
10537 tree container
, depset
*dep
)
10539 if (dep
&& is_key_order ())
10541 gcc_checking_assert (dep
->is_special ());
10542 dep
= dep
->deps
[0];
10545 if (streaming_p ())
10546 dump (dumper::MERGE
)
10547 && dump ("Writing:%d's %s merge key (%s) %C:%N", tag
, merge_kind_name
[mk
],
10548 dep
? dep
->entity_kind_name () : "contained",
10549 TREE_CODE (decl
), decl
);
10551 /* Now write the locating information. */
10552 if (mk
& MK_template_mask
)
10554 /* Specializations are located via their originating template,
10555 and the set of template args they specialize. */
10556 gcc_checking_assert (dep
&& dep
->is_special ());
10557 spec_entry
*entry
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
10559 tree_node (entry
->tmpl
);
10560 tree_node (entry
->args
);
10561 if (mk
& MK_tmpl_decl_mask
)
10562 if (flag_concepts
&& TREE_CODE (inner
) == VAR_DECL
)
10564 /* Variable template partial specializations might need
10565 constraints (see spec_hasher::equal). It's simpler to
10566 write NULL when we don't need them. */
10567 tree constraints
= NULL_TREE
;
10569 if (uses_template_parms (entry
->args
))
10570 constraints
= get_constraints (inner
);
10571 tree_node (constraints
);
10576 /* Make sure we can locate the decl. */
10577 tree existing
= match_mergeable_specialization
10578 (bool (mk
& MK_tmpl_decl_mask
), entry
);
10580 gcc_assert (existing
);
10581 if (mk
& MK_tmpl_decl_mask
)
10583 if (mk
& MK_tmpl_alias_mask
)
10584 /* It should be in both tables. */
10585 gcc_checking_assert
10586 (same_type_p (match_mergeable_specialization (false, entry
),
10587 TREE_TYPE (existing
)));
10588 if (mk
& MK_tmpl_tmpl_mask
)
10589 existing
= DECL_TI_TEMPLATE (existing
);
10593 if (mk
& MK_tmpl_tmpl_mask
)
10594 existing
= CLASSTYPE_TI_TEMPLATE (existing
);
10596 existing
= TYPE_NAME (existing
);
10599 /* The walkabout should have found ourselves. */
10600 gcc_checking_assert (TREE_CODE (decl
) == TYPE_DECL
10601 ? same_type_p (TREE_TYPE (decl
),
10602 TREE_TYPE (existing
))
10603 : existing
== decl
);
10606 else if (mk
!= MK_unique
)
10609 tree name
= DECL_NAME (decl
);
10614 gcc_unreachable ();
10617 case MK_friend_spec
:
10618 if (IDENTIFIER_CONV_OP_P (name
))
10619 name
= conv_op_identifier
;
10621 if (TREE_CODE (inner
) == FUNCTION_DECL
)
10623 /* Functions are distinguished by parameter types. */
10624 tree fn_type
= TREE_TYPE (inner
);
10626 key
.ref_q
= type_memfn_rqual (fn_type
);
10627 key
.args
= TYPE_ARG_TYPES (fn_type
);
10629 if (tree reqs
= get_constraints (inner
))
10631 if (cxx_dialect
< cxx20
)
10632 reqs
= CI_ASSOCIATED_CONSTRAINTS (reqs
);
10634 reqs
= CI_DECLARATOR_REQS (reqs
);
10635 key
.constraints
= reqs
;
10638 if (IDENTIFIER_CONV_OP_P (name
)
10640 && !(name
== fun_identifier
10641 /* In case the user names something _FUN */
10642 && LAMBDA_TYPE_P (DECL_CONTEXT (inner
)))))
10643 /* And a function template, or conversion operator needs
10644 the return type. Except for the _FUN thunk of a
10645 generic lambda, which has a recursive decl_type'd
10647 // FIXME: What if the return type is a voldemort?
10648 key
.ret
= fndecl_declared_return_type (inner
);
10655 if (TREE_CODE (inner
) != FIELD_DECL
)
10658 gcc_checking_assert (!name
|| !IDENTIFIER_ANON_P (name
));
10660 for (tree field
= TYPE_FIELDS (TREE_TYPE (container
));
10661 ; field
= DECL_CHAIN (field
))
10663 tree finner
= STRIP_TEMPLATE (field
);
10664 if (TREE_CODE (finner
) == TREE_CODE (inner
))
10666 if (finner
== inner
)
10677 tree vtable
= CLASSTYPE_VTABLES (TREE_TYPE (container
));
10678 for (unsigned ix
= 0; ; vtable
= DECL_CHAIN (vtable
), ix
++)
10679 if (vtable
== decl
)
10689 gcc_checking_assert
10690 (decl
== TYPE_NAME (CLASSTYPE_AS_BASE (TREE_TYPE (container
))));
10693 case MK_local_friend
:
10695 /* Find by index on the class's DECL_LIST */
10697 for (tree decls
= CLASSTYPE_DECL_LIST (TREE_CHAIN (decl
));
10698 decls
; decls
= TREE_CHAIN (decls
))
10699 if (!TREE_PURPOSE (decls
))
10701 tree frnd
= friend_from_decl_list (TREE_VALUE (decls
));
10713 /* Anonymous enums are located by their first identifier,
10714 and underlying type. */
10715 tree type
= TREE_TYPE (decl
);
10717 gcc_checking_assert (UNSCOPED_ENUM_P (type
));
10718 /* Using the type name drops the bit precision we might
10719 have been using on the enum. */
10720 key
.ret
= TYPE_NAME (ENUM_UNDERLYING_TYPE (type
));
10721 if (tree values
= TYPE_VALUES (type
))
10722 name
= DECL_NAME (TREE_VALUE (values
));
10728 gcc_checking_assert (LAMBDA_TYPE_P (TREE_TYPE (inner
)));
10729 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
10730 (TREE_TYPE (inner
)));
10731 gcc_checking_assert (TREE_CODE (scope
) == VAR_DECL
);
10732 auto *root
= keyed_table
->get (scope
);
10733 unsigned ix
= root
->length ();
10734 /* If we don't find it, we'll write a really big number
10735 that the reader will ignore. */
10737 if ((*root
)[ix
] == inner
)
10740 /* Use the keyed-to decl as the 'name'. */
10748 tree ti
= get_template_info (inner
);
10749 key
.constraints
= get_constraints (inner
);
10750 key
.ret
= TI_TEMPLATE (ti
);
10751 key
.args
= TI_ARGS (ti
);
10757 if (streaming_p ())
10759 unsigned code
= (key
.ref_q
<< 0) | (key
.index
<< 2);
10764 tree_node (key
.ret
);
10765 else if (mk
== MK_partial
10766 || (mk
== MK_named
&& inner
10767 && TREE_CODE (inner
) == FUNCTION_DECL
))
10769 tree_node (key
.ret
);
10770 tree arg
= key
.args
;
10771 if (mk
== MK_named
)
10772 while (arg
&& arg
!= void_list_node
)
10774 tree_node (TREE_VALUE (arg
));
10775 arg
= TREE_CHAIN (arg
);
10778 tree_node (key
.constraints
);
10783 /* DECL is a new declaration that may be duplicated in OVL. Use RET &
10784 ARGS to find its clone, or NULL. If DECL's DECL_NAME is NULL, this
10785 has been found by a proxy. It will be an enum type located by its
10788 We're conservative with matches, so ambiguous decls will be
10789 registered as different, then lead to a lookup error if the two
10790 modules are both visible. Perhaps we want to do something similar
10791 to duplicate decls to get ODR errors on loading? We already have
10792 some special casing for namespaces. */
10795 check_mergeable_decl (merge_kind mk
, tree decl
, tree ovl
, merge_key
const &key
)
10797 tree found
= NULL_TREE
;
10798 for (ovl_iterator
iter (ovl
); !found
&& iter
; ++iter
)
10800 tree match
= *iter
;
10802 tree d_inner
= decl
;
10803 tree m_inner
= match
;
10806 if (TREE_CODE (d_inner
) != TREE_CODE (m_inner
))
10808 if (TREE_CODE (match
) == NAMESPACE_DECL
10809 && !DECL_NAMESPACE_ALIAS (match
))
10810 /* Namespaces are never overloaded. */
10816 switch (TREE_CODE (d_inner
))
10818 case TEMPLATE_DECL
:
10819 if (template_heads_equivalent_p (d_inner
, m_inner
))
10821 d_inner
= DECL_TEMPLATE_RESULT (d_inner
);
10822 m_inner
= DECL_TEMPLATE_RESULT (m_inner
);
10823 if (d_inner
== error_mark_node
10824 && TYPE_DECL_ALIAS_P (m_inner
))
10833 case FUNCTION_DECL
:
10834 if (tree m_type
= TREE_TYPE (m_inner
))
10836 || same_type_p (key
.ret
, fndecl_declared_return_type (m_inner
)))
10837 && type_memfn_rqual (m_type
) == key
.ref_q
10838 && compparms (key
.args
, TYPE_ARG_TYPES (m_type
))
10839 /* Reject if old is a "C" builtin and new is not "C".
10840 Matches decls_match behaviour. */
10841 && (!DECL_IS_UNDECLARED_BUILTIN (m_inner
)
10842 || !DECL_EXTERN_C_P (m_inner
)
10843 || DECL_EXTERN_C_P (d_inner
))
10844 /* Reject if one is a different member of a
10845 guarded/pre/post fn set. */
10846 && (!flag_contracts
10847 || (DECL_IS_PRE_FN_P (d_inner
)
10848 == DECL_IS_PRE_FN_P (m_inner
)))
10849 && (!flag_contracts
10850 || (DECL_IS_POST_FN_P (d_inner
)
10851 == DECL_IS_POST_FN_P (m_inner
))))
10853 tree m_reqs
= get_constraints (m_inner
);
10856 if (cxx_dialect
< cxx20
)
10857 m_reqs
= CI_ASSOCIATED_CONSTRAINTS (m_reqs
);
10859 m_reqs
= CI_DECLARATOR_REQS (m_reqs
);
10862 if (cp_tree_equal (key
.constraints
, m_reqs
))
10868 if (DECL_IMPLICIT_TYPEDEF_P (d_inner
)
10869 == DECL_IMPLICIT_TYPEDEF_P (m_inner
))
10871 if (!IDENTIFIER_ANON_P (DECL_NAME (m_inner
)))
10873 else if (mk
== MK_enum
10874 && (TYPE_NAME (ENUM_UNDERLYING_TYPE (TREE_TYPE (m_inner
)))
10889 /* DECL, INNER & TYPE are a skeleton set of nodes for a decl. Only
10890 the bools have been filled in. Read its merging key and merge it.
10891 Returns the existing decl if there is one. */
10894 trees_in::key_mergeable (int tag
, merge_kind mk
, tree decl
, tree inner
,
10895 tree type
, tree container
, bool is_attached
)
10897 const char *kind
= "new";
10898 tree existing
= NULL_TREE
;
10900 if (mk
& MK_template_mask
)
10902 // FIXME: We could stream the specialization hash?
10904 spec
.tmpl
= tree_node ();
10905 spec
.args
= tree_node ();
10907 if (get_overrun ())
10908 return error_mark_node
;
10910 DECL_NAME (decl
) = DECL_NAME (spec
.tmpl
);
10911 DECL_CONTEXT (decl
) = DECL_CONTEXT (spec
.tmpl
);
10912 DECL_NAME (inner
) = DECL_NAME (decl
);
10913 DECL_CONTEXT (inner
) = DECL_CONTEXT (decl
);
10915 tree constr
= NULL_TREE
;
10916 bool is_decl
= mk
& MK_tmpl_decl_mask
;
10919 if (flag_concepts
&& TREE_CODE (inner
) == VAR_DECL
)
10921 constr
= tree_node ();
10923 set_constraints (inner
, constr
);
10925 spec
.spec
= (mk
& MK_tmpl_tmpl_mask
) ? inner
: decl
;
10929 existing
= match_mergeable_specialization (is_decl
, &spec
);
10931 /* We'll add these back later, if this is the new decl. */
10932 remove_constraints (inner
);
10935 ; /* We'll add to the table once read. */
10936 else if (mk
& MK_tmpl_decl_mask
)
10938 /* A declaration specialization. */
10939 if (mk
& MK_tmpl_tmpl_mask
)
10940 existing
= DECL_TI_TEMPLATE (existing
);
10944 /* A type specialization. */
10945 if (mk
& MK_tmpl_tmpl_mask
)
10946 existing
= CLASSTYPE_TI_TEMPLATE (existing
);
10948 existing
= TYPE_NAME (existing
);
10951 else if (mk
== MK_unique
)
10955 tree name
= tree_node ();
10958 unsigned code
= u ();
10959 key
.ref_q
= cp_ref_qualifier ((code
>> 0) & 3);
10960 key
.index
= code
>> 2;
10963 key
.ret
= tree_node ();
10964 else if (mk
== MK_partial
10965 || ((mk
== MK_named
|| mk
== MK_friend_spec
)
10966 && TREE_CODE (inner
) == FUNCTION_DECL
))
10968 key
.ret
= tree_node ();
10969 tree arg
, *arg_ptr
= &key
.args
;
10970 while ((arg
= tree_node ())
10971 && arg
!= void_list_node
10972 && mk
!= MK_partial
)
10974 *arg_ptr
= tree_cons (NULL_TREE
, arg
, NULL_TREE
);
10975 arg_ptr
= &TREE_CHAIN (*arg_ptr
);
10978 key
.constraints
= tree_node ();
10981 if (get_overrun ())
10982 return error_mark_node
;
10984 if (mk
< MK_indirect_lwm
)
10986 DECL_NAME (decl
) = name
;
10987 DECL_CONTEXT (decl
) = FROB_CONTEXT (container
);
10989 DECL_NAME (inner
) = DECL_NAME (decl
);
10990 DECL_CONTEXT (inner
) = DECL_CONTEXT (decl
);
10992 if (mk
== MK_partial
)
10994 for (tree spec
= DECL_TEMPLATE_SPECIALIZATIONS (key
.ret
);
10995 spec
; spec
= TREE_CHAIN (spec
))
10997 tree tmpl
= TREE_VALUE (spec
);
10998 tree ti
= get_template_info (tmpl
);
10999 if (template_args_equal (key
.args
, TI_ARGS (ti
))
11000 && cp_tree_equal (key
.constraints
,
11002 (DECL_TEMPLATE_RESULT (tmpl
))))
11010 switch (TREE_CODE (container
))
11013 gcc_unreachable ();
11015 case NAMESPACE_DECL
:
11016 if (mk
== MK_keyed
)
11018 if (DECL_LANG_SPECIFIC (name
)
11019 && VAR_OR_FUNCTION_DECL_P (name
)
11020 && DECL_MODULE_KEYED_DECLS_P (name
))
11021 if (auto *set
= keyed_table
->get (name
))
11022 if (key
.index
< set
->length ())
11024 existing
= (*set
)[key
.index
];
11027 gcc_checking_assert
11028 (DECL_IMPLICIT_TYPEDEF_P (existing
));
11031 = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (existing
));
11035 else if (is_attached
11036 && !(state
->is_module () || state
->is_partition ()))
11040 gcc_checking_assert (mk
== MK_named
|| mk
== MK_enum
);
11042 tree
*vslot
= mergeable_namespace_slots (container
, name
,
11043 is_attached
, &mvec
);
11044 existing
= check_mergeable_decl (mk
, decl
, *vslot
, key
);
11046 add_mergeable_namespace_entity (vslot
, decl
);
11049 /* Note that we now have duplicates to deal with in
11052 BINDING_VECTOR_PARTITION_DUPS_P (mvec
) = true;
11054 BINDING_VECTOR_GLOBAL_DUPS_P (mvec
) = true;
11059 case FUNCTION_DECL
:
11060 // FIXME: What about a voldemort? how do we find what it
11061 // duplicates? Do we have to number vmorts relative to
11062 // their containing function? But how would that work
11063 // when matching an in-TU declaration?
11068 if (is_attached
&& !(state
->is_module () || state
->is_partition ())
11069 /* Implicit member functions can come from
11071 && !(DECL_ARTIFICIAL (decl
)
11072 && TREE_CODE (decl
) == FUNCTION_DECL
11073 && !DECL_THUNK_P (decl
)))
11077 tree ctx
= TREE_TYPE (container
);
11079 /* For some reason templated enumeral types are not marked
11080 as COMPLETE_TYPE_P, even though they have members.
11081 This may well be a bug elsewhere. */
11082 if (TREE_CODE (ctx
) == ENUMERAL_TYPE
)
11083 existing
= find_enum_member (ctx
, name
);
11084 else if (COMPLETE_TYPE_P (ctx
))
11089 gcc_unreachable ();
11092 existing
= lookup_class_binding (ctx
, name
);
11096 if (TREE_CODE (inner
) == TEMPLATE_DECL
11097 && !DECL_MEMBER_TEMPLATE_P (inner
))
11098 inner
= DECL_TEMPLATE_RESULT (inner
);
11100 existing
= check_mergeable_decl
11101 (mk
, inner
, existing
, key
);
11103 if (!existing
&& DECL_ALIAS_TEMPLATE_P (decl
))
11104 {} // FIXME: Insert into specialization
11105 // tables, we'll need the arguments for that!
11111 unsigned ix
= key
.index
;
11112 for (tree field
= TYPE_FIELDS (ctx
);
11113 field
; field
= DECL_CHAIN (field
))
11115 tree finner
= STRIP_TEMPLATE (field
);
11116 if (TREE_CODE (finner
) == TREE_CODE (inner
))
11128 unsigned ix
= key
.index
;
11129 for (tree vtable
= CLASSTYPE_VTABLES (ctx
);
11130 vtable
; vtable
= DECL_CHAIN (vtable
))
11141 tree as_base
= CLASSTYPE_AS_BASE (ctx
);
11142 if (as_base
&& as_base
!= ctx
)
11143 existing
= TYPE_NAME (as_base
);
11147 case MK_local_friend
:
11149 unsigned ix
= key
.index
;
11150 for (tree decls
= CLASSTYPE_DECL_LIST (ctx
);
11151 decls
; decls
= TREE_CHAIN (decls
))
11152 if (!TREE_PURPOSE (decls
) && !ix
--)
11155 = friend_from_decl_list (TREE_VALUE (decls
));
11162 if (existing
&& mk
< MK_indirect_lwm
&& mk
!= MK_partial
11163 && TREE_CODE (decl
) == TEMPLATE_DECL
11164 && !DECL_MEMBER_TEMPLATE_P (decl
))
11167 if (DECL_IMPLICIT_TYPEDEF_P (existing
))
11168 ti
= TYPE_TEMPLATE_INFO (TREE_TYPE (existing
));
11170 ti
= DECL_TEMPLATE_INFO (existing
);
11171 existing
= TI_TEMPLATE (ti
);
11178 dump (dumper::MERGE
)
11179 && dump ("Read:%d's %s merge key (%s) %C:%N", tag
, merge_kind_name
[mk
],
11180 existing
? "matched" : kind
, TREE_CODE (decl
), decl
);
11186 trees_out::binfo_mergeable (tree binfo
)
11189 while (tree parent
= BINFO_INHERITANCE_CHAIN (dom
))
11191 tree type
= BINFO_TYPE (dom
);
11192 gcc_checking_assert (TYPE_BINFO (type
) == dom
);
11194 if (streaming_p ())
11197 for (; dom
!= binfo
; dom
= TREE_CHAIN (dom
))
11204 trees_in::binfo_mergeable (tree
*type
)
11206 *type
= tree_node ();
11210 /* DECL is a just streamed mergeable decl that should match EXISTING. Check
11211 it does and issue an appropriate diagnostic if not. Merge any
11212 bits from DECL to EXISTING. This is stricter matching than
11213 decls_match, because we can rely on ODR-sameness, and we cannot use
11214 decls_match because it can cause instantiations of constraints. */
11217 trees_in::is_matching_decl (tree existing
, tree decl
, bool is_typedef
)
11219 // FIXME: We should probably do some duplicate decl-like stuff here
11220 // (beware, default parms should be the same?) Can we just call
11221 // duplicate_decls and teach it how to handle the module-specific
11222 // permitted/required duplications?
11224 // We know at this point that the decls have matched by key, so we
11225 // can elide some of the checking
11226 gcc_checking_assert (TREE_CODE (existing
) == TREE_CODE (decl
));
11228 tree d_inner
= decl
;
11229 tree e_inner
= existing
;
11230 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
11232 d_inner
= DECL_TEMPLATE_RESULT (d_inner
);
11233 e_inner
= DECL_TEMPLATE_RESULT (e_inner
);
11234 gcc_checking_assert (TREE_CODE (e_inner
) == TREE_CODE (d_inner
));
11237 if (TREE_CODE (d_inner
) == FUNCTION_DECL
)
11239 tree e_ret
= fndecl_declared_return_type (existing
);
11240 tree d_ret
= fndecl_declared_return_type (decl
);
11242 if (decl
!= d_inner
&& DECL_NAME (d_inner
) == fun_identifier
11243 && LAMBDA_TYPE_P (DECL_CONTEXT (d_inner
)))
11244 /* This has a recursive type that will compare different. */;
11245 else if (!same_type_p (d_ret
, e_ret
))
11248 tree e_type
= TREE_TYPE (e_inner
);
11249 tree d_type
= TREE_TYPE (d_inner
);
11251 if (DECL_EXTERN_C_P (d_inner
) != DECL_EXTERN_C_P (e_inner
))
11254 for (tree e_args
= TYPE_ARG_TYPES (e_type
),
11255 d_args
= TYPE_ARG_TYPES (d_type
);
11256 e_args
!= d_args
&& (e_args
|| d_args
);
11257 e_args
= TREE_CHAIN (e_args
), d_args
= TREE_CHAIN (d_args
))
11259 if (!(e_args
&& d_args
))
11262 if (!same_type_p (TREE_VALUE (d_args
), TREE_VALUE (e_args
)))
11265 // FIXME: Check default values
11268 /* If EXISTING has an undeduced or uninstantiated exception
11269 specification, but DECL does not, propagate the exception
11270 specification. Otherwise we end up asserting or trying to
11271 instantiate it in the middle of loading. */
11272 tree e_spec
= TYPE_RAISES_EXCEPTIONS (e_type
);
11273 tree d_spec
= TYPE_RAISES_EXCEPTIONS (d_type
);
11274 if (DEFERRED_NOEXCEPT_SPEC_P (e_spec
))
11276 if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec
)
11277 || (UNEVALUATED_NOEXCEPT_SPEC_P (e_spec
)
11278 && !UNEVALUATED_NOEXCEPT_SPEC_P (d_spec
)))
11280 dump (dumper::MERGE
)
11281 && dump ("Propagating instantiated noexcept to %N", existing
);
11282 TREE_TYPE (existing
) = d_type
;
11284 /* Propagate to existing clones. */
11286 FOR_EACH_CLONE (clone
, existing
)
11288 if (TREE_TYPE (clone
) == e_type
)
11289 TREE_TYPE (clone
) = d_type
;
11292 = build_exception_variant (TREE_TYPE (clone
), d_spec
);
11296 else if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec
)
11297 && !comp_except_specs (d_spec
, e_spec
, ce_type
))
11300 else if (is_typedef
)
11302 if (!DECL_ORIGINAL_TYPE (e_inner
)
11303 || !same_type_p (DECL_ORIGINAL_TYPE (d_inner
),
11304 DECL_ORIGINAL_TYPE (e_inner
)))
11307 /* Using cp_tree_equal because we can meet TYPE_ARGUMENT_PACKs
11308 here. I suspect the entities that directly do that are things
11309 that shouldn't go to duplicate_decls (FIELD_DECLs etc). */
11310 else if (!cp_tree_equal (TREE_TYPE (decl
), TREE_TYPE (existing
)))
11313 if (DECL_IS_UNDECLARED_BUILTIN (existing
))
11314 /* Just like duplicate_decls, presum the user knows what
11315 they're doing in overriding a builtin. */
11316 TREE_TYPE (existing
) = TREE_TYPE (decl
);
11319 // FIXME:QOI Might be template specialization from a module,
11320 // not necessarily global module
11321 error_at (DECL_SOURCE_LOCATION (decl
),
11322 "conflicting global module declaration %#qD", decl
);
11323 inform (DECL_SOURCE_LOCATION (existing
),
11324 "existing declaration %#qD", existing
);
11329 if (DECL_IS_UNDECLARED_BUILTIN (existing
)
11330 && !DECL_IS_UNDECLARED_BUILTIN (decl
))
11332 /* We're matching a builtin that the user has yet to declare.
11333 We are the one! This is very much duplicate-decl
11335 DECL_SOURCE_LOCATION (existing
) = DECL_SOURCE_LOCATION (decl
);
11336 if (TREE_CODE (decl
) != TYPE_DECL
)
11338 /* Propagate exceptions etc. */
11339 TREE_TYPE (existing
) = TREE_TYPE (decl
);
11340 TREE_NOTHROW (existing
) = TREE_NOTHROW (decl
);
11342 /* This is actually an import! */
11343 DECL_MODULE_IMPORT_P (existing
) = true;
11346 existing
->base
= decl
->base
;
11348 if (TREE_CODE (decl
) == FUNCTION_DECL
)
11351 memcpy (&existing
->decl_common
.size
,
11352 &decl
->decl_common
.size
,
11353 (offsetof (tree_decl_common
, pt_uid
)
11354 - offsetof (tree_decl_common
, size
)));
11355 auto bltin_class
= DECL_BUILT_IN_CLASS (decl
);
11356 existing
->function_decl
.built_in_class
= bltin_class
;
11357 auto fncode
= DECL_UNCHECKED_FUNCTION_CODE (decl
);
11358 DECL_UNCHECKED_FUNCTION_CODE (existing
) = fncode
;
11359 if (existing
->function_decl
.built_in_class
== BUILT_IN_NORMAL
)
11361 if (builtin_decl_explicit_p (built_in_function (fncode
)))
11364 case BUILT_IN_STPCPY
:
11365 set_builtin_decl_implicit_p
11366 (built_in_function (fncode
), true);
11369 set_builtin_decl_declared_p
11370 (built_in_function (fncode
), true);
11373 copy_attributes_to_builtin (decl
);
11378 if (VAR_OR_FUNCTION_DECL_P (decl
)
11379 && DECL_TEMPLATE_INSTANTIATED (decl
))
11380 /* Don't instantiate again! */
11381 DECL_TEMPLATE_INSTANTIATED (existing
) = true;
11383 if (TREE_CODE (d_inner
) == FUNCTION_DECL
11384 && DECL_DECLARED_INLINE_P (d_inner
))
11385 DECL_DECLARED_INLINE_P (e_inner
) = true;
11386 if (!DECL_EXTERNAL (d_inner
))
11387 DECL_EXTERNAL (e_inner
) = false;
11389 // FIXME: Check default tmpl and fn parms here
11394 /* FN is an implicit member function that we've discovered is new to
11395 the class. Add it to the TYPE_FIELDS chain and the method vector.
11396 Reset the appropriate classtype lazy flag. */
11399 trees_in::install_implicit_member (tree fn
)
11401 tree ctx
= DECL_CONTEXT (fn
);
11402 tree name
= DECL_NAME (fn
);
11403 /* We know these are synthesized, so the set of expected prototypes
11404 is quite restricted. We're not validating correctness, just
11405 distinguishing beteeen the small set of possibilities. */
11406 tree parm_type
= TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (fn
));
11407 if (IDENTIFIER_CTOR_P (name
))
11409 if (CLASSTYPE_LAZY_DEFAULT_CTOR (ctx
)
11410 && VOID_TYPE_P (parm_type
))
11411 CLASSTYPE_LAZY_DEFAULT_CTOR (ctx
) = false;
11412 else if (!TYPE_REF_P (parm_type
))
11414 else if (CLASSTYPE_LAZY_COPY_CTOR (ctx
)
11415 && !TYPE_REF_IS_RVALUE (parm_type
))
11416 CLASSTYPE_LAZY_COPY_CTOR (ctx
) = false;
11417 else if (CLASSTYPE_LAZY_MOVE_CTOR (ctx
))
11418 CLASSTYPE_LAZY_MOVE_CTOR (ctx
) = false;
11422 else if (IDENTIFIER_DTOR_P (name
))
11424 if (CLASSTYPE_LAZY_DESTRUCTOR (ctx
))
11425 CLASSTYPE_LAZY_DESTRUCTOR (ctx
) = false;
11428 if (DECL_VIRTUAL_P (fn
))
11429 /* A virtual dtor should have been created when the class
11430 became complete. */
11433 else if (name
== assign_op_identifier
)
11435 if (!TYPE_REF_P (parm_type
))
11437 else if (CLASSTYPE_LAZY_COPY_ASSIGN (ctx
)
11438 && !TYPE_REF_IS_RVALUE (parm_type
))
11439 CLASSTYPE_LAZY_COPY_ASSIGN (ctx
) = false;
11440 else if (CLASSTYPE_LAZY_MOVE_ASSIGN (ctx
))
11441 CLASSTYPE_LAZY_MOVE_ASSIGN (ctx
) = false;
11448 dump (dumper::MERGE
) && dump ("Adding implicit member %N", fn
);
11450 DECL_CHAIN (fn
) = TYPE_FIELDS (ctx
);
11451 TYPE_FIELDS (ctx
) = fn
;
11453 add_method (ctx
, fn
, false);
11455 /* Propagate TYPE_FIELDS. */
11456 fixup_type_variants (ctx
);
11461 /* Return non-zero if DECL has a definition that would be interesting to
11465 has_definition (tree decl
)
11467 bool is_tmpl
= TREE_CODE (decl
) == TEMPLATE_DECL
;
11469 decl
= DECL_TEMPLATE_RESULT (decl
);
11471 switch (TREE_CODE (decl
))
11476 case FUNCTION_DECL
:
11477 if (!DECL_SAVED_TREE (decl
))
11481 if (DECL_DECLARED_INLINE_P (decl
))
11484 if (DECL_THIS_STATIC (decl
)
11485 && (header_module_p ()
11486 || (!DECL_LANG_SPECIFIC (decl
) || !DECL_MODULE_PURVIEW_P (decl
))))
11487 /* GM static function. */
11490 if (DECL_TEMPLATE_INFO (decl
))
11492 int use_tpl
= DECL_USE_TEMPLATE (decl
);
11494 // FIXME: Partial specializations have definitions too.
11502 tree type
= TREE_TYPE (decl
);
11503 if (type
== TYPE_MAIN_VARIANT (type
)
11504 && decl
== TYPE_NAME (type
)
11505 && (TREE_CODE (type
) == ENUMERAL_TYPE
11506 ? TYPE_VALUES (type
) : TYPE_FIELDS (type
)))
11512 if (DECL_LANG_SPECIFIC (decl
)
11513 && DECL_TEMPLATE_INFO (decl
))
11514 return DECL_INITIAL (decl
);
11517 if (!DECL_INITIALIZED_P (decl
))
11520 if (header_module_p ()
11521 || (!DECL_LANG_SPECIFIC (decl
) || !DECL_MODULE_PURVIEW_P (decl
)))
11522 /* GM static variable. */
11525 if (!TREE_CONSTANT (decl
))
11533 if (DECL_INITIAL (decl
))
11543 trees_in::find_duplicate (tree existing
)
11548 return duplicates
->get (existing
);
11551 /* We're starting to read a duplicate DECL. EXISTING is the already
11555 trees_in::register_duplicate (tree decl
, tree existing
)
11558 duplicates
= new duplicate_hash_map (40);
11561 uintptr_t &slot
= duplicates
->get_or_insert (existing
, &existed
);
11562 gcc_checking_assert (!existed
);
11563 slot
= reinterpret_cast<uintptr_t> (decl
);
11566 /* We've read a definition of MAYBE_EXISTING. If not a duplicate,
11567 return MAYBE_EXISTING (into which the definition should be
11568 installed). Otherwise return NULL if already known bad, or the
11569 duplicate we read (for ODR checking, or extracting additional merge
11573 trees_in::odr_duplicate (tree maybe_existing
, bool has_defn
)
11575 tree res
= NULL_TREE
;
11577 if (uintptr_t *dup
= find_duplicate (maybe_existing
))
11580 res
= reinterpret_cast<tree
> (*dup
);
11583 res
= maybe_existing
;
11585 assert_definition (maybe_existing
, res
&& !has_defn
);
11587 // FIXME: We probably need to return the template, so that the
11588 // template header can be checked?
11589 return res
? STRIP_TEMPLATE (res
) : NULL_TREE
;
11592 /* The following writer functions rely on the current behaviour of
11593 depset::hash::add_dependency making the decl and defn depset nodes
11594 depend on eachother. That way we don't have to worry about seeding
11595 the tree map with named decls that cannot be looked up by name (I.e
11596 template and function parms). We know the decl and definition will
11597 be in the same cluster, which is what we want. */
11600 trees_out::write_function_def (tree decl
)
11602 tree_node (DECL_RESULT (decl
));
11603 tree_node (DECL_INITIAL (decl
));
11604 tree_node (DECL_SAVED_TREE (decl
));
11605 tree_node (DECL_FRIEND_CONTEXT (decl
));
11607 constexpr_fundef
*cexpr
= retrieve_constexpr_fundef (decl
);
11609 if (streaming_p ())
11610 u (cexpr
!= nullptr);
11613 chained_decls (cexpr
->parms
);
11614 tree_node (cexpr
->result
);
11615 tree_node (cexpr
->body
);
11618 if (streaming_p ())
11620 unsigned flags
= 0;
11622 if (DECL_NOT_REALLY_EXTERN (decl
))
11630 trees_out::mark_function_def (tree
)
11635 trees_in::read_function_def (tree decl
, tree maybe_template
)
11637 dump () && dump ("Reading function definition %N", decl
);
11638 tree result
= tree_node ();
11639 tree initial
= tree_node ();
11640 tree saved
= tree_node ();
11641 tree context
= tree_node ();
11642 constexpr_fundef cexpr
;
11644 tree maybe_dup
= odr_duplicate (maybe_template
, DECL_SAVED_TREE (decl
));
11645 bool installing
= maybe_dup
&& !DECL_SAVED_TREE (decl
);
11649 cexpr
.parms
= chained_decls ();
11650 cexpr
.result
= tree_node ();
11651 cexpr
.body
= tree_node ();
11655 cexpr
.decl
= NULL_TREE
;
11657 unsigned flags
= u ();
11659 if (get_overrun ())
11664 DECL_NOT_REALLY_EXTERN (decl
) = flags
& 1;
11665 DECL_RESULT (decl
) = result
;
11666 DECL_INITIAL (decl
) = initial
;
11667 DECL_SAVED_TREE (decl
) = saved
;
11669 DECL_ARGUMENTS (decl
) = DECL_ARGUMENTS (maybe_dup
);
11672 SET_DECL_FRIEND_CONTEXT (decl
, context
);
11674 register_constexpr_fundef (cexpr
);
11675 post_process (maybe_template
);
11677 else if (maybe_dup
)
11679 // FIXME:QOI Check matching defn
11685 /* Also for CONCEPT_DECLs. */
11688 trees_out::write_var_def (tree decl
)
11690 tree init
= DECL_INITIAL (decl
);
11694 tree dyn_init
= NULL_TREE
;
11696 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
11698 dyn_init
= value_member (decl
,
11699 CP_DECL_THREAD_LOCAL_P (decl
)
11700 ? tls_aggregates
: static_aggregates
);
11701 gcc_checking_assert (dyn_init
);
11702 /* Mark it so write_inits knows this is needed. */
11703 TREE_LANG_FLAG_0 (dyn_init
) = true;
11704 dyn_init
= TREE_PURPOSE (dyn_init
);
11706 tree_node (dyn_init
);
11711 trees_out::mark_var_def (tree
)
11716 trees_in::read_var_def (tree decl
, tree maybe_template
)
11718 /* Do not mark the virtual table entries as used. */
11719 bool vtable
= VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
);
11721 tree init
= tree_node ();
11722 tree dyn_init
= init
? NULL_TREE
: tree_node ();
11725 if (get_overrun ())
11728 bool initialized
= (VAR_P (decl
) ? bool (DECL_INITIALIZED_P (decl
))
11729 : bool (DECL_INITIAL (decl
)));
11730 tree maybe_dup
= odr_duplicate (maybe_template
, initialized
);
11731 bool installing
= maybe_dup
&& !initialized
;
11734 if (DECL_EXTERNAL (decl
))
11735 DECL_NOT_REALLY_EXTERN (decl
) = true;
11738 DECL_INITIALIZED_P (decl
) = true;
11739 if (maybe_dup
&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (maybe_dup
))
11740 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
11742 DECL_INITIAL (decl
) = init
;
11745 else if (CP_DECL_THREAD_LOCAL_P (decl
))
11746 tls_aggregates
= tree_cons (dyn_init
, decl
, tls_aggregates
);
11748 static_aggregates
= tree_cons (dyn_init
, decl
, static_aggregates
);
11750 else if (maybe_dup
)
11752 // FIXME:QOI Check matching defn
11758 /* If MEMBER doesn't have an independent life outside the class,
11759 return it (or its TEMPLATE_DECL). Otherwise NULL. */
11762 member_owned_by_class (tree member
)
11764 gcc_assert (DECL_P (member
));
11766 /* Clones are owned by their origin. */
11767 if (DECL_CLONED_FUNCTION_P (member
))
11770 if (TREE_CODE (member
) == FIELD_DECL
)
11771 /* FIELD_DECLS can have template info in some cases. We always
11772 want the FIELD_DECL though, as there's never a TEMPLATE_DECL
11777 if (tree ti
= node_template_info (member
, use_tpl
))
11779 // FIXME: Don't bail on things that CANNOT have their own
11780 // template header. No, make sure they're in the same cluster.
11784 if (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti
)) == member
)
11785 member
= TI_TEMPLATE (ti
);
11791 trees_out::write_class_def (tree defn
)
11793 gcc_assert (DECL_P (defn
));
11794 if (streaming_p ())
11795 dump () && dump ("Writing class definition %N", defn
);
11797 tree type
= TREE_TYPE (defn
);
11798 tree_node (TYPE_SIZE (type
));
11799 tree_node (TYPE_SIZE_UNIT (type
));
11800 tree_node (TYPE_VFIELD (type
));
11801 tree_node (TYPE_BINFO (type
));
11803 vec_chained_decls (TYPE_FIELDS (type
));
11805 /* Every class but __as_base has a type-specific. */
11806 gcc_checking_assert (!TYPE_LANG_SPECIFIC (type
) == IS_FAKE_BASE_TYPE (type
));
11808 if (TYPE_LANG_SPECIFIC (type
))
11811 vec
<tree
, va_gc
> *v
= CLASSTYPE_MEMBER_VEC (type
);
11814 gcc_checking_assert (!streaming_p ());
11815 /* Force a class vector. */
11816 v
= set_class_bindings (type
, -1);
11817 gcc_checking_assert (v
);
11820 unsigned len
= v
->length ();
11821 if (streaming_p ())
11823 for (unsigned ix
= 0; ix
!= len
; ix
++)
11826 if (TREE_CODE (m
) == TYPE_DECL
11827 && DECL_ARTIFICIAL (m
)
11828 && TYPE_STUB_DECL (TREE_TYPE (m
)) == m
)
11829 /* This is a using-decl for a type, or an anonymous
11830 struct (maybe with a typedef name). Write the type. */
11835 tree_node (CLASSTYPE_LAMBDA_EXPR (type
));
11837 /* TYPE_CONTAINS_VPTR_P looks at the vbase vector, which the
11838 reader won't know at this point. */
11839 int has_vptr
= TYPE_CONTAINS_VPTR_P (type
);
11841 if (streaming_p ())
11843 unsigned nvbases
= vec_safe_length (CLASSTYPE_VBASECLASSES (type
));
11850 tree_vec (CLASSTYPE_PURE_VIRTUALS (type
));
11851 tree_pair_vec (CLASSTYPE_VCALL_INDICES (type
));
11852 tree_node (CLASSTYPE_KEY_METHOD (type
));
11856 if (TYPE_LANG_SPECIFIC (type
))
11858 tree_node (CLASSTYPE_PRIMARY_BINFO (type
));
11860 tree as_base
= CLASSTYPE_AS_BASE (type
);
11862 as_base
= TYPE_NAME (as_base
);
11863 tree_node (as_base
);
11865 /* Write the vtables. */
11866 tree vtables
= CLASSTYPE_VTABLES (type
);
11867 vec_chained_decls (vtables
);
11868 for (; vtables
; vtables
= TREE_CHAIN (vtables
))
11869 write_definition (vtables
);
11871 /* Write the friend classes. */
11872 tree_list (CLASSTYPE_FRIEND_CLASSES (type
), false);
11874 /* Write the friend functions. */
11875 for (tree friends
= DECL_FRIENDLIST (defn
);
11876 friends
; friends
= TREE_CHAIN (friends
))
11878 /* Name of these friends. */
11879 tree_node (TREE_PURPOSE (friends
));
11880 tree_list (TREE_VALUE (friends
), false);
11882 /* End of friend fns. */
11883 tree_node (NULL_TREE
);
11885 /* Write the decl list. */
11886 tree_list (CLASSTYPE_DECL_LIST (type
), true);
11888 if (TYPE_CONTAINS_VPTR_P (type
))
11890 /* Write the thunks. */
11891 for (tree decls
= TYPE_FIELDS (type
);
11892 decls
; decls
= DECL_CHAIN (decls
))
11893 if (TREE_CODE (decls
) == FUNCTION_DECL
11894 && DECL_VIRTUAL_P (decls
)
11895 && DECL_THUNKS (decls
))
11898 /* Thunks are always unique, so chaining is ok. */
11899 chained_decls (DECL_THUNKS (decls
));
11901 tree_node (NULL_TREE
);
11907 trees_out::mark_class_member (tree member
, bool do_defn
)
11909 gcc_assert (DECL_P (member
));
11911 member
= member_owned_by_class (member
);
11913 mark_declaration (member
, do_defn
&& has_definition (member
));
11917 trees_out::mark_class_def (tree defn
)
11919 gcc_assert (DECL_P (defn
));
11920 tree type
= TREE_TYPE (defn
);
11921 /* Mark the class members that are not type-decls and cannot have
11922 independent definitions. */
11923 for (tree member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
11924 if (TREE_CODE (member
) == FIELD_DECL
11925 || TREE_CODE (member
) == USING_DECL
11926 /* A cloned enum-decl from 'using enum unrelated;' */
11927 || (TREE_CODE (member
) == CONST_DECL
11928 && DECL_CONTEXT (member
) == type
))
11930 mark_class_member (member
);
11931 if (TREE_CODE (member
) == FIELD_DECL
)
11932 if (tree repr
= DECL_BIT_FIELD_REPRESENTATIVE (member
))
11933 /* If we're marking a class template definition, then
11934 this'll contain the width (as set by grokbitfield)
11935 instead of a decl. */
11937 mark_declaration (repr
, false);
11940 /* Mark the binfo hierarchy. */
11941 for (tree child
= TYPE_BINFO (type
); child
; child
= TREE_CHAIN (child
))
11942 mark_by_value (child
);
11944 if (TYPE_LANG_SPECIFIC (type
))
11946 for (tree vtable
= CLASSTYPE_VTABLES (type
);
11947 vtable
; vtable
= TREE_CHAIN (vtable
))
11948 mark_declaration (vtable
, true);
11950 if (TYPE_CONTAINS_VPTR_P (type
))
11951 /* Mark the thunks, they belong to the class definition,
11952 /not/ the thunked-to function. */
11953 for (tree decls
= TYPE_FIELDS (type
);
11954 decls
; decls
= DECL_CHAIN (decls
))
11955 if (TREE_CODE (decls
) == FUNCTION_DECL
)
11956 for (tree thunks
= DECL_THUNKS (decls
);
11957 thunks
; thunks
= DECL_CHAIN (thunks
))
11958 mark_declaration (thunks
, false);
11962 /* Nop sorting, needed for resorting the member vec. */
11965 nop (void *, void *, void *)
11970 trees_in::read_class_def (tree defn
, tree maybe_template
)
11972 gcc_assert (DECL_P (defn
));
11973 dump () && dump ("Reading class definition %N", defn
);
11974 tree type
= TREE_TYPE (defn
);
11975 tree size
= tree_node ();
11976 tree size_unit
= tree_node ();
11977 tree vfield
= tree_node ();
11978 tree binfo
= tree_node ();
11979 vec
<tree
, va_gc
> *vbase_vec
= NULL
;
11980 vec
<tree
, va_gc
> *member_vec
= NULL
;
11981 vec
<tree
, va_gc
> *pure_virts
= NULL
;
11982 vec
<tree_pair_s
, va_gc
> *vcall_indices
= NULL
;
11983 tree key_method
= NULL_TREE
;
11984 tree lambda
= NULL_TREE
;
11986 /* Read the fields. */
11987 vec
<tree
, va_heap
> *fields
= vec_chained_decls ();
11989 if (TYPE_LANG_SPECIFIC (type
))
11991 if (unsigned len
= u ())
11993 vec_alloc (member_vec
, len
);
11994 for (unsigned ix
= 0; ix
!= len
; ix
++)
11996 tree m
= tree_node ();
11997 if (get_overrun ())
12000 m
= TYPE_STUB_DECL (m
);
12001 member_vec
->quick_push (m
);
12004 lambda
= tree_node ();
12006 if (!get_overrun ())
12008 unsigned nvbases
= u ();
12011 vec_alloc (vbase_vec
, nvbases
);
12012 for (tree child
= binfo
; child
; child
= TREE_CHAIN (child
))
12013 if (BINFO_VIRTUAL_P (child
))
12014 vbase_vec
->quick_push (child
);
12018 if (!get_overrun ())
12020 int has_vptr
= i ();
12023 pure_virts
= tree_vec ();
12024 vcall_indices
= tree_pair_vec ();
12025 key_method
= tree_node ();
12030 tree maybe_dup
= odr_duplicate (maybe_template
, TYPE_SIZE (type
));
12031 bool installing
= maybe_dup
&& !TYPE_SIZE (type
);
12034 if (DECL_EXTERNAL (defn
) && TYPE_LANG_SPECIFIC (type
))
12036 /* We don't deal with not-really-extern, because, for a
12037 module you want the import to be the interface, and for a
12038 header-unit, you're doing it wrong. */
12039 CLASSTYPE_INTERFACE_UNKNOWN (type
) = false;
12040 CLASSTYPE_INTERFACE_ONLY (type
) = true;
12043 if (maybe_dup
!= defn
)
12045 // FIXME: This is needed on other defns too, almost
12046 // duplicate-decl like? See is_matching_decl too.
12047 /* Copy flags from the duplicate. */
12048 tree type_dup
= TREE_TYPE (maybe_dup
);
12051 TYPE_MODE_RAW (type
) = TYPE_MODE_RAW (type_dup
);
12052 SET_DECL_MODE (defn
, DECL_MODE (maybe_dup
));
12053 TREE_ADDRESSABLE (type
) = TREE_ADDRESSABLE (type_dup
);
12054 DECL_SIZE (defn
) = DECL_SIZE (maybe_dup
);
12055 DECL_SIZE_UNIT (defn
) = DECL_SIZE_UNIT (maybe_dup
);
12056 DECL_ALIGN_RAW (defn
) = DECL_ALIGN_RAW (maybe_dup
);
12057 DECL_WARN_IF_NOT_ALIGN_RAW (defn
)
12058 = DECL_WARN_IF_NOT_ALIGN_RAW (maybe_dup
);
12059 DECL_USER_ALIGN (defn
) = DECL_USER_ALIGN (maybe_dup
);
12062 TYPE_POLYMORPHIC_P (type
) = TYPE_POLYMORPHIC_P (type_dup
);
12063 TYPE_HAS_USER_CONSTRUCTOR (type
)
12064 = TYPE_HAS_USER_CONSTRUCTOR (type_dup
);
12065 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
12066 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type_dup
);
12068 if (auto ls
= TYPE_LANG_SPECIFIC (type_dup
))
12070 if (TYPE_LANG_SPECIFIC (type
))
12072 CLASSTYPE_BEFRIENDING_CLASSES (type_dup
)
12073 = CLASSTYPE_BEFRIENDING_CLASSES (type
);
12074 if (!ANON_AGGR_TYPE_P (type
))
12075 CLASSTYPE_TYPEINFO_VAR (type_dup
)
12076 = CLASSTYPE_TYPEINFO_VAR (type
);
12078 for (tree v
= type
; v
; v
= TYPE_NEXT_VARIANT (v
))
12079 TYPE_LANG_SPECIFIC (v
) = ls
;
12083 TYPE_SIZE (type
) = size
;
12084 TYPE_SIZE_UNIT (type
) = size_unit
;
12088 tree
*chain
= &TYPE_FIELDS (type
);
12089 unsigned len
= fields
->length ();
12090 for (unsigned ix
= 0; ix
!= len
; ix
++)
12092 tree decl
= (*fields
)[ix
];
12096 /* An anonymous struct with typedef name. */
12097 tree tdef
= (*fields
)[ix
+1];
12098 decl
= TYPE_STUB_DECL (TREE_TYPE (tdef
));
12099 gcc_checking_assert (IDENTIFIER_ANON_P (DECL_NAME (decl
))
12103 gcc_checking_assert (!*chain
== !DECL_CLONED_FUNCTION_P (decl
));
12105 chain
= &DECL_CHAIN (decl
);
12107 if (TREE_CODE (decl
) == FIELD_DECL
12108 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
12109 ANON_AGGR_TYPE_FIELD
12110 (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))) = decl
;
12112 if (TREE_CODE (decl
) == USING_DECL
12113 && TREE_CODE (USING_DECL_SCOPE (decl
)) == RECORD_TYPE
)
12115 /* Reconstruct DECL_ACCESS. */
12116 tree decls
= USING_DECL_DECLS (decl
);
12117 tree access
= declared_access (decl
);
12119 for (ovl_iterator
iter (decls
); iter
; ++iter
)
12123 retrofit_lang_decl (d
);
12124 tree list
= DECL_ACCESS (d
);
12126 if (!purpose_member (type
, list
))
12127 DECL_ACCESS (d
) = tree_cons (type
, access
, list
);
12133 TYPE_VFIELD (type
) = vfield
;
12134 TYPE_BINFO (type
) = binfo
;
12136 if (TYPE_LANG_SPECIFIC (type
))
12138 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
12140 CLASSTYPE_MEMBER_VEC (type
) = member_vec
;
12141 CLASSTYPE_PURE_VIRTUALS (type
) = pure_virts
;
12142 CLASSTYPE_VCALL_INDICES (type
) = vcall_indices
;
12144 CLASSTYPE_KEY_METHOD (type
) = key_method
;
12146 CLASSTYPE_VBASECLASSES (type
) = vbase_vec
;
12148 /* Resort the member vector. */
12149 resort_type_member_vec (member_vec
, NULL
, nop
, NULL
);
12152 else if (maybe_dup
)
12154 // FIXME:QOI Check matching defn
12157 if (TYPE_LANG_SPECIFIC (type
))
12159 tree primary
= tree_node ();
12160 tree as_base
= tree_node ();
12163 as_base
= TREE_TYPE (as_base
);
12165 /* Read the vtables. */
12166 vec
<tree
, va_heap
> *vtables
= vec_chained_decls ();
12169 unsigned len
= vtables
->length ();
12170 for (unsigned ix
= 0; ix
!= len
; ix
++)
12172 tree vtable
= (*vtables
)[ix
];
12173 read_var_def (vtable
, vtable
);
12177 tree friend_classes
= tree_list (false);
12178 tree friend_functions
= NULL_TREE
;
12179 for (tree
*chain
= &friend_functions
;
12180 tree name
= tree_node (); chain
= &TREE_CHAIN (*chain
))
12182 tree val
= tree_list (false);
12183 *chain
= build_tree_list (name
, val
);
12185 tree decl_list
= tree_list (true);
12189 CLASSTYPE_PRIMARY_BINFO (type
) = primary
;
12190 CLASSTYPE_AS_BASE (type
) = as_base
;
12194 if (!CLASSTYPE_KEY_METHOD (type
)
12195 /* Sneaky user may have defined it inline
12197 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type
)))
12198 vec_safe_push (keyed_classes
, type
);
12199 unsigned len
= vtables
->length ();
12200 tree
*chain
= &CLASSTYPE_VTABLES (type
);
12201 for (unsigned ix
= 0; ix
!= len
; ix
++)
12203 tree vtable
= (*vtables
)[ix
];
12204 gcc_checking_assert (!*chain
);
12206 chain
= &DECL_CHAIN (vtable
);
12209 CLASSTYPE_FRIEND_CLASSES (type
) = friend_classes
;
12210 DECL_FRIENDLIST (defn
) = friend_functions
;
12211 CLASSTYPE_DECL_LIST (type
) = decl_list
;
12213 for (; friend_classes
; friend_classes
= TREE_CHAIN (friend_classes
))
12215 tree f
= TREE_VALUE (friend_classes
);
12217 if (CLASS_TYPE_P (f
))
12219 CLASSTYPE_BEFRIENDING_CLASSES (f
)
12220 = tree_cons (NULL_TREE
, type
,
12221 CLASSTYPE_BEFRIENDING_CLASSES (f
));
12222 dump () && dump ("Class %N befriending %C:%N",
12223 type
, TREE_CODE (f
), f
);
12227 for (; friend_functions
;
12228 friend_functions
= TREE_CHAIN (friend_functions
))
12229 for (tree friend_decls
= TREE_VALUE (friend_functions
);
12230 friend_decls
; friend_decls
= TREE_CHAIN (friend_decls
))
12232 tree f
= TREE_VALUE (friend_decls
);
12234 DECL_BEFRIENDING_CLASSES (f
)
12235 = tree_cons (NULL_TREE
, type
, DECL_BEFRIENDING_CLASSES (f
));
12236 dump () && dump ("Class %N befriending %C:%N",
12237 type
, TREE_CODE (f
), f
);
12241 if (TYPE_CONTAINS_VPTR_P (type
))
12242 /* Read and install the thunks. */
12243 while (tree vfunc
= tree_node ())
12245 tree thunks
= chained_decls ();
12247 SET_DECL_THUNKS (vfunc
, thunks
);
12250 vec_free (vtables
);
12253 /* Propagate to all variants. */
12255 fixup_type_variants (type
);
12257 /* IS_FAKE_BASE_TYPE is inaccurate at this point, because if this is
12258 the fake base, we've not hooked it into the containing class's
12259 data structure yet. Fortunately it has a unique name. */
12261 && DECL_NAME (defn
) != as_base_identifier
12262 && (!CLASSTYPE_TEMPLATE_INFO (type
)
12263 || !uses_template_parms (TI_ARGS (CLASSTYPE_TEMPLATE_INFO (type
)))))
12264 /* Emit debug info. It'd be nice to know if the interface TU
12265 already emitted this. */
12266 rest_of_type_compilation (type
, !LOCAL_CLASS_P (type
));
12270 return !get_overrun ();
12274 trees_out::write_enum_def (tree decl
)
12276 tree type
= TREE_TYPE (decl
);
12278 tree_node (TYPE_VALUES (type
));
12279 /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
12284 trees_out::mark_enum_def (tree decl
)
12286 tree type
= TREE_TYPE (decl
);
12288 for (tree values
= TYPE_VALUES (type
); values
; values
= TREE_CHAIN (values
))
12290 tree cst
= TREE_VALUE (values
);
12291 mark_by_value (cst
);
12292 /* We must mark the init to avoid circularity in tt_enum_int. */
12293 if (tree init
= DECL_INITIAL (cst
))
12294 if (TREE_CODE (init
) == INTEGER_CST
)
12295 mark_by_value (init
);
12300 trees_in::read_enum_def (tree defn
, tree maybe_template
)
12302 tree type
= TREE_TYPE (defn
);
12303 tree values
= tree_node ();
12305 if (get_overrun ())
12308 tree maybe_dup
= odr_duplicate (maybe_template
, TYPE_VALUES (type
));
12309 bool installing
= maybe_dup
&& !TYPE_VALUES (type
);
12313 TYPE_VALUES (type
) = values
;
12314 /* Note that we stream TYPE_MIN/MAX_VALUE directly as part of the
12317 rest_of_type_compilation (type
, DECL_NAMESPACE_SCOPE_P (defn
));
12319 else if (maybe_dup
)
12321 tree known
= TYPE_VALUES (type
);
12322 for (; known
&& values
;
12323 known
= TREE_CHAIN (known
), values
= TREE_CHAIN (values
))
12325 tree known_decl
= TREE_VALUE (known
);
12326 tree new_decl
= TREE_VALUE (values
);
12328 if (DECL_NAME (known_decl
) != DECL_NAME (new_decl
))
12331 new_decl
= maybe_duplicate (new_decl
);
12333 if (!cp_tree_equal (DECL_INITIAL (known_decl
),
12334 DECL_INITIAL (new_decl
)))
12338 if (known
|| values
)
12340 error_at (DECL_SOURCE_LOCATION (maybe_dup
),
12341 "definition of %qD does not match", maybe_dup
);
12342 inform (DECL_SOURCE_LOCATION (defn
),
12343 "existing definition %qD", defn
);
12345 tree known_decl
= NULL_TREE
, new_decl
= NULL_TREE
;
12348 known_decl
= TREE_VALUE (known
);
12350 new_decl
= maybe_duplicate (TREE_VALUE (values
));
12352 if (known_decl
&& new_decl
)
12354 inform (DECL_SOURCE_LOCATION (new_decl
),
12355 "... this enumerator %qD", new_decl
);
12356 inform (DECL_SOURCE_LOCATION (known_decl
),
12357 "enumerator %qD does not match ...", known_decl
);
12359 else if (known_decl
|| new_decl
)
12361 tree extra
= known_decl
? known_decl
: new_decl
;
12362 inform (DECL_SOURCE_LOCATION (extra
),
12363 "additional enumerators beginning with %qD", extra
);
12366 inform (DECL_SOURCE_LOCATION (maybe_dup
),
12367 "enumeration range differs");
12370 unmatched_duplicate (maybe_template
);
12377 /* Write out the body of DECL. See above circularity note. */
12380 trees_out::write_definition (tree decl
)
12382 if (streaming_p ())
12384 assert_definition (decl
);
12386 && dump ("Writing definition %C:%N", TREE_CODE (decl
), decl
);
12389 dump (dumper::DEPEND
)
12390 && dump ("Depending definition %C:%N", TREE_CODE (decl
), decl
);
12393 switch (TREE_CODE (decl
))
12396 gcc_unreachable ();
12398 case TEMPLATE_DECL
:
12399 decl
= DECL_TEMPLATE_RESULT (decl
);
12402 case FUNCTION_DECL
:
12403 write_function_def (decl
);
12408 tree type
= TREE_TYPE (decl
);
12409 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12410 && TYPE_NAME (type
) == decl
);
12411 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12412 write_enum_def (decl
);
12414 write_class_def (decl
);
12420 write_var_def (decl
);
12425 /* Mark a declaration for by-value walking. If DO_DEFN is true, mark
12429 trees_out::mark_declaration (tree decl
, bool do_defn
)
12431 mark_by_value (decl
);
12433 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12434 decl
= DECL_TEMPLATE_RESULT (decl
);
12439 switch (TREE_CODE (decl
))
12442 gcc_unreachable ();
12444 case FUNCTION_DECL
:
12445 mark_function_def (decl
);
12450 tree type
= TREE_TYPE (decl
);
12451 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12452 && TYPE_NAME (type
) == decl
);
12453 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12454 mark_enum_def (decl
);
12456 mark_class_def (decl
);
12462 mark_var_def (decl
);
12467 /* Read in the body of DECL. See above circularity note. */
12470 trees_in::read_definition (tree decl
)
12472 dump () && dump ("Reading definition %C %N", TREE_CODE (decl
), decl
);
12474 tree maybe_template
= decl
;
12477 switch (TREE_CODE (decl
))
12482 case TEMPLATE_DECL
:
12483 decl
= DECL_TEMPLATE_RESULT (decl
);
12486 case FUNCTION_DECL
:
12487 return read_function_def (decl
, maybe_template
);
12491 tree type
= TREE_TYPE (decl
);
12492 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
12493 && TYPE_NAME (type
) == decl
);
12494 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12495 return read_enum_def (decl
, maybe_template
);
12497 return read_class_def (decl
, maybe_template
);
12503 return read_var_def (decl
, maybe_template
);
12509 /* Lookup an maybe insert a slot for depset for KEY. */
12512 depset::hash::entity_slot (tree entity
, bool insert
)
12514 traits::compare_type
key (entity
, NULL
);
12515 depset
**slot
= find_slot_with_hash (key
, traits::hash (key
),
12516 insert
? INSERT
: NO_INSERT
);
12522 depset::hash::binding_slot (tree ctx
, tree name
, bool insert
)
12524 traits::compare_type
key (ctx
, name
);
12525 depset
**slot
= find_slot_with_hash (key
, traits::hash (key
),
12526 insert
? INSERT
: NO_INSERT
);
12532 depset::hash::find_dependency (tree decl
)
12534 depset
**slot
= entity_slot (decl
, false);
12536 return slot
? *slot
: NULL
;
12540 depset::hash::find_binding (tree ctx
, tree name
)
12542 depset
**slot
= binding_slot (ctx
, name
, false);
12544 return slot
? *slot
: NULL
;
12547 /* DECL is a newly discovered dependency. Create the depset, if it
12548 doesn't already exist. Add it to the worklist if so.
12550 DECL will be an OVL_USING_P OVERLOAD, if it's from a binding that's
12553 We do not have to worry about adding the same dependency more than
12554 once. First it's harmless, but secondly the TREE_VISITED marking
12555 prevents us wanting to do it anyway. */
12558 depset::hash::make_dependency (tree decl
, entity_kind ek
)
12560 /* Make sure we're being told consistent information. */
12561 gcc_checking_assert ((ek
== EK_NAMESPACE
)
12562 == (TREE_CODE (decl
) == NAMESPACE_DECL
12563 && !DECL_NAMESPACE_ALIAS (decl
)));
12564 gcc_checking_assert (ek
!= EK_BINDING
&& ek
!= EK_REDIRECT
);
12565 gcc_checking_assert (TREE_CODE (decl
) != FIELD_DECL
12566 && (TREE_CODE (decl
) != USING_DECL
12567 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
));
12568 gcc_checking_assert (!is_key_order ());
12569 if (ek
== EK_USING
)
12570 gcc_checking_assert (TREE_CODE (decl
) == OVERLOAD
);
12572 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12573 /* The template should have copied these from its result decl. */
12574 gcc_checking_assert (DECL_MODULE_EXPORT_P (decl
)
12575 == DECL_MODULE_EXPORT_P (DECL_TEMPLATE_RESULT (decl
)));
12577 depset
**slot
= entity_slot (decl
, true);
12578 depset
*dep
= *slot
;
12579 bool for_binding
= ek
== EK_FOR_BINDING
;
12583 if ((DECL_IMPLICIT_TYPEDEF_P (decl
)
12584 /* ... not an enum, for instance. */
12585 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
12586 && TYPE_LANG_SPECIFIC (TREE_TYPE (decl
))
12587 && CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)) == 2)
12589 && DECL_LANG_SPECIFIC (decl
)
12590 && DECL_USE_TEMPLATE (decl
) == 2))
12592 /* A partial or explicit specialization. Partial
12593 specializations might not be in the hash table, because
12594 there can be multiple differently-constrained variants.
12596 template<typename T> class silly;
12597 template<typename T> requires true class silly {};
12599 We need to find them, insert their TEMPLATE_DECL in the
12600 dep_hash, and then convert the dep we just found into a
12603 tree ti
= get_template_info (decl
);
12604 tree tmpl
= TI_TEMPLATE (ti
);
12605 tree partial
= NULL_TREE
;
12606 for (tree spec
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
12607 spec
; spec
= TREE_CHAIN (spec
))
12608 if (DECL_TEMPLATE_RESULT (TREE_VALUE (spec
)) == decl
)
12610 partial
= TREE_VALUE (spec
);
12616 /* Eagerly create an empty redirect. The following
12617 make_dependency call could cause hash reallocation,
12618 and invalidate slot's value. */
12619 depset
*redirect
= make_entity (decl
, EK_REDIRECT
);
12621 /* Redirects are never reached -- always snap to their target. */
12622 redirect
->set_flag_bit
<DB_UNREACHED_BIT
> ();
12626 depset
*tmpl_dep
= make_dependency (partial
, EK_PARTIAL
);
12627 gcc_checking_assert (tmpl_dep
->get_entity_kind () == EK_PARTIAL
);
12629 redirect
->deps
.safe_push (tmpl_dep
);
12635 bool has_def
= ek
!= EK_USING
&& has_definition (decl
);
12636 if (ek
> EK_BINDING
)
12639 /* The only OVERLOADS we should see are USING decls from
12641 *slot
= dep
= make_entity (decl
, ek
, has_def
);
12643 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
12645 if (DECL_ALIAS_TEMPLATE_P (decl
) && DECL_TEMPLATE_INFO (decl
))
12646 dep
->set_flag_bit
<DB_ALIAS_TMPL_INST_BIT
> ();
12647 else if (CHECKING_P
)
12648 /* The template_result should otherwise not be in the
12649 table, or be an empty redirect (created above). */
12650 if (auto *eslot
= entity_slot (DECL_TEMPLATE_RESULT (decl
), false))
12651 gcc_checking_assert ((*eslot
)->get_entity_kind () == EK_REDIRECT
12652 && !(*eslot
)->deps
.length ());
12655 if (ek
!= EK_USING
)
12657 tree not_tmpl
= STRIP_TEMPLATE (decl
);
12659 if (DECL_LANG_SPECIFIC (not_tmpl
)
12660 && DECL_MODULE_IMPORT_P (not_tmpl
))
12662 /* Store the module number and index in cluster/section,
12663 so we don't have to look them up again. */
12664 unsigned index
= import_entity_index (decl
);
12665 module_state
*from
= import_entity_module (index
);
12666 /* Remap will be zero for imports from partitions, which
12667 we want to treat as-if declared in this TU. */
12670 dep
->cluster
= index
- from
->entity_lwm
;
12671 dep
->section
= from
->remap
;
12672 dep
->set_flag_bit
<DB_IMPORTED_BIT
> ();
12677 && !dep
->is_import ()
12678 && TREE_CODE (CP_DECL_CONTEXT (decl
)) == NAMESPACE_DECL
12679 && !(TREE_CODE (decl
) == TEMPLATE_DECL
12680 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
)))
12682 tree ctx
= CP_DECL_CONTEXT (decl
);
12684 if (!TREE_PUBLIC (ctx
))
12685 /* Member of internal namespace. */
12686 dep
->set_flag_bit
<DB_IS_INTERNAL_BIT
> ();
12687 else if (VAR_OR_FUNCTION_DECL_P (not_tmpl
)
12688 && DECL_THIS_STATIC (not_tmpl
))
12690 /* An internal decl. This is ok in a GM entity. */
12691 if (!(header_module_p ()
12692 || !DECL_LANG_SPECIFIC (not_tmpl
)
12693 || !DECL_MODULE_PURVIEW_P (not_tmpl
)))
12694 dep
->set_flag_bit
<DB_IS_INTERNAL_BIT
> ();
12699 if (!dep
->is_import ())
12700 worklist
.safe_push (dep
);
12703 dump (dumper::DEPEND
)
12704 && dump ("%s on %s %C:%N found",
12705 ek
== EK_REDIRECT
? "Redirect"
12706 : for_binding
? "Binding" : "Dependency",
12707 dep
->entity_kind_name (), TREE_CODE (decl
), decl
);
12712 /* DEP is a newly discovered dependency. Append it to current's
12716 depset::hash::add_dependency (depset
*dep
)
12718 gcc_checking_assert (current
&& !is_key_order ());
12719 current
->deps
.safe_push (dep
);
12721 if (dep
->is_internal () && !current
->is_internal ())
12722 current
->set_flag_bit
<DB_REFS_INTERNAL_BIT
> ();
12724 if (current
->get_entity_kind () == EK_USING
12725 && DECL_IMPLICIT_TYPEDEF_P (dep
->get_entity ())
12726 && TREE_CODE (TREE_TYPE (dep
->get_entity ())) == ENUMERAL_TYPE
)
12728 /* CURRENT is an unwrapped using-decl and DECL is an enum's
12729 implicit typedef. Is CURRENT a member of the enum? */
12730 tree c_decl
= OVL_FUNCTION (current
->get_entity ());
12732 if (TREE_CODE (c_decl
) == CONST_DECL
12733 && (current
->deps
[0]->get_entity ()
12734 == CP_DECL_CONTEXT (dep
->get_entity ())))
12735 /* Make DECL depend on CURRENT. */
12736 dep
->deps
.safe_push (current
);
12739 if (dep
->is_unreached ())
12741 /* The dependency is reachable now. */
12742 reached_unreached
= true;
12743 dep
->clear_flag_bit
<DB_UNREACHED_BIT
> ();
12744 dump (dumper::DEPEND
)
12745 && dump ("Reaching unreached %s %C:%N", dep
->entity_kind_name (),
12746 TREE_CODE (dep
->get_entity ()), dep
->get_entity ());
12751 depset::hash::add_dependency (tree decl
, entity_kind ek
)
12755 if (is_key_order ())
12757 dep
= find_dependency (decl
);
12760 current
->deps
.safe_push (dep
);
12761 dump (dumper::MERGE
)
12762 && dump ("Key dependency on %s %C:%N found",
12763 dep
->entity_kind_name (), TREE_CODE (decl
), decl
);
12767 /* It's not a mergeable decl, look for it in the original
12769 dep
= chain
->find_dependency (decl
);
12770 gcc_checking_assert (dep
);
12775 dep
= make_dependency (decl
, ek
);
12776 if (dep
->get_entity_kind () != EK_REDIRECT
)
12777 add_dependency (dep
);
12784 depset::hash::add_namespace_context (depset
*dep
, tree ns
)
12786 depset
*ns_dep
= make_dependency (ns
, depset::EK_NAMESPACE
);
12787 dep
->deps
.safe_push (ns_dep
);
12789 /* Mark it as special if imported so we don't walk connect when
12791 if (!dep
->is_binding () && ns_dep
->is_import ())
12792 dep
->set_special ();
12795 struct add_binding_data
12800 depset::hash
*hash
;
12801 bool met_namespace
;
12804 /* Return true if we are, or contain something that is exported. */
12807 depset::hash::add_binding_entity (tree decl
, WMB_Flags flags
, void *data_
)
12809 auto data
= static_cast <add_binding_data
*> (data_
);
12811 if (!(TREE_CODE (decl
) == NAMESPACE_DECL
&& !DECL_NAMESPACE_ALIAS (decl
)))
12815 if (TREE_CODE (inner
) == CONST_DECL
12816 && TREE_CODE (DECL_CONTEXT (inner
)) == ENUMERAL_TYPE
)
12817 inner
= TYPE_NAME (DECL_CONTEXT (inner
));
12818 else if (TREE_CODE (inner
) == TEMPLATE_DECL
)
12819 inner
= DECL_TEMPLATE_RESULT (inner
);
12821 if (!DECL_LANG_SPECIFIC (inner
) || !DECL_MODULE_PURVIEW_P (inner
))
12822 /* Ignore global module fragment entities. */
12825 if (VAR_OR_FUNCTION_DECL_P (inner
)
12826 && DECL_THIS_STATIC (inner
))
12828 if (!header_module_p ())
12829 /* Ignore internal-linkage entitites. */
12833 if ((TREE_CODE (decl
) == VAR_DECL
12834 || TREE_CODE (decl
) == TYPE_DECL
)
12835 && DECL_TINFO_P (decl
))
12836 /* Ignore TINFO things. */
12839 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_NTTP_OBJECT_P (decl
))
12840 /* Ignore NTTP objects. */
12843 if (!(flags
& WMB_Using
) && CP_DECL_CONTEXT (decl
) != data
->ns
)
12845 /* A using that lost its wrapper or an unscoped enum
12847 flags
= WMB_Flags (flags
| WMB_Using
);
12848 if (DECL_MODULE_EXPORT_P (TREE_CODE (decl
) == CONST_DECL
12849 ? TYPE_NAME (TREE_TYPE (decl
))
12850 : STRIP_TEMPLATE (decl
)))
12851 flags
= WMB_Flags (flags
| WMB_Export
);
12854 if (!data
->binding
)
12855 /* No binding to check. */;
12856 else if (flags
& WMB_Using
)
12858 /* Look in the binding to see if we already have this
12860 for (unsigned ix
= data
->binding
->deps
.length (); --ix
;)
12862 depset
*d
= data
->binding
->deps
[ix
];
12863 if (d
->get_entity_kind () == EK_USING
12864 && OVL_FUNCTION (d
->get_entity ()) == decl
)
12866 if (!(flags
& WMB_Hidden
))
12867 d
->clear_hidden_binding ();
12868 if (flags
& WMB_Export
)
12869 OVL_EXPORT_P (d
->get_entity ()) = true;
12870 return bool (flags
& WMB_Export
);
12874 else if (flags
& WMB_Dups
)
12876 /* Look in the binding to see if we already have this decl. */
12877 for (unsigned ix
= data
->binding
->deps
.length (); --ix
;)
12879 depset
*d
= data
->binding
->deps
[ix
];
12880 if (d
->get_entity () == decl
)
12882 if (!(flags
& WMB_Hidden
))
12883 d
->clear_hidden_binding ();
12889 /* We're adding something. */
12890 if (!data
->binding
)
12892 data
->binding
= make_binding (data
->ns
, DECL_NAME (decl
));
12893 data
->hash
->add_namespace_context (data
->binding
, data
->ns
);
12895 depset
**slot
= data
->hash
->binding_slot (data
->ns
,
12896 DECL_NAME (decl
), true);
12897 gcc_checking_assert (!*slot
);
12898 *slot
= data
->binding
;
12901 /* Make sure nobody left a tree visited lying about. */
12902 gcc_checking_assert (!TREE_VISITED (decl
));
12904 if (flags
& WMB_Using
)
12906 decl
= ovl_make (decl
, NULL_TREE
);
12907 if (flags
& WMB_Export
)
12908 OVL_EXPORT_P (decl
) = true;
12911 depset
*dep
= data
->hash
->make_dependency
12912 (decl
, flags
& WMB_Using
? EK_USING
: EK_FOR_BINDING
);
12913 if (flags
& WMB_Hidden
)
12914 dep
->set_hidden_binding ();
12915 data
->binding
->deps
.safe_push (dep
);
12916 /* Binding and contents are mutually dependent. */
12917 dep
->deps
.safe_push (data
->binding
);
12919 return (flags
& WMB_Using
12920 ? flags
& WMB_Export
: DECL_MODULE_EXPORT_P (decl
));
12922 else if (DECL_NAME (decl
) && !data
->met_namespace
)
12924 /* Namespace, walk exactly once. */
12925 gcc_checking_assert (TREE_PUBLIC (decl
));
12926 data
->met_namespace
= true;
12927 if (data
->hash
->add_namespace_entities (decl
, data
->partitions
))
12929 /* It contains an exported thing, so it is exported. */
12930 gcc_checking_assert (DECL_MODULE_PURVIEW_P (decl
));
12931 DECL_MODULE_EXPORT_P (decl
) = true;
12934 if (DECL_MODULE_PURVIEW_P (decl
))
12936 data
->hash
->make_dependency (decl
, depset::EK_NAMESPACE
);
12938 return DECL_MODULE_EXPORT_P (decl
);
12945 /* Recursively find all the namespace bindings of NS. Add a depset
12946 for every binding that contains an export or module-linkage entity.
12947 Add a defining depset for every such decl that we need to write a
12948 definition. Such defining depsets depend on the binding depset.
12949 Returns true if we contain something exported. */
12952 depset::hash::add_namespace_entities (tree ns
, bitmap partitions
)
12954 dump () && dump ("Looking for writables in %N", ns
);
12957 unsigned count
= 0;
12958 add_binding_data data
;
12960 data
.partitions
= partitions
;
12963 hash_table
<named_decl_hash
>::iterator end
12964 (DECL_NAMESPACE_BINDINGS (ns
)->end ());
12965 for (hash_table
<named_decl_hash
>::iterator iter
12966 (DECL_NAMESPACE_BINDINGS (ns
)->begin ()); iter
!= end
; ++iter
)
12968 data
.binding
= nullptr;
12969 data
.met_namespace
= false;
12970 if (walk_module_binding (*iter
, partitions
, add_binding_entity
, &data
))
12975 dump () && dump ("Found %u entries", count
);
12982 depset::hash::add_partial_entities (vec
<tree
, va_gc
> *partial_classes
)
12984 for (unsigned ix
= 0; ix
!= partial_classes
->length (); ix
++)
12986 tree inner
= (*partial_classes
)[ix
];
12988 depset
*dep
= make_dependency (inner
, depset::EK_DECL
);
12990 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
12991 /* We should have recorded the template as a partial
12993 gcc_checking_assert (dep
->deps
[0]->get_entity_kind ()
12994 == depset::EK_PARTIAL
);
12996 /* It was an explicit specialization, not a partial one. */
12997 gcc_checking_assert (dep
->get_entity_kind ()
12998 == depset::EK_SPECIALIZATION
);
13002 /* Add the members of imported classes that we defined in this TU.
13003 This will also include lazily created implicit member function
13004 declarations. (All others will be definitions.) */
13007 depset::hash::add_class_entities (vec
<tree
, va_gc
> *class_members
)
13009 for (unsigned ix
= 0; ix
!= class_members
->length (); ix
++)
13011 tree defn
= (*class_members
)[ix
];
13012 depset
*dep
= make_dependency (defn
, EK_INNER_DECL
);
13014 if (dep
->get_entity_kind () == EK_REDIRECT
)
13015 dep
= dep
->deps
[0];
13017 /* Only non-instantiations need marking as members. */
13018 if (dep
->get_entity_kind () == EK_DECL
)
13019 dep
->set_flag_bit
<DB_IS_MEMBER_BIT
> ();
13023 /* We add the partial & explicit specializations, and the explicit
13027 specialization_add (bool decl_p
, spec_entry
*entry
, void *data_
)
13029 vec
<spec_entry
*> *data
= reinterpret_cast <vec
<spec_entry
*> *> (data_
);
13033 /* We exclusively use decls to locate things. Make sure there's
13034 no mismatch between the two specialization tables we keep.
13035 pt.cc optimizes instantiation lookup using a complicated
13036 heuristic. We don't attempt to replicate that algorithm, but
13037 observe its behaviour and reproduce it upon read back. */
13039 gcc_checking_assert (DECL_ALIAS_TEMPLATE_P (entry
->tmpl
)
13040 || TREE_CODE (entry
->spec
) == ENUMERAL_TYPE
13041 || DECL_CLASS_TEMPLATE_P (entry
->tmpl
));
13043 /* Only alias templates can appear in both tables (and
13044 if they're in the type table they must also be in the decl
13046 gcc_checking_assert
13047 (!match_mergeable_specialization (true, entry
)
13048 == !DECL_ALIAS_TEMPLATE_P (entry
->tmpl
));
13050 else if (VAR_OR_FUNCTION_DECL_P (entry
->spec
))
13051 gcc_checking_assert (!DECL_LOCAL_DECL_P (entry
->spec
));
13053 data
->safe_push (entry
);
13056 /* Arbitrary stable comparison. */
13059 specialization_cmp (const void *a_
, const void *b_
)
13061 const spec_entry
*ea
= *reinterpret_cast<const spec_entry
*const *> (a_
);
13062 const spec_entry
*eb
= *reinterpret_cast<const spec_entry
*const *> (b_
);
13076 /* This can happen with friend specializations. Just order by
13077 entry address. See note in depset_cmp. */
13078 return ea
< eb
? -1 : +1;
13080 return DECL_UID (a
) < DECL_UID (b
) ? -1 : +1;
13083 /* We add all kinds of specialializations. Implicit specializations
13084 should only streamed and walked if they are reachable from
13085 elsewhere. Hence the UNREACHED flag. This is making the
13086 assumption that it is cheaper to reinstantiate them on demand
13087 elsewhere, rather than stream them in when we instantiate their
13088 general template. Also, if we do stream them, we can only do that
13089 if they are not internal (which they can become if they themselves
13090 touch an internal entity?). */
13093 depset::hash::add_specializations (bool decl_p
)
13095 vec
<spec_entry
*> data
;
13097 walk_specializations (decl_p
, specialization_add
, &data
);
13098 data
.qsort (specialization_cmp
);
13099 while (data
.length ())
13101 spec_entry
*entry
= data
.pop ();
13102 tree spec
= entry
->spec
;
13104 bool is_alias
= false;
13105 bool is_friend
= false;
13107 if (decl_p
&& DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (entry
->tmpl
))
13108 /* A friend of a template. This is keyed to the
13112 if (!decl_p
&& DECL_ALIAS_TEMPLATE_P (entry
->tmpl
))
13114 spec
= TYPE_NAME (spec
);
13118 if (decl_p
|| is_alias
)
13120 if (tree ti
= DECL_TEMPLATE_INFO (spec
))
13122 tree tmpl
= TI_TEMPLATE (ti
);
13124 use_tpl
= DECL_USE_TEMPLATE (spec
);
13125 if (spec
== DECL_TEMPLATE_RESULT (tmpl
))
13128 gcc_checking_assert (DECL_USE_TEMPLATE (spec
) == use_tpl
);
13130 else if (is_friend
)
13132 if (TI_TEMPLATE (ti
) != entry
->tmpl
13133 || !template_args_equal (TI_ARGS (ti
), entry
->tmpl
))
13134 goto template_friend
;
13140 gcc_checking_assert (is_friend
);
13141 /* This is a friend of a template class, but not the one
13142 that generated entry->spec itself (i.e. it's an
13143 equivalent clone). We do not need to record
13150 if (TREE_CODE (spec
) == ENUMERAL_TYPE
)
13152 tree ctx
= DECL_CONTEXT (TYPE_NAME (spec
));
13155 use_tpl
= CLASSTYPE_USE_TEMPLATE (ctx
);
13157 use_tpl
= DECL_USE_TEMPLATE (ctx
);
13160 use_tpl
= CLASSTYPE_USE_TEMPLATE (spec
);
13162 tree ti
= TYPE_TEMPLATE_INFO (spec
);
13163 tree tmpl
= TI_TEMPLATE (ti
);
13165 spec
= TYPE_NAME (spec
);
13166 if (spec
== DECL_TEMPLATE_RESULT (tmpl
))
13169 use_tpl
= DECL_USE_TEMPLATE (spec
);
13173 bool needs_reaching
= false;
13175 /* Implicit instantiations only walked if we reach them. */
13176 needs_reaching
= true;
13177 else if (!DECL_LANG_SPECIFIC (spec
)
13178 || !DECL_MODULE_PURVIEW_P (STRIP_TEMPLATE (spec
)))
13179 /* Likewise, GMF explicit or partial specializations. */
13180 needs_reaching
= true;
13182 #if false && CHECKING_P
13183 /* The instantiation isn't always on
13184 DECL_TEMPLATE_INSTANTIATIONS, */
13185 // FIXME: we probably need to remember this information?
13186 /* Verify the specialization is on the
13187 DECL_TEMPLATE_INSTANTIATIONS of the template. */
13188 for (tree cons
= DECL_TEMPLATE_INSTANTIATIONS (entry
->tmpl
);
13189 cons
; cons
= TREE_CHAIN (cons
))
13190 if (TREE_VALUE (cons
) == entry
->spec
)
13192 gcc_assert (entry
->args
== TREE_PURPOSE (cons
));
13195 gcc_unreachable ();
13199 /* Make sure nobody left a tree visited lying about. */
13200 gcc_checking_assert (!TREE_VISITED (spec
));
13201 depset
*dep
= make_dependency (spec
, depset::EK_SPECIALIZATION
);
13202 if (dep
->is_special ())
13204 /* An already located specialization, this must be the TYPE
13205 corresponding to an alias_decl we found in the decl
13207 spec_entry
*other
= reinterpret_cast <spec_entry
*> (dep
->deps
[0]);
13208 gcc_checking_assert (!decl_p
&& is_alias
&& !dep
->is_type_spec ());
13209 gcc_checking_assert (other
->tmpl
== entry
->tmpl
13210 && template_args_equal (other
->args
, entry
->args
)
13211 && TREE_TYPE (other
->spec
) == entry
->spec
);
13212 dep
->set_flag_bit
<DB_ALIAS_SPEC_BIT
> ();
13216 gcc_checking_assert (decl_p
|| !is_alias
);
13217 if (dep
->get_entity_kind () == depset::EK_REDIRECT
)
13218 dep
= dep
->deps
[0];
13219 else if (dep
->get_entity_kind () == depset::EK_SPECIALIZATION
)
13221 dep
->set_special ();
13222 dep
->deps
.safe_push (reinterpret_cast<depset
*> (entry
));
13224 dep
->set_flag_bit
<DB_TYPE_SPEC_BIT
> ();
13227 if (needs_reaching
)
13228 dep
->set_flag_bit
<DB_UNREACHED_BIT
> ();
13230 dep
->set_flag_bit
<DB_FRIEND_SPEC_BIT
> ();
13236 /* Add a depset into the mergeable hash. */
13239 depset::hash::add_mergeable (depset
*mergeable
)
13241 gcc_checking_assert (is_key_order ());
13242 entity_kind ek
= mergeable
->get_entity_kind ();
13243 tree decl
= mergeable
->get_entity ();
13244 gcc_checking_assert (ek
< EK_DIRECT_HWM
);
13246 depset
**slot
= entity_slot (decl
, true);
13247 gcc_checking_assert (!*slot
);
13248 depset
*dep
= make_entity (decl
, ek
);
13251 worklist
.safe_push (dep
);
13253 /* So we can locate the mergeable depset this depset refers to,
13254 mark the first dep. */
13255 dep
->set_special ();
13256 dep
->deps
.safe_push (mergeable
);
13259 /* Find the innermost-namespace scope of DECL, and that
13260 namespace-scope decl. */
13263 find_pending_key (tree decl
, tree
*decl_p
= nullptr)
13269 ns
= CP_DECL_CONTEXT (ns
);
13271 ns
= TYPE_NAME (ns
);
13273 while (TREE_CODE (ns
) != NAMESPACE_DECL
);
13281 /* Iteratively find dependencies. During the walk we may find more
13282 entries on the same binding that need walking. */
13285 depset::hash::find_dependencies (module_state
*module
)
13287 trees_out
walker (NULL
, module
, *this);
13288 vec
<depset
*> unreached
;
13289 unreached
.create (worklist
.length ());
13293 reached_unreached
= false;
13294 while (worklist
.length ())
13296 depset
*item
= worklist
.pop ();
13298 gcc_checking_assert (!item
->is_binding ());
13299 if (item
->is_unreached ())
13300 unreached
.quick_push (item
);
13304 tree decl
= current
->get_entity ();
13305 dump (is_key_order () ? dumper::MERGE
: dumper::DEPEND
)
13306 && dump ("Dependencies of %s %C:%N",
13307 is_key_order () ? "key-order"
13308 : current
->entity_kind_name (), TREE_CODE (decl
), decl
);
13311 if (current
->get_entity_kind () == EK_USING
)
13312 walker
.tree_node (OVL_FUNCTION (decl
));
13313 else if (TREE_VISITED (decl
))
13314 /* A global tree. */;
13315 else if (item
->get_entity_kind () == EK_NAMESPACE
)
13317 module
->note_location (DECL_SOURCE_LOCATION (decl
));
13318 add_namespace_context (current
, CP_DECL_CONTEXT (decl
));
13322 walker
.mark_declaration (decl
, current
->has_defn ());
13324 if (!walker
.is_key_order ()
13325 && (item
->get_entity_kind () == EK_SPECIALIZATION
13326 || item
->get_entity_kind () == EK_PARTIAL
13327 || (item
->get_entity_kind () == EK_DECL
13328 && item
->is_member ())))
13330 tree ns
= find_pending_key (decl
, nullptr);
13331 add_namespace_context (item
, ns
);
13334 // FIXME: Perhaps p1815 makes this redundant? Or at
13335 // least simplifies it. Voldemort types are only
13336 // ever emissable when containing (inline) function
13337 // definition is emitted?
13338 /* Turn the Sneakoscope on when depending the decl. */
13339 sneakoscope
= true;
13340 walker
.decl_value (decl
, current
);
13341 sneakoscope
= false;
13342 if (current
->has_defn ())
13343 walker
.write_definition (decl
);
13347 if (!walker
.is_key_order ()
13348 && TREE_CODE (decl
) == TEMPLATE_DECL
13349 && !DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
13350 /* Mark all the explicit & partial specializations as
13352 for (tree cons
= DECL_TEMPLATE_INSTANTIATIONS (decl
);
13353 cons
; cons
= TREE_CHAIN (cons
))
13355 tree spec
= TREE_VALUE (cons
);
13357 spec
= TYPE_NAME (spec
);
13359 node_template_info (spec
, use_tpl
);
13362 depset
*spec_dep
= find_dependency (spec
);
13363 if (spec_dep
->get_entity_kind () == EK_REDIRECT
)
13364 spec_dep
= spec_dep
->deps
[0];
13365 if (spec_dep
->is_unreached ())
13367 reached_unreached
= true;
13368 spec_dep
->clear_flag_bit
<DB_UNREACHED_BIT
> ();
13369 dump (dumper::DEPEND
)
13370 && dump ("Reaching unreached specialization"
13371 " %C:%N", TREE_CODE (spec
), spec
);
13381 if (!reached_unreached
)
13384 /* It's possible the we reached the unreached before we
13385 processed it in the above loop, so we'll be doing this an
13386 extra time. However, to avoid that we have to do some
13387 bit shuffling that also involves a scan of the list.
13388 Swings & roundabouts I guess. */
13389 std::swap (worklist
, unreached
);
13392 unreached
.release ();
13395 /* Compare two entries of a single binding. TYPE_DECL before
13396 non-exported before exported. */
13399 binding_cmp (const void *a_
, const void *b_
)
13401 depset
*a
= *(depset
*const *)a_
;
13402 depset
*b
= *(depset
*const *)b_
;
13404 tree a_ent
= a
->get_entity ();
13405 tree b_ent
= b
->get_entity ();
13406 gcc_checking_assert (a_ent
!= b_ent
13407 && !a
->is_binding ()
13408 && !b
->is_binding ());
13410 /* Implicit typedefs come first. */
13411 bool a_implicit
= DECL_IMPLICIT_TYPEDEF_P (a_ent
);
13412 bool b_implicit
= DECL_IMPLICIT_TYPEDEF_P (b_ent
);
13413 if (a_implicit
|| b_implicit
)
13415 /* A binding with two implicit type decls? That's unpossible! */
13416 gcc_checking_assert (!(a_implicit
&& b_implicit
));
13417 return a_implicit
? -1 : +1; /* Implicit first. */
13420 /* Hidden before non-hidden. */
13421 bool a_hidden
= a
->is_hidden ();
13422 bool b_hidden
= b
->is_hidden ();
13423 if (a_hidden
!= b_hidden
)
13424 return a_hidden
? -1 : +1;
13426 bool a_using
= a
->get_entity_kind () == depset::EK_USING
;
13430 a_export
= OVL_EXPORT_P (a_ent
);
13431 a_ent
= OVL_FUNCTION (a_ent
);
13434 a_export
= DECL_MODULE_EXPORT_P (TREE_CODE (a_ent
) == CONST_DECL
13435 ? TYPE_NAME (TREE_TYPE (a_ent
))
13436 : STRIP_TEMPLATE (a_ent
));
13438 bool b_using
= b
->get_entity_kind () == depset::EK_USING
;
13442 b_export
= OVL_EXPORT_P (b_ent
);
13443 b_ent
= OVL_FUNCTION (b_ent
);
13446 b_export
= DECL_MODULE_EXPORT_P (TREE_CODE (b_ent
) == CONST_DECL
13447 ? TYPE_NAME (TREE_TYPE (b_ent
))
13448 : STRIP_TEMPLATE (b_ent
));
13450 /* Non-exports before exports. */
13451 if (a_export
!= b_export
)
13452 return a_export
? +1 : -1;
13454 /* At this point we don't care, but want a stable sort. */
13456 if (a_using
!= b_using
)
13458 return a_using
? -1 : +1;
13460 return DECL_UID (a_ent
) < DECL_UID (b_ent
) ? -1 : +1;
13463 /* Sort the bindings, issue errors about bad internal refs. */
13466 depset::hash::finalize_dependencies ()
13469 depset::hash::iterator
end (this->end ());
13470 for (depset::hash::iterator
iter (begin ()); iter
!= end
; ++iter
)
13472 depset
*dep
= *iter
;
13473 if (dep
->is_binding ())
13475 /* Keep the containing namespace dep first. */
13476 gcc_checking_assert (dep
->deps
.length () > 1
13477 && (dep
->deps
[0]->get_entity_kind ()
13479 && (dep
->deps
[0]->get_entity ()
13480 == dep
->get_entity ()));
13481 if (dep
->deps
.length () > 2)
13482 gcc_qsort (&dep
->deps
[1], dep
->deps
.length () - 1,
13483 sizeof (dep
->deps
[1]), binding_cmp
);
13485 else if (dep
->refs_internal ())
13487 for (unsigned ix
= dep
->deps
.length (); ix
--;)
13489 depset
*rdep
= dep
->deps
[ix
];
13490 if (rdep
->is_internal ())
13492 // FIXME:QOI Better location information? We're
13493 // losing, so it doesn't matter about efficiency
13494 tree decl
= dep
->get_entity ();
13495 error_at (DECL_SOURCE_LOCATION (decl
),
13496 "%q#D references internal linkage entity %q#D",
13497 decl
, rdep
->get_entity ());
13508 /* Core of TARJAN's algorithm to find Strongly Connected Components
13509 within a graph. See https://en.wikipedia.org/wiki/
13510 Tarjan%27s_strongly_connected_components_algorithm for details.
13512 We use depset::section as lowlink. Completed nodes have
13513 depset::cluster containing the cluster number, with the top
13516 A useful property is that the output vector is a reverse
13517 topological sort of the resulting DAG. In our case that means
13518 dependent SCCs are found before their dependers. We make use of
13522 depset::tarjan::connect (depset
*v
)
13524 gcc_checking_assert (v
->is_binding ()
13525 || !(v
->is_unreached () || v
->is_import ()));
13527 v
->cluster
= v
->section
= ++index
;
13528 stack
.safe_push (v
);
13530 /* Walk all our dependencies, ignore a first marked slot */
13531 for (unsigned ix
= v
->is_special (); ix
!= v
->deps
.length (); ix
++)
13533 depset
*dep
= v
->deps
[ix
];
13535 if (dep
->is_binding () || !dep
->is_import ())
13537 unsigned lwm
= dep
->cluster
;
13541 /* A new node. Connect it. */
13543 lwm
= dep
->section
;
13546 if (dep
->section
&& v
->section
> lwm
)
13551 if (v
->section
== v
->cluster
)
13553 /* Root of a new SCC. Push all the members onto the result list. */
13554 unsigned num
= v
->cluster
;
13561 result
.quick_push (p
);
13567 /* Compare two depsets. The specific ordering is unimportant, we're
13568 just trying to get consistency. */
13571 depset_cmp (const void *a_
, const void *b_
)
13573 depset
*a
= *(depset
*const *)a_
;
13574 depset
*b
= *(depset
*const *)b_
;
13576 depset::entity_kind a_kind
= a
->get_entity_kind ();
13577 depset::entity_kind b_kind
= b
->get_entity_kind ();
13579 if (a_kind
!= b_kind
)
13580 /* Different entity kinds, order by that. */
13581 return a_kind
< b_kind
? -1 : +1;
13583 tree a_decl
= a
->get_entity ();
13584 tree b_decl
= b
->get_entity ();
13585 if (a_kind
== depset::EK_USING
)
13587 /* If one is a using, the other must be too. */
13588 a_decl
= OVL_FUNCTION (a_decl
);
13589 b_decl
= OVL_FUNCTION (b_decl
);
13592 if (a_decl
!= b_decl
)
13593 /* Different entities, order by their UID. */
13594 return DECL_UID (a_decl
) < DECL_UID (b_decl
) ? -1 : +1;
13596 if (a_kind
== depset::EK_BINDING
)
13598 /* Both are bindings. Order by identifier hash. */
13599 gcc_checking_assert (a
->get_name () != b
->get_name ());
13600 return (IDENTIFIER_HASH_VALUE (a
->get_name ())
13601 < IDENTIFIER_HASH_VALUE (b
->get_name ())
13605 /* They are the same decl. This can happen with two using decls
13606 pointing to the same target. The best we can aim for is
13607 consistently telling qsort how to order them. Hopefully we'll
13608 never have to debug a case that depends on this. Oh, who am I
13609 kidding? Good luck. */
13610 gcc_checking_assert (a_kind
== depset::EK_USING
);
13612 /* Order by depset address. Not the best, but it is something. */
13613 return a
< b
? -1 : +1;
13616 /* Sort the clusters in SCC such that those that depend on one another
13617 are placed later. */
13619 // FIXME: I am not convinced this is needed and, if needed,
13620 // sufficient. We emit the decls in this order but that emission
13621 // could walk into later decls (from the body of the decl, or default
13622 // arg-like things). Why doesn't that walk do the right thing? And
13623 // if it DTRT why do we need to sort here -- won't things naturally
13624 // work? I think part of the issue is that when we're going to refer
13625 // to an entity by name, and that entity is in the same cluster as us,
13626 // we need to actually walk that entity, if we've not already walked
13629 sort_cluster (depset::hash
*original
, depset
*scc
[], unsigned size
)
13631 depset::hash
table (size
, original
);
13635 /* Place bindings last, usings before that. It's not strictly
13636 necessary, but it does make things neater. Says Mr OCD. */
13637 unsigned bind_lwm
= size
;
13638 unsigned use_lwm
= size
;
13639 for (unsigned ix
= 0; ix
!= use_lwm
;)
13641 depset
*dep
= scc
[ix
];
13642 switch (dep
->get_entity_kind ())
13644 case depset::EK_BINDING
:
13645 /* Move to end. No increment. Notice this could be moving
13646 a using decl, which we'll then move again. */
13647 if (--bind_lwm
!= ix
)
13649 scc
[ix
] = scc
[bind_lwm
];
13650 scc
[bind_lwm
] = dep
;
13652 if (use_lwm
> bind_lwm
)
13657 /* We must have copied a using, so move it too. */
13659 gcc_checking_assert (dep
->get_entity_kind () == depset::EK_USING
);
13662 case depset::EK_USING
:
13663 if (--use_lwm
!= ix
)
13665 scc
[ix
] = scc
[use_lwm
];
13666 scc
[use_lwm
] = dep
;
13670 case depset::EK_DECL
:
13671 case depset::EK_SPECIALIZATION
:
13672 case depset::EK_PARTIAL
:
13673 table
.add_mergeable (dep
);
13678 gcc_unreachable ();
13682 gcc_checking_assert (use_lwm
<= bind_lwm
);
13683 dump (dumper::MERGE
) && dump ("Ordering %u/%u depsets", use_lwm
, size
);
13685 table
.find_dependencies (nullptr);
13687 vec
<depset
*> order
= table
.connect ();
13688 gcc_checking_assert (order
.length () == use_lwm
);
13690 /* Now rewrite entries [0,lwm), in the dependency order we
13691 discovered. Usually each entity is in its own cluster. Rarely,
13692 we can get multi-entity clusters, in which case all but one must
13693 only be reached from within the cluster. This happens for
13696 template<typename T>
13697 auto Foo (const T &arg) -> TPL<decltype (arg)>;
13699 The instantiation of TPL will be in the specialization table, and
13700 refer to Foo via arg. But we can only get to that specialization
13701 from Foo's declaration, so we only need to treat Foo as mergable
13702 (We'll do structural comparison of TPL<decltype (arg)>).
13704 Finding the single cluster entry dep is very tricky and
13705 expensive. Let's just not do that. It's harmless in this case
13708 unsigned cluster
= ~0u;
13709 for (unsigned ix
= 0; ix
!= order
.length (); ix
++)
13711 gcc_checking_assert (order
[ix
]->is_special ());
13712 depset
*dep
= order
[ix
]->deps
[0];
13714 dump (dumper::MERGE
)
13715 && dump ("Mergeable %u is %N%s", ix
, dep
->get_entity (),
13716 order
[ix
]->cluster
== cluster
? " (tight)" : "");
13717 cluster
= order
[ix
]->cluster
;
13720 gcc_checking_assert (pos
== use_lwm
);
13723 dump (dumper::MERGE
) && dump ("Ordered %u keys", pos
);
13727 /* Reduce graph to SCCS clusters. SCCS will be populated with the
13728 depsets in dependency order. Each depset's CLUSTER field contains
13729 its cluster number. Each SCC has a unique cluster number, and are
13730 contiguous in SCCS. Cluster numbers are otherwise arbitrary. */
13733 depset::hash::connect ()
13735 tarjan
connector (size ());
13736 vec
<depset
*> deps
;
13737 deps
.create (size ());
13738 iterator
end (this->end ());
13739 for (iterator
iter (begin ()); iter
!= end
; ++iter
)
13741 depset
*item
= *iter
;
13743 entity_kind kind
= item
->get_entity_kind ();
13744 if (kind
== EK_BINDING
13745 || !(kind
== EK_REDIRECT
13746 || item
->is_unreached ()
13747 || item
->is_import ()))
13748 deps
.quick_push (item
);
13751 /* Iteration over the hash table is an unspecified ordering. While
13752 that has advantages, it causes 2 problems. Firstly repeatable
13753 builds are tricky. Secondly creating testcases that check
13754 dependencies are correct by making sure a bad ordering would
13755 happen if that was wrong. */
13756 deps
.qsort (depset_cmp
);
13758 while (deps
.length ())
13760 depset
*v
= deps
.pop ();
13761 dump (dumper::CLUSTER
) &&
13763 ? dump ("Connecting binding %P", v
->get_entity (), v
->get_name ())
13764 : dump ("Connecting %s %s %C:%N",
13765 is_key_order () ? "key-order"
13766 : !v
->has_defn () ? "declaration" : "definition",
13767 v
->entity_kind_name (), TREE_CODE (v
->get_entity ()),
13768 v
->get_entity ()));
13770 connector
.connect (v
);
13774 return connector
.result
;
13777 /* Initialize location spans. */
13780 loc_spans::init (const line_maps
*lmaps
, const line_map_ordinary
*map
)
13782 gcc_checking_assert (!init_p ());
13783 spans
= new vec
<span
> ();
13784 spans
->reserve (20);
13787 interval
.ordinary
.first
= 0;
13788 interval
.macro
.second
= MAX_LOCATION_T
+ 1;
13789 interval
.ordinary_delta
= interval
.macro_delta
= 0;
13791 /* A span for reserved fixed locs. */
13792 interval
.ordinary
.second
13793 = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0));
13794 interval
.macro
.first
= interval
.macro
.second
;
13795 dump (dumper::LOCATION
)
13796 && dump ("Fixed span %u ordinary:[%u,%u) macro:[%u,%u)", spans
->length (),
13797 interval
.ordinary
.first
, interval
.ordinary
.second
,
13798 interval
.macro
.first
, interval
.macro
.second
);
13799 spans
->quick_push (interval
);
13801 /* A span for command line & forced headers. */
13802 interval
.ordinary
.first
= interval
.ordinary
.second
;
13803 interval
.macro
.second
= interval
.macro
.first
;
13806 interval
.ordinary
.second
= map
->start_location
;
13807 interval
.macro
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (lmaps
);
13809 dump (dumper::LOCATION
)
13810 && dump ("Pre span %u ordinary:[%u,%u) macro:[%u,%u)", spans
->length (),
13811 interval
.ordinary
.first
, interval
.ordinary
.second
,
13812 interval
.macro
.first
, interval
.macro
.second
);
13813 spans
->quick_push (interval
);
13815 /* Start an interval for the main file. */
13816 interval
.ordinary
.first
= interval
.ordinary
.second
;
13817 interval
.macro
.second
= interval
.macro
.first
;
13818 dump (dumper::LOCATION
)
13819 && dump ("Main span %u ordinary:[%u,*) macro:[*,%u)", spans
->length (),
13820 interval
.ordinary
.first
, interval
.macro
.second
);
13821 spans
->quick_push (interval
);
13824 /* Reopen the span, if we want the about-to-be-inserted set of maps to
13825 be propagated in our own location table. I.e. we are the primary
13826 interface and we're importing a partition. */
13829 loc_spans::maybe_propagate (module_state
*import
, location_t hwm
)
13831 bool opened
= (module_interface_p () && !module_partition_p ()
13832 && import
->is_partition ());
13838 /* Open a new linemap interval. The just-created ordinary map is the
13839 first map of the interval. */
13842 loc_spans::open (location_t hwm
)
13845 interval
.ordinary
.first
= interval
.ordinary
.second
= hwm
;
13846 interval
.macro
.first
= interval
.macro
.second
13847 = LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
13848 interval
.ordinary_delta
= interval
.macro_delta
= 0;
13849 dump (dumper::LOCATION
)
13850 && dump ("Opening span %u ordinary:[%u,... macro:...,%u)",
13851 spans
->length (), interval
.ordinary
.first
,
13852 interval
.macro
.second
);
13853 if (spans
->length ())
13855 /* No overlapping! */
13856 auto &last
= spans
->last ();
13857 gcc_checking_assert (interval
.ordinary
.first
>= last
.ordinary
.second
);
13858 gcc_checking_assert (interval
.macro
.second
<= last
.macro
.first
);
13860 spans
->safe_push (interval
);
13863 /* Close out the current linemap interval. The last maps are within
13867 loc_spans::close ()
13869 span
&interval
= spans
->last ();
13871 interval
.ordinary
.second
13872 = ((line_table
->highest_location
+ (1 << line_table
->default_range_bits
))
13873 & ~((1u << line_table
->default_range_bits
) - 1));
13874 interval
.macro
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
13875 dump (dumper::LOCATION
)
13876 && dump ("Closing span %u ordinary:[%u,%u) macro:[%u,%u)",
13877 spans
->length () - 1,
13878 interval
.ordinary
.first
,interval
.ordinary
.second
,
13879 interval
.macro
.first
, interval
.macro
.second
);
13882 /* Given an ordinary location LOC, return the lmap_interval it resides
13883 in. NULL if it is not in an interval. */
13885 const loc_spans::span
*
13886 loc_spans::ordinary (location_t loc
)
13888 unsigned len
= spans
->length ();
13892 unsigned half
= len
/ 2;
13893 const span
&probe
= (*spans
)[pos
+ half
];
13894 if (loc
< probe
.ordinary
.first
)
13896 else if (loc
< probe
.ordinary
.second
)
13901 len
= len
- (half
+ 1);
13907 /* Likewise, given a macro location LOC, return the lmap interval it
13910 const loc_spans::span
*
13911 loc_spans::macro (location_t loc
)
13913 unsigned len
= spans
->length ();
13917 unsigned half
= len
/ 2;
13918 const span
&probe
= (*spans
)[pos
+ half
];
13919 if (loc
>= probe
.macro
.second
)
13921 else if (loc
>= probe
.macro
.first
)
13926 len
= len
- (half
+ 1);
13932 /* Return the ordinary location closest to FROM. */
13935 ordinary_loc_of (line_maps
*lmaps
, location_t from
)
13937 while (!IS_ORDINARY_LOC (from
))
13939 if (IS_ADHOC_LOC (from
))
13940 from
= get_location_from_adhoc_loc (lmaps
, from
);
13941 if (from
>= LINEMAPS_MACRO_LOWEST_LOCATION (lmaps
))
13943 /* Find the ordinary location nearest FROM. */
13944 const line_map
*map
= linemap_lookup (lmaps
, from
);
13945 const line_map_macro
*mac_map
= linemap_check_macro (map
);
13946 from
= mac_map
->get_expansion_point_location ();
13952 static module_state
**
13953 get_module_slot (tree name
, module_state
*parent
, bool partition
, bool insert
)
13955 module_state_hash::compare_type
ct (name
, uintptr_t (parent
) | partition
);
13956 hashval_t hv
= module_state_hash::hash (ct
);
13958 return modules_hash
->find_slot_with_hash (ct
, hv
, insert
? INSERT
: NO_INSERT
);
13961 static module_state
*
13962 get_primary (module_state
*parent
)
13964 while (parent
->is_partition ())
13965 parent
= parent
->parent
;
13968 // Implementation unit has null name
13969 parent
= parent
->parent
;
13974 /* Find or create module NAME & PARENT in the hash table. */
13977 get_module (tree name
, module_state
*parent
, bool partition
)
13982 parent
= get_primary ((*modules
)[0]);
13984 if (!parent
->is_partition () && !parent
->flatname
)
13985 parent
->set_flatname ();
13988 module_state
**slot
= get_module_slot (name
, parent
, partition
, true);
13989 module_state
*state
= *slot
;
13992 state
= (new (ggc_alloc
<module_state
> ())
13993 module_state (name
, parent
, partition
));
13999 /* Process string name PTR into a module_state. */
14001 static module_state
*
14002 get_module (const char *ptr
)
14004 /* On DOS based file systems, there is an ambiguity with A:B which can be
14005 interpreted as a module Module:Partition or Drive:PATH. Interpret strings
14006 which clearly starts as pathnames as header-names and everything else is
14007 treated as a (possibly malformed) named moduled. */
14008 if (IS_DIR_SEPARATOR (ptr
[ptr
[0] == '.']) // ./FOO or /FOO
14009 #if HAVE_DOS_BASED_FILE_SYSTEM
14010 || (HAS_DRIVE_SPEC (ptr
) && IS_DIR_SEPARATOR (ptr
[2])) // A:/FOO
14013 /* A header name. */
14014 return get_module (build_string (strlen (ptr
), ptr
));
14016 bool partition
= false;
14017 module_state
*mod
= NULL
;
14019 for (const char *probe
= ptr
;; probe
++)
14020 if (!*probe
|| *probe
== '.' || *probe
== ':')
14025 mod
= get_module (get_identifier_with_length (ptr
, probe
- ptr
),
14038 else if (!(ISALPHA (*probe
) || *probe
== '_'
14039 || (probe
!= ptr
&& ISDIGIT (*probe
))))
14045 /* Create a new mapper connecting to OPTION. */
14048 make_mapper (location_t loc
, class mkdeps
*deps
)
14050 timevar_start (TV_MODULE_MAPPER
);
14051 const char *option
= module_mapper_name
;
14053 option
= getenv ("CXX_MODULE_MAPPER");
14055 mapper
= module_client::open_module_client
14056 (loc
, option
, deps
, &set_cmi_repo
,
14057 (save_decoded_options
[0].opt_index
== OPT_SPECIAL_program_name
)
14058 && save_decoded_options
[0].arg
!= progname
14059 ? save_decoded_options
[0].arg
: nullptr);
14061 timevar_stop (TV_MODULE_MAPPER
);
14066 static unsigned lazy_snum
;
14069 recursive_lazy (unsigned snum
= ~0u)
14073 error_at (input_location
, "recursive lazy load");
14081 /* If THIS is the current purview, issue an import error and return false. */
14084 module_state::check_not_purview (location_t from
)
14086 module_state
*imp
= (*modules
)[0];
14087 if (imp
&& !imp
->name
)
14091 /* Cannot import the current module. */
14092 error_at (from
, "cannot import module in its own purview");
14093 inform (loc
, "module %qs declared here", get_flatname ());
14099 /* Module name substitutions. */
14100 static vec
<module_state
*,va_heap
> substs
;
14103 module_state::mangle (bool include_partition
)
14106 mangle_module_substitution (subst
);
14110 parent
->mangle (include_partition
);
14111 if (include_partition
|| !is_partition ())
14113 // Partitions are significant for global initializer
14115 bool partition
= is_partition () && !parent
->is_partition ();
14116 subst
= mangle_module_component (name
, partition
);
14117 substs
.safe_push (this);
14123 mangle_module (int mod
, bool include_partition
)
14125 module_state
*imp
= (*modules
)[mod
];
14127 gcc_checking_assert (!imp
->is_header ());
14130 /* Set when importing the primary module interface. */
14133 imp
->mangle (include_partition
);
14136 /* Clean up substitutions. */
14138 mangle_module_fini ()
14140 while (substs
.length ())
14141 substs
.pop ()->subst
= 0;
14144 /* Announce WHAT about the module. */
14147 module_state::announce (const char *what
) const
14151 fprintf (stderr
, " %s:%s", what
, get_flatname ());
14156 /* A human-readable README section. The contents of this section to
14157 not contribute to the CRC, so the contents can change per
14158 compilation. That allows us to embed CWD, hostname, build time and
14159 what not. It is a STRTAB that may be extracted with:
14160 readelf -pgnu.c++.README $(module).gcm */
14163 module_state::write_readme (elf_out
*to
, cpp_reader
*reader
, const char *dialect
)
14165 bytes_out
readme (to
);
14167 readme
.begin (false);
14169 readme
.printf ("GNU C++ %s",
14170 is_header () ? "header unit"
14171 : !is_partition () ? "primary interface"
14172 : is_interface () ? "interface partition"
14173 : "internal partition");
14175 /* Compiler's version. */
14176 readme
.printf ("compiler: %s", version_string
);
14178 /* Module format version. */
14180 version2string (MODULE_VERSION
, string
);
14181 readme
.printf ("version: %s", string
);
14183 /* Module information. */
14184 readme
.printf ("module: %s", get_flatname ());
14185 readme
.printf ("source: %s", main_input_filename
);
14186 readme
.printf ("dialect: %s", dialect
);
14188 readme
.printf ("extensions: %s",
14189 extensions
& SE_OPENMP
? "-fopenmp" : "");
14191 /* The following fields could be expected to change between
14192 otherwise identical compilations. Consider a distributed build
14193 system. We should have a way of overriding that. */
14194 if (char *cwd
= getcwd (NULL
, 0))
14196 readme
.printf ("cwd: %s", cwd
);
14199 readme
.printf ("repository: %s", cmi_repo
? cmi_repo
: ".");
14203 if (!gethostname (hostname
, sizeof (hostname
)))
14204 readme
.printf ("host: %s", hostname
);
14208 /* This of course will change! */
14210 auto kind
= cpp_get_date (reader
, &stampy
);
14211 if (kind
!= CPP_time_kind::UNKNOWN
)
14215 time
= gmtime (&stampy
);
14216 readme
.print_time ("build", time
, "UTC");
14218 if (kind
== CPP_time_kind::DYNAMIC
)
14220 time
= localtime (&stampy
);
14221 readme
.print_time ("local", time
,
14222 #if defined (__USE_MISC) || defined (__USE_BSD) /* Is there a better way? */
14232 /* Its direct imports. */
14233 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14235 module_state
*state
= (*modules
)[ix
];
14237 if (state
->is_direct ())
14238 readme
.printf ("%s: %s %s", state
->exported_p
? "export" : "import",
14239 state
->get_flatname (), state
->filename
);
14242 readme
.end (to
, to
->name (MOD_SNAME_PFX
".README"), NULL
);
14245 /* Sort environment var names in reverse order. */
14248 env_var_cmp (const void *a_
, const void *b_
)
14250 const unsigned char *a
= *(const unsigned char *const *)a_
;
14251 const unsigned char *b
= *(const unsigned char *const *)b_
;
14253 for (unsigned ix
= 0; ; ix
++)
14255 bool a_end
= !a
[ix
] || a
[ix
] == '=';
14256 if (a
[ix
] == b
[ix
])
14263 bool b_end
= !b
[ix
] || b
[ix
] == '=';
14265 if (!a_end
&& !b_end
)
14266 return a
[ix
] < b
[ix
] ? +1 : -1;
14267 if (a_end
&& b_end
)
14269 return a_end
? +1 : -1;
14276 /* Write the environment. It is a STRTAB that may be extracted with:
14277 readelf -pgnu.c++.ENV $(module).gcm */
14280 module_state::write_env (elf_out
*to
)
14282 vec
<const char *> vars
;
14285 extern char **environ
;
14286 while (const char *var
= environ
[vars
.length ()])
14287 vars
.safe_push (var
);
14288 vars
.qsort (env_var_cmp
);
14290 bytes_out
env (to
);
14292 while (vars
.length ())
14293 env
.printf ("%s", vars
.pop ());
14294 env
.end (to
, to
->name (MOD_SNAME_PFX
".ENV"), NULL
);
14299 /* Write the direct or indirect imports.
14305 s:filename (direct)
14306 u:exported (direct)
14311 module_state::write_imports (bytes_out
&sec
, bool direct
)
14313 unsigned count
= 0;
14315 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14317 module_state
*imp
= (*modules
)[ix
];
14319 if (imp
->remap
&& imp
->is_direct () == direct
)
14323 gcc_assert (!direct
|| count
);
14326 for (unsigned ix
= 1; ix
< modules
->length (); ix
++)
14328 module_state
*imp
= (*modules
)[ix
];
14330 if (imp
->remap
&& imp
->is_direct () == direct
)
14332 dump () && dump ("Writing %simport:%u->%u %M (crc=%x)",
14333 !direct
? "indirect "
14334 : imp
->exported_p
? "exported " : "",
14335 ix
, imp
->remap
, imp
, imp
->crc
);
14336 sec
.u (imp
->remap
);
14337 sec
.str (imp
->get_flatname ());
14338 sec
.u32 (imp
->crc
);
14341 write_location (sec
, imp
->imported_from ());
14342 sec
.str (imp
->filename
);
14343 int exportedness
= 0;
14344 if (imp
->exported_p
)
14346 else if (!imp
->is_purview_direct ())
14348 sec
.i (exportedness
);
14354 /* READER, LMAPS != NULL == direct imports,
14355 == NUL == indirect imports. */
14358 module_state::read_imports (bytes_in
&sec
, cpp_reader
*reader
, line_maps
*lmaps
)
14360 unsigned count
= sec
.u ();
14361 unsigned loaded
= 0;
14365 unsigned ix
= sec
.u ();
14366 if (ix
>= slurp
->remap
->length () || !ix
|| (*slurp
->remap
)[ix
])
14368 sec
.set_overrun ();
14372 const char *name
= sec
.str (NULL
);
14373 module_state
*imp
= get_module (name
);
14374 unsigned crc
= sec
.u32 ();
14375 int exportedness
= 0;
14377 /* If the import is a partition, it must be the same primary
14378 module as this TU. */
14379 if (imp
&& imp
->is_partition () &&
14380 (!named_module_p ()
14381 || (get_primary ((*modules
)[0]) != get_primary (imp
))))
14385 sec
.set_overrun ();
14386 if (sec
.get_overrun ())
14391 /* A direct import, maybe load it. */
14392 location_t floc
= read_location (sec
);
14393 const char *fname
= sec
.str (NULL
);
14394 exportedness
= sec
.i ();
14396 if (sec
.get_overrun ())
14399 if (!imp
->check_not_purview (loc
))
14402 if (imp
->loadedness
== ML_NONE
)
14406 if (!imp
->get_flatname ())
14407 imp
->set_flatname ();
14409 unsigned n
= dump
.push (imp
);
14411 if (!imp
->filename
&& fname
)
14412 imp
->filename
= xstrdup (fname
);
14414 if (imp
->is_partition ())
14415 dump () && dump ("Importing elided partition %M", imp
);
14417 if (!imp
->do_import (reader
, false))
14424 if (is_partition ())
14426 if (!imp
->is_direct ())
14427 imp
->directness
= MD_PARTITION_DIRECT
;
14428 if (exportedness
> 0)
14429 imp
->exported_p
= true;
14434 /* An indirect import, find it, it should already be here. */
14435 if (imp
->loadedness
== ML_NONE
)
14437 error_at (loc
, "indirect import %qs is not already loaded", name
);
14442 if (imp
->crc
!= crc
)
14443 error_at (loc
, "import %qs has CRC mismatch", imp
->get_flatname ());
14445 (*slurp
->remap
)[ix
] = (imp
->mod
<< 1) | (lmaps
!= NULL
);
14447 if (lmaps
&& exportedness
>= 0)
14448 set_import (imp
, bool (exportedness
));
14449 dump () && dump ("Found %simport:%u %M->%u", !lmaps
? "indirect "
14450 : exportedness
> 0 ? "exported "
14451 : exportedness
< 0 ? "gmf" : "", ix
, imp
,
14459 /* Write the import table to MOD_SNAME_PFX.imp. */
14462 module_state::write_imports (elf_out
*to
, unsigned *crc_ptr
)
14464 dump () && dump ("Writing imports");
14467 bytes_out
sec (to
);
14470 write_imports (sec
, true);
14471 write_imports (sec
, false);
14473 sec
.end (to
, to
->name (MOD_SNAME_PFX
".imp"), crc_ptr
);
14478 module_state::read_imports (cpp_reader
*reader
, line_maps
*lmaps
)
14482 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".imp"))
14485 dump () && dump ("Reading %u imports", slurp
->remap
->length () - 1);
14488 /* Read the imports. */
14489 unsigned direct
= read_imports (sec
, reader
, lmaps
);
14490 unsigned indirect
= read_imports (sec
, NULL
, NULL
);
14491 if (direct
+ indirect
+ 1 != slurp
->remap
->length ())
14492 from ()->set_error (elf::E_BAD_IMPORT
);
14495 if (!sec
.end (from ()))
14500 /* We're the primary module interface, but have partitions. Document
14501 them so that non-partition module implementation units know which
14502 have already been loaded. */
14505 module_state::write_partitions (elf_out
*to
, unsigned count
, unsigned *crc_ptr
)
14507 dump () && dump ("Writing %u elided partitions", count
);
14510 bytes_out
sec (to
);
14513 for (unsigned ix
= 1; ix
!= modules
->length (); ix
++)
14515 module_state
*imp
= (*modules
)[ix
];
14516 if (imp
->is_partition ())
14518 dump () && dump ("Writing elided partition %M (crc=%x)",
14520 sec
.str (imp
->get_flatname ());
14521 sec
.u32 (imp
->crc
);
14522 write_location (sec
, imp
->is_direct ()
14523 ? imp
->imported_from () : UNKNOWN_LOCATION
);
14524 sec
.str (imp
->filename
);
14528 sec
.end (to
, to
->name (MOD_SNAME_PFX
".prt"), crc_ptr
);
14533 module_state::read_partitions (unsigned count
)
14536 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".prt"))
14539 dump () && dump ("Reading %u elided partitions", count
);
14544 const char *name
= sec
.str (NULL
);
14545 unsigned crc
= sec
.u32 ();
14546 location_t floc
= read_location (sec
);
14547 const char *fname
= sec
.str (NULL
);
14549 if (sec
.get_overrun ())
14552 dump () && dump ("Reading elided partition %s (crc=%x)", name
, crc
);
14554 module_state
*imp
= get_module (name
);
14555 if (!imp
/* Partition should be ... */
14556 || !imp
->is_partition () /* a partition ... */
14557 || imp
->loadedness
!= ML_NONE
/* that is not yet loaded ... */
14558 || get_primary (imp
) != this) /* whose primary is this. */
14560 sec
.set_overrun ();
14564 if (!imp
->has_location ())
14567 if (!imp
->filename
&& fname
[0])
14568 imp
->filename
= xstrdup (fname
);
14572 if (!sec
.end (from ()))
14577 /* Data for config reading and writing. */
14578 struct module_state_config
{
14579 const char *dialect_str
;
14580 unsigned num_imports
;
14581 unsigned num_partitions
;
14582 unsigned num_entities
;
14583 unsigned ordinary_locs
;
14584 unsigned macro_locs
;
14585 unsigned loc_range_bits
;
14586 unsigned active_init
;
14589 module_state_config ()
14590 :dialect_str (get_dialect ()),
14591 num_imports (0), num_partitions (0), num_entities (0),
14592 ordinary_locs (0), macro_locs (0), loc_range_bits (0),
14597 static void release ()
14599 XDELETEVEC (dialect
);
14604 static const char *get_dialect ();
14605 static char *dialect
;
14608 char *module_state_config::dialect
;
14610 /* Generate a string of the significant compilation options.
14611 Generally assume the user knows what they're doing, in the same way
14612 that object files can be mixed. */
14615 module_state_config::get_dialect ()
14618 dialect
= concat (get_cxx_dialect_name (cxx_dialect
),
14619 /* C++ implies these, only show if disabled. */
14620 flag_exceptions
? "" : "/no-exceptions",
14621 flag_rtti
? "" : "/no-rtti",
14622 flag_new_inheriting_ctors
? "" : "/old-inheriting-ctors",
14623 /* C++ 20 implies concepts. */
14624 cxx_dialect
< cxx20
&& flag_concepts
? "/concepts" : "",
14625 flag_coroutines
? "/coroutines" : "",
14626 flag_module_implicit_inline
? "/implicit-inline" : "",
14627 flag_contracts
? "/contracts" : "",
14633 /* Contents of a cluster. */
14635 ct_decl
, /* A decl. */
14636 ct_defn
, /* A definition. */
14637 ct_bind
, /* A binding. */
14641 /* Binding modifiers. */
14644 cbf_export
= 0x1, /* An exported decl. */
14645 cbf_hidden
= 0x2, /* A hidden (friend) decl. */
14646 cbf_using
= 0x4, /* A using decl. */
14647 cbf_wrapped
= 0x8, /* ... that is wrapped. */
14650 /* DEP belongs to a different cluster, seed it to prevent
14651 unfortunately timed duplicate import. */
14652 // FIXME: QOI For inter-cluster references we could just only pick
14653 // one entity from an earlier cluster. Even better track
14654 // dependencies between earlier clusters
14657 module_state::intercluster_seed (trees_out
&sec
, unsigned index_hwm
, depset
*dep
)
14659 if (dep
->is_import ()
14660 || dep
->cluster
< index_hwm
)
14662 tree ent
= dep
->get_entity ();
14663 if (!TREE_VISITED (ent
))
14665 sec
.tree_node (ent
);
14666 dump (dumper::CLUSTER
)
14667 && dump ("Seeded %s %N",
14668 dep
->is_import () ? "import" : "intercluster", ent
);
14673 /* Write the cluster of depsets in SCC[0-SIZE).
14674 dep->section -> section number
14675 dep->cluster -> entity number
14679 module_state::write_cluster (elf_out
*to
, depset
*scc
[], unsigned size
,
14680 depset::hash
&table
, unsigned *counts
,
14683 dump () && dump ("Writing section:%u %u depsets", table
.section
, size
);
14686 trees_out
sec (to
, this, table
, table
.section
);
14688 unsigned index_lwm
= counts
[MSC_entities
];
14690 /* Determine entity numbers, mark for writing. */
14691 dump (dumper::CLUSTER
) && dump ("Cluster members:") && (dump
.indent (), true);
14692 for (unsigned ix
= 0; ix
!= size
; ix
++)
14694 depset
*b
= scc
[ix
];
14696 switch (b
->get_entity_kind ())
14699 gcc_unreachable ();
14701 case depset::EK_BINDING
:
14703 dump (dumper::CLUSTER
)
14704 && dump ("[%u]=%s %P", ix
, b
->entity_kind_name (),
14705 b
->get_entity (), b
->get_name ());
14706 depset
*ns_dep
= b
->deps
[0];
14707 gcc_checking_assert (ns_dep
->get_entity_kind ()
14708 == depset::EK_NAMESPACE
14709 && ns_dep
->get_entity () == b
->get_entity ());
14710 for (unsigned jx
= b
->deps
.length (); --jx
;)
14712 depset
*dep
= b
->deps
[jx
];
14713 // We could be declaring something that is also a
14715 gcc_checking_assert (dep
->is_import ()
14716 || TREE_VISITED (dep
->get_entity ())
14717 || (dep
->get_entity_kind ()
14718 == depset::EK_USING
));
14723 case depset::EK_DECL
:
14724 case depset::EK_SPECIALIZATION
:
14725 case depset::EK_PARTIAL
:
14726 b
->cluster
= counts
[MSC_entities
]++;
14727 sec
.mark_declaration (b
->get_entity (), b
->has_defn ());
14730 case depset::EK_USING
:
14731 gcc_checking_assert (!b
->is_import ()
14732 && !b
->is_unreached ());
14733 dump (dumper::CLUSTER
)
14734 && dump ("[%u]=%s %s %N", ix
, b
->entity_kind_name (),
14735 b
->has_defn () ? "definition" : "declaration",
14740 dump (dumper::CLUSTER
) && (dump
.outdent (), true);
14742 /* Ensure every out-of-cluster decl is referenced before we start
14743 streaming. We must do both imports *and* earlier clusters,
14744 because the latter could reach into the former and cause a
14746 sec
.set_importing (+1);
14747 for (unsigned ix
= 0; ix
!= size
; ix
++)
14749 depset
*b
= scc
[ix
];
14750 for (unsigned jx
= (b
->get_entity_kind () == depset::EK_BINDING
14751 || b
->is_special ()) ? 1 : 0;
14752 jx
!= b
->deps
.length (); jx
++)
14754 depset
*dep
= b
->deps
[jx
];
14756 if (dep
->is_binding ())
14758 for (unsigned ix
= dep
->deps
.length (); --ix
;)
14760 depset
*bind
= dep
->deps
[ix
];
14761 if (bind
->get_entity_kind () == depset::EK_USING
)
14762 bind
= bind
->deps
[1];
14764 intercluster_seed (sec
, index_lwm
, bind
);
14766 /* Also check the namespace itself. */
14767 dep
= dep
->deps
[0];
14770 intercluster_seed (sec
, index_lwm
, dep
);
14773 sec
.tree_node (NULL_TREE
);
14774 /* We're done importing now. */
14775 sec
.set_importing (-1);
14777 /* Write non-definitions. */
14778 for (unsigned ix
= 0; ix
!= size
; ix
++)
14780 depset
*b
= scc
[ix
];
14781 tree decl
= b
->get_entity ();
14782 switch (b
->get_entity_kind ())
14785 gcc_unreachable ();
14788 case depset::EK_BINDING
:
14790 gcc_assert (TREE_CODE (decl
) == NAMESPACE_DECL
);
14791 dump () && dump ("Depset:%u binding %C:%P", ix
, TREE_CODE (decl
),
14792 decl
, b
->get_name ());
14794 sec
.tree_node (decl
);
14795 sec
.tree_node (b
->get_name ());
14797 /* Write in reverse order, so reading will see the exports
14798 first, thus building the overload chain will be
14800 for (unsigned jx
= b
->deps
.length (); --jx
;)
14802 depset
*dep
= b
->deps
[jx
];
14803 tree bound
= dep
->get_entity ();
14804 unsigned flags
= 0;
14805 if (dep
->get_entity_kind () == depset::EK_USING
)
14808 bound
= OVL_FUNCTION (bound
);
14809 if (!(TREE_CODE (bound
) == CONST_DECL
14810 && UNSCOPED_ENUM_P (TREE_TYPE (bound
))
14811 && decl
== TYPE_NAME (TREE_TYPE (bound
))))
14813 /* An unscope enumerator in its enumeration's
14814 scope is not a using. */
14815 flags
|= cbf_using
;
14816 if (OVL_USING_P (ovl
))
14817 flags
|= cbf_wrapped
;
14819 if (OVL_EXPORT_P (ovl
))
14820 flags
|= cbf_export
;
14824 /* An implicit typedef must be at one. */
14825 gcc_assert (!DECL_IMPLICIT_TYPEDEF_P (bound
) || jx
== 1);
14826 if (dep
->is_hidden ())
14827 flags
|= cbf_hidden
;
14828 else if (DECL_MODULE_EXPORT_P (STRIP_TEMPLATE (bound
)))
14829 flags
|= cbf_export
;
14832 gcc_checking_assert (DECL_P (bound
));
14835 sec
.tree_node (bound
);
14838 /* Terminate the list. */
14843 case depset::EK_USING
:
14844 dump () && dump ("Depset:%u %s %C:%N", ix
, b
->entity_kind_name (),
14845 TREE_CODE (decl
), decl
);
14848 case depset::EK_SPECIALIZATION
:
14849 case depset::EK_PARTIAL
:
14850 case depset::EK_DECL
:
14851 dump () && dump ("Depset:%u %s entity:%u %C:%N", ix
,
14852 b
->entity_kind_name (), b
->cluster
,
14853 TREE_CODE (decl
), decl
);
14856 sec
.tree_node (decl
);
14858 dump () && dump ("Wrote declaration entity:%u %C:%N",
14859 b
->cluster
, TREE_CODE (decl
), decl
);
14864 depset
*namer
= NULL
;
14866 /* Write out definitions */
14867 for (unsigned ix
= 0; ix
!= size
; ix
++)
14869 depset
*b
= scc
[ix
];
14870 tree decl
= b
->get_entity ();
14871 switch (b
->get_entity_kind ())
14876 case depset::EK_SPECIALIZATION
:
14877 case depset::EK_PARTIAL
:
14878 case depset::EK_DECL
:
14882 if (b
->has_defn ())
14885 sec
.tree_node (decl
);
14886 dump () && dump ("Writing definition %N", decl
);
14887 sec
.write_definition (decl
);
14889 if (!namer
->has_defn ())
14896 /* We don't find the section by name. Use depset's decl's name for
14897 human friendliness. */
14899 tree naming_decl
= NULL_TREE
;
14902 naming_decl
= namer
->get_entity ();
14903 if (namer
->get_entity_kind () == depset::EK_USING
)
14904 /* This unfortunately names the section from the target of the
14905 using decl. But the name is only a guide, so Do Not Care. */
14906 naming_decl
= OVL_FUNCTION (naming_decl
);
14907 if (DECL_IMPLICIT_TYPEDEF_P (naming_decl
))
14908 /* Lose any anonymousness. */
14909 naming_decl
= TYPE_NAME (TREE_TYPE (naming_decl
));
14910 name
= to
->qualified_name (naming_decl
, namer
->has_defn ());
14913 unsigned bytes
= sec
.pos
;
14914 unsigned snum
= sec
.end (to
, name
, crc_ptr
);
14916 for (unsigned ix
= size
; ix
--;)
14917 gcc_checking_assert (scc
[ix
]->section
== snum
);
14920 dump () && dump ("Wrote section:%u named-by:%N", table
.section
, naming_decl
);
14925 /* Read a cluster from section SNUM. */
14928 module_state::read_cluster (unsigned snum
)
14930 trees_in
sec (this);
14932 if (!sec
.begin (loc
, from (), snum
))
14935 dump () && dump ("Reading section:%u", snum
);
14938 /* We care about structural equality. */
14939 comparing_dependent_aliases
++;
14941 /* First seed the imports. */
14942 while (tree import
= sec
.tree_node ())
14943 dump (dumper::CLUSTER
) && dump ("Seeded import %N", import
);
14945 while (!sec
.get_overrun () && sec
.more_p ())
14947 unsigned ct
= sec
.u ();
14951 sec
.set_overrun ();
14955 /* A set of namespace bindings. */
14957 tree ns
= sec
.tree_node ();
14958 tree name
= sec
.tree_node ();
14959 tree decls
= NULL_TREE
;
14960 tree visible
= NULL_TREE
;
14961 tree type
= NULL_TREE
;
14962 bool dedup
= false;
14964 /* We rely on the bindings being in the reverse order of
14965 the resulting overload set. */
14968 int flags
= sec
.i ();
14972 if ((flags
& cbf_hidden
)
14973 && (flags
& (cbf_using
| cbf_export
)))
14974 sec
.set_overrun ();
14976 tree decl
= sec
.tree_node ();
14977 if (sec
.get_overrun ())
14980 if (decls
&& TREE_CODE (decl
) == TYPE_DECL
)
14983 if (type
|| !DECL_IMPLICIT_TYPEDEF_P (decl
))
14984 sec
.set_overrun ();
14990 || (flags
& (cbf_hidden
| cbf_wrapped
))
14991 || DECL_FUNCTION_TEMPLATE_P (decl
))
14993 decls
= ovl_make (decl
, decls
);
14994 if (flags
& cbf_using
)
14997 OVL_USING_P (decls
) = true;
14998 if (flags
& cbf_export
)
14999 OVL_EXPORT_P (decls
) = true;
15002 if (flags
& cbf_hidden
)
15003 OVL_HIDDEN_P (decls
) = true;
15005 OVL_DEDUP_P (decls
) = true;
15010 if (flags
& cbf_export
15011 || (!(flags
& cbf_hidden
)
15012 && (is_module () || is_partition ())))
15018 sec
.set_overrun ();
15020 if (sec
.get_overrun ())
15023 dump () && dump ("Binding of %P", ns
, name
);
15024 if (!set_module_binding (ns
, name
, mod
,
15026 : is_module () || is_partition () ? 1
15028 decls
, type
, visible
))
15029 sec
.set_overrun ();
15036 tree decl
= sec
.tree_node ();
15037 dump () && dump ("Read declaration of %N", decl
);
15043 tree decl
= sec
.tree_node ();
15044 dump () && dump ("Reading definition of %N", decl
);
15045 sec
.read_definition (decl
);
15051 /* When lazy loading is in effect, we can be in the middle of
15052 parsing or instantiating a function. Save it away.
15053 push_function_context does too much work. */
15054 tree old_cfd
= current_function_decl
;
15055 struct function
*old_cfun
= cfun
;
15056 while (tree decl
= sec
.post_process ())
15058 bool abstract
= false;
15059 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
15062 decl
= DECL_TEMPLATE_RESULT (decl
);
15065 current_function_decl
= decl
;
15066 allocate_struct_function (decl
, abstract
);
15067 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
15068 cfun
->language
->base
.x_stmt_tree
.stmts_are_full_exprs_p
= 1;
15072 else if (DECL_ABSTRACT_P (decl
))
15073 vec_safe_push (post_load_decls
, decl
);
15076 bool aggr
= aggregate_value_p (DECL_RESULT (decl
), decl
);
15077 #ifdef PCC_STATIC_STRUCT_RETURN
15078 cfun
->returns_pcc_struct
= aggr
;
15080 cfun
->returns_struct
= aggr
;
15082 if (DECL_COMDAT (decl
))
15083 // FIXME: Comdat grouping?
15084 comdat_linkage (decl
);
15085 note_vague_linkage_fn (decl
);
15086 cgraph_node::finalize_function (decl
, true);
15090 /* Look, function.cc's interface to cfun does too much for us, we
15091 just need to restore the old value. I do not want to go
15092 redesigning that API right now. */
15095 current_function_decl
= old_cfd
;
15096 comparing_dependent_aliases
--;
15099 dump () && dump ("Read section:%u", snum
);
15103 if (!sec
.end (from ()))
15110 module_state::write_namespace (bytes_out
&sec
, depset
*dep
)
15112 unsigned ns_num
= dep
->cluster
;
15113 unsigned ns_import
= 0;
15115 if (dep
->is_import ())
15116 ns_import
= dep
->section
;
15117 else if (dep
->get_entity () != global_namespace
)
15125 module_state::read_namespace (bytes_in
&sec
)
15127 unsigned ns_import
= sec
.u ();
15128 unsigned ns_num
= sec
.u ();
15129 tree ns
= NULL_TREE
;
15131 if (ns_import
|| ns_num
)
15136 if (unsigned origin
= slurp
->remap_module (ns_import
))
15138 module_state
*from
= (*modules
)[origin
];
15139 if (ns_num
< from
->entity_num
)
15141 binding_slot
&slot
= (*entity_ary
)[from
->entity_lwm
+ ns_num
];
15143 if (!slot
.is_lazy ())
15148 sec
.set_overrun ();
15151 ns
= global_namespace
;
15156 /* SPACES is a sorted vector of namespaces. Write out the namespaces
15157 to MOD_SNAME_PFX.nms section. */
15160 module_state::write_namespaces (elf_out
*to
, vec
<depset
*> spaces
,
15161 unsigned num
, unsigned *crc_p
)
15163 dump () && dump ("Writing namespaces");
15166 bytes_out
sec (to
);
15169 for (unsigned ix
= 0; ix
!= num
; ix
++)
15171 depset
*b
= spaces
[ix
];
15172 tree ns
= b
->get_entity ();
15174 gcc_checking_assert (TREE_CODE (ns
) == NAMESPACE_DECL
);
15175 /* P1815 may have something to say about this. */
15176 gcc_checking_assert (TREE_PUBLIC (ns
));
15178 unsigned flags
= 0;
15179 if (TREE_PUBLIC (ns
))
15181 if (DECL_NAMESPACE_INLINE_P (ns
))
15183 if (DECL_MODULE_PURVIEW_P (ns
))
15185 if (DECL_MODULE_EXPORT_P (ns
))
15188 dump () && dump ("Writing namespace:%u %N%s%s%s%s",
15190 flags
& 1 ? ", public" : "",
15191 flags
& 2 ? ", inline" : "",
15192 flags
& 4 ? ", purview" : "",
15193 flags
& 8 ? ", export" : "");
15194 sec
.u (b
->cluster
);
15195 sec
.u (to
->name (DECL_NAME (ns
)));
15196 write_namespace (sec
, b
->deps
[0]);
15199 write_location (sec
, DECL_SOURCE_LOCATION (ns
));
15202 sec
.end (to
, to
->name (MOD_SNAME_PFX
".nms"), crc_p
);
15206 /* Read the namespace hierarchy from MOD_SNAME_PFX.namespace. Fill in
15207 SPACES from that data. */
15210 module_state::read_namespaces (unsigned num
)
15214 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".nms"))
15217 dump () && dump ("Reading namespaces");
15220 for (unsigned ix
= 0; ix
!= num
; ix
++)
15222 unsigned entity_index
= sec
.u ();
15223 unsigned name
= sec
.u ();
15225 tree parent
= read_namespace (sec
);
15227 /* See comment in write_namespace about why not bits. */
15228 unsigned flags
= sec
.u ();
15229 location_t src_loc
= read_location (sec
);
15231 if (entity_index
>= entity_num
15233 || (flags
& 0xc) == 0x8)
15234 sec
.set_overrun ();
15235 if (sec
.get_overrun ())
15238 tree id
= name
? get_identifier (from ()->name (name
)) : NULL_TREE
;
15240 dump () && dump ("Read namespace:%u %P%s%s%s%s",
15241 entity_index
, parent
, id
,
15242 flags
& 1 ? ", public" : "",
15243 flags
& 2 ? ", inline" : "",
15244 flags
& 4 ? ", purview" : "",
15245 flags
& 8 ? ", export" : "");
15246 bool visible_p
= ((flags
& 8)
15249 && (is_partition () || is_module ())));
15250 tree inner
= add_imported_namespace (parent
, id
, src_loc
, mod
,
15251 bool (flags
& 2), visible_p
);
15254 sec
.set_overrun ();
15258 if (is_partition ())
15261 DECL_MODULE_PURVIEW_P (inner
) = true;
15263 DECL_MODULE_EXPORT_P (inner
) = true;
15266 /* Install the namespace. */
15267 (*entity_ary
)[entity_lwm
+ entity_index
] = inner
;
15268 if (DECL_MODULE_IMPORT_P (inner
))
15271 unsigned *slot
= &entity_map
->get_or_insert
15272 (DECL_UID (inner
), &existed
);
15274 /* If it existed, it should match. */
15275 gcc_checking_assert (inner
== (*entity_ary
)[*slot
]);
15277 *slot
= entity_lwm
+ entity_index
;
15281 if (!sec
.end (from ()))
15286 /* Write the binding TABLE to MOD_SNAME_PFX.bnd */
15289 module_state::write_bindings (elf_out
*to
, vec
<depset
*> sccs
, unsigned *crc_p
)
15291 dump () && dump ("Writing binding table");
15295 bytes_out
sec (to
);
15298 for (unsigned ix
= 0; ix
!= sccs
.length (); ix
++)
15300 depset
*b
= sccs
[ix
];
15301 if (b
->is_binding ())
15303 tree ns
= b
->get_entity ();
15304 dump () && dump ("Bindings %P section:%u", ns
, b
->get_name (),
15306 sec
.u (to
->name (b
->get_name ()));
15307 write_namespace (sec
, b
->deps
[0]);
15308 sec
.u (b
->section
);
15313 sec
.end (to
, to
->name (MOD_SNAME_PFX
".bnd"), crc_p
);
15319 /* Read the binding table from MOD_SNAME_PFX.bind. */
15322 module_state::read_bindings (unsigned num
, unsigned lwm
, unsigned hwm
)
15326 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".bnd"))
15329 dump () && dump ("Reading binding table");
15331 for (; !sec
.get_overrun () && num
--;)
15333 const char *name
= from ()->name (sec
.u ());
15334 tree ns
= read_namespace (sec
);
15335 unsigned snum
= sec
.u ();
15337 if (!ns
|| !name
|| (snum
- lwm
) >= (hwm
- lwm
))
15338 sec
.set_overrun ();
15339 if (!sec
.get_overrun ())
15341 tree id
= get_identifier (name
);
15342 dump () && dump ("Bindings %P section:%u", ns
, id
, snum
);
15343 if (mod
&& !import_module_binding (ns
, id
, mod
, snum
))
15349 if (!sec
.end (from ()))
15354 /* Write the entity table to MOD_SNAME_PFX.ent
15356 Each entry is a section number. */
15359 module_state::write_entities (elf_out
*to
, vec
<depset
*> depsets
,
15360 unsigned count
, unsigned *crc_p
)
15362 dump () && dump ("Writing entities");
15365 bytes_out
sec (to
);
15368 unsigned current
= 0;
15369 for (unsigned ix
= 0; ix
< depsets
.length (); ix
++)
15371 depset
*d
= depsets
[ix
];
15373 switch (d
->get_entity_kind ())
15378 case depset::EK_NAMESPACE
:
15379 if (!d
->is_import () && d
->get_entity () != global_namespace
)
15381 gcc_checking_assert (d
->cluster
== current
);
15387 case depset::EK_DECL
:
15388 case depset::EK_SPECIALIZATION
:
15389 case depset::EK_PARTIAL
:
15390 gcc_checking_assert (!d
->is_unreached ()
15391 && !d
->is_import ()
15392 && d
->cluster
== current
15395 sec
.u (d
->section
);
15399 gcc_assert (count
== current
);
15400 sec
.end (to
, to
->name (MOD_SNAME_PFX
".ent"), crc_p
);
15405 module_state::read_entities (unsigned count
, unsigned lwm
, unsigned hwm
)
15407 trees_in
sec (this);
15409 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".ent"))
15412 dump () && dump ("Reading entities");
15415 for (binding_slot
*slot
= entity_ary
->begin () + entity_lwm
; count
--; slot
++)
15417 unsigned snum
= sec
.u ();
15418 if (snum
&& (snum
- lwm
) >= (hwm
- lwm
))
15419 sec
.set_overrun ();
15420 if (sec
.get_overrun ())
15424 slot
->set_lazy (snum
<< 2);
15428 if (!sec
.end (from ()))
15433 /* Write the pending table to MOD_SNAME_PFX.pnd
15435 The pending table holds information about clusters that need to be
15436 loaded because they contain information about something that is not
15437 found by namespace-scope lookup.
15439 The three cases are:
15441 (a) Template (maybe-partial) specializations that we have
15442 instantiated or defined. When an importer needs to instantiate
15443 that template, they /must have/ the partial, explicit & extern
15444 specializations available. If they have the other specializations
15445 available, they'll have less work to do. Thus, when we're about to
15446 instantiate FOO, we have to be able to ask 'are there any
15447 specialization of FOO in our imports?'.
15449 (b) (Maybe-implicit) member functions definitions. A class could
15450 be defined in one header, and an inline member defined in a
15451 different header (this occurs in the STL). Similarly, like the
15452 specialization case, an implicit member function could have been
15453 'instantiated' in one module, and it'd be nice to not have to
15454 reinstantiate it in another.
15456 (c) A member classes completed elsewhere. A member class could be
15457 declared in one header and defined in another. We need to know to
15458 load the class definition before looking in it. This turns out to
15459 be a specific case of #b, so we can treat these the same. But it
15460 does highlight an issue -- there could be an intermediate import
15461 between the outermost containing namespace-scope class and the
15462 innermost being-defined member class. This is actually possible
15463 with all of these cases, so be aware -- we're not just talking of
15464 one level of import to get to the innermost namespace.
15466 This gets complicated fast, it took me multiple attempts to even
15467 get something remotely working. Partially because I focussed on
15468 optimizing what I think turns out to be a smaller problem, given
15469 the known need to do the more general case *anyway*. I document
15470 the smaller problem, because it does appear to be the natural way
15471 to do it. It's trap!
15475 Let's refer to the primary template or the containing class as the
15476 KEY. And the specialization or member as the PENDING-ENTITY. (To
15477 avoid having to say those mouthfuls all the time.)
15479 In either case, we have an entity and we need some way of mapping
15480 that to a set of entities that need to be loaded before we can
15481 proceed with whatever processing of the entity we were going to do.
15483 We need to link the key to the pending-entity in some way. Given a
15484 key, tell me the pending-entities I need to have loaded. However
15485 we tie the key to the pending-entity must not rely on the key being
15486 loaded -- that'd defeat the lazy loading scheme.
15488 As the key will be an import in we know its entity number (either
15489 because we imported it, or we're writing it out too). Thus we can
15490 generate a map of key-indices to pending-entities. The
15491 pending-entity indices will be into our span of the entity table,
15492 and thus allow them to be lazily loaded. The key index will be
15493 into another slot of the entity table. Notice that this checking
15494 could be expensive, we don't want to iterate over a bunch of
15495 pending-entity indices (across multiple imports), every time we're
15496 about do to the thing with the key. We need to quickly determine
15497 'definitely nothing needed'.
15499 That's almost good enough, except that key indices are not unique
15500 in a couple of cases :( Specifically the Global Module or a module
15501 partition can result in multiple modules assigning an entity index
15502 for the key. The decl-merging on loading will detect that so we
15503 only have one Key loaded, and in the entity hash it'll indicate the
15504 entity index of first load. Which might be different to how we
15505 know it. Notice this is restricted to GM entities or this-module
15506 entities. Foreign imports cannot have this.
15508 We can simply resolve this in the direction of how this module
15509 referred to the key to how the importer knows it. Look in the
15510 entity table slot that we nominate, maybe lazy load it, and then
15511 lookup the resultant entity in the entity hash to learn how the
15514 But we need to go in the other direction :( Given the key, find all
15515 the index-aliases of that key. We can partially solve that by
15516 adding an alias hash table. Whenever we load a merged decl, add or
15517 augment a mapping from the entity (or its entity-index) to the
15518 newly-discovered index. Then when we look for pending entities of
15519 a key, we also iterate over this aliases this mapping provides.
15521 But that requires the alias to be loaded. And that's not
15524 *** THE SIMPLER WAY
15526 The remaining fixed thing we have is the innermost namespace
15527 containing the ultimate namespace-scope container of the key and
15528 the name of that container (which might be the key itself). I.e. a
15529 namespace-decl/identifier/module tuple. Let's call this the
15530 top-key. We'll discover that the module is not important here,
15531 because of cross-module possibilities mentioned in case #c above.
15532 We can't markup namespace-binding slots. The best we can do is
15533 mark the binding vector with 'there's something here', and have
15534 another map from namespace/identifier pairs to a vector of pending
15537 Maintain a pending-entity map. This is keyed by top-key, and
15538 maps to a vector of pending-entity indices. On the binding vector
15539 have flags saying whether the pending-name-entity map has contents.
15540 (We might want to further extend the key to be GM-vs-Partition and
15541 specialization-vs-member, but let's not get ahead of ourselves.)
15543 For every key-like entity, find the outermost namespace-scope
15544 name. Use that to lookup in the pending-entity map and then make
15545 sure the specified entities are loaded.
15547 An optimization might be to have a flag in each key-entity saying
15548 that its top key might be in the entity table. It's not clear to
15549 me how to set that flag cheaply -- cheaper than just looking.
15551 FIXME: It'd be nice to have a bit in decls to tell us whether to
15552 even try this. We can have a 'already done' flag, that we set when
15553 we've done KLASS's lazy pendings. When we import a module that
15554 registers pendings on the same top-key as KLASS we need to clear
15555 the flag. A recursive walk of the top-key clearing the bit will
15556 suffice. Plus we only need to recurse on classes that have the bit
15557 set. (That means we need to set the bit on parents of KLASS here,
15558 don't forget.) However, first: correctness, second: efficiency. */
15561 module_state::write_pendings (elf_out
*to
, vec
<depset
*> depsets
,
15562 depset::hash
&table
, unsigned *crc_p
)
15564 dump () && dump ("Writing pending-entities");
15567 trees_out
sec (to
, this, table
);
15570 unsigned count
= 0;
15571 tree cache_ns
= NULL_TREE
;
15572 tree cache_id
= NULL_TREE
;
15573 unsigned cache_section
= ~0;
15574 for (unsigned ix
= 0; ix
< depsets
.length (); ix
++)
15576 depset
*d
= depsets
[ix
];
15578 if (d
->is_binding ())
15581 if (d
->is_import ())
15584 if (!(d
->get_entity_kind () == depset::EK_SPECIALIZATION
15585 || d
->get_entity_kind () == depset::EK_PARTIAL
15586 || (d
->get_entity_kind () == depset::EK_DECL
&& d
->is_member ())))
15589 tree key_decl
= nullptr;
15590 tree key_ns
= find_pending_key (d
->get_entity (), &key_decl
);
15591 tree key_name
= DECL_NAME (key_decl
);
15593 if (IDENTIFIER_ANON_P (key_name
))
15595 gcc_checking_assert (IDENTIFIER_LAMBDA_P (key_name
));
15596 if (tree attached
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (key_decl
)))
15597 key_name
= DECL_NAME (attached
);
15600 /* There's nothing to attach it to. Must
15601 always reinstantiate. */
15603 && dump ("Unattached lambda %N[%u] section:%u",
15604 d
->get_entity_kind () == depset::EK_DECL
15605 ? "Member" : "Specialization", d
->get_entity (),
15606 d
->cluster
, d
->section
);
15611 char const *also
= "";
15612 if (d
->section
== cache_section
15613 && key_ns
== cache_ns
15614 && key_name
== cache_id
)
15615 /* Same section & key as previous, no need to repeat ourselves. */
15620 cache_id
= key_name
;
15621 cache_section
= d
->section
;
15622 gcc_checking_assert (table
.find_dependency (cache_ns
));
15623 sec
.tree_node (cache_ns
);
15624 sec
.tree_node (cache_id
);
15625 sec
.u (d
->cluster
);
15628 dump () && dump ("Pending %s %N entity:%u section:%u %skeyed to %P",
15629 d
->get_entity_kind () == depset::EK_DECL
15630 ? "member" : "specialization", d
->get_entity (),
15631 d
->cluster
, cache_section
, also
, cache_ns
, cache_id
);
15633 sec
.end (to
, to
->name (MOD_SNAME_PFX
".pnd"), crc_p
);
15640 module_state::read_pendings (unsigned count
)
15642 trees_in
sec (this);
15644 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".pnd"))
15647 dump () && dump ("Reading %u pendings", count
);
15650 for (unsigned ix
= 0; ix
!= count
; ix
++)
15655 key
.ns
= sec
.tree_node ();
15656 key
.id
= sec
.tree_node ();
15659 if (!key
.ns
|| !key
.id
15660 || !(TREE_CODE (key
.ns
) == NAMESPACE_DECL
15661 && !DECL_NAMESPACE_ALIAS (key
.ns
))
15662 || !identifier_p (key
.id
)
15663 || index
>= entity_num
)
15664 sec
.set_overrun ();
15666 if (sec
.get_overrun ())
15669 dump () && dump ("Pending:%u keyed to %P", index
, key
.ns
, key
.id
);
15671 index
+= entity_lwm
;
15672 auto &vec
= pending_table
->get_or_insert (key
);
15673 vec
.safe_push (index
);
15677 if (!sec
.end (from ()))
15682 /* Read & write locations. */
15686 LK_IMPORT_ORDINARY
,
15692 static const module_state
*
15693 module_for_ordinary_loc (location_t loc
)
15696 unsigned len
= ool
->length () - pos
;
15700 unsigned half
= len
/ 2;
15701 module_state
*probe
= (*ool
)[pos
+ half
];
15702 if (loc
< probe
->ordinary_locs
.first
)
15704 else if (loc
< probe
->ordinary_locs
.first
+ probe
->ordinary_locs
.second
)
15709 len
= len
- (half
+ 1);
15716 static const module_state
*
15717 module_for_macro_loc (location_t loc
)
15720 unsigned len
= modules
->length () - pos
;
15724 unsigned half
= len
/ 2;
15725 module_state
*probe
= (*modules
)[pos
+ half
];
15726 if (loc
< probe
->macro_locs
.first
)
15729 len
= len
- (half
+ 1);
15731 else if (loc
>= probe
->macro_locs
.first
+ probe
->macro_locs
.second
)
15741 module_state::imported_from () const
15743 location_t from
= loc
;
15744 line_map_ordinary
const *fmap
15745 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
15747 if (MAP_MODULE_P (fmap
))
15748 from
= linemap_included_from (fmap
);
15753 /* Note that LOC will need writing. This allows us to prune locations
15754 that are not needed. */
15757 module_state::note_location (location_t loc
)
15759 bool added
= false;
15760 if (!macro_loc_table
&& !ord_loc_table
)
15762 else if (loc
< RESERVED_LOCATION_COUNT
)
15764 else if (IS_ADHOC_LOC (loc
))
15766 location_t locus
= get_location_from_adhoc_loc (line_table
, loc
);
15767 note_location (locus
);
15768 source_range range
= get_range_from_loc (line_table
, loc
);
15769 if (range
.m_start
!= locus
)
15770 note_location (range
.m_start
);
15771 note_location (range
.m_finish
);
15773 else if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
))
15775 if (spans
.macro (loc
))
15777 const line_map
*map
= linemap_lookup (line_table
, loc
);
15778 const line_map_macro
*mac_map
= linemap_check_macro (map
);
15779 hashval_t hv
= macro_loc_traits::hash (mac_map
);
15780 macro_loc_info
*slot
15781 = macro_loc_table
->find_slot_with_hash (mac_map
, hv
, INSERT
);
15784 slot
->src
= mac_map
;
15786 // Expansion locations could themselves be from a
15787 // macro, we need to note them all.
15788 note_location (mac_map
->m_expansion
);
15789 gcc_checking_assert (mac_map
->n_tokens
);
15790 location_t tloc
= UNKNOWN_LOCATION
;
15791 for (unsigned ix
= mac_map
->n_tokens
* 2; ix
--;)
15792 if (mac_map
->macro_locations
[ix
] != tloc
)
15794 tloc
= mac_map
->macro_locations
[ix
];
15795 note_location (tloc
);
15801 else if (IS_ORDINARY_LOC (loc
))
15803 if (spans
.ordinary (loc
))
15805 const line_map
*map
= linemap_lookup (line_table
, loc
);
15806 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
15808 lkup
.src
= ord_map
;
15809 lkup
.span
= 1 << ord_map
->m_column_and_range_bits
;
15810 lkup
.offset
= (loc
- MAP_START_LOCATION (ord_map
)) & ~(lkup
.span
- 1);
15812 ord_loc_info
*slot
= (ord_loc_table
->find_slot_with_hash
15813 (lkup
, ord_loc_traits::hash (lkup
), INSERT
));
15822 gcc_unreachable ();
15826 /* If we're not streaming, record that we need location LOC.
15827 Otherwise stream it. */
15830 module_state::write_location (bytes_out
&sec
, location_t loc
)
15832 if (!sec
.streaming_p ())
15834 note_location (loc
);
15838 if (loc
< RESERVED_LOCATION_COUNT
)
15840 dump (dumper::LOCATION
) && dump ("Reserved location %u", unsigned (loc
));
15841 sec
.u (LK_RESERVED
+ loc
);
15843 else if (IS_ADHOC_LOC (loc
))
15845 dump (dumper::LOCATION
) && dump ("Adhoc location");
15847 location_t locus
= get_location_from_adhoc_loc (line_table
, loc
);
15848 write_location (sec
, locus
);
15849 source_range range
= get_range_from_loc (line_table
, loc
);
15850 if (range
.m_start
== locus
)
15852 range
.m_start
= UNKNOWN_LOCATION
;
15853 write_location (sec
, range
.m_start
);
15854 write_location (sec
, range
.m_finish
);
15855 unsigned discriminator
= get_discriminator_from_adhoc_loc (line_table
, loc
);
15856 sec
.u (discriminator
);
15858 else if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
))
15860 const macro_loc_info
*info
= nullptr;
15861 unsigned offset
= 0;
15862 if (unsigned hwm
= macro_loc_remap
->length ())
15864 info
= macro_loc_remap
->begin ();
15867 unsigned mid
= hwm
/ 2;
15868 if (MAP_START_LOCATION (info
[mid
].src
) <= loc
)
15876 offset
= loc
- MAP_START_LOCATION (info
->src
);
15877 if (offset
> info
->src
->n_tokens
)
15881 gcc_checking_assert (bool (info
) == bool (spans
.macro (loc
)));
15885 offset
+= info
->remap
;
15888 dump (dumper::LOCATION
)
15889 && dump ("Macro location %u output %u", loc
, offset
);
15891 else if (const module_state
*import
= module_for_macro_loc (loc
))
15893 unsigned off
= loc
- import
->macro_locs
.first
;
15894 sec
.u (LK_IMPORT_MACRO
);
15895 sec
.u (import
->remap
);
15897 dump (dumper::LOCATION
)
15898 && dump ("Imported macro location %u output %u:%u",
15899 loc
, import
->remap
, off
);
15902 gcc_unreachable ();
15904 else if (IS_ORDINARY_LOC (loc
))
15906 const ord_loc_info
*info
= nullptr;
15907 unsigned offset
= 0;
15908 if (unsigned hwm
= ord_loc_remap
->length ())
15910 info
= ord_loc_remap
->begin ();
15913 unsigned mid
= hwm
/ 2;
15914 if (MAP_START_LOCATION (info
[mid
].src
) + info
[mid
].offset
<= loc
)
15922 offset
= loc
- MAP_START_LOCATION (info
->src
) - info
->offset
;
15923 if (offset
> info
->span
)
15927 gcc_checking_assert (bool (info
) == bool (spans
.ordinary (loc
)));
15931 offset
+= info
->remap
;
15932 sec
.u (LK_ORDINARY
);
15935 dump (dumper::LOCATION
)
15936 && dump ("Ordinary location %u output %u", loc
, offset
);
15938 else if (const module_state
*import
= module_for_ordinary_loc (loc
))
15940 unsigned off
= loc
- import
->ordinary_locs
.first
;
15941 sec
.u (LK_IMPORT_ORDINARY
);
15942 sec
.u (import
->remap
);
15944 dump (dumper::LOCATION
)
15945 && dump ("Imported ordinary location %u output %u:%u",
15946 import
->remap
, import
->remap
, off
);
15949 gcc_unreachable ();
15952 gcc_unreachable ();
15956 module_state::read_location (bytes_in
&sec
) const
15958 location_t locus
= UNKNOWN_LOCATION
;
15959 unsigned kind
= sec
.u ();
15964 if (kind
< LK_RESERVED
+ RESERVED_LOCATION_COUNT
)
15965 locus
= location_t (kind
- LK_RESERVED
);
15967 sec
.set_overrun ();
15968 dump (dumper::LOCATION
)
15969 && dump ("Reserved location %u", unsigned (locus
));
15975 dump (dumper::LOCATION
) && dump ("Adhoc location");
15976 locus
= read_location (sec
);
15977 source_range range
;
15978 range
.m_start
= read_location (sec
);
15979 if (range
.m_start
== UNKNOWN_LOCATION
)
15980 range
.m_start
= locus
;
15981 range
.m_finish
= read_location (sec
);
15982 unsigned discriminator
= sec
.u ();
15983 if (locus
!= loc
&& range
.m_start
!= loc
&& range
.m_finish
!= loc
)
15984 locus
= line_table
->get_or_create_combined_loc (locus
, range
,
15985 nullptr, discriminator
);
15991 unsigned off
= sec
.u ();
15993 if (macro_locs
.second
)
15995 if (off
< macro_locs
.second
)
15996 locus
= off
+ macro_locs
.first
;
15998 sec
.set_overrun ();
16002 dump (dumper::LOCATION
)
16003 && dump ("Macro %u becoming %u", off
, locus
);
16009 unsigned off
= sec
.u ();
16010 if (ordinary_locs
.second
)
16012 if (off
< ordinary_locs
.second
)
16013 locus
= off
+ ordinary_locs
.first
;
16015 sec
.set_overrun ();
16020 dump (dumper::LOCATION
)
16021 && dump ("Ordinary location %u becoming %u", off
, locus
);
16025 case LK_IMPORT_MACRO
:
16026 case LK_IMPORT_ORDINARY
:
16028 unsigned mod
= sec
.u ();
16029 unsigned off
= sec
.u ();
16030 const module_state
*import
= NULL
;
16032 if (!mod
&& !slurp
->remap
)
16033 /* This is an early read of a partition location during the
16034 read of our ordinary location map. */
16038 mod
= slurp
->remap_module (mod
);
16040 sec
.set_overrun ();
16042 import
= (*modules
)[mod
];
16047 if (kind
== LK_IMPORT_MACRO
)
16049 if (!import
->macro_locs
.second
)
16050 locus
= import
->loc
;
16051 else if (off
< import
->macro_locs
.second
)
16052 locus
= off
+ import
->macro_locs
.first
;
16054 sec
.set_overrun ();
16058 if (!import
->ordinary_locs
.second
)
16059 locus
= import
->loc
;
16060 else if (off
< import
->ordinary_locs
.second
)
16061 locus
= import
->ordinary_locs
.first
+ off
;
16063 sec
.set_overrun ();
16073 /* Allocate hash tables to record needed locations. */
16076 module_state::write_init_maps ()
16078 macro_loc_table
= new hash_table
<macro_loc_traits
> (EXPERIMENT (1, 400));
16079 ord_loc_table
= new hash_table
<ord_loc_traits
> (EXPERIMENT (1, 400));
16082 /* Prepare the span adjustments. We prune unneeded locations -- at
16083 this point every needed location must have been seen by
16087 module_state::write_prepare_maps (module_state_config
*cfg
, bool has_partitions
)
16089 dump () && dump ("Preparing locations");
16092 dump () && dump ("Reserved locations [%u,%u) macro [%u,%u)",
16093 spans
[loc_spans::SPAN_RESERVED
].ordinary
.first
,
16094 spans
[loc_spans::SPAN_RESERVED
].ordinary
.second
,
16095 spans
[loc_spans::SPAN_RESERVED
].macro
.first
,
16096 spans
[loc_spans::SPAN_RESERVED
].macro
.second
);
16098 range_t info
{0, 0};
16100 // Sort the noted lines.
16101 vec_alloc (ord_loc_remap
, ord_loc_table
->size ());
16102 for (auto iter
= ord_loc_table
->begin (), end
= ord_loc_table
->end ();
16103 iter
!= end
; ++iter
)
16104 ord_loc_remap
->quick_push (*iter
);
16105 ord_loc_remap
->qsort (&ord_loc_info::compare
);
16107 // Note included-from maps.
16108 bool added
= false;
16109 const line_map_ordinary
*current
= nullptr;
16110 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16111 iter
!= end
; ++iter
)
16112 if (iter
->src
!= current
)
16114 current
= iter
->src
;
16115 for (auto probe
= current
;
16116 auto from
= linemap_included_from (probe
);
16117 probe
= linemap_check_ordinary (linemap_lookup (line_table
, from
)))
16119 if (has_partitions
)
16121 // Partition locations need to elide their module map
16124 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
16125 if (MAP_MODULE_P (probe
))
16126 from
= linemap_included_from (probe
);
16129 if (!note_location (from
))
16136 // Reconstruct the line array as we added items to the hash table.
16137 vec_free (ord_loc_remap
);
16138 vec_alloc (ord_loc_remap
, ord_loc_table
->size ());
16139 for (auto iter
= ord_loc_table
->begin (), end
= ord_loc_table
->end ();
16140 iter
!= end
; ++iter
)
16141 ord_loc_remap
->quick_push (*iter
);
16142 ord_loc_remap
->qsort (&ord_loc_info::compare
);
16144 delete ord_loc_table
;
16145 ord_loc_table
= nullptr;
16147 // Merge (sufficiently) adjacent spans, and calculate remapping.
16148 constexpr unsigned adjacency
= 2; // Allow 2 missing lines.
16149 auto begin
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16151 unsigned offset
= 0, range_bits
= 0;
16152 ord_loc_info
*base
= nullptr;
16153 for (auto iter
= begin
; iter
!= end
; ++iter
)
16155 if (base
&& iter
->src
== base
->src
)
16157 if (base
->offset
+ base
->span
+
16158 ((adjacency
<< base
->src
->m_column_and_range_bits
)
16159 // If there are few c&r bits, allow further separation.
16160 | (adjacency
<< 4))
16164 offset
-= base
->span
;
16165 base
->span
= iter
->offset
+ iter
->span
- base
->offset
;
16166 offset
+= base
->span
;
16170 else if (range_bits
< iter
->src
->m_range_bits
)
16171 range_bits
= iter
->src
->m_range_bits
;
16173 offset
+= ((1u << iter
->src
->m_range_bits
) - 1);
16174 offset
&= ~((1u << iter
->src
->m_range_bits
) - 1);
16175 iter
->remap
= offset
;
16176 offset
+= iter
->span
;
16180 ord_loc_remap
->truncate (dst
- begin
);
16182 info
.first
= ord_loc_remap
->length ();
16183 cfg
->ordinary_locs
= offset
;
16184 cfg
->loc_range_bits
= range_bits
;
16185 dump () && dump ("Ordinary maps:%u locs:%u range_bits:%u",
16186 info
.first
, cfg
->ordinary_locs
,
16187 cfg
->loc_range_bits
);
16189 // Remap the macro locations.
16190 vec_alloc (macro_loc_remap
, macro_loc_table
->size ());
16191 for (auto iter
= macro_loc_table
->begin (), end
= macro_loc_table
->end ();
16192 iter
!= end
; ++iter
)
16193 macro_loc_remap
->quick_push (*iter
);
16194 delete macro_loc_table
;
16195 macro_loc_table
= nullptr;
16197 macro_loc_remap
->qsort (¯o_loc_info::compare
);
16199 for (auto iter
= macro_loc_remap
->begin (), end
= macro_loc_remap
->end ();
16200 iter
!= end
; ++iter
)
16202 auto mac
= iter
->src
;
16203 iter
->remap
= offset
;
16204 offset
+= mac
->n_tokens
;
16206 info
.second
= macro_loc_remap
->length ();
16207 cfg
->macro_locs
= offset
;
16209 dump () && dump ("Macro maps:%u locs:%u", info
.second
, cfg
->macro_locs
);
16213 // If we have no ordinary locs, we must also have no macro locs.
16214 gcc_checking_assert (cfg
->ordinary_locs
|| !cfg
->macro_locs
);
16220 module_state::read_prepare_maps (const module_state_config
*cfg
)
16222 location_t ordinary
= line_table
->highest_location
+ 1;
16223 ordinary
+= cfg
->ordinary_locs
;
16225 location_t macro
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
16226 macro
-= cfg
->macro_locs
;
16228 if (ordinary
< LINE_MAP_MAX_LOCATION_WITH_COLS
16229 && macro
>= LINE_MAP_MAX_LOCATION
)
16230 /* OK, we have enough locations. */
16233 ordinary_locs
.first
= ordinary_locs
.second
= 0;
16234 macro_locs
.first
= macro_locs
.second
= 0;
16236 static bool informed
= false;
16239 /* Just give the notice once. */
16241 inform (loc
, "unable to represent further imported source locations");
16247 /* Write & read the location maps. Not called if there are no
16251 module_state::write_ordinary_maps (elf_out
*to
, range_t
&info
,
16252 bool has_partitions
, unsigned *crc_p
)
16254 dump () && dump ("Writing ordinary location maps");
16257 vec
<const char *> filenames
;
16258 filenames
.create (20);
16260 /* Determine the unique filenames. */
16261 const line_map_ordinary
*current
= nullptr;
16262 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16263 iter
!= end
; ++iter
)
16264 if (iter
->src
!= current
)
16266 current
= iter
->src
;
16267 const char *fname
= ORDINARY_MAP_FILE_NAME (iter
->src
);
16269 /* We should never find a module linemap in an interval. */
16270 gcc_checking_assert (!MAP_MODULE_P (iter
->src
));
16272 /* We expect very few filenames, so just an array.
16273 (Not true when headers are still in play :() */
16274 for (unsigned jx
= filenames
.length (); jx
--;)
16276 const char *name
= filenames
[jx
];
16277 if (0 == strcmp (name
, fname
))
16279 /* Reset the linemap's name, because for things like
16280 preprocessed input we could have multiple instances
16281 of the same name, and we'd rather not percolate
16283 const_cast<line_map_ordinary
*> (iter
->src
)->to_file
= name
;
16289 filenames
.safe_push (fname
);
16292 bytes_out
sec (to
);
16295 /* Write the filenames. */
16296 unsigned len
= filenames
.length ();
16298 dump () && dump ("%u source file names", len
);
16299 for (unsigned ix
= 0; ix
!= len
; ix
++)
16301 const char *fname
= filenames
[ix
];
16302 dump (dumper::LOCATION
) && dump ("Source file[%u]=%s", ix
, fname
);
16306 sec
.u (info
.first
); /* Num maps. */
16307 const ord_loc_info
*base
= nullptr;
16308 for (auto iter
= ord_loc_remap
->begin (), end
= ord_loc_remap
->end ();
16309 iter
!= end
; ++iter
)
16311 dump (dumper::LOCATION
)
16312 && dump ("Span:%u ordinary [%u+%u,+%u)->[%u,+%u)",
16313 iter
- ord_loc_remap
->begin (),
16314 MAP_START_LOCATION (iter
->src
), iter
->offset
, iter
->span
,
16315 iter
->remap
, iter
->span
);
16317 if (!base
|| iter
->src
!= base
->src
)
16319 sec
.u (iter
->offset
- base
->offset
);
16322 sec
.u (iter
->src
->sysp
);
16323 sec
.u (iter
->src
->m_range_bits
);
16324 sec
.u (iter
->src
->m_column_and_range_bits
- iter
->src
->m_range_bits
);
16326 const char *fname
= ORDINARY_MAP_FILE_NAME (iter
->src
);
16327 for (unsigned ix
= 0; ix
!= filenames
.length (); ix
++)
16328 if (filenames
[ix
] == fname
)
16333 unsigned line
= ORDINARY_MAP_STARTING_LINE_NUMBER (iter
->src
);
16334 line
+= iter
->offset
>> iter
->src
->m_column_and_range_bits
;
16337 sec
.u (iter
->remap
);
16340 /* Write the included from location, which means reading it
16341 while reading in the ordinary maps. So we'd better not
16342 be getting ahead of ourselves. */
16343 location_t from
= linemap_included_from (iter
->src
);
16344 gcc_checking_assert (from
< MAP_START_LOCATION (iter
->src
));
16345 if (from
!= UNKNOWN_LOCATION
&& has_partitions
)
16347 /* A partition's span will have a from pointing at a
16348 MODULE_INC. Find that map's from. */
16349 line_map_ordinary
const *fmap
16350 = linemap_check_ordinary (linemap_lookup (line_table
, from
));
16351 if (MAP_MODULE_P (fmap
))
16352 from
= linemap_included_from (fmap
);
16354 write_location (sec
, from
);
16358 filenames
.release ();
16360 sec
.end (to
, to
->name (MOD_SNAME_PFX
".olm"), crc_p
);
16365 module_state::write_macro_maps (elf_out
*to
, range_t
&info
, unsigned *crc_p
)
16367 dump () && dump ("Writing macro location maps");
16370 bytes_out
sec (to
);
16373 dump () && dump ("Macro maps:%u", info
.second
);
16374 sec
.u (info
.second
);
16376 unsigned macro_num
= 0;
16377 for (auto iter
= macro_loc_remap
->end (), begin
= macro_loc_remap
->begin ();
16380 auto mac
= iter
->src
;
16381 sec
.u (iter
->remap
);
16382 sec
.u (mac
->n_tokens
);
16383 sec
.cpp_node (mac
->macro
);
16384 write_location (sec
, mac
->m_expansion
);
16385 const location_t
*locs
= mac
->macro_locations
;
16386 /* There are lots of identical runs. */
16387 location_t prev
= UNKNOWN_LOCATION
;
16388 unsigned count
= 0;
16390 for (unsigned jx
= mac
->n_tokens
* 2; jx
--;)
16392 location_t tok_loc
= locs
[jx
];
16393 if (tok_loc
== prev
)
16402 write_location (sec
, tok_loc
);
16405 dump (dumper::LOCATION
)
16406 && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)->%u",
16407 macro_num
, identifier (mac
->macro
),
16408 runs
, mac
->n_tokens
,
16409 MAP_START_LOCATION (mac
),
16410 MAP_START_LOCATION (mac
) + mac
->n_tokens
,
16414 gcc_assert (macro_num
== info
.second
);
16416 sec
.end (to
, to
->name (MOD_SNAME_PFX
".mlm"), crc_p
);
16421 module_state::read_ordinary_maps (unsigned num_ord_locs
, unsigned range_bits
)
16425 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".olm"))
16427 dump () && dump ("Reading ordinary location maps");
16430 /* Read the filename table. */
16431 unsigned len
= sec
.u ();
16432 dump () && dump ("%u source file names", len
);
16433 vec
<const char *> filenames
;
16434 filenames
.create (len
);
16435 for (unsigned ix
= 0; ix
!= len
; ix
++)
16438 const char *buf
= sec
.str (&l
);
16439 char *fname
= XNEWVEC (char, l
+ 1);
16440 memcpy (fname
, buf
, l
+ 1);
16441 dump (dumper::LOCATION
) && dump ("Source file[%u]=%s", ix
, fname
);
16442 /* We leak these names into the line-map table. But it
16443 doesn't own them. */
16444 filenames
.quick_push (fname
);
16447 unsigned num_ordinary
= sec
.u ();
16448 dump () && dump ("Ordinary maps:%u, range_bits:%u", num_ordinary
, range_bits
);
16450 location_t offset
= line_table
->highest_location
+ 1;
16451 offset
+= ((1u << range_bits
) - 1);
16452 offset
&= ~((1u << range_bits
) - 1);
16453 ordinary_locs
.first
= offset
;
16455 bool propagated
= spans
.maybe_propagate (this, offset
);
16456 line_map_ordinary
*maps
= static_cast<line_map_ordinary
*>
16457 (line_map_new_raw (line_table
, false, num_ordinary
));
16459 const line_map_ordinary
*base
= nullptr;
16460 for (unsigned ix
= 0; ix
!= num_ordinary
&& !sec
.get_overrun (); ix
++)
16462 line_map_ordinary
*map
= &maps
[ix
];
16464 unsigned offset
= sec
.u ();
16467 map
->reason
= LC_RENAME
;
16468 map
->sysp
= sec
.u ();
16469 map
->m_range_bits
= sec
.u ();
16470 map
->m_column_and_range_bits
= sec
.u () + map
->m_range_bits
;
16471 unsigned fnum
= sec
.u ();
16472 map
->to_file
= (fnum
< filenames
.length () ? filenames
[fnum
] : "");
16473 map
->to_line
= sec
.u ();
16479 map
->to_line
+= offset
>> map
->m_column_and_range_bits
;
16481 unsigned remap
= sec
.u ();
16482 map
->start_location
= remap
+ ordinary_locs
.first
;
16485 /* Root the outermost map at our location. */
16486 ordinary_locs
.second
= remap
;
16487 location_t from
= read_location (sec
);
16488 map
->included_from
= from
!= UNKNOWN_LOCATION
? from
: loc
;
16492 ordinary_locs
.second
= num_ord_locs
;
16493 /* highest_location is the one handed out, not the next one to
16495 line_table
->highest_location
= ordinary_locs
.first
+ ordinary_locs
.second
- 1;
16497 if (line_table
->highest_location
>= LINE_MAP_MAX_LOCATION_WITH_COLS
)
16498 /* We shouldn't run out of locations, as we checked before
16500 sec
.set_overrun ();
16501 dump () && dump ("Ordinary location [%u,+%u)",
16502 ordinary_locs
.first
, ordinary_locs
.second
);
16507 filenames
.release ();
16510 if (!sec
.end (from ()))
16517 module_state::read_macro_maps (unsigned num_macro_locs
)
16521 if (!sec
.begin (loc
, from (), MOD_SNAME_PFX
".mlm"))
16523 dump () && dump ("Reading macro location maps");
16526 unsigned num_macros
= sec
.u ();
16527 dump () && dump ("Macro maps:%u locs:%u", num_macros
, num_macro_locs
);
16529 bool propagated
= spans
.maybe_propagate (this,
16530 line_table
->highest_location
+ 1);
16532 location_t offset
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
16533 macro_locs
.second
= num_macro_locs
;
16534 macro_locs
.first
= offset
- num_macro_locs
;
16536 dump () && dump ("Macro loc delta %d", offset
);
16537 dump () && dump ("Macro locations [%u,%u)",
16538 macro_locs
.first
, macro_locs
.second
);
16540 for (unsigned ix
= 0; ix
!= num_macros
&& !sec
.get_overrun (); ix
++)
16542 unsigned offset
= sec
.u ();
16543 unsigned n_tokens
= sec
.u ();
16544 cpp_hashnode
*node
= sec
.cpp_node ();
16545 location_t exp_loc
= read_location (sec
);
16547 const line_map_macro
*macro
16548 = linemap_enter_macro (line_table
, node
, exp_loc
, n_tokens
);
16550 /* We shouldn't run out of locations, as we checked that we
16551 had enough before starting. */
16553 gcc_checking_assert (MAP_START_LOCATION (macro
)
16554 == offset
+ macro_locs
.first
);
16556 location_t
*locs
= macro
->macro_locations
;
16557 location_t tok_loc
= UNKNOWN_LOCATION
;
16558 unsigned count
= sec
.u ();
16560 for (unsigned jx
= macro
->n_tokens
* 2; jx
-- && !sec
.get_overrun ();)
16562 while (!count
-- && !sec
.get_overrun ())
16565 tok_loc
= read_location (sec
);
16568 locs
[jx
] = tok_loc
;
16571 sec
.set_overrun ();
16572 dump (dumper::LOCATION
)
16573 && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)",
16574 ix
, identifier (node
), runs
, n_tokens
,
16575 MAP_START_LOCATION (macro
),
16576 MAP_START_LOCATION (macro
) + n_tokens
);
16579 dump () && dump ("Macro location lwm:%u", macro_locs
.first
);
16584 if (!sec
.end (from ()))
16590 /* Serialize the definition of MACRO. */
16593 module_state::write_define (bytes_out
&sec
, const cpp_macro
*macro
)
16595 sec
.u (macro
->count
);
16597 sec
.b (macro
->fun_like
);
16598 sec
.b (macro
->variadic
);
16599 sec
.b (macro
->syshdr
);
16602 write_location (sec
, macro
->line
);
16603 if (macro
->fun_like
)
16605 sec
.u (macro
->paramc
);
16606 const cpp_hashnode
*const *parms
= macro
->parm
.params
;
16607 for (unsigned ix
= 0; ix
!= macro
->paramc
; ix
++)
16608 sec
.cpp_node (parms
[ix
]);
16612 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
16614 const cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16615 write_location (sec
, token
->src_loc
);
16616 sec
.u (token
->type
);
16617 sec
.u (token
->flags
);
16618 switch (cpp_token_val_index (token
))
16621 gcc_unreachable ();
16623 case CPP_TOKEN_FLD_ARG_NO
:
16624 /* An argument reference. */
16625 sec
.u (token
->val
.macro_arg
.arg_no
);
16626 sec
.cpp_node (token
->val
.macro_arg
.spelling
);
16629 case CPP_TOKEN_FLD_NODE
:
16630 /* An identifier. */
16631 sec
.cpp_node (token
->val
.node
.node
);
16632 if (token
->val
.node
.spelling
== token
->val
.node
.node
)
16633 /* The spelling will usually be the same. so optimize
16637 sec
.cpp_node (token
->val
.node
.spelling
);
16640 case CPP_TOKEN_FLD_NONE
:
16643 case CPP_TOKEN_FLD_STR
:
16644 /* A string, number or comment. Not always NUL terminated,
16645 we stream out in a single contatenation with embedded
16646 NULs as that's a safe default. */
16647 len
+= token
->val
.str
.len
+ 1;
16648 sec
.u (token
->val
.str
.len
);
16651 case CPP_TOKEN_FLD_SOURCE
:
16652 case CPP_TOKEN_FLD_TOKEN_NO
:
16653 case CPP_TOKEN_FLD_PRAGMA
:
16654 /* These do not occur inside a macro itself. */
16655 gcc_unreachable ();
16661 char *ptr
= reinterpret_cast<char *> (sec
.buf (len
));
16663 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
16665 const cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16666 if (cpp_token_val_index (token
) == CPP_TOKEN_FLD_STR
)
16668 memcpy (ptr
+ len
, token
->val
.str
.text
,
16669 token
->val
.str
.len
);
16670 len
+= token
->val
.str
.len
;
16677 /* Read a macro definition. */
16680 module_state::read_define (bytes_in
&sec
, cpp_reader
*reader
) const
16682 unsigned count
= sec
.u ();
16683 /* We rely on knowing cpp_reader's hash table is ident_hash, and
16684 its subobject allocator is stringpool_ggc_alloc and that is just
16685 a wrapper for ggc_alloc_atomic. */
16687 = (cpp_macro
*)ggc_alloc_atomic (sizeof (cpp_macro
)
16688 + sizeof (cpp_token
) * (count
- !!count
));
16689 memset (macro
, 0, sizeof (cpp_macro
) + sizeof (cpp_token
) * (count
- !!count
));
16691 macro
->count
= count
;
16692 macro
->kind
= cmk_macro
;
16693 macro
->imported_p
= true;
16695 macro
->fun_like
= sec
.b ();
16696 macro
->variadic
= sec
.b ();
16697 macro
->syshdr
= sec
.b ();
16700 macro
->line
= read_location (sec
);
16702 if (macro
->fun_like
)
16704 unsigned paramc
= sec
.u ();
16705 cpp_hashnode
**params
16706 = (cpp_hashnode
**)ggc_alloc_atomic (sizeof (cpp_hashnode
*) * paramc
);
16707 macro
->paramc
= paramc
;
16708 macro
->parm
.params
= params
;
16709 for (unsigned ix
= 0; ix
!= paramc
; ix
++)
16710 params
[ix
] = sec
.cpp_node ();
16714 for (unsigned ix
= 0; ix
!= count
&& !sec
.get_overrun (); ix
++)
16716 cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16717 token
->src_loc
= read_location (sec
);
16718 token
->type
= cpp_ttype (sec
.u ());
16719 token
->flags
= sec
.u ();
16720 switch (cpp_token_val_index (token
))
16723 sec
.set_overrun ();
16726 case CPP_TOKEN_FLD_ARG_NO
:
16727 /* An argument reference. */
16729 unsigned arg_no
= sec
.u ();
16730 if (arg_no
- 1 >= macro
->paramc
)
16731 sec
.set_overrun ();
16732 token
->val
.macro_arg
.arg_no
= arg_no
;
16733 token
->val
.macro_arg
.spelling
= sec
.cpp_node ();
16737 case CPP_TOKEN_FLD_NODE
:
16738 /* An identifier. */
16739 token
->val
.node
.node
= sec
.cpp_node ();
16740 token
->val
.node
.spelling
= sec
.cpp_node ();
16741 if (!token
->val
.node
.spelling
)
16742 token
->val
.node
.spelling
= token
->val
.node
.node
;
16745 case CPP_TOKEN_FLD_NONE
:
16748 case CPP_TOKEN_FLD_STR
:
16749 /* A string, number or comment. */
16750 token
->val
.str
.len
= sec
.u ();
16751 len
+= token
->val
.str
.len
+ 1;
16757 if (const char *ptr
= reinterpret_cast<const char *> (sec
.buf (len
)))
16759 /* There should be a final NUL. */
16761 sec
.set_overrun ();
16762 /* cpp_alloc_token_string will add a final NUL. */
16763 const unsigned char *buf
16764 = cpp_alloc_token_string (reader
, (const unsigned char *)ptr
, len
- 1);
16766 for (unsigned ix
= 0; ix
!= count
&& !sec
.get_overrun (); ix
++)
16768 cpp_token
*token
= ¯o
->exp
.tokens
[ix
];
16769 if (cpp_token_val_index (token
) == CPP_TOKEN_FLD_STR
)
16771 token
->val
.str
.text
= buf
+ len
;
16772 len
+= token
->val
.str
.len
;
16774 sec
.set_overrun ();
16779 if (sec
.get_overrun ())
16784 /* Exported macro data. */
16785 struct GTY(()) macro_export
{
16787 location_t undef_loc
;
16790 :def (NULL
), undef_loc (UNKNOWN_LOCATION
)
16795 /* Imported macro data. */
16796 class macro_import
{
16799 #if defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8
16802 /* We need to ensure we don't use the LSB for representation, as
16803 that's the union discriminator below. */
16806 #if !(defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8)
16819 /* Not a regular ctor, because we put it in a union, and that's
16820 not allowed in C++ 98. */
16821 static slot
ctor (unsigned module
, unsigned defness
)
16823 gcc_checking_assert (defness
);
16825 s
.bits
= defness
| (module
<< L_MODULE_SHIFT
);
16831 unsigned get_defness () const
16833 return bits
& L_BOTH
;
16835 unsigned get_module () const
16837 return bits
>> L_MODULE_SHIFT
;
16839 void become_undef ()
16841 bits
&= ~unsigned (L_DEF
);
16842 bits
|= unsigned (L_UNDEF
);
16847 typedef vec
<slot
, va_heap
, vl_embed
> ary_t
;
16849 /* Discriminated by bits 0|1 != 0. The expected case is that
16850 there will be exactly one slot per macro, hence the effort of
16863 bool single_p () const
16865 return u
.single
.bits
& slot::L_BOTH
;
16867 bool occupied_p () const
16869 return u
.ary
!= NULL
;
16873 unsigned length () const
16875 gcc_checking_assert (occupied_p ());
16876 return single_p () ? 1 : u
.ary
->length ();
16878 slot
&operator[] (unsigned ix
)
16880 gcc_checking_assert (occupied_p ());
16883 gcc_checking_assert (!ix
);
16887 return (*u
.ary
)[ix
];
16892 slot
&append (unsigned module
, unsigned defness
);
16895 /* O is a new import to append to the list for. If we're an empty
16896 set, initialize us. */
16898 macro_import::slot
&
16899 macro_import::append (unsigned module
, unsigned defness
)
16901 if (!occupied_p ())
16903 u
.single
= slot::ctor (module
, defness
);
16908 bool single
= single_p ();
16909 ary_t
*m
= single
? NULL
: u
.ary
;
16910 vec_safe_reserve (m
, 1 + single
);
16912 m
->quick_push (u
.single
);
16914 return *u
.ary
->quick_push (slot::ctor (module
, defness
));
16918 /* We're going to export something. Make sure the first import slot
16921 macro_import::slot
&
16922 macro_import::exported ()
16924 if (occupied_p () && !(*this)[0].get_module ())
16926 slot
&res
= (*this)[0];
16927 res
.bits
|= slot::L_DEF
;
16931 slot
*a
= &append (0, slot::L_DEF
);
16934 slot
&f
= (*this)[0];
16941 /* The import (&exported) macros. cpp_hasnode's deferred field
16942 indexes this array (offset by 1, so zero means 'not present'. */
16944 static vec
<macro_import
, va_heap
, vl_embed
> *macro_imports
;
16946 /* The exported macros. A macro_import slot's zeroth element's offset
16947 indexes this array. If the zeroth slot is not for module zero,
16948 there is no export. */
16950 static GTY(()) vec
<macro_export
, va_gc
> *macro_exports
;
16952 /* The reachable set of header imports from this TU. */
16954 static GTY(()) bitmap headers
;
16956 /* Get the (possibly empty) macro imports for NODE. */
16958 static macro_import
&
16959 get_macro_imports (cpp_hashnode
*node
)
16961 if (node
->deferred
)
16962 return (*macro_imports
)[node
->deferred
- 1];
16964 vec_safe_reserve (macro_imports
, 1);
16965 node
->deferred
= macro_imports
->length () + 1;
16966 return *vec_safe_push (macro_imports
, macro_import ());
16969 /* Get the macro export for export EXP of NODE. */
16971 static macro_export
&
16972 get_macro_export (macro_import::slot
&slot
)
16974 if (slot
.offset
>= 0)
16975 return (*macro_exports
)[slot
.offset
];
16977 vec_safe_reserve (macro_exports
, 1);
16978 slot
.offset
= macro_exports
->length ();
16979 return *macro_exports
->quick_push (macro_export ());
16982 /* If NODE is an exportable macro, add it to the export set. */
16985 maybe_add_macro (cpp_reader
*, cpp_hashnode
*node
, void *data_
)
16987 bool exporting
= false;
16989 if (cpp_user_macro_p (node
))
16990 if (cpp_macro
*macro
= node
->value
.macro
)
16991 /* Ignore imported, builtins, command line and forced header macros. */
16992 if (!macro
->imported_p
16993 && !macro
->lazy
&& macro
->line
>= spans
.main_start ())
16995 gcc_checking_assert (macro
->kind
== cmk_macro
);
16996 /* I don't want to deal with this corner case, that I suspect is
16997 a devil's advocate reading of the standard. */
16998 gcc_checking_assert (!macro
->extra_tokens
);
17000 macro_import::slot
&slot
= get_macro_imports (node
).exported ();
17001 macro_export
&exp
= get_macro_export (slot
);
17006 if (!exporting
&& node
->deferred
)
17008 macro_import
&imports
= (*macro_imports
)[node
->deferred
- 1];
17009 macro_import::slot
&slot
= imports
[0];
17010 if (!slot
.get_module ())
17012 gcc_checking_assert (slot
.get_defness ());
17018 static_cast<vec
<cpp_hashnode
*> *> (data_
)->safe_push (node
);
17020 return 1; /* Don't stop. */
17023 /* Order cpp_hashnodes A_ and B_ by their exported macro locations. */
17026 macro_loc_cmp (const void *a_
, const void *b_
)
17028 const cpp_hashnode
*node_a
= *(const cpp_hashnode
*const *)a_
;
17029 macro_import
&import_a
= (*macro_imports
)[node_a
->deferred
- 1];
17030 const macro_export
&export_a
= (*macro_exports
)[import_a
[0].offset
];
17031 location_t loc_a
= export_a
.def
? export_a
.def
->line
: export_a
.undef_loc
;
17033 const cpp_hashnode
*node_b
= *(const cpp_hashnode
*const *)b_
;
17034 macro_import
&import_b
= (*macro_imports
)[node_b
->deferred
- 1];
17035 const macro_export
&export_b
= (*macro_exports
)[import_b
[0].offset
];
17036 location_t loc_b
= export_b
.def
? export_b
.def
->line
: export_b
.undef_loc
;
17040 else if (loc_a
> loc_b
)
17046 /* Gather the macro definitions and undefinitions that we will need to
17049 vec
<cpp_hashnode
*> *
17050 module_state::prepare_macros (cpp_reader
*reader
)
17052 vec
<cpp_hashnode
*> *macros
;
17053 vec_alloc (macros
, 100);
17055 cpp_forall_identifiers (reader
, maybe_add_macro
, macros
);
17057 dump (dumper::MACRO
) && dump ("No more than %u macros", macros
->length ());
17059 macros
->qsort (macro_loc_cmp
);
17061 // Note the locations.
17062 for (unsigned ix
= macros
->length (); ix
--;)
17064 cpp_hashnode
*node
= (*macros
)[ix
];
17065 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17066 macro_export
&mac
= (*macro_exports
)[slot
.offset
];
17068 if (IDENTIFIER_KEYWORD_P (identifier (node
)))
17071 if (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17072 note_location (mac
.undef_loc
);
17075 note_location (mac
.def
->line
);
17076 for (unsigned ix
= 0; ix
!= mac
.def
->count
; ix
++)
17077 note_location (mac
.def
->exp
.tokens
[ix
].src_loc
);
17084 /* Write out the exported defines. This is two sections, one
17085 containing the definitions, the other a table of node names. */
17088 module_state::write_macros (elf_out
*to
, vec
<cpp_hashnode
*> *macros
,
17091 dump () && dump ("Writing macros");
17094 /* Write the defs */
17095 bytes_out
sec (to
);
17098 unsigned count
= 0;
17099 for (unsigned ix
= macros
->length (); ix
--;)
17101 cpp_hashnode
*node
= (*macros
)[ix
];
17102 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17103 gcc_assert (!slot
.get_module () && slot
.get_defness ());
17105 macro_export
&mac
= (*macro_exports
)[slot
.offset
];
17106 gcc_assert (!!(slot
.get_defness () & macro_import::slot::L_UNDEF
)
17107 == (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17108 && !!(slot
.get_defness () & macro_import::slot::L_DEF
)
17109 == (mac
.def
!= NULL
));
17111 if (IDENTIFIER_KEYWORD_P (identifier (node
)))
17113 warning_at (mac
.def
->line
, 0,
17114 "not exporting %<#define %E%> as it is a keyword",
17115 identifier (node
));
17121 slot
.offset
= sec
.pos
;
17122 dump (dumper::MACRO
)
17123 && dump ("Writing macro %s%s%s %I at %u",
17124 slot
.get_defness () & macro_import::slot::L_UNDEF
17126 slot
.get_defness () == macro_import::slot::L_BOTH
17128 slot
.get_defness () & macro_import::slot::L_DEF
17130 identifier (node
), slot
.offset
);
17131 if (mac
.undef_loc
!= UNKNOWN_LOCATION
)
17132 write_location (sec
, mac
.undef_loc
);
17134 write_define (sec
, mac
.def
);
17137 // We may have ended on a tokenless macro with a very short
17138 // location, that will cause problems reading its bit flags.
17140 sec
.end (to
, to
->name (MOD_SNAME_PFX
".def"), crc_p
);
17144 /* Write the table. */
17145 bytes_out
sec (to
);
17149 for (unsigned ix
= macros
->length (); ix
--;)
17151 const cpp_hashnode
*node
= (*macros
)[ix
];
17152 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1][0];
17156 sec
.cpp_node (node
);
17157 sec
.u (slot
.get_defness ());
17158 sec
.u (slot
.offset
);
17161 sec
.end (to
, to
->name (MOD_SNAME_PFX
".mac"), crc_p
);
17169 module_state::read_macros ()
17171 /* Get the def section. */
17172 if (!slurp
->macro_defs
.begin (loc
, from (), MOD_SNAME_PFX
".def"))
17175 /* Get the tbl section, if there are defs. */
17176 if (slurp
->macro_defs
.more_p ()
17177 && !slurp
->macro_tbl
.begin (loc
, from (), MOD_SNAME_PFX
".mac"))
17183 /* Install the macro name table. */
17186 module_state::install_macros ()
17188 bytes_in
&sec
= slurp
->macro_tbl
;
17192 dump () && dump ("Reading macro table %M", this);
17195 unsigned count
= sec
.u ();
17196 dump () && dump ("%u macros", count
);
17199 cpp_hashnode
*node
= sec
.cpp_node ();
17200 macro_import
&imp
= get_macro_imports (node
);
17201 unsigned flags
= sec
.u () & macro_import::slot::L_BOTH
;
17203 sec
.set_overrun ();
17205 if (sec
.get_overrun ())
17208 macro_import::slot
&slot
= imp
.append (mod
, flags
);
17209 slot
.offset
= sec
.u ();
17211 dump (dumper::MACRO
)
17212 && dump ("Read %s macro %s%s%s %I at %u",
17213 imp
.length () > 1 ? "add" : "new",
17214 flags
& macro_import::slot::L_UNDEF
? "#undef" : "",
17215 flags
== macro_import::slot::L_BOTH
? " & " : "",
17216 flags
& macro_import::slot::L_DEF
? "#define" : "",
17217 identifier (node
), slot
.offset
);
17219 /* We'll leak an imported definition's TOKEN_FLD_STR's data
17220 here. But that only happens when we've had to resolve the
17221 deferred macro before this import -- why are you doing
17223 if (cpp_macro
*cur
= cpp_set_deferred_macro (node
))
17224 if (!cur
->imported_p
)
17226 macro_import::slot
&slot
= imp
.exported ();
17227 macro_export
&exp
= get_macro_export (slot
);
17229 dump (dumper::MACRO
)
17230 && dump ("Saving current #define %I", identifier (node
));
17234 /* We're now done with the table. */
17235 elf_in::release (slurp
->from
, sec
);
17240 /* Import the transitive macros. */
17243 module_state::import_macros ()
17245 bitmap_ior_into (headers
, slurp
->headers
);
17247 bitmap_iterator bititer
;
17249 EXECUTE_IF_SET_IN_BITMAP (slurp
->headers
, 0, bitnum
, bititer
)
17250 (*modules
)[bitnum
]->install_macros ();
17253 /* NODE is being undefined at LOC. Record it in the export table, if
17257 module_state::undef_macro (cpp_reader
*, location_t loc
, cpp_hashnode
*node
)
17259 if (!node
->deferred
)
17260 /* The macro is not imported, so our undef is irrelevant. */
17263 unsigned n
= dump
.push (NULL
);
17265 macro_import::slot
&slot
= (*macro_imports
)[node
->deferred
- 1].exported ();
17266 macro_export
&exp
= get_macro_export (slot
);
17268 exp
.undef_loc
= loc
;
17269 slot
.become_undef ();
17272 dump (dumper::MACRO
) && dump ("Recording macro #undef %I", identifier (node
));
17277 /* NODE is a deferred macro node. Determine the definition and return
17278 it, with NULL if undefined. May issue diagnostics.
17280 This can leak memory, when merging declarations -- the string
17281 contents (TOKEN_FLD_STR) of each definition are allocated in
17282 unreclaimable cpp objstack. Only one will win. However, I do not
17283 expect this to be common -- mostly macros have a single point of
17284 definition. Perhaps we could restore the objstack to its position
17285 after the first imported definition (if that wins)? The macros
17286 themselves are GC'd. */
17289 module_state::deferred_macro (cpp_reader
*reader
, location_t loc
,
17290 cpp_hashnode
*node
)
17292 macro_import
&imports
= (*macro_imports
)[node
->deferred
- 1];
17294 unsigned n
= dump
.push (NULL
);
17295 dump (dumper::MACRO
) && dump ("Deferred macro %I", identifier (node
));
17297 bitmap
visible (BITMAP_GGC_ALLOC ());
17299 if (!((imports
[0].get_defness () & macro_import::slot::L_UNDEF
)
17300 && !imports
[0].get_module ()))
17302 /* Calculate the set of visible header imports. */
17303 bitmap_copy (visible
, headers
);
17304 for (unsigned ix
= imports
.length (); ix
--;)
17306 const macro_import::slot
&slot
= imports
[ix
];
17307 unsigned mod
= slot
.get_module ();
17308 if ((slot
.get_defness () & macro_import::slot::L_UNDEF
)
17309 && bitmap_bit_p (visible
, mod
))
17311 bitmap arg
= mod
? (*modules
)[mod
]->slurp
->headers
: headers
;
17312 bitmap_and_compl_into (visible
, arg
);
17313 bitmap_set_bit (visible
, mod
);
17317 bitmap_set_bit (visible
, 0);
17319 /* Now find the macros that are still visible. */
17320 bool failed
= false;
17321 cpp_macro
*def
= NULL
;
17322 vec
<macro_export
> defs
;
17323 defs
.create (imports
.length ());
17324 for (unsigned ix
= imports
.length (); ix
--;)
17326 const macro_import::slot
&slot
= imports
[ix
];
17327 unsigned mod
= slot
.get_module ();
17328 if (bitmap_bit_p (visible
, mod
))
17330 macro_export
*pushed
= NULL
;
17333 const module_state
*imp
= (*modules
)[mod
];
17334 bytes_in
&sec
= imp
->slurp
->macro_defs
;
17335 if (!sec
.get_overrun ())
17337 dump (dumper::MACRO
)
17338 && dump ("Reading macro %s%s%s %I module %M at %u",
17339 slot
.get_defness () & macro_import::slot::L_UNDEF
17341 slot
.get_defness () == macro_import::slot::L_BOTH
17343 slot
.get_defness () & macro_import::slot::L_DEF
17345 identifier (node
), imp
, slot
.offset
);
17346 sec
.random_access (slot
.offset
);
17349 if (slot
.get_defness () & macro_import::slot::L_UNDEF
)
17350 exp
.undef_loc
= imp
->read_location (sec
);
17351 if (slot
.get_defness () & macro_import::slot::L_DEF
)
17352 exp
.def
= imp
->read_define (sec
, reader
);
17353 if (sec
.get_overrun ())
17354 error_at (loc
, "macro definitions of %qE corrupted",
17357 pushed
= defs
.quick_push (exp
);
17361 pushed
= defs
.quick_push ((*macro_exports
)[slot
.offset
]);
17362 if (pushed
&& pushed
->def
)
17366 else if (cpp_compare_macros (def
, pushed
->def
))
17374 /* If LOC is the first loc, this is the end of file check, which
17376 if (loc
== MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0)))
17377 warning_at (loc
, OPT_Winvalid_imported_macros
,
17378 "inconsistent imported macro definition %qE",
17379 identifier (node
));
17381 error_at (loc
, "inconsistent imported macro definition %qE",
17382 identifier (node
));
17383 for (unsigned ix
= defs
.length (); ix
--;)
17385 macro_export
&exp
= defs
[ix
];
17387 inform (exp
.undef_loc
, "%<#undef %E%>", identifier (node
));
17389 inform (exp
.def
->line
, "%<#define %s%>",
17390 cpp_macro_definition (reader
, node
, exp
.def
));
17402 /* Stream the static aggregates. Sadly some headers (ahem:
17403 iostream) contain static vars, and rely on them to run global
17406 module_state::write_inits (elf_out
*to
, depset::hash
&table
, unsigned *crc_ptr
)
17408 if (!static_aggregates
&& !tls_aggregates
)
17411 dump () && dump ("Writing initializers");
17414 static_aggregates
= nreverse (static_aggregates
);
17415 tls_aggregates
= nreverse (tls_aggregates
);
17417 unsigned count
= 0;
17418 trees_out
sec (to
, this, table
, ~0u);
17421 tree list
= static_aggregates
;
17422 for (int passes
= 0; passes
!= 2; passes
++)
17424 for (tree init
= list
; init
; init
= TREE_CHAIN (init
), count
++)
17425 if (TREE_LANG_FLAG_0 (init
))
17427 tree decl
= TREE_VALUE (init
);
17429 dump ("Initializer:%u for %N", count
, decl
);
17430 sec
.tree_node (decl
);
17433 list
= tls_aggregates
;
17436 sec
.end (to
, to
->name (MOD_SNAME_PFX
".ini"), crc_ptr
);
17442 /* We have to defer some post-load processing until we've completed
17443 reading, because they can cause more reading. */
17446 post_load_processing ()
17448 /* We mustn't cause a GC, our caller should have arranged for that
17450 gcc_checking_assert (function_depth
);
17452 if (!post_load_decls
)
17455 tree old_cfd
= current_function_decl
;
17456 struct function
*old_cfun
= cfun
;
17457 while (post_load_decls
->length ())
17459 tree decl
= post_load_decls
->pop ();
17461 dump () && dump ("Post-load processing of %N", decl
);
17463 gcc_checking_assert (DECL_ABSTRACT_P (decl
));
17464 /* Cloning can cause loading -- specifically operator delete for
17465 the deleting dtor. */
17466 maybe_clone_body (decl
);
17470 current_function_decl
= old_cfd
;
17474 module_state::read_inits (unsigned count
)
17476 trees_in
sec (this);
17477 if (!sec
.begin (loc
, from (), from ()->find (MOD_SNAME_PFX
".ini")))
17479 dump () && dump ("Reading %u initializers", count
);
17483 for (unsigned ix
= 0; ix
!= count
; ix
++)
17485 /* Merely referencing the decl causes its initializer to be read
17486 and added to the correct list. */
17487 tree decl
= sec
.tree_node ();
17489 if (sec
.get_overrun ())
17492 dump ("Initializer:%u for %N", count
, decl
);
17495 post_load_processing ();
17497 if (!sec
.end (from ()))
17503 module_state::write_counts (elf_out
*to
, unsigned counts
[MSC_HWM
],
17506 bytes_out
cfg (to
);
17510 for (unsigned ix
= MSC_HWM
; ix
--;)
17511 cfg
.u (counts
[ix
]);
17515 dump ("Cluster sections are [%u,%u)",
17516 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]);
17517 dump ("Bindings %u", counts
[MSC_bindings
]);
17518 dump ("Pendings %u", counts
[MSC_pendings
]);
17519 dump ("Entities %u", counts
[MSC_entities
]);
17520 dump ("Namespaces %u", counts
[MSC_namespaces
]);
17521 dump ("Macros %u", counts
[MSC_macros
]);
17522 dump ("Initializers %u", counts
[MSC_inits
]);
17525 cfg
.end (to
, to
->name (MOD_SNAME_PFX
".cnt"), crc_ptr
);
17529 module_state::read_counts (unsigned counts
[MSC_HWM
])
17533 if (!cfg
.begin (loc
, from (), MOD_SNAME_PFX
".cnt"))
17536 for (unsigned ix
= MSC_HWM
; ix
--;)
17537 counts
[ix
] = cfg
.u ();
17541 dump ("Declaration sections are [%u,%u)",
17542 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]);
17543 dump ("Bindings %u", counts
[MSC_bindings
]);
17544 dump ("Pendings %u", counts
[MSC_pendings
]);
17545 dump ("Entities %u", counts
[MSC_entities
]);
17546 dump ("Namespaces %u", counts
[MSC_namespaces
]);
17547 dump ("Macros %u", counts
[MSC_macros
]);
17548 dump ("Initializers %u", counts
[MSC_inits
]);
17551 return cfg
.end (from ());
17554 /* Tool configuration: MOD_SNAME_PFX .config
17556 This is data that confirms current state (or fails). */
17559 module_state::write_config (elf_out
*to
, module_state_config
&config
,
17560 unsigned inner_crc
)
17562 bytes_out
cfg (to
);
17566 /* Write version and inner crc as u32 values, for easier
17567 debug inspection. */
17568 dump () && dump ("Writing version=%V, inner_crc=%x",
17569 MODULE_VERSION
, inner_crc
);
17570 cfg
.u32 (unsigned (MODULE_VERSION
));
17571 cfg
.u32 (inner_crc
);
17573 cfg
.u (to
->name (is_header () ? "" : get_flatname ()));
17575 /* Configuration. */
17576 dump () && dump ("Writing target='%s', host='%s'",
17577 TARGET_MACHINE
, HOST_MACHINE
);
17578 unsigned target
= to
->name (TARGET_MACHINE
);
17579 unsigned host
= (!strcmp (TARGET_MACHINE
, HOST_MACHINE
)
17580 ? target
: to
->name (HOST_MACHINE
));
17584 cfg
.str (config
.dialect_str
);
17585 cfg
.u (extensions
);
17587 /* Global tree information. We write the globals crc separately,
17588 rather than mix it directly into the overall crc, as it is used
17589 to ensure data match between instances of the compiler, not
17590 integrity of the file. */
17591 dump () && dump ("Writing globals=%u, crc=%x",
17592 fixed_trees
->length (), global_crc
);
17593 cfg
.u (fixed_trees
->length ());
17594 cfg
.u32 (global_crc
);
17596 if (is_partition ())
17597 cfg
.u (is_interface ());
17599 cfg
.u (config
.num_imports
);
17600 cfg
.u (config
.num_partitions
);
17601 cfg
.u (config
.num_entities
);
17603 cfg
.u (config
.ordinary_locs
);
17604 cfg
.u (config
.macro_locs
);
17605 cfg
.u (config
.loc_range_bits
);
17607 cfg
.u (config
.active_init
);
17609 /* Now generate CRC, we'll have incorporated the inner CRC because
17610 of its serialization above. */
17611 cfg
.end (to
, to
->name (MOD_SNAME_PFX
".cfg"), &crc
);
17612 dump () && dump ("Writing CRC=%x", crc
);
17616 module_state::note_cmi_name ()
17618 if (!cmi_noted_p
&& filename
)
17620 cmi_noted_p
= true;
17621 inform (loc
, "compiled module file is %qs",
17622 maybe_add_cmi_prefix (filename
));
17627 module_state::read_config (module_state_config
&config
)
17631 if (!cfg
.begin (loc
, from (), MOD_SNAME_PFX
".cfg"))
17634 /* Check version. */
17635 unsigned my_ver
= MODULE_VERSION
;
17636 unsigned their_ver
= cfg
.u32 ();
17637 dump () && dump (my_ver
== their_ver
? "Version %V"
17638 : "Expecting %V found %V", my_ver
, their_ver
);
17639 if (their_ver
!= my_ver
)
17641 /* The compiler versions differ. Close enough? */
17642 verstr_t my_string
, their_string
;
17644 version2string (my_ver
, my_string
);
17645 version2string (their_ver
, their_string
);
17647 /* Reject when either is non-experimental or when experimental
17648 major versions differ. */
17649 bool reject_p
= ((!IS_EXPERIMENTAL (my_ver
)
17650 || !IS_EXPERIMENTAL (their_ver
)
17651 || MODULE_MAJOR (my_ver
) != MODULE_MAJOR (their_ver
))
17652 /* The 'I know what I'm doing' switch. */
17653 && !flag_module_version_ignore
);
17654 bool inform_p
= true;
17657 cfg
.set_overrun ();
17658 error_at (loc
, "compiled module is %sversion %s",
17659 IS_EXPERIMENTAL (their_ver
) ? "experimental " : "",
17663 inform_p
= warning_at (loc
, 0, "compiled module is %sversion %s",
17664 IS_EXPERIMENTAL (their_ver
) ? "experimental " : "",
17669 inform (loc
, "compiler is %sversion %s%s%s",
17670 IS_EXPERIMENTAL (my_ver
) ? "experimental " : "",
17672 reject_p
? "" : flag_module_version_ignore
17673 ? ", be it on your own head!" : ", close enough?",
17674 reject_p
? "" : " \xc2\xaf\\_(\xe3\x83\x84)_/\xc2\xaf");
17682 /* We wrote the inner crc merely to merge it, so simply read it
17683 back and forget it. */
17686 /* Check module name. */
17688 const char *their_name
= from ()->name (cfg
.u ());
17689 const char *our_name
= "";
17692 our_name
= get_flatname ();
17694 /* Header units can be aliased, so name checking is
17696 if (0 != strcmp (their_name
, our_name
))
17699 their_name
[0] && our_name
[0] ? G_("module %qs found")
17701 ? G_("header module expected, module %qs found")
17702 : G_("module %qs expected, header module found"),
17703 their_name
[0] ? their_name
: our_name
);
17704 cfg
.set_overrun ();
17709 /* Check the CRC after the above sanity checks, so that the user is
17712 unsigned e_crc
= crc
;
17713 crc
= cfg
.get_crc ();
17714 dump () && dump ("Reading CRC=%x", crc
);
17715 if (!is_direct () && crc
!= e_crc
)
17717 error_at (loc
, "module %qs CRC mismatch", get_flatname ());
17718 cfg
.set_overrun ();
17723 /* Check target & host. */
17725 const char *their_target
= from ()->name (cfg
.u ());
17726 const char *their_host
= from ()->name (cfg
.u ());
17727 dump () && dump ("Read target='%s', host='%s'", their_target
, their_host
);
17728 if (strcmp (their_target
, TARGET_MACHINE
)
17729 || strcmp (their_host
, HOST_MACHINE
))
17731 error_at (loc
, "target & host is %qs:%qs, expected %qs:%qs",
17732 their_target
, TARGET_MACHINE
, their_host
, HOST_MACHINE
);
17733 cfg
.set_overrun ();
17738 /* Check compilation dialect. This must match. */
17740 const char *their_dialect
= cfg
.str ();
17741 if (strcmp (their_dialect
, config
.dialect_str
))
17743 error_at (loc
, "language dialect differs %qs, expected %qs",
17744 their_dialect
, config
.dialect_str
);
17745 cfg
.set_overrun ();
17750 /* Check for extensions. If they set any, we must have them set
17753 unsigned ext
= cfg
.u ();
17754 unsigned allowed
= (flag_openmp
? SE_OPENMP
: 0);
17756 if (unsigned bad
= ext
& ~allowed
)
17758 if (bad
& SE_OPENMP
)
17759 error_at (loc
, "module contains OpenMP, use %<-fopenmp%> to enable");
17760 cfg
.set_overrun ();
17766 /* Check global trees. */
17768 unsigned their_fixed_length
= cfg
.u ();
17769 unsigned their_fixed_crc
= cfg
.u32 ();
17770 dump () && dump ("Read globals=%u, crc=%x",
17771 their_fixed_length
, their_fixed_crc
);
17772 if (!flag_preprocess_only
17773 && (their_fixed_length
!= fixed_trees
->length ()
17774 || their_fixed_crc
!= global_crc
))
17776 error_at (loc
, "fixed tree mismatch");
17777 cfg
.set_overrun ();
17782 /* All non-partitions are interfaces. */
17783 interface_p
= !is_partition () || cfg
.u ();
17785 config
.num_imports
= cfg
.u ();
17786 config
.num_partitions
= cfg
.u ();
17787 config
.num_entities
= cfg
.u ();
17789 config
.ordinary_locs
= cfg
.u ();
17790 config
.macro_locs
= cfg
.u ();
17791 config
.loc_range_bits
= cfg
.u ();
17793 config
.active_init
= cfg
.u ();
17796 return cfg
.end (from ());
17799 /* Comparator for ordering the Ordered Ordinary Location array. */
17802 ool_cmp (const void *a_
, const void *b_
)
17804 auto *a
= *static_cast<const module_state
*const *> (a_
);
17805 auto *b
= *static_cast<const module_state
*const *> (b_
);
17808 else if (a
->ordinary_locs
.first
< b
->ordinary_locs
.first
)
17814 /* Use ELROND format to record the following sections:
17815 qualified-names : binding value(s)
17816 MOD_SNAME_PFX.README : human readable, strings
17817 MOD_SNAME_PFX.ENV : environment strings, strings
17818 MOD_SNAME_PFX.nms : namespace hierarchy
17819 MOD_SNAME_PFX.bnd : binding table
17820 MOD_SNAME_PFX.spc : specialization table
17821 MOD_SNAME_PFX.imp : import table
17822 MOD_SNAME_PFX.ent : entity table
17823 MOD_SNAME_PFX.prt : partitions table
17824 MOD_SNAME_PFX.olm : ordinary line maps
17825 MOD_SNAME_PFX.mlm : macro line maps
17826 MOD_SNAME_PFX.def : macro definitions
17827 MOD_SNAME_PFX.mac : macro index
17828 MOD_SNAME_PFX.ini : inits
17829 MOD_SNAME_PFX.cnt : counts
17830 MOD_SNAME_PFX.cfg : config data
17834 module_state::write_begin (elf_out
*to
, cpp_reader
*reader
,
17835 module_state_config
&config
, unsigned &crc
)
17837 /* Figure out remapped module numbers, which might elide
17839 bitmap partitions
= NULL
;
17840 if (!is_header () && !is_partition ())
17841 partitions
= BITMAP_GGC_ALLOC ();
17842 write_init_maps ();
17844 unsigned mod_hwm
= 1;
17845 for (unsigned ix
= 1; ix
!= modules
->length (); ix
++)
17847 module_state
*imp
= (*modules
)[ix
];
17849 /* Promote any non-partition direct import from a partition, unless
17850 we're a partition. */
17851 if (!is_partition () && !imp
->is_partition ()
17852 && imp
->is_partition_direct ())
17853 imp
->directness
= MD_PURVIEW_DIRECT
;
17855 /* Write any import that is not a partition, unless we're a
17857 if (!partitions
|| !imp
->is_partition ())
17858 imp
->remap
= mod_hwm
++;
17861 dump () && dump ("Partition %M %u", imp
, ix
);
17862 bitmap_set_bit (partitions
, ix
);
17864 /* All interface partitions must be exported. */
17865 if (imp
->is_interface () && !bitmap_bit_p (exports
, imp
->mod
))
17867 error_at (imp
->loc
, "interface partition is not exported");
17868 bitmap_set_bit (exports
, imp
->mod
);
17871 /* All the partition entities should have been loaded when
17872 loading the partition. */
17874 for (unsigned jx
= 0; jx
!= imp
->entity_num
; jx
++)
17876 binding_slot
*slot
= &(*entity_ary
)[imp
->entity_lwm
+ jx
];
17877 gcc_checking_assert (!slot
->is_lazy ());
17881 if (imp
->is_direct () && (imp
->remap
|| imp
->is_partition ()))
17882 note_location (imp
->imported_from ());
17885 if (partitions
&& bitmap_empty_p (partitions
))
17886 /* No partitions present. */
17887 partitions
= nullptr;
17889 /* Find the set of decls we must write out. */
17890 depset::hash
table (DECL_NAMESPACE_BINDINGS (global_namespace
)->size () * 8);
17891 /* Add the specializations before the writables, so that we can
17892 detect injected friend specializations. */
17893 table
.add_specializations (true);
17894 table
.add_specializations (false);
17895 if (partial_specializations
)
17897 table
.add_partial_entities (partial_specializations
);
17898 partial_specializations
= NULL
;
17900 table
.add_namespace_entities (global_namespace
, partitions
);
17903 table
.add_class_entities (class_members
);
17904 class_members
= NULL
;
17907 /* Now join everything up. */
17908 table
.find_dependencies (this);
17910 if (!table
.finalize_dependencies ())
17917 /* We're done verifying at-most once reading, reset to verify
17918 at-most once writing. */
17919 note_defs
= note_defs_table_t::create_ggc (1000);
17922 /* Determine Strongy Connected Components. */
17923 vec
<depset
*> sccs
= table
.connect ();
17925 vec_alloc (ool
, modules
->length ());
17926 for (unsigned ix
= modules
->length (); --ix
;)
17928 auto *import
= (*modules
)[ix
];
17929 if (import
->loadedness
> ML_NONE
17930 && !(partitions
&& bitmap_bit_p (partitions
, import
->mod
)))
17931 ool
->quick_push (import
);
17933 ool
->qsort (ool_cmp
);
17935 vec
<cpp_hashnode
*> *macros
= nullptr;
17937 macros
= prepare_macros (reader
);
17939 config
.num_imports
= mod_hwm
;
17940 config
.num_partitions
= modules
->length () - mod_hwm
;
17941 auto map_info
= write_prepare_maps (&config
, bool (config
.num_partitions
));
17942 unsigned counts
[MSC_HWM
];
17943 memset (counts
, 0, sizeof (counts
));
17945 /* depset::cluster is the cluster number,
17946 depset::section is unspecified scratch value.
17948 The following loops make use of the tarjan property that
17949 dependencies will be earlier in the SCCS array. */
17951 /* This first loop determines the number of depsets in each SCC, and
17952 also the number of namespaces we're dealing with. During the
17953 loop, the meaning of a couple of depset fields now change:
17955 depset::cluster -> size_of cluster, if first of cluster & !namespace
17956 depset::section -> section number of cluster (if !namespace). */
17958 unsigned n_spaces
= 0;
17959 counts
[MSC_sec_lwm
] = counts
[MSC_sec_hwm
] = to
->get_section_limit ();
17960 for (unsigned size
, ix
= 0; ix
< sccs
.length (); ix
+= size
)
17962 depset
**base
= &sccs
[ix
];
17964 if (base
[0]->get_entity_kind () == depset::EK_NAMESPACE
)
17971 /* Count the members in this cluster. */
17972 for (size
= 1; ix
+ size
< sccs
.length (); size
++)
17973 if (base
[size
]->cluster
!= base
[0]->cluster
)
17976 for (unsigned jx
= 0; jx
!= size
; jx
++)
17978 /* Set the section number. */
17979 base
[jx
]->cluster
= ~(~0u >> 1); /* A bad value. */
17980 base
[jx
]->section
= counts
[MSC_sec_hwm
];
17983 /* Save the size in the first member's cluster slot. */
17984 base
[0]->cluster
= size
;
17986 counts
[MSC_sec_hwm
]++;
17990 /* Write the clusters. Namespace decls are put in the spaces array.
17991 The meaning of depset::cluster changes to provide the
17992 unnamed-decl count of the depset's decl (and remains zero for
17993 non-decls and non-unnamed). */
17994 unsigned bytes
= 0;
17995 vec
<depset
*> spaces
;
17996 spaces
.create (n_spaces
);
17998 for (unsigned size
, ix
= 0; ix
< sccs
.length (); ix
+= size
)
18000 depset
**base
= &sccs
[ix
];
18002 if (base
[0]->get_entity_kind () == depset::EK_NAMESPACE
)
18004 tree decl
= base
[0]->get_entity ();
18005 if (decl
== global_namespace
)
18006 base
[0]->cluster
= 0;
18007 else if (!base
[0]->is_import ())
18009 base
[0]->cluster
= counts
[MSC_entities
]++;
18010 spaces
.quick_push (base
[0]);
18011 counts
[MSC_namespaces
]++;
18014 /* Add it to the entity map, such that we can tell it is
18017 unsigned *slot
= &entity_map
->get_or_insert
18018 (DECL_UID (decl
), &existed
);
18020 /* It must have come from a partition. */
18021 gcc_checking_assert
18022 (import_entity_module (*slot
)->is_partition ());
18023 *slot
= ~base
[0]->cluster
;
18025 dump (dumper::CLUSTER
) && dump ("Cluster namespace %N", decl
);
18031 size
= base
[0]->cluster
;
18033 /* Cluster is now used to number entities. */
18034 base
[0]->cluster
= ~(~0u >> 1); /* A bad value. */
18036 sort_cluster (&table
, base
, size
);
18038 /* Record the section for consistency checking during stream
18039 out -- we don't want to start writing decls in different
18041 table
.section
= base
[0]->section
;
18042 bytes
+= write_cluster (to
, base
, size
, table
, counts
, &crc
);
18047 /* depset::cluster - entity number (on entities)
18048 depset::section - cluster number */
18049 /* We'd better have written as many sections and found as many
18050 namespaces as we predicted. */
18051 gcc_assert (counts
[MSC_sec_hwm
] == to
->get_section_limit ()
18052 && spaces
.length () == counts
[MSC_namespaces
]);
18054 /* Write the entitites. None happens if we contain namespaces or
18056 config
.num_entities
= counts
[MSC_entities
];
18057 if (counts
[MSC_entities
])
18058 write_entities (to
, sccs
, counts
[MSC_entities
], &crc
);
18060 /* Write the namespaces. */
18061 if (counts
[MSC_namespaces
])
18062 write_namespaces (to
, spaces
, counts
[MSC_namespaces
], &crc
);
18064 /* Write the bindings themselves. */
18065 counts
[MSC_bindings
] = write_bindings (to
, sccs
, &crc
);
18067 /* Write the unnamed. */
18068 counts
[MSC_pendings
] = write_pendings (to
, sccs
, table
, &crc
);
18070 /* Write the import table. */
18071 if (config
.num_imports
> 1)
18072 write_imports (to
, &crc
);
18074 /* Write elided partition table. */
18075 if (config
.num_partitions
)
18076 write_partitions (to
, config
.num_partitions
, &crc
);
18078 /* Write the line maps. */
18079 if (config
.ordinary_locs
)
18080 write_ordinary_maps (to
, map_info
, bool (config
.num_partitions
), &crc
);
18081 if (config
.macro_locs
)
18082 write_macro_maps (to
, map_info
, &crc
);
18086 counts
[MSC_macros
] = write_macros (to
, macros
, &crc
);
18087 counts
[MSC_inits
] = write_inits (to
, table
, &crc
);
18091 unsigned clusters
= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18092 dump () && dump ("Wrote %u clusters, average %u bytes/cluster",
18093 clusters
, (bytes
+ clusters
/ 2) / (clusters
+ !clusters
));
18094 trees_out::instrument ();
18096 write_counts (to
, counts
, &crc
);
18101 vec_free (macro_loc_remap
);
18102 vec_free (ord_loc_remap
);
18105 // FIXME:QOI: Have a command line switch to control more detailed
18106 // information (which might leak data you do not want to leak).
18107 // Perhaps (some of) the write_readme contents should also be
18113 // Finish module writing after we've emitted all dynamic initializers.
18116 module_state::write_end (elf_out
*to
, cpp_reader
*reader
,
18117 module_state_config
&config
, unsigned &crc
)
18119 /* And finish up. */
18120 write_config (to
, config
, crc
);
18122 /* Human-readable info. */
18123 write_readme (to
, reader
, config
.dialect_str
);
18125 dump () && dump ("Wrote %u sections", to
->get_section_limit ());
18128 /* Initial read of a CMI. Checks config, loads up imports and line
18132 module_state::read_initial (cpp_reader
*reader
)
18134 module_state_config config
;
18137 if (ok
&& !from ()->begin (loc
))
18140 if (ok
&& !read_config (config
))
18143 bool have_locs
= ok
&& read_prepare_maps (&config
);
18145 /* Ordinary maps before the imports. */
18146 if (!(have_locs
&& config
.ordinary_locs
))
18147 ordinary_locs
.first
= line_table
->highest_location
+ 1;
18148 else if (!read_ordinary_maps (config
.ordinary_locs
, config
.loc_range_bits
))
18151 /* Allocate the REMAP vector. */
18152 slurp
->alloc_remap (config
.num_imports
);
18156 /* Read the import table. Decrement current to stop this CMI
18157 from being evicted during the import. */
18159 if (config
.num_imports
> 1 && !read_imports (reader
, line_table
))
18164 /* Read the elided partition table, if we're the primary partition. */
18165 if (ok
&& config
.num_partitions
&& is_module ()
18166 && !read_partitions (config
.num_partitions
))
18169 /* Determine the module's number. */
18170 gcc_checking_assert (mod
== MODULE_UNKNOWN
);
18171 gcc_checking_assert (this != (*modules
)[0]);
18174 /* Allocate space in the entities array now -- that array must be
18175 monotonically in step with the modules array. */
18176 entity_lwm
= vec_safe_length (entity_ary
);
18177 entity_num
= config
.num_entities
;
18178 gcc_checking_assert (modules
->length () == 1
18179 || modules
->last ()->entity_lwm
<= entity_lwm
);
18180 vec_safe_reserve (entity_ary
, config
.num_entities
);
18183 slot
.u
.binding
= NULL_TREE
;
18184 for (unsigned count
= config
.num_entities
; count
--;)
18185 entity_ary
->quick_push (slot
);
18188 /* We'll run out of other resources before we run out of module
18190 mod
= modules
->length ();
18191 vec_safe_push (modules
, this);
18193 /* We always import and export ourselves. */
18194 bitmap_set_bit (imports
, mod
);
18195 bitmap_set_bit (exports
, mod
);
18198 (*slurp
->remap
)[0] = mod
<< 1;
18199 dump () && dump ("Assigning %M module number %u", this, mod
);
18201 /* We should not have been frozen during the importing done by
18203 gcc_assert (!from ()->is_frozen ());
18205 /* Macro maps after the imports. */
18206 if (!(ok
&& have_locs
&& config
.macro_locs
))
18207 macro_locs
.first
= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
);
18208 else if (!read_macro_maps (config
.macro_locs
))
18211 /* Note whether there's an active initializer. */
18212 active_init_p
= !is_header () && bool (config
.active_init
);
18214 gcc_assert (slurp
->current
== ~0u);
18218 /* Read a preprocessor state. */
18221 module_state::read_preprocessor (bool outermost
)
18223 gcc_checking_assert (is_header () && slurp
18224 && slurp
->remap_module (0) == mod
);
18226 if (loadedness
== ML_PREPROCESSOR
)
18227 return !(from () && from ()->get_error ());
18231 /* Read direct header imports. */
18232 unsigned len
= slurp
->remap
->length ();
18233 for (unsigned ix
= 1; ok
&& ix
!= len
; ix
++)
18235 unsigned map
= (*slurp
->remap
)[ix
];
18238 module_state
*import
= (*modules
)[map
>> 1];
18239 if (import
->is_header ())
18241 ok
= import
->read_preprocessor (false);
18242 bitmap_ior_into (slurp
->headers
, import
->slurp
->headers
);
18247 /* Record as a direct header. */
18249 bitmap_set_bit (slurp
->headers
, mod
);
18251 if (ok
&& !read_macros ())
18254 loadedness
= ML_PREPROCESSOR
;
18255 announce ("macros");
18257 if (flag_preprocess_only
)
18258 /* We're done with the string table. */
18259 from ()->release ();
18261 return check_read (outermost
, ok
);
18264 /* Read language state. */
18267 module_state::read_language (bool outermost
)
18269 gcc_checking_assert (!lazy_snum
);
18271 if (loadedness
== ML_LANGUAGE
)
18272 return !(slurp
&& from () && from ()->get_error ());
18274 gcc_checking_assert (slurp
&& slurp
->current
== ~0u
18275 && slurp
->remap_module (0) == mod
);
18279 /* Read direct imports. */
18280 unsigned len
= slurp
->remap
->length ();
18281 for (unsigned ix
= 1; ok
&& ix
!= len
; ix
++)
18283 unsigned map
= (*slurp
->remap
)[ix
];
18286 module_state
*import
= (*modules
)[map
>> 1];
18287 if (!import
->read_language (false))
18292 unsigned counts
[MSC_HWM
];
18294 if (ok
&& !read_counts (counts
))
18297 function_depth
++; /* Prevent unexpected GCs. */
18299 if (ok
&& counts
[MSC_entities
] != entity_num
)
18301 if (ok
&& counts
[MSC_entities
]
18302 && !read_entities (counts
[MSC_entities
],
18303 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]))
18306 /* Read the namespace hierarchy. */
18307 if (ok
&& counts
[MSC_namespaces
]
18308 && !read_namespaces (counts
[MSC_namespaces
]))
18311 if (ok
&& !read_bindings (counts
[MSC_bindings
],
18312 counts
[MSC_sec_lwm
], counts
[MSC_sec_hwm
]))
18316 if (ok
&& counts
[MSC_pendings
] && !read_pendings (counts
[MSC_pendings
]))
18321 slurp
->remaining
= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18322 available_clusters
+= counts
[MSC_sec_hwm
] - counts
[MSC_sec_lwm
];
18325 if (!flag_module_lazy
18326 || (is_partition ()
18327 && module_interface_p ()
18328 && !module_partition_p ()))
18330 /* Read the sections in forward order, so that dependencies are read
18331 first. See note about tarjan_connect. */
18336 unsigned hwm
= counts
[MSC_sec_hwm
];
18337 for (unsigned ix
= counts
[MSC_sec_lwm
]; ok
&& ix
!= hwm
; ix
++)
18338 if (!load_section (ix
, NULL
))
18344 post_load_processing ();
18348 if (ok
&& CHECKING_P
)
18349 for (unsigned ix
= 0; ix
!= entity_num
; ix
++)
18350 gcc_assert (!(*entity_ary
)[ix
+ entity_lwm
].is_lazy ());
18353 // If the import is a header-unit, we need to register initializers
18354 // of any static objects it contains (looking at you _Ioinit).
18355 // Notice, the ordering of these initializers will be that of a
18356 // dynamic initializer at this point in the current TU. (Other
18357 // instances of these objects in other TUs will be initialized as
18358 // part of that TU's global initializers.)
18359 if (ok
&& counts
[MSC_inits
] && !read_inits (counts
[MSC_inits
]))
18364 announce (flag_module_lazy
? "lazy" : "imported");
18365 loadedness
= ML_LANGUAGE
;
18367 gcc_assert (slurp
->current
== ~0u);
18369 /* We're done with the string table. */
18370 from ()->release ();
18372 return check_read (outermost
, ok
);
18376 module_state::maybe_defrost ()
18379 if (from ()->is_frozen ())
18381 if (lazy_open
>= lazy_limit
)
18383 dump () && dump ("Defrosting '%s'", filename
);
18384 ok
= from ()->defrost (maybe_add_cmi_prefix (filename
));
18391 /* Load section SNUM, dealing with laziness. It doesn't matter if we
18392 have multiple concurrent loads, because we do not use TREE_VISITED
18393 when reading back in. */
18396 module_state::load_section (unsigned snum
, binding_slot
*mslot
)
18398 if (from ()->get_error ())
18401 if (snum
>= slurp
->current
)
18402 from ()->set_error (elf::E_BAD_LAZY
);
18403 else if (maybe_defrost ())
18405 unsigned old_current
= slurp
->current
;
18406 slurp
->current
= snum
;
18407 slurp
->lru
= 0; /* Do not swap out. */
18408 slurp
->remaining
--;
18409 read_cluster (snum
);
18410 slurp
->lru
= ++lazy_lru
;
18411 slurp
->current
= old_current
;
18414 if (mslot
&& mslot
->is_lazy ())
18416 /* Oops, the section didn't set this slot. */
18417 from ()->set_error (elf::E_BAD_DATA
);
18418 *mslot
= NULL_TREE
;
18421 bool ok
= !from ()->get_error ();
18424 error_at (loc
, "failed to read compiled module cluster %u: %s",
18425 snum
, from ()->get_error (filename
));
18429 maybe_completed_reading ();
18435 module_state::maybe_completed_reading ()
18437 if (loadedness
== ML_LANGUAGE
&& slurp
->current
== ~0u && !slurp
->remaining
)
18440 /* We no longer need the macros, all tokenizing has been done. */
18441 slurp
->release_macros ();
18449 /* After a reading operation, make sure things are still ok. If not,
18450 emit an error and clean up. */
18453 module_state::check_read (bool outermost
, bool ok
)
18455 gcc_checking_assert (!outermost
|| slurp
->current
== ~0u);
18458 from ()->set_error ();
18460 if (int e
= from ()->get_error ())
18462 error_at (loc
, "failed to read compiled module: %s",
18463 from ()->get_error (filename
));
18472 inform (loc
, "consider using %<-fno-module-lazy%>,"
18473 " increasing %<-param-lazy-modules=%u%> value,"
18474 " or increasing the per-process file descriptor limit",
18475 param_lazy_modules
);
18476 else if (e
== ENOENT
)
18477 inform (loc
, "imports must be built before being imported");
18480 fatal_error (loc
, "returning to the gate for a mechanical issue");
18485 maybe_completed_reading ();
18490 /* Return the IDENTIFIER_NODE naming module IX. This is the name
18494 module_name (unsigned ix
, bool header_ok
)
18498 module_state
*imp
= (*modules
)[ix
];
18500 if (ix
&& !imp
->name
)
18503 if (header_ok
|| !imp
->is_header ())
18504 return imp
->get_flatname ();
18510 /* Return the bitmap describing what modules are imported. Remember,
18511 we always import ourselves. */
18514 get_import_bitmap ()
18516 return (*modules
)[0]->imports
;
18519 /* Return the visible imports and path of instantiation for an
18520 instantiation at TINST. If TINST is nullptr, we're not in an
18521 instantiation, and thus will return the visible imports of the
18522 current TU (and NULL *PATH_MAP_P). We cache the information on
18523 the tinst level itself. */
18526 path_of_instantiation (tinst_level
*tinst
, bitmap
*path_map_p
)
18528 gcc_checking_assert (modules_p ());
18532 /* Not inside an instantiation, just the regular case. */
18533 *path_map_p
= nullptr;
18534 return get_import_bitmap ();
18540 bitmap visible
= path_of_instantiation (tinst
->next
, path_map_p
);
18541 bitmap path_map
= *path_map_p
;
18545 path_map
= BITMAP_GGC_ALLOC ();
18546 bitmap_set_bit (path_map
, 0);
18549 tree decl
= tinst
->tldcl
;
18550 if (TREE_CODE (decl
) == TREE_LIST
)
18551 decl
= TREE_PURPOSE (decl
);
18553 decl
= TYPE_NAME (decl
);
18555 if (unsigned mod
= get_originating_module (decl
))
18556 if (!bitmap_bit_p (path_map
, mod
))
18558 /* This is brand new information! */
18559 bitmap new_path
= BITMAP_GGC_ALLOC ();
18560 bitmap_copy (new_path
, path_map
);
18561 bitmap_set_bit (new_path
, mod
);
18562 path_map
= new_path
;
18564 bitmap imports
= (*modules
)[mod
]->imports
;
18565 if (bitmap_intersect_compl_p (imports
, visible
))
18567 /* IMPORTS contains additional modules to VISIBLE. */
18568 bitmap new_visible
= BITMAP_GGC_ALLOC ();
18570 bitmap_ior (new_visible
, visible
, imports
);
18571 visible
= new_visible
;
18575 tinst
->path
= path_map
;
18576 tinst
->visible
= visible
;
18579 *path_map_p
= tinst
->path
;
18580 return tinst
->visible
;
18583 /* Return the bitmap describing what modules are visible along the
18584 path of instantiation. If we're not an instantiation, this will be
18585 the visible imports of the TU. *PATH_MAP_P is filled in with the
18586 modules owning the instantiation path -- we see the module-linkage
18587 entities of those modules. */
18590 visible_instantiation_path (bitmap
*path_map_p
)
18595 return path_of_instantiation (current_instantiation (), path_map_p
);
18598 /* We've just directly imported IMPORT. Update our import/export
18599 bitmaps. IS_EXPORT is true if we're reexporting the OTHER. */
18602 module_state::set_import (module_state
const *import
, bool is_export
)
18604 gcc_checking_assert (this != import
);
18606 /* We see IMPORT's exports (which includes IMPORT). If IMPORT is
18607 the primary interface or a partition we'll see its imports. */
18608 bitmap_ior_into (imports
, import
->is_module () || import
->is_partition ()
18609 ? import
->imports
: import
->exports
);
18612 /* We'll export OTHER's exports. */
18613 bitmap_ior_into (exports
, import
->exports
);
18616 /* Return the declaring entity of DECL. That is the decl determining
18617 how to decorate DECL with module information. Returns NULL_TREE if
18618 it's the global module. */
18621 get_originating_module_decl (tree decl
)
18623 /* An enumeration constant. */
18624 if (TREE_CODE (decl
) == CONST_DECL
18625 && DECL_CONTEXT (decl
)
18626 && (TREE_CODE (DECL_CONTEXT (decl
)) == ENUMERAL_TYPE
))
18627 decl
= TYPE_NAME (DECL_CONTEXT (decl
));
18628 else if (TREE_CODE (decl
) == FIELD_DECL
18629 || TREE_CODE (decl
) == USING_DECL
)
18631 decl
= DECL_CONTEXT (decl
);
18632 if (TREE_CODE (decl
) != FUNCTION_DECL
)
18633 decl
= TYPE_NAME (decl
);
18636 gcc_checking_assert (TREE_CODE (decl
) == TEMPLATE_DECL
18637 || TREE_CODE (decl
) == FUNCTION_DECL
18638 || TREE_CODE (decl
) == TYPE_DECL
18639 || TREE_CODE (decl
) == VAR_DECL
18640 || TREE_CODE (decl
) == CONCEPT_DECL
18641 || TREE_CODE (decl
) == NAMESPACE_DECL
);
18645 /* Uninstantiated template friends are owned by the befriending
18646 class -- not their context. */
18647 if (TREE_CODE (decl
) == TEMPLATE_DECL
18648 && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl
))
18649 decl
= TYPE_NAME (DECL_CHAIN (decl
));
18652 if (tree ti
= node_template_info (decl
, use
))
18654 decl
= TI_TEMPLATE (ti
);
18655 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18657 /* A friend template specialization. */
18658 gcc_checking_assert (OVL_P (decl
));
18659 return global_namespace
;
18664 tree ctx
= CP_DECL_CONTEXT (decl
);
18665 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
18670 ctx
= TYPE_NAME (ctx
);
18673 /* Some kind of internal type. */
18674 gcc_checking_assert (DECL_ARTIFICIAL (decl
));
18675 return global_namespace
;
18686 get_originating_module (tree decl
, bool for_mangle
)
18688 tree owner
= get_originating_module_decl (decl
);
18689 tree not_tmpl
= STRIP_TEMPLATE (owner
);
18691 if (!DECL_LANG_SPECIFIC (not_tmpl
))
18692 return for_mangle
? -1 : 0;
18694 if (for_mangle
&& !DECL_MODULE_ATTACH_P (not_tmpl
))
18697 int mod
= !DECL_MODULE_IMPORT_P (not_tmpl
) ? 0 : get_importing_module (owner
);
18698 gcc_checking_assert (!for_mangle
|| !(*modules
)[mod
]->is_header ());
18703 get_importing_module (tree decl
, bool flexible
)
18705 unsigned index
= import_entity_index (decl
, flexible
);
18706 if (index
== ~(~0u >> 1))
18708 module_state
*module
= import_entity_module (index
);
18710 return module
->mod
;
18713 /* Is it permissible to redeclare DECL. */
18716 module_may_redeclare (tree decl
)
18720 tree ctx
= CP_DECL_CONTEXT (decl
);
18721 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
18722 // Found the namespace-scope decl.
18724 if (!CLASS_TYPE_P (ctx
))
18725 // We've met a non-class scope. Such a thing is not
18726 // reopenable, so we must be ok.
18728 decl
= TYPE_NAME (ctx
);
18731 tree not_tmpl
= STRIP_TEMPLATE (decl
);
18734 if (node_template_info (not_tmpl
, use_tpl
) && use_tpl
)
18735 // Specializations of any kind can be redeclared anywhere.
18736 // FIXME: Should we be checking this in more places on the scope chain?
18739 if (!DECL_LANG_SPECIFIC (not_tmpl
) || !DECL_MODULE_ATTACH_P (not_tmpl
))
18740 // Decl is attached to global module. Current scope needs to be too.
18741 return !module_attach_p ();
18743 module_state
*me
= (*modules
)[0];
18744 module_state
*them
= me
;
18746 if (DECL_LANG_SPECIFIC (not_tmpl
) && DECL_MODULE_IMPORT_P (not_tmpl
))
18748 /* We can be given the TEMPLATE_RESULT. We want the
18751 if (tree ti
= node_template_info (decl
, use_tpl
))
18753 tree tmpl
= TI_TEMPLATE (ti
);
18756 /* A partial specialization. Find that specialization's
18758 for (tree list
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
18759 list
; list
= TREE_CHAIN (list
))
18760 if (DECL_TEMPLATE_RESULT (TREE_VALUE (list
)) == decl
)
18762 decl
= TREE_VALUE (list
);
18766 else if (DECL_TEMPLATE_RESULT (tmpl
) == decl
)
18769 unsigned index
= import_entity_index (decl
);
18770 them
= import_entity_module (index
);
18773 // Decl is attached to named module. Current scope needs to be
18774 // attaching to the same module.
18775 if (!module_attach_p ())
18778 // Both attached to named module.
18782 return me
&& get_primary (them
) == get_primary (me
);
18785 /* DECL is being created by this TU. Record it came from here. We
18786 record module purview, so we can see if partial or explicit
18787 specialization needs to be written out, even though its purviewness
18788 comes from the most general template. */
18791 set_instantiating_module (tree decl
)
18793 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
18795 || TREE_CODE (decl
) == TYPE_DECL
18796 || TREE_CODE (decl
) == CONCEPT_DECL
18797 || TREE_CODE (decl
) == TEMPLATE_DECL
18798 || (TREE_CODE (decl
) == NAMESPACE_DECL
18799 && DECL_NAMESPACE_ALIAS (decl
)));
18804 decl
= STRIP_TEMPLATE (decl
);
18806 if (!DECL_LANG_SPECIFIC (decl
) && module_purview_p ())
18807 retrofit_lang_decl (decl
);
18809 if (DECL_LANG_SPECIFIC (decl
))
18811 DECL_MODULE_PURVIEW_P (decl
) = module_purview_p ();
18812 /* If this was imported, we'll still be in the entity_hash. */
18813 DECL_MODULE_IMPORT_P (decl
) = false;
18817 /* If DECL is a class member, whose class is not defined in this TU
18818 (it was imported), remember this decl. */
18821 set_defining_module (tree decl
)
18823 gcc_checking_assert (!DECL_LANG_SPECIFIC (decl
)
18824 || !DECL_MODULE_IMPORT_P (decl
));
18826 if (module_has_cmi_p ())
18828 tree ctx
= DECL_CONTEXT (decl
);
18830 && (TREE_CODE (ctx
) == RECORD_TYPE
|| TREE_CODE (ctx
) == UNION_TYPE
)
18831 && DECL_LANG_SPECIFIC (TYPE_NAME (ctx
))
18832 && DECL_MODULE_IMPORT_P (TYPE_NAME (ctx
)))
18834 /* This entity's context is from an import. We may need to
18835 record this entity to make sure we emit it in the CMI.
18836 Template specializations are in the template hash tables,
18837 so we don't need to record them here as well. */
18839 tree ti
= node_template_info (decl
, use_tpl
);
18844 gcc_checking_assert (!use_tpl
);
18845 /* Get to the TEMPLATE_DECL. */
18846 decl
= TI_TEMPLATE (ti
);
18849 /* Record it on the class_members list. */
18850 vec_safe_push (class_members
, decl
);
18853 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
18854 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18855 /* This is a partial or explicit specialization. */
18856 vec_safe_push (partial_specializations
, decl
);
18861 set_originating_module (tree decl
, bool friend_p ATTRIBUTE_UNUSED
)
18863 set_instantiating_module (decl
);
18865 if (!DECL_NAMESPACE_SCOPE_P (decl
))
18868 gcc_checking_assert (friend_p
|| decl
== get_originating_module_decl (decl
));
18870 if (module_attach_p ())
18872 retrofit_lang_decl (decl
);
18873 DECL_MODULE_ATTACH_P (decl
) = true;
18876 if (!module_exporting_p ())
18879 // FIXME: Check ill-formed linkage
18880 DECL_MODULE_EXPORT_P (decl
) = true;
18883 /* DECL is keyed to CTX for odr purposes. */
18886 maybe_key_decl (tree ctx
, tree decl
)
18891 // FIXME: For now just deal with lambdas attached to var decls.
18892 // This might be sufficient?
18893 if (TREE_CODE (ctx
) != VAR_DECL
)
18896 gcc_checking_assert (DECL_NAMESPACE_SCOPE_P (ctx
));
18899 keyed_table
= new keyed_map_t (EXPERIMENT (1, 400));
18901 auto &vec
= keyed_table
->get_or_insert (ctx
);
18902 if (!vec
.length ())
18904 retrofit_lang_decl (ctx
);
18905 DECL_MODULE_KEYED_DECLS_P (ctx
) = true;
18907 vec
.safe_push (decl
);
18910 /* Create the flat name string. It is simplest to have it handy. */
18913 module_state::set_flatname ()
18915 gcc_checking_assert (!flatname
);
18918 auto_vec
<tree
,5> ids
;
18920 char const *primary
= NULL
;
18921 size_t pfx_len
= 0;
18923 for (module_state
*probe
= this;
18925 probe
= probe
->parent
)
18926 if (is_partition () && !probe
->is_partition ())
18928 primary
= probe
->get_flatname ();
18929 pfx_len
= strlen (primary
);
18934 ids
.safe_push (probe
->name
);
18935 len
+= IDENTIFIER_LENGTH (probe
->name
) + 1;
18938 char *flat
= XNEWVEC (char, pfx_len
+ len
+ is_partition ());
18943 memcpy (flat
, primary
, pfx_len
);
18948 for (unsigned len
= 0; ids
.length ();)
18952 tree elt
= ids
.pop ();
18953 unsigned l
= IDENTIFIER_LENGTH (elt
);
18954 memcpy (flat
+ len
, IDENTIFIER_POINTER (elt
), l
+ 1);
18958 else if (is_header ())
18959 flatname
= TREE_STRING_POINTER (name
);
18961 flatname
= IDENTIFIER_POINTER (name
);
18964 /* Read the CMI file for a module. */
18967 module_state::do_import (cpp_reader
*reader
, bool outermost
)
18969 gcc_assert (global_namespace
== current_scope () && loadedness
== ML_NONE
);
18971 loc
= linemap_module_loc (line_table
, loc
, get_flatname ());
18973 if (lazy_open
>= lazy_limit
)
18980 const char *file
= maybe_add_cmi_prefix (filename
);
18981 dump () && dump ("CMI is %s", file
);
18982 if (note_module_cmi_yes
|| inform_cmi_p
)
18983 inform (loc
, "reading CMI %qs", file
);
18984 /* Add the CMI file to the dependency tracking. */
18985 if (cpp_get_deps (reader
))
18986 deps_add_dep (cpp_get_deps (reader
), file
);
18987 fd
= open (file
, O_RDONLY
| O_CLOEXEC
| O_BINARY
);
18991 gcc_checking_assert (!slurp
);
18992 slurp
= new slurping (new elf_in (fd
, e
));
18995 if (!from ()->get_error ())
18997 announce ("importing");
18998 loadedness
= ML_CONFIG
;
19000 ok
= read_initial (reader
);
19001 slurp
->lru
= ++lazy_lru
;
19004 gcc_assert (slurp
->current
== ~0u);
19006 return check_read (outermost
, ok
);
19009 /* Attempt to increase the file descriptor limit. */
19012 try_increase_lazy (unsigned want
)
19014 gcc_checking_assert (lazy_open
>= lazy_limit
);
19016 /* If we're increasing, saturate at hard limit. */
19017 if (want
> lazy_hard_limit
&& lazy_limit
< lazy_hard_limit
)
19018 want
= lazy_hard_limit
;
19021 if ((!lazy_limit
|| !param_lazy_modules
)
19023 && want
<= lazy_hard_limit
)
19025 struct rlimit rlimit
;
19026 rlimit
.rlim_cur
= want
+ LAZY_HEADROOM
;
19027 rlimit
.rlim_max
= lazy_hard_limit
+ LAZY_HEADROOM
;
19028 if (!setrlimit (RLIMIT_NOFILE
, &rlimit
))
19033 return lazy_open
< lazy_limit
;
19036 /* Pick a victim module to freeze its reader. */
19039 module_state::freeze_an_elf ()
19041 if (try_increase_lazy (lazy_open
* 2))
19044 module_state
*victim
= NULL
;
19045 for (unsigned ix
= modules
->length (); ix
--;)
19047 module_state
*candidate
= (*modules
)[ix
];
19048 if (candidate
&& candidate
->slurp
&& candidate
->slurp
->lru
19049 && candidate
->from ()->is_freezable ()
19050 && (!victim
|| victim
->slurp
->lru
> candidate
->slurp
->lru
))
19051 victim
= candidate
;
19056 dump () && dump ("Freezing '%s'", victim
->filename
);
19057 if (victim
->slurp
->macro_defs
.size
)
19058 /* Save the macro definitions to a buffer. */
19059 victim
->from ()->preserve (victim
->slurp
->macro_defs
);
19060 if (victim
->slurp
->macro_tbl
.size
)
19061 /* Save the macro definitions to a buffer. */
19062 victim
->from ()->preserve (victim
->slurp
->macro_tbl
);
19063 victim
->from ()->freeze ();
19067 dump () && dump ("No module available for freezing");
19070 /* Load the lazy slot *MSLOT, INDEX'th slot of the module. */
19073 module_state::lazy_load (unsigned index
, binding_slot
*mslot
)
19075 unsigned n
= dump
.push (this);
19077 gcc_checking_assert (function_depth
);
19079 unsigned cookie
= mslot
->get_lazy ();
19080 unsigned snum
= cookie
>> 2;
19081 dump () && dump ("Loading entity %M[%u] section:%u", this, index
, snum
);
19083 bool ok
= load_section (snum
, mslot
);
19090 /* Load MOD's binding for NS::ID into *MSLOT. *MSLOT contains the
19091 lazy cookie. OUTER is true if this is the outermost lazy, (used
19092 for diagnostics). */
19095 lazy_load_binding (unsigned mod
, tree ns
, tree id
, binding_slot
*mslot
)
19097 int count
= errorcount
+ warningcount
;
19099 timevar_start (TV_MODULE_IMPORT
);
19101 /* Make sure lazy loading from a template context behaves as if
19102 from a non-template context. */
19103 processing_template_decl_sentinel ptds
;
19105 /* Stop GC happening, even in outermost loads (because our caller
19106 could well be building up a lookup set). */
19109 gcc_checking_assert (mod
);
19110 module_state
*module
= (*modules
)[mod
];
19111 unsigned n
= dump
.push (module
);
19113 unsigned snum
= mslot
->get_lazy ();
19114 dump () && dump ("Lazily binding %P@%N section:%u", ns
, id
,
19115 module
->name
, snum
);
19117 bool ok
= !recursive_lazy (snum
);
19120 ok
= module
->load_section (snum
, mslot
);
19122 post_load_processing ();
19129 timevar_stop (TV_MODULE_IMPORT
);
19132 fatal_error (input_location
,
19133 module
->is_header ()
19134 ? G_("failed to load binding %<%E%s%E%>")
19135 : G_("failed to load binding %<%E%s%E@%s%>"),
19136 ns
, &"::"[ns
== global_namespace
? 2 : 0], id
,
19137 module
->get_flatname ());
19139 if (count
!= errorcount
+ warningcount
)
19140 inform (input_location
,
19141 module
->is_header ()
19142 ? G_("during load of binding %<%E%s%E%>")
19143 : G_("during load of binding %<%E%s%E@%s%>"),
19144 ns
, &"::"[ns
== global_namespace
? 2 : 0], id
,
19145 module
->get_flatname ());
19148 /* Load any pending entities keyed to the top-key of DECL. */
19151 lazy_load_pendings (tree decl
)
19153 /* Make sure lazy loading from a template context behaves as if
19154 from a non-template context. */
19155 processing_template_decl_sentinel ptds
;
19159 key
.ns
= find_pending_key (decl
, &key_decl
);
19160 key
.id
= DECL_NAME (key_decl
);
19162 auto *pending_vec
= pending_table
? pending_table
->get (key
) : nullptr;
19166 int count
= errorcount
+ warningcount
;
19168 timevar_start (TV_MODULE_IMPORT
);
19169 bool ok
= !recursive_lazy ();
19172 function_depth
++; /* Prevent GC */
19173 unsigned n
= dump
.push (NULL
);
19174 dump () && dump ("Reading %u pending entities keyed to %P",
19175 pending_vec
->length (), key
.ns
, key
.id
);
19176 for (unsigned ix
= pending_vec
->length (); ix
--;)
19178 unsigned index
= (*pending_vec
)[ix
];
19179 binding_slot
*slot
= &(*entity_ary
)[index
];
19181 if (slot
->is_lazy ())
19183 module_state
*import
= import_entity_module (index
);
19184 if (!import
->lazy_load (index
- import
->entity_lwm
, slot
))
19189 module_state
*import
= import_entity_module (index
);
19190 dump () && dump ("Entity %M[%u] already loaded",
19191 import
, index
- import
->entity_lwm
);
19195 pending_table
->remove (key
);
19198 post_load_processing ();
19202 timevar_stop (TV_MODULE_IMPORT
);
19205 fatal_error (input_location
, "failed to load pendings for %<%E%s%E%>",
19206 key
.ns
, &"::"[key
.ns
== global_namespace
? 2 : 0], key
.id
);
19208 if (count
!= errorcount
+ warningcount
)
19209 inform (input_location
, "during load of pendings for %<%E%s%E%>",
19210 key
.ns
, &"::"[key
.ns
== global_namespace
? 2 : 0], key
.id
);
19214 direct_import (module_state
*import
, cpp_reader
*reader
)
19216 timevar_start (TV_MODULE_IMPORT
);
19217 unsigned n
= dump
.push (import
);
19219 gcc_checking_assert (import
->is_direct () && import
->has_location ());
19220 if (import
->loadedness
== ML_NONE
)
19221 if (!import
->do_import (reader
, true))
19222 gcc_unreachable ();
19224 if (import
->loadedness
< ML_LANGUAGE
)
19227 keyed_table
= new keyed_map_t (EXPERIMENT (1, 400));
19228 import
->read_language (true);
19231 (*modules
)[0]->set_import (import
, import
->exported_p
);
19234 timevar_stop (TV_MODULE_IMPORT
);
19237 /* Import module IMPORT. */
19240 import_module (module_state
*import
, location_t from_loc
, bool exporting_p
,
19241 tree
, cpp_reader
*reader
)
19243 if (!import
->check_not_purview (from_loc
))
19246 if (!import
->is_header () && current_lang_depth ())
19247 /* Only header units should appear inside language
19248 specifications. The std doesn't specify this, but I think
19249 that's an error in resolving US 033, because language linkage
19250 is also our escape clause to getting things into the global
19251 module, so we don't want to confuse things by having to think
19252 about whether 'extern "C++" { import foo; }' puts foo's
19253 contents into the global module all of a sudden. */
19254 warning (0, "import of named module %qs inside language-linkage block",
19255 import
->get_flatname ());
19257 if (exporting_p
|| module_exporting_p ())
19258 import
->exported_p
= true;
19260 if (import
->loadedness
!= ML_NONE
)
19262 from_loc
= ordinary_loc_of (line_table
, from_loc
);
19263 linemap_module_reparent (line_table
, import
->loc
, from_loc
);
19265 gcc_checking_assert (!import
->module_p
);
19266 gcc_checking_assert (import
->is_direct () && import
->has_location ());
19268 direct_import (import
, reader
);
19271 /* Declare the name of the current module to be NAME. EXPORTING_p is
19272 true if this TU is the exporting module unit. */
19275 declare_module (module_state
*module
, location_t from_loc
, bool exporting_p
,
19276 tree
, cpp_reader
*reader
)
19278 gcc_assert (global_namespace
== current_scope ());
19280 module_state
*current
= (*modules
)[0];
19281 if (module_purview_p () || module
->loadedness
> ML_CONFIG
)
19283 error_at (from_loc
, module_purview_p ()
19284 ? G_("module already declared")
19285 : G_("module already imported"));
19286 if (module_purview_p ())
19288 inform (module
->loc
, module_purview_p ()
19289 ? G_("module %qs declared here")
19290 : G_("module %qs imported here"),
19291 module
->get_flatname ());
19295 gcc_checking_assert (module
->module_p
);
19296 gcc_checking_assert (module
->is_direct () && module
->has_location ());
19298 /* Yer a module, 'arry. */
19299 module_kind
= module
->is_header () ? MK_HEADER
: MK_NAMED
| MK_ATTACH
;
19301 // Even in header units, we consider the decls to be purview
19302 module_kind
|= MK_PURVIEW
;
19304 if (module
->is_partition ())
19305 module_kind
|= MK_PARTITION
;
19308 module
->interface_p
= true;
19309 module_kind
|= MK_INTERFACE
;
19312 if (module_has_cmi_p ())
19314 /* Copy the importing information we may have already done. We
19315 do not need to separate out the imports that only happen in
19316 the GMF, inspite of what the literal wording of the std
19317 might imply. See p2191, the core list had a discussion
19318 where the module implementors agreed that the GMF of a named
19319 module is invisible to importers. */
19320 module
->imports
= current
->imports
;
19323 (*modules
)[0] = module
;
19327 module
->interface_p
= true;
19328 current
->parent
= module
; /* So mangler knows module identity. */
19329 direct_import (module
, reader
);
19333 /* Return true IFF we must emit a module global initializer function
19334 (which will be called by importers' init code). */
19337 module_global_init_needed ()
19339 return module_has_cmi_p () && !header_module_p ();
19342 /* Calculate which, if any, import initializers need calling. */
19345 module_determine_import_inits ()
19347 if (!modules
|| header_module_p ())
19350 /* Prune active_init_p. We need the same bitmap allocation
19351 scheme as for the imports member. */
19352 function_depth
++; /* Disable GC. */
19353 bitmap
covered_imports (BITMAP_GGC_ALLOC ());
19357 /* Because indirect imports are before their direct import, and
19358 we're scanning the array backwards, we only need one pass! */
19359 for (unsigned ix
= modules
->length (); --ix
;)
19361 module_state
*import
= (*modules
)[ix
];
19363 if (!import
->active_init_p
)
19365 else if (bitmap_bit_p (covered_imports
, ix
))
19366 import
->active_init_p
= false;
19369 /* Everything this imports is therefore handled by its
19370 initializer, so doesn't need initializing by us. */
19371 bitmap_ior_into (covered_imports
, import
->imports
);
19380 /* Emit calls to each direct import's global initializer. Including
19381 direct imports of directly imported header units. The initializers
19382 of (static) entities in header units will be called by their
19383 importing modules (for the instance contained within that), or by
19384 the current TU (for the instances we've brought in). Of course
19385 such header unit behaviour is evil, but iostream went through that
19386 door some time ago. */
19389 module_add_import_initializers ()
19391 if (!modules
|| header_module_p ())
19394 tree fntype
= build_function_type (void_type_node
, void_list_node
);
19395 releasing_vec args
; // There are no args
19397 for (unsigned ix
= modules
->length (); --ix
;)
19399 module_state
*import
= (*modules
)[ix
];
19400 if (import
->active_init_p
)
19402 tree name
= mangle_module_global_init (ix
);
19403 tree fndecl
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
19405 DECL_CONTEXT (fndecl
) = FROB_CONTEXT (global_namespace
);
19406 SET_DECL_ASSEMBLER_NAME (fndecl
, name
);
19407 TREE_PUBLIC (fndecl
) = true;
19408 determine_visibility (fndecl
);
19410 tree call
= cp_build_function_call_vec (fndecl
, &args
,
19411 tf_warning_or_error
);
19412 finish_expr_stmt (call
);
19417 /* NAME & LEN are a preprocessed header name, possibly including the
19418 surrounding "" or <> characters. Return the raw string name of the
19419 module to which it refers. This will be an absolute path, or begin
19420 with ./, so it is immediately distinguishable from a (non-header
19421 unit) module name. If READER is non-null, ask the preprocessor to
19422 locate the header to which it refers using the appropriate include
19423 path. Note that we do never do \ processing of the string, as that
19424 matches the preprocessor's behaviour. */
19426 static const char *
19427 canonicalize_header_name (cpp_reader
*reader
, location_t loc
, bool unquoted
,
19428 const char *str
, size_t &len_r
)
19430 size_t len
= len_r
;
19431 static char *buf
= 0;
19432 static size_t alloc
= 0;
19436 gcc_checking_assert (len
>= 2
19437 && ((reader
&& str
[0] == '<' && str
[len
-1] == '>')
19438 || (str
[0] == '"' && str
[len
-1] == '"')));
19445 gcc_assert (!unquoted
);
19450 buf
= XRESIZEVEC (char, buf
, alloc
);
19452 memcpy (buf
, str
, len
);
19455 if (const char *hdr
19456 = cpp_probe_header_unit (reader
, buf
, str
[-1] == '<', loc
))
19458 len
= strlen (hdr
);
19465 if (!(str
[0] == '.' ? IS_DIR_SEPARATOR (str
[1]) : IS_ABSOLUTE_PATH (str
)))
19468 if (len
+ 3 > alloc
)
19471 buf
= XRESIZEVEC (char, buf
, alloc
);
19475 buf
[1] = DIR_SEPARATOR
;
19476 memmove (buf
+ 2, str
, len
);
19486 /* Set the CMI name from a cody packet. Issue an error if
19489 void module_state::set_filename (const Cody::Packet
&packet
)
19491 gcc_checking_assert (!filename
);
19492 if (packet
.GetCode () == Cody::Client::PC_PATHNAME
)
19493 filename
= xstrdup (packet
.GetString ().c_str ());
19496 gcc_checking_assert (packet
.GetCode () == Cody::Client::PC_ERROR
);
19497 error_at (loc
, "unknown Compiled Module Interface: %s",
19498 packet
.GetString ().c_str ());
19502 /* Figure out whether to treat HEADER as an include or an import. */
19505 maybe_translate_include (cpp_reader
*reader
, line_maps
*lmaps
, location_t loc
,
19511 cpp_get_callbacks (reader
)->translate_include
= NULL
;
19515 if (!spans
.init_p ())
19516 /* Before the main file, don't divert. */
19521 dump () && dump ("Checking include translation '%s'", path
);
19522 auto *mapper
= get_mapper (cpp_main_loc (reader
), cpp_get_deps (reader
));
19524 size_t len
= strlen (path
);
19525 path
= canonicalize_header_name (NULL
, loc
, true, path
, len
);
19526 auto packet
= mapper
->IncludeTranslate (path
, Cody::Flags::None
, len
);
19528 if (packet
.GetCode () == Cody::Client::PC_BOOL
)
19529 xlate
= -int (packet
.GetInteger ());
19530 else if (packet
.GetCode () == Cody::Client::PC_PATHNAME
)
19532 /* Record the CMI name for when we do the import. */
19533 module_state
*import
= get_module (build_string (len
, path
));
19534 import
->set_filename (packet
);
19539 gcc_checking_assert (packet
.GetCode () == Cody::Client::PC_ERROR
);
19540 error_at (loc
, "cannot determine %<#include%> translation of %s: %s",
19541 path
, packet
.GetString ().c_str ());
19545 if (note_include_translate_yes
&& xlate
> 1)
19547 else if (note_include_translate_no
&& xlate
== 0)
19549 else if (note_includes
)
19550 /* We do not expect the note_includes vector to be large, so O(N)
19552 for (unsigned ix
= note_includes
->length (); !note
&& ix
--;)
19553 if (!strcmp ((*note_includes
)[ix
], path
))
19558 ? G_("include %qs translated to import")
19559 : G_("include %qs processed textually") , path
);
19561 dump () && dump (xlate
? "Translating include to import"
19562 : "Keeping include as include");
19568 /* Create the translation text. */
19569 loc
= ordinary_loc_of (lmaps
, loc
);
19570 const line_map_ordinary
*map
19571 = linemap_check_ordinary (linemap_lookup (lmaps
, loc
));
19572 unsigned col
= SOURCE_COLUMN (map
, loc
);
19573 col
-= (col
!= 0); /* Columns are 1-based. */
19575 unsigned alloc
= len
+ col
+ 60;
19576 char *res
= XNEWVEC (char, alloc
);
19578 strcpy (res
, "__import");
19579 unsigned actual
= 8;
19582 /* Pad out so the filename appears at the same position. */
19583 memset (res
+ actual
, ' ', col
- actual
);
19586 /* No need to encode characters, that's not how header names are
19588 actual
+= snprintf (res
+ actual
, alloc
- actual
,
19589 "\"%s\" [[__translated]];\n", path
);
19590 gcc_checking_assert (actual
< alloc
);
19592 /* cpplib will delete the buffer. */
19597 begin_header_unit (cpp_reader
*reader
)
19599 /* Set the module header name from the main_input_filename. */
19600 const char *main
= main_input_filename
;
19601 size_t len
= strlen (main
);
19602 main
= canonicalize_header_name (NULL
, 0, true, main
, len
);
19603 module_state
*module
= get_module (build_string (len
, main
));
19605 preprocess_module (module
, cpp_main_loc (reader
), false, false, true, reader
);
19608 /* We've just properly entered the main source file. I.e. after the
19609 command line, builtins and forced headers. Record the line map and
19610 location of this map. Note we may be called more than once. The
19611 first call sticks. */
19614 module_begin_main_file (cpp_reader
*reader
, line_maps
*lmaps
,
19615 const line_map_ordinary
*map
)
19617 gcc_checking_assert (lmaps
== line_table
);
19618 if (modules_p () && !spans
.init_p ())
19620 unsigned n
= dump
.push (NULL
);
19621 spans
.init (lmaps
, map
);
19623 if (flag_header_unit
&& !cpp_get_options (reader
)->preprocessed
)
19625 /* Tell the preprocessor this is an include file. */
19626 cpp_retrofit_as_include (reader
);
19627 begin_header_unit (reader
);
19632 /* Process the pending_import queue, making sure we know the
19636 name_pending_imports (cpp_reader
*reader
)
19638 auto *mapper
= get_mapper (cpp_main_loc (reader
), cpp_get_deps (reader
));
19640 if (!vec_safe_length (pending_imports
))
19641 /* Not doing anything. */
19644 timevar_start (TV_MODULE_MAPPER
);
19646 auto n
= dump
.push (NULL
);
19647 dump () && dump ("Resolving direct import names");
19648 bool want_deps
= (bool (mapper
->get_flags () & Cody::Flags::NameOnly
)
19649 || cpp_get_deps (reader
));
19652 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19654 module_state
*module
= (*pending_imports
)[ix
];
19655 gcc_checking_assert (module
->is_direct ());
19656 if (!module
->filename
&& !module
->visited_p
)
19658 bool export_p
= (module
->module_p
19659 && (module
->is_partition () || module
->exported_p
));
19661 Cody::Flags flags
= Cody::Flags::None
;
19662 if (flag_preprocess_only
19663 && !(module
->is_header () && !export_p
))
19667 flags
= Cody::Flags::NameOnly
;
19676 mapper
->ModuleExport (module
->get_flatname (), flags
);
19678 mapper
->ModuleImport (module
->get_flatname (), flags
);
19679 module
->visited_p
= true;
19685 auto response
= mapper
->Uncork ();
19686 auto r_iter
= response
.begin ();
19687 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19689 module_state
*module
= (*pending_imports
)[ix
];
19690 if (module
->visited_p
)
19692 module
->visited_p
= false;
19693 gcc_checking_assert (!module
->filename
);
19695 module
->set_filename (*r_iter
);
19703 timevar_stop (TV_MODULE_MAPPER
);
19706 /* We've just lexed a module-specific control line for MODULE. Mark
19707 the module as a direct import, and possibly load up its macro
19708 state. Returns the primary module, if this is a module
19710 /* Perhaps we should offer a preprocessing mode where we read the
19711 directives from the header unit, rather than require the header's
19715 preprocess_module (module_state
*module
, location_t from_loc
,
19716 bool in_purview
, bool is_import
, bool is_export
,
19717 cpp_reader
*reader
)
19722 /* It's already been mentioned, so ignore its module-ness. */
19726 /* Record it is the module. */
19727 module
->module_p
= true;
19730 module
->exported_p
= true;
19731 module
->interface_p
= true;
19736 if (module
->directness
< MD_DIRECT
+ in_purview
)
19738 /* Mark as a direct import. */
19739 module
->directness
= module_directness (MD_DIRECT
+ in_purview
);
19741 /* Set the location to be most informative for users. */
19742 from_loc
= ordinary_loc_of (line_table
, from_loc
);
19743 if (module
->loadedness
!= ML_NONE
)
19744 linemap_module_reparent (line_table
, module
->loc
, from_loc
);
19747 module
->loc
= from_loc
;
19748 if (!module
->flatname
)
19749 module
->set_flatname ();
19753 auto desired
= ML_CONFIG
;
19755 && module
->is_header ()
19756 && (!cpp_get_options (reader
)->preprocessed
19757 || cpp_get_options (reader
)->directives_only
))
19758 /* We need preprocessor state now. */
19759 desired
= ML_PREPROCESSOR
;
19761 if (!is_import
|| module
->loadedness
< desired
)
19763 vec_safe_push (pending_imports
, module
);
19765 if (desired
== ML_PREPROCESSOR
)
19767 unsigned n
= dump
.push (NULL
);
19769 dump () && dump ("Reading %M preprocessor state", module
);
19770 name_pending_imports (reader
);
19772 /* Preserve the state of the line-map. */
19773 unsigned pre_hwm
= LINEMAPS_ORDINARY_USED (line_table
);
19775 /* We only need to close the span, if we're going to emit a
19776 CMI. But that's a little tricky -- our token scanner
19777 needs to be smarter -- and this isn't much state.
19778 Remember, we've not parsed anything at this point, so
19779 our module state flags are inadequate. */
19780 spans
.maybe_init ();
19783 timevar_start (TV_MODULE_IMPORT
);
19785 /* Load the config of each pending import -- we must assign
19786 module numbers monotonically. */
19787 for (unsigned ix
= 0; ix
!= pending_imports
->length (); ix
++)
19789 auto *import
= (*pending_imports
)[ix
];
19790 if (!(import
->module_p
19791 && (import
->is_partition () || import
->exported_p
))
19792 && import
->loadedness
== ML_NONE
19793 && (import
->is_header () || !flag_preprocess_only
))
19795 unsigned n
= dump
.push (import
);
19796 import
->do_import (reader
, true);
19800 vec_free (pending_imports
);
19802 /* Restore the line-map state. */
19803 spans
.open (linemap_module_restore (line_table
, pre_hwm
));
19805 /* Now read the preprocessor state of this particular
19807 if (module
->loadedness
== ML_CONFIG
19808 && module
->read_preprocessor (true))
19809 module
->import_macros ();
19811 timevar_stop (TV_MODULE_IMPORT
);
19817 return is_import
? NULL
: get_primary (module
);
19820 /* We've completed phase-4 translation. Emit any dependency
19821 information for the not-yet-loaded direct imports, and fill in
19822 their file names. We'll have already loaded up the direct header
19826 preprocessed_module (cpp_reader
*reader
)
19828 unsigned n
= dump
.push (NULL
);
19830 dump () && dump ("Completed phase-4 (tokenization) processing");
19832 name_pending_imports (reader
);
19833 vec_free (pending_imports
);
19835 spans
.maybe_init ();
19838 using iterator
= hash_table
<module_state_hash
>::iterator
;
19839 if (mkdeps
*deps
= cpp_get_deps (reader
))
19841 /* Walk the module hash, informing the dependency machinery. */
19842 iterator end
= modules_hash
->end ();
19843 for (iterator iter
= modules_hash
->begin (); iter
!= end
; ++iter
)
19845 module_state
*module
= *iter
;
19847 if (module
->is_direct ())
19849 if (module
->is_module ()
19850 && (module
->is_interface () || module
->is_partition ()))
19851 deps_add_module_target (deps
, module
->get_flatname (),
19852 maybe_add_cmi_prefix (module
->filename
),
19853 module
->is_header (),
19854 module
->is_exported ());
19856 deps_add_module_dep (deps
, module
->get_flatname ());
19861 if (flag_header_unit
&& !flag_preprocess_only
)
19863 /* Find the main module -- remember, it's not yet in the module
19865 iterator end
= modules_hash
->end ();
19866 for (iterator iter
= modules_hash
->begin (); iter
!= end
; ++iter
)
19868 module_state
*module
= *iter
;
19869 if (module
->is_module ())
19871 declare_module (module
, cpp_main_loc (reader
), true, NULL
, reader
);
19872 module_kind
|= MK_EXPORTING
;
19881 /* VAL is a global tree, add it to the global vec if it is
19882 interesting. Add some of its targets, if they too are
19883 interesting. We do not add identifiers, as they can be re-found
19884 via the identifier hash table. There is a cost to the number of
19888 maybe_add_global (tree val
, unsigned &crc
)
19892 if (val
&& !(identifier_p (val
) || TREE_VISITED (val
)))
19894 TREE_VISITED (val
) = true;
19895 crc
= crc32_unsigned (crc
, fixed_trees
->length ());
19896 vec_safe_push (fixed_trees
, val
);
19899 if (CODE_CONTAINS_STRUCT (TREE_CODE (val
), TS_TYPED
))
19900 v
+= maybe_add_global (TREE_TYPE (val
), crc
);
19901 if (CODE_CONTAINS_STRUCT (TREE_CODE (val
), TS_TYPE_COMMON
))
19902 v
+= maybe_add_global (TYPE_NAME (val
), crc
);
19908 /* Initialize module state. Create the hash table, determine the
19909 global trees. Create the module for current TU. */
19912 init_modules (cpp_reader
*reader
)
19914 /* PCH should not be reachable because of lang-specs, but the
19915 user could have overriden that. */
19917 fatal_error (input_location
,
19918 "C++ modules are incompatible with precompiled headers");
19920 if (cpp_get_options (reader
)->traditional
)
19921 fatal_error (input_location
,
19922 "C++ modules are incompatible with traditional preprocessing");
19924 if (flag_preprocess_only
)
19926 cpp_options
*cpp_opts
= cpp_get_options (reader
);
19928 || (cpp_opts
->deps
.style
!= DEPS_NONE
19929 && !cpp_opts
->deps
.need_preprocessor_output
))
19931 warning (0, flag_dump_macros
== 'M'
19932 ? G_("macro debug output may be incomplete with modules")
19933 : G_("module dependencies require preprocessing"));
19934 if (cpp_opts
->deps
.style
!= DEPS_NONE
)
19935 inform (input_location
, "you should use the %<-%s%> option",
19936 cpp_opts
->deps
.style
== DEPS_SYSTEM
? "MD" : "MMD");
19940 /* :: is always exported. */
19941 DECL_MODULE_EXPORT_P (global_namespace
) = true;
19943 modules_hash
= hash_table
<module_state_hash
>::create_ggc (31);
19944 vec_safe_reserve (modules
, 20);
19946 /* Create module for current TU. */
19947 module_state
*current
19948 = new (ggc_alloc
<module_state
> ()) module_state (NULL_TREE
, NULL
, false);
19950 bitmap_set_bit (current
->imports
, 0);
19951 modules
->quick_push (current
);
19953 gcc_checking_assert (!fixed_trees
);
19955 headers
= BITMAP_GGC_ALLOC ();
19958 /* Canonicalize header names. */
19959 for (unsigned ix
= 0; ix
!= note_includes
->length (); ix
++)
19961 const char *hdr
= (*note_includes
)[ix
];
19962 size_t len
= strlen (hdr
);
19964 bool system
= hdr
[0] == '<';
19965 bool user
= hdr
[0] == '"';
19966 bool delimed
= system
|| user
;
19968 if (len
<= (delimed
? 2 : 0)
19969 || (delimed
&& hdr
[len
-1] != (system
? '>' : '"')))
19970 error ("invalid header name %qs", hdr
);
19972 hdr
= canonicalize_header_name (delimed
? reader
: NULL
,
19973 0, !delimed
, hdr
, len
);
19974 char *path
= XNEWVEC (char, len
+ 1);
19975 memcpy (path
, hdr
, len
);
19978 (*note_includes
)[ix
] = path
;
19982 /* Canonicalize & mark module names. */
19983 for (unsigned ix
= 0; ix
!= note_cmis
->length (); ix
++)
19985 const char *name
= (*note_cmis
)[ix
];
19986 size_t len
= strlen (name
);
19988 bool is_system
= name
[0] == '<';
19989 bool is_user
= name
[0] == '"';
19990 bool is_pathname
= false;
19991 if (!(is_system
|| is_user
))
19992 for (unsigned ix
= len
; !is_pathname
&& ix
--;)
19993 is_pathname
= IS_DIR_SEPARATOR (name
[ix
]);
19994 if (is_system
|| is_user
|| is_pathname
)
19996 if (len
<= (is_pathname
? 0 : 2)
19997 || (!is_pathname
&& name
[len
-1] != (is_system
? '>' : '"')))
19999 error ("invalid header name %qs", name
);
20003 name
= canonicalize_header_name (is_pathname
? nullptr : reader
,
20004 0, is_pathname
, name
, len
);
20006 if (auto module
= get_module (name
))
20007 module
->inform_cmi_p
= 1;
20009 error ("invalid module name %qs", name
);
20014 /* Determine lazy handle bound. */
20016 unsigned limit
= 1000;
20018 struct rlimit rlimit
;
20019 if (!getrlimit (RLIMIT_NOFILE
, &rlimit
))
20021 lazy_hard_limit
= (rlimit
.rlim_max
< 1000000
20022 ? unsigned (rlimit
.rlim_max
) : 1000000);
20023 lazy_hard_limit
= (lazy_hard_limit
> LAZY_HEADROOM
20024 ? lazy_hard_limit
- LAZY_HEADROOM
: 0);
20025 if (rlimit
.rlim_cur
< limit
)
20026 limit
= unsigned (rlimit
.rlim_cur
);
20029 limit
= limit
> LAZY_HEADROOM
? limit
- LAZY_HEADROOM
: 1;
20031 if (unsigned parm
= param_lazy_modules
)
20033 if (parm
<= limit
|| !lazy_hard_limit
|| !try_increase_lazy (parm
))
20037 lazy_limit
= limit
;
20043 version2string (MODULE_VERSION
, ver
);
20044 dump ("Source: %s", main_input_filename
);
20045 dump ("Compiler: %s", version_string
);
20046 dump ("Modules: %s", ver
);
20047 dump ("Checking: %s",
20050 #elif ENABLE_ASSERT_CHECKING
20056 dump ("Compiled by: "
20058 "GCC %d.%d, %s", __GNUC__
, __GNUC_MINOR__
,
20059 #ifdef __OPTIMIZE__
20068 dump ("Reading: %s", MAPPED_READING
? "mmap" : "fileio");
20069 dump ("Writing: %s", MAPPED_WRITING
? "mmap" : "fileio");
20070 dump ("Lazy limit: %u", lazy_limit
);
20071 dump ("Lazy hard limit: %u", lazy_hard_limit
);
20075 /* Construct the global tree array. This is an array of unique
20076 global trees (& types). Do this now, rather than lazily, as
20077 some global trees are lazily created and we don't want that to
20078 mess with our syndrome of fixed trees. */
20080 vec_alloc (fixed_trees
, 200);
20082 dump () && dump ("+Creating globals");
20083 /* Insert the TRANSLATION_UNIT_DECL. */
20084 TREE_VISITED (DECL_CONTEXT (global_namespace
)) = true;
20085 fixed_trees
->quick_push (DECL_CONTEXT (global_namespace
));
20086 for (unsigned jx
= 0; global_tree_arys
[jx
].first
; jx
++)
20088 const tree
*ptr
= global_tree_arys
[jx
].first
;
20089 unsigned limit
= global_tree_arys
[jx
].second
;
20091 for (unsigned ix
= 0; ix
!= limit
; ix
++, ptr
++)
20093 !(ix
& 31) && dump ("") && dump ("+\t%u:%u:", jx
, ix
);
20094 unsigned v
= maybe_add_global (*ptr
, crc
);
20095 dump () && dump ("+%u", v
);
20098 global_crc
= crc32_unsigned (crc
, fixed_trees
->length ());
20099 dump ("") && dump ("Created %u unique globals, crc=%x",
20100 fixed_trees
->length (), global_crc
);
20101 for (unsigned ix
= fixed_trees
->length (); ix
--;)
20102 TREE_VISITED ((*fixed_trees
)[ix
]) = false;
20106 if (!flag_module_lazy
)
20107 /* Get the mapper now, if we're not being lazy. */
20108 get_mapper (cpp_main_loc (reader
), cpp_get_deps (reader
));
20110 if (!flag_preprocess_only
)
20112 pending_table
= new pending_map_t (EXPERIMENT (1, 400));
20113 entity_map
= new entity_map_t (EXPERIMENT (1, 400));
20114 vec_safe_reserve (entity_ary
, EXPERIMENT (1, 400));
20118 note_defs
= note_defs_table_t::create_ggc (1000);
20121 if (flag_header_unit
&& cpp_get_options (reader
)->preprocessed
)
20122 begin_header_unit (reader
);
20124 /* Collect here to make sure things are tagged correctly (when
20125 aggressively GC'd). */
20129 /* If NODE is a deferred macro, load it. */
20132 load_macros (cpp_reader
*reader
, cpp_hashnode
*node
, void *)
20134 location_t main_loc
20135 = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table
, 0));
20137 if (cpp_user_macro_p (node
)
20138 && !node
->value
.macro
)
20140 cpp_macro
*macro
= cpp_get_deferred_macro (reader
, node
, main_loc
);
20141 dump () && dump ("Loaded macro #%s %I",
20142 macro
? "define" : "undef", identifier (node
));
20148 /* At the end of tokenizing, we no longer need the macro tables of
20149 imports. But the user might have requested some checking. */
20152 maybe_check_all_macros (cpp_reader
*reader
)
20154 if (!warn_imported_macros
)
20157 /* Force loading of any remaining deferred macros. This will
20158 produce diagnostics if they are ill-formed. */
20159 unsigned n
= dump
.push (NULL
);
20160 cpp_forall_identifiers (reader
, load_macros
, NULL
);
20164 // State propagated from finish_module_processing to fini_modules
20166 struct module_processing_cookie
20169 module_state_config config
;
20175 module_processing_cookie (char *cmi
, char *tmp
, int fd
, int e
)
20176 : out (fd
, e
), cmi_name (cmi
), tmp_name (tmp
), crc (0), began (false)
20179 ~module_processing_cookie ()
20181 XDELETEVEC (tmp_name
);
20182 XDELETEVEC (cmi_name
);
20186 /* Write the CMI, if we're a module interface. */
20189 finish_module_processing (cpp_reader
*reader
)
20191 module_processing_cookie
*cookie
= nullptr;
20193 if (header_module_p ())
20194 module_kind
&= ~MK_EXPORTING
;
20196 if (!modules
|| !(*modules
)[0]->name
)
20198 if (flag_module_only
)
20199 warning (0, "%<-fmodule-only%> used for non-interface");
20201 else if (!flag_syntax_only
)
20206 timevar_start (TV_MODULE_EXPORT
);
20208 /* Force a valid but empty line map at the end. This simplifies
20209 the line table preparation and writing logic. */
20210 linemap_add (line_table
, LC_ENTER
, false, "", 0);
20212 /* We write to a tmpname, and then atomically rename. */
20213 char *cmi_name
= NULL
;
20214 char *tmp_name
= NULL
;
20215 module_state
*state
= (*modules
)[0];
20217 unsigned n
= dump
.push (state
);
20218 state
->announce ("creating");
20219 if (state
->filename
)
20222 cmi_name
= xstrdup (maybe_add_cmi_prefix (state
->filename
, &len
));
20223 tmp_name
= XNEWVEC (char, len
+ 3);
20224 memcpy (tmp_name
, cmi_name
, len
);
20225 strcpy (&tmp_name
[len
], "~");
20228 for (unsigned again
= 2; ; again
--)
20230 fd
= open (tmp_name
,
20231 O_RDWR
| O_CREAT
| O_TRUNC
| O_CLOEXEC
| O_BINARY
,
20232 S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IWGRP
|S_IROTH
|S_IWOTH
);
20234 if (fd
>= 0 || !again
|| e
!= ENOENT
)
20236 create_dirs (tmp_name
);
20238 if (note_module_cmi_yes
|| state
->inform_cmi_p
)
20239 inform (state
->loc
, "writing CMI %qs", cmi_name
);
20240 dump () && dump ("CMI is %s", cmi_name
);
20243 cookie
= new module_processing_cookie (cmi_name
, tmp_name
, fd
, e
);
20246 warning_at (state
->loc
, 0, "not writing module %qs due to errors",
20247 state
->get_flatname ());
20248 else if (cookie
->out
.begin ())
20250 cookie
->began
= true;
20251 auto loc
= input_location
;
20252 /* So crashes finger-point the module decl. */
20253 input_location
= state
->loc
;
20254 state
->write_begin (&cookie
->out
, reader
, cookie
->config
, cookie
->crc
);
20255 input_location
= loc
;
20259 timevar_stop (TV_MODULE_EXPORT
);
20266 unsigned n
= dump
.push (NULL
);
20267 dump () && dump ("Imported %u modules", modules
->length () - 1);
20268 dump () && dump ("Containing %u clusters", available_clusters
);
20269 dump () && dump ("Loaded %u clusters (%u%%)", loaded_clusters
,
20270 (loaded_clusters
* 100 + available_clusters
/ 2) /
20271 (available_clusters
+ !available_clusters
));
20278 // Do the final emission of a module. At this point we know whether
20279 // the module static initializer is a NOP or not.
20282 late_finish_module (cpp_reader
*reader
, module_processing_cookie
*cookie
,
20283 bool init_fn_non_empty
)
20285 timevar_start (TV_MODULE_EXPORT
);
20287 module_state
*state
= (*modules
)[0];
20288 unsigned n
= dump
.push (state
);
20289 state
->announce ("finishing");
20291 cookie
->config
.active_init
= init_fn_non_empty
;
20293 state
->write_end (&cookie
->out
, reader
, cookie
->config
, cookie
->crc
);
20295 if (cookie
->out
.end () && cookie
->cmi_name
)
20297 /* Some OS's do not replace NEWNAME if it already exists.
20298 This'll have a race condition in erroneous concurrent
20300 unlink (cookie
->cmi_name
);
20301 if (rename (cookie
->tmp_name
, cookie
->cmi_name
))
20303 dump () && dump ("Rename ('%s','%s') errno=%u",
20304 cookie
->tmp_name
, cookie
->cmi_name
, errno
);
20305 cookie
->out
.set_error (errno
);
20309 if (cookie
->out
.get_error () && cookie
->began
)
20311 error_at (state
->loc
, "failed to write compiled module: %s",
20312 cookie
->out
.get_error (state
->filename
));
20313 state
->note_cmi_name ();
20318 auto *mapper
= get_mapper (cpp_main_loc (reader
), cpp_get_deps (reader
));
20319 mapper
->ModuleCompiled (state
->get_flatname ());
20321 else if (cookie
->cmi_name
)
20323 /* We failed, attempt to erase all evidence we even tried. */
20324 unlink (cookie
->tmp_name
);
20325 unlink (cookie
->cmi_name
);
20330 timevar_stop (TV_MODULE_EXPORT
);
20334 fini_modules (cpp_reader
*reader
, void *cookie
, bool has_inits
)
20337 late_finish_module (reader
,
20338 static_cast<module_processing_cookie
*> (cookie
),
20341 /* We're done with the macro tables now. */
20342 vec_free (macro_exports
);
20343 vec_free (macro_imports
);
20346 /* We're now done with everything but the module names. */
20347 set_cmi_repo (NULL
);
20350 timevar_start (TV_MODULE_MAPPER
);
20351 module_client::close_module_client (0, mapper
);
20353 timevar_stop (TV_MODULE_MAPPER
);
20355 module_state_config::release ();
20362 for (unsigned ix
= modules
->length (); --ix
;)
20363 if (module_state
*state
= (*modules
)[ix
])
20366 /* No need to lookup modules anymore. */
20367 modules_hash
= NULL
;
20369 /* Or entity array. We still need the entity map to find import numbers. */
20370 vec_free (entity_ary
);
20373 /* Or remember any pending entities. */
20374 delete pending_table
;
20375 pending_table
= NULL
;
20377 /* Or any keys -- Let it go! */
20378 delete keyed_table
;
20379 keyed_table
= NULL
;
20381 /* Allow a GC, we've possibly made much data unreachable. */
20385 /* If CODE is a module option, handle it & return true. Otherwise
20386 return false. For unknown reasons I cannot get the option
20387 generation machinery to set fmodule-mapper or -fmodule-header to
20388 make a string type option variable. */
20391 handle_module_option (unsigned code
, const char *str
, int)
20393 auto hdr
= CMS_header
;
20395 switch (opt_code (code
))
20397 case OPT_fmodule_mapper_
:
20398 module_mapper_name
= str
;
20401 case OPT_fmodule_header_
:
20403 if (!strcmp (str
, "user"))
20405 else if (!strcmp (str
, "system"))
20408 error ("unknown header kind %qs", str
);
20412 case OPT_fmodule_header
:
20413 flag_header_unit
= hdr
;
20417 case OPT_flang_info_include_translate_
:
20418 vec_safe_push (note_includes
, str
);
20421 case OPT_flang_info_module_cmi_
:
20422 vec_safe_push (note_cmis
, str
);
20430 /* Set preprocessor callbacks and options for modules. */
20433 module_preprocess_options (cpp_reader
*reader
)
20435 gcc_checking_assert (!lang_hooks
.preprocess_undef
);
20438 auto *cb
= cpp_get_callbacks (reader
);
20440 cb
->translate_include
= maybe_translate_include
;
20441 cb
->user_deferred_macro
= module_state::deferred_macro
;
20442 if (flag_header_unit
)
20444 /* If the preprocessor hook is already in use, that
20445 implementation will call the undef langhook. */
20447 lang_hooks
.preprocess_undef
= module_state::undef_macro
;
20449 cb
->undef
= module_state::undef_macro
;
20451 auto *opt
= cpp_get_options (reader
);
20452 opt
->module_directives
= true;
20453 opt
->main_search
= cpp_main_search (flag_header_unit
);
20457 #include "gt-cp-module.h"