/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc

Bug Summary

File:	build/gcc/cp/module.cc
Warning:	line 776, column 27 The result of the '<<' expression is undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name module.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D HOST_MACHINE="x86_64-pc-linux-gnu" -D TARGET_MACHINE="x86_64-pc-linux-gnu" -D MODULE_VERSION=(2301211953U) -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I cp -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-I2pYkf.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc
1/* C++ modules.  Experimental!
 Copyright (C) 2017-2023 Free Software Foundation, Inc.
 Written by Nathan Sidwell <nathan@acm.org> while at FaceBook

 This file is part of GCC.

 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 3, or (at your option)
 any later version.

 GCC is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.

17You should have received a copy of the GNU General Public License
18along 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
 or at least inaccurate.  Due to (a) my misunderstanding, (b)
 ambiguities that I have interpretted differently to original intent
 (c) changes in the specification, (d) my poor wording, (e) source
 changes.  */

27/* (Incomplete) Design Notes

 A hash table contains all module names.  Imported modules are
 present in a modules array, which by construction places an
 import's dependencies before the import itself.  The single
 exception is the current TU, which always occupies slot zero (even
 when it is not a module).

 Imported decls occupy an entity_ary, an array of binding_slots, indexed
 by importing module and index within that module.  A flat index is
 used, as each module reserves a contiguous range of indices.
 Initially each slot indicates the CMI section containing the
 streamed decl.  When the decl is imported it will point to the decl
 itself.

 Additionally each imported decl is mapped in the entity_map via its
 DECL_UID to the flat index in the entity_ary.  Thus we can locate
 the index for any imported decl by using this map and then
 de-flattening the index via a binary seach of the module vector.
 Cross-module references are by (remapped) module number and
 module-local index.

 Each importable DECL contains several flags.  The simple set are
 DECL_MODULE_EXPORT_P, DECL_MODULE_PURVIEW_P, DECL_MODULE_ATTACH_P
 and DECL_MODULE_IMPORT_P.  The first indicates whether it is
 exported, the second whether it is in module or header-unit
 purview.  The third indicates it is attached to the named module in
 whose purview it resides and the fourth indicates whether it was an
 import into this TU or not.  DECL_MODULE_ATTACH_P will be false for
 all decls in a header-unit, and for those in a named module inside
 a linkage declaration.

 The more detailed flags are DECL_MODULE_PARTITION_P,
 DECL_MODULE_ENTITY_P.  The first is set in a primary interface unit
 on decls that were read from module partitions (these will have
 DECL_MODULE_IMPORT_P set too).  Such decls will be streamed out to
 the primary's CMI.  DECL_MODULE_ENTITY_P is set when an entity is
 imported, even if it matched a non-imported entity.  Such a decl
 will not have DECL_MODULE_IMPORT_P set, even though it has an entry
 in the entity map and array.

 Header units are module-like.

 For namespace-scope lookup, the decls for a particular module are
 held located in a sparse array hanging off the binding of the name.
 This is partitioned into two: a few fixed slots at the start
 followed by the sparse slots afterwards.  By construction we only
 need to append new slots to the end -- there is never a need to
 insert in the middle.  The fixed slots are MODULE_SLOT_CURRENT for
 the current TU (regardless of whether it is a module or not),
 MODULE_SLOT_GLOBAL and MODULE_SLOT_PARTITION.  These latter two
 slots are used for merging entities across the global module and
 module partitions respectively.  MODULE_SLOT_PARTITION is only
 present in a module.  Neither of those two slots is searched during
 name lookup -- they are internal use only.  This vector is created
 lazily once we require it, if there is only a declaration from the
 current TU, a regular binding is present.  It is converted on
 demand.

 OPTIMIZATION: Outside of the current TU, we only need ADL to work.
 We could optimize regular lookup for the current TU by glomming all
 the visible decls on its slot.  Perhaps wait until design is a
 little more settled though.

 There is only one instance of each extern-linkage namespace.  It
 appears in every module slot that makes it visible.  It also
 appears in MODULE_SLOT_GLOBAL.  (It is an ODR violation if they
 collide with some other global module entity.)  We also have an
 optimization that shares the slot for adjacent modules that declare
 the same such namespace.

 A module interface compilation produces a Compiled Module Interface
 (CMI).  The format used is Encapsulated Lazy Records Of Numbered
 Declarations, which is essentially ELF's section encapsulation. (As
 all good nerds are aware, Elrond is half Elf.)  Some sections are
 named, and contain information about the module as a whole (indices
 etc), and other sections are referenced by number.  Although I
 don't defend against actively hostile CMIs, there is some
 checksumming involved to verify data integrity.  When dumping out
 an interface, we generate a graph of all the
 independently-redeclarable DECLS that are needed, and the decls
 they reference.  From that we determine the strongly connected
 components (SCC) within this TU.  Each SCC is dumped to a separate
 numbered section of the CMI.  We generate a binding table section,
 mapping each namespace&name to a defining section.  This allows
 lazy loading.

 Lazy loading employs mmap to map a read-only image of the CMI.
 It thus only occupies address space and is paged in on demand,
 backed by the CMI file itself.  If mmap is unavailable, regular
 FILEIO is used.  Also, there's a bespoke ELF reader/writer here,
 which implements just the section table and sections (including
 string sections) of a 32-bit ELF in host byte-order.  You can of
 course inspect it with readelf.  I figured 32-bit is sufficient,
 for a single module.  I detect running out of section numbers, but
 do not implement the ELF overflow mechanism.  At least you'll get
 an error if that happens.

 We do not separate declarations and definitions.  My guess is that
 if you refer to the declaration, you'll also need the definition
 (template body, inline function, class definition etc).  But this
 does mean we can get larger SCCs than if we separated them.  It is
 unclear whether this is a win or not.

 Notice that we embed section indices into the contents of other
 sections.  Thus random manipulation of the CMI file by ELF tools
 may well break it.  The kosher way would probably be to introduce
 indirection via section symbols, but that would require defining a
 relocation type.

 Notice that lazy loading of one module's decls can cause lazy
 loading of other decls in the same or another module.  Clearly we
 want to avoid loops.  In a correct program there can be no loops in
 the module dependency graph, and the above-mentioned SCC algorithm
 places all intra-module circular dependencies in the same SCC.  It
 also orders the SCCs wrt each other, so dependent SCCs come first.
 As we load dependent modules first, we know there can be no
 reference to a higher-numbered module, and because we write out
 dependent SCCs first, likewise for SCCs within the module.  This
 allows us to immediately detect broken references.  When loading,
 we must ensure the rest of the compiler doesn't cause some
 unconnected load to occur (for instance, instantiate a template).

150Classes used:

 dumper - logger

 data - buffer

 bytes - data streamer
 bytes_in : bytes - scalar reader
 bytes_out : bytes - scalar writer

 elf - ELROND format
 elf_in : elf - ELROND reader
 elf_out : elf - ELROND writer

 trees_in : bytes_in - tree reader
 trees_out : bytes_out - tree writer

 depset - dependency set
 depset::hash - hash table of depsets
 depset::tarjan - SCC determinator

 uidset<T> - set T's related to a UID
 uidset<T>::hash hash table of uidset<T>

 loc_spans - location map data

 module_state - module object

 slurping - data needed during loading

 macro_import - imported macro data
 macro_export - exported macro data

 The ELROND objects use mmap, for both reading and writing.  If mmap
 is unavailable, fileno IO is used to read and write blocks of data.

 The mapper object uses fileno IO to communicate with the server or
 program.   */

189/* In expermental (trunk) sources, MODULE_VERSION is a #define passed
 in from the Makefile.  It records the modification date of the
 source directory -- that's the only way to stay sane.  In release
 sources, we (plan to) use the compiler's major.minor versioning.
 While the format might not change between at minor versions, it
 seems simplest to tie the two together.  There's no concept of
 inter-version compatibility.  */
196#define IS_EXPERIMENTAL(V)((V) >= (1U << 20)) ((V) >= (1U << 20))
197#define MODULE_MAJOR(V)((V) / 10000) ((V) / 10000)
198#define MODULE_MINOR(V)((V) % 10000) ((V) % 10000)
199#define EXPERIMENT(A,B)((((2301211953U)) >= (1U << 20)) ? (A) : (B)) (IS_EXPERIMENTAL (MODULE_VERSION)(((2301211953U)) >= (1U << 20)) ? (A) : (B))
200#ifndef MODULE_VERSION(2301211953U)
201#include "bversion.h"
202#define MODULE_VERSION(2301211953U) (BUILDING_GCC_MAJOR13 * 10000U + BUILDING_GCC_MINOR0)
203#elif !IS_EXPERIMENTAL (MODULE_VERSION)(((2301211953U)) >= (1U << 20))
204#error "This is not the version I was looking for."
205#endif

207#define _DEFAULT_SOURCE1 1 /* To get TZ field of struct tm, if available.  */
208#include "config.h"
209#define INCLUDE_MEMORY
210#define INCLUDE_STRING
211#define INCLUDE_VECTOR
212#include "system.h"
213#include "coretypes.h"
214#include "cp-tree.h"
215#include "timevar.h"
216#include "stringpool.h"
217#include "dumpfile.h"
218#include "bitmap.h"
219#include "cgraph.h"
220#include "tree-iterator.h"
221#include "cpplib.h"
222#include "mkdeps.h"
223#include "incpath.h"
224#include "libiberty.h"
225#include "stor-layout.h"
226#include "version.h"
227#include "tree-diagnostic.h"
228#include "toplev.h"
229#include "opts.h"
230#include "attribs.h"
231#include "intl.h"
232#include "langhooks.h"
233/* This TU doesn't need or want to see the networking.  */
234#define CODY_NETWORKING0 0
235#include "mapper-client.h"

237#if 0 // 1 for testing no mmap
238#define MAPPED_READING1 0
239#define MAPPED_WRITING1 0
240#else
241#if HAVE_MMAP_FILE1 && _POSIX_MAPPED_FILES200809L > 0
242/* mmap, munmap.  */
243#define MAPPED_READING1 1
244#if HAVE_SYSCONF1 && defined (_SC_PAGE_SIZE_SC_PAGESIZE)
245/* msync, sysconf (_SC_PAGE_SIZE), ftruncate  */
246/* posix_fallocate used if available.  */
247#define MAPPED_WRITING1 1
248#else
249#define MAPPED_WRITING1 0
250#endif
251#else
252#define MAPPED_READING1 0
253#define MAPPED_WRITING1 0
254#endif
255#endif

257/* Some open(2) flag differences, what a colourful world it is!  */
258#if defined (O_CLOEXEC02000000)
259// OK
260#elif defined (_O_NOINHERIT)
261/* Windows' _O_NOINHERIT matches O_CLOEXEC flag */
262#define O_CLOEXEC02000000 _O_NOINHERIT
263#else
264#define O_CLOEXEC02000000 0
265#endif
266#if defined (O_BINARY0)
267// Ok?
268#elif defined (_O_BINARY)
269/* Windows' open(2) call defaults to text!  */
270#define O_BINARY0 _O_BINARY
271#else
272#define O_BINARY0 0
273#endif

275static inline cpp_hashnode *cpp_node (tree id)
276{
return CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (id))((cpp_hashnode *) ((&((struct tree_identifier *) (id))->
id)));
278}

280static inline tree identifier (const cpp_hashnode *node)
281{
/* HT_NODE() expands to node->ident that HT_IDENT_TO_GCC_IDENT()
   then subtracts a nonzero constant, deriving a pointer to
   a different member than ident.  That's strictly undefined
   and detected by -Warray-bounds.  Suppress it.  See PR 101372.  */
286#pragma GCC diagnostic push
287#pragma GCC diagnostic ignored "-Warray-bounds"
return HT_IDENT_TO_GCC_IDENT (HT_NODE (const_cast<cpp_hashnode *> (node)))((tree) ((char *) ((&(const_cast<cpp_hashnode *> (node
))->ident)) - sizeof (struct tree_common)));
289#pragma GCC diagnostic pop
290}

292/* Id for dumping module information.  */
293int module_dump_id;

295/* We have a special module owner.  */
296#define MODULE_UNKNOWN(~0U) (~0U)    /* Not yet known.  */

298/* Prefix for section names.  */
299#define MOD_SNAME_PFX".gnu.c++" ".gnu.c++"

301/* Format a version for user consumption.  */

303typedef char verstr_t[32];
304static void
305version2string (unsigned version, verstr_t &out)
306{
unsigned major = MODULE_MAJOR (version)((version) / 10000);
unsigned minor = MODULE_MINOR (version)((version) % 10000);

if (IS_EXPERIMENTAL (version)((version) >= (1U << 20)))
  sprintf (out, "%04u/%02u/%02u-%02u:%02u%s",
    2000 + major / 10000, (major / 100) % 100, (major % 100),
    minor / 100, minor % 100,
    EXPERIMENT ("", " (experimental)")((((2301211953U)) >= (1U << 20)) ? ("") : (" (experimental)"
)));
else
  sprintf (out, "%u.%u", major, minor);
317}

319/* Include files to note translation for.  */
320static vec<const char *, va_heap, vl_embed> *note_includes;

322/* Modules to note CMI pathames.  */
323static vec<const char *, va_heap, vl_embed> *note_cmis;

325/* Traits to hash an arbitrary pointer.  Entries are not deletable,
 and removal is a noop (removal needed upon destruction).  */
327template <typename T>
328struct nodel_ptr_hash : pointer_hash<T>, typed_noop_remove <T *> {
/* Nothing is deletable.  Everything is insertable.  */
static bool is_deleted (T *) { return false; }
static void mark_deleted (T *) { gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 331, __FUNCTION__)); }
332};

334/* Map from pointer to signed integer.   */
335typedef simple_hashmap_traits<nodel_ptr_hash<void>, int> ptr_int_traits;
336typedef hash_map<void *,signed,ptr_int_traits> ptr_int_hash_map;

338/********************************************************************/
339/* Basic streaming & ELF.  Serialization is usually via mmap.  For
 writing we slide a buffer over the output file, syncing it
 approproiately.  For reading we simply map the whole file (as a
 file-backed read-only map -- it's just address space, leaving the
 OS pager to deal with getting the data to us).  Some buffers need
 to be more conventional malloc'd contents.   */

346/* Variable length buffer.  */

348class data {
349public:
class allocator {
public:
  /* Tools tend to moan if the dtor's not virtual.  */
  virtual ~allocator () {}

public:
  void grow (data &obj, unsigned needed, bool exact);
  void shrink (data &obj);

public:
  virtual char *grow (char *ptr, unsigned needed);
  virtual void shrink (char *ptr);
};

364public:
char *buffer;		/* Buffer being transferred.  */
/* Although size_t would be the usual size, we know we never get
   more than 4GB of buffer -- because that's the limit of the
   encapsulation format.  And if you need bigger imports, you're
   doing it wrong.  */
unsigned size;	/* Allocated size of buffer.  */
unsigned pos;		/* Position in buffer.  */

373public:
data ()
  :buffer (NULLnullptr), size (0), pos (0)
{
}
~data ()
{
  /* Make sure the derived and/or using class know what they're
     doing.  */
  gcc_checking_assert (!buffer)((void)(!(!buffer) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 382, __FUNCTION__), 0 : 0));
}

385protected:
char *use (unsigned count)
{
  if (size < pos + count)
    return NULLnullptr;
  char *res = &buffer[pos];
  pos += count;
  return res;
}

395public:
void unuse (unsigned count)
{
  pos -= count;
}

401public:
static allocator simple_memory;
403};

405/* The simple data allocator.  */
406data::allocator data::simple_memory;

408/* Grow buffer to at least size NEEDED.  */

410void
411data::allocator::grow (data &obj, unsigned needed, bool exact)
412{
gcc_checking_assert (needed ? needed > obj.size : !obj.size)((void)(!(needed ? needed > obj.size : !obj.size) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 413, __FUNCTION__), 0 : 0));
if (!needed)
  /* Pick a default size.  */
  needed = EXPERIMENT (100, 1000)((((2301211953U)) >= (1U << 20)) ? (100) : (1000));

if (!exact)
  needed *= 2;
obj.buffer = grow (obj.buffer, needed);
if (obj.buffer)
  obj.size = needed;
else
  obj.pos = obj.size = 0;
425}

427/* Free a buffer.  */

429void
430data::allocator::shrink (data &obj)
431{
shrink (obj.buffer);
obj.buffer = NULLnullptr;
obj.size = 0;
435}

437char *
438data::allocator::grow (char *ptr, unsigned needed)
439{
return XRESIZEVAR (char, ptr, needed)((char *) xrealloc ((ptr), (needed)));
441}

443void
444data::allocator::shrink (char *ptr)
445{
XDELETEVEC (ptr)free ((void*) (ptr));
447}

449/* Byte streamer base.   Buffer with read/write position and smarts
 for single bits.  */

452class bytes : public data {
453public:
typedef data parent;

456protected:
uint32_t bit_val;	/* Bit buffer.  */
unsigned bit_pos;	/* Next bit in bit buffer.  */

460public:
bytes ()
  :parent (), bit_val (0), bit_pos (0)
{}
~bytes () 
{
}

468protected:
unsigned calc_crc (unsigned) const;

471protected:
/* Finish bit packet.  Rewind the bytes not used.  */
unsigned bit_flush ()
{
  gcc_assert (bit_pos)((void)(!(bit_pos) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 475, __FUNCTION__), 0 : 0));
  unsigned bytes = (bit_pos + 7) / 8;
  unuse (4 - bytes);
  bit_pos = 0;
  bit_val = 0;
  return bytes;
}
482};

484/* Calculate the crc32 of the buffer.  Note the CRC is stored in the
 first 4 bytes, so don't include them.  */

487unsigned
488bytes::calc_crc (unsigned l) const
489{
unsigned crc = 0;
for (size_t ix = 4; ix < l; ix++)
  crc = crc32_byte (crc, buffer[ix]);
return crc;
494}

496class elf_in;

498/* Byte stream reader.  */

500class bytes_in : public bytes {
typedef bytes parent;

503protected:
bool overrun;  /* Sticky read-too-much flag.  */

506public:
bytes_in ()
  : parent (), overrun (false)
{
}
~bytes_in ()
{
}

515public:
/* Begin reading a named section.  */
bool begin (location_t loc, elf_in *src, const char *name);
/* Begin reading a numbered section with optional name.  */
bool begin (location_t loc, elf_in *src, unsigned, const char * = NULLnullptr);
/* Complete reading a buffer.  Propagate errors and return true on
   success.  */
bool end (elf_in *src);
/* Return true if there is unread data.  */
bool more_p () const
{
  return pos != size;
}

529public:
/* Start reading at OFFSET.  */
void random_access (unsigned offset)
{
  if (offset > size)
    set_overrun ();
  pos = offset;
  bit_pos = bit_val = 0;
}

539public:
void align (unsigned boundary)
{
  if (unsigned pad = pos & (boundary - 1))
    read (boundary - pad);
}

546public:
const char *read (unsigned count)
{
  char *ptr = use (count);
  if (!ptr)
    set_overrun ();
  return ptr;
}

555public:
bool check_crc () const;
/* We store the CRC in the first 4 bytes, using host endianness.  */
unsigned get_crc () const
{
  return *(const unsigned *)&buffer[0];
}

563public:
/* Manipulate the overrun flag.  */
bool get_overrun () const
{
  return overrun;
}
void set_overrun ()
{
  overrun = true;
}

574public:
unsigned u32 ();  	/* Read uncompressed integer.  */

577public:
bool b ();	    	/* Read a bool.  */
void bflush ();	/* Completed a block of bools.  */

581private:
void bfill ();	/* Get the next block of bools.  */

584public:
int c ();		/* Read a char.  */
int i ();		/* Read a signed int.  */
unsigned u ();	/* Read an unsigned int.  */
size_t z ();		/* Read a size_t.  */
HOST_WIDE_INTlong wi ();  /* Read a HOST_WIDE_INT.  */
unsigned HOST_WIDE_INTlong wu (); /* Read an unsigned HOST_WIDE_INT.  */
const char *str (size_t * = NULLnullptr); /* Read a string.  */
const void *buf (size_t); /* Read a fixed-length buffer.  */
cpp_hashnode *cpp_node (); /* Read a cpp node.  */
594};

596/* Verify the buffer's CRC is correct.  */

598bool
599bytes_in::check_crc () const
600{
if (size < 4)
  return false;

unsigned c_crc = calc_crc (size);
if (c_crc != get_crc ())
  return false;

return true;
609}

611class elf_out;

613/* Byte stream writer.  */

615class bytes_out : public bytes {
typedef bytes parent;

618public:
allocator *memory;	/* Obtainer of memory.  */

621public:
bytes_out (allocator *memory)
  : parent (), memory (memory)
{
}
~bytes_out ()
{
}

630public:
bool streaming_p () const
{
  return memory != NULLnullptr;
}

636public:
void set_crc (unsigned *crc_ptr);

639public:
/* Begin writing, maybe reserve space for CRC.  */
void begin (bool need_crc = true);
/* Finish writing.  Spill to section by number.  */
unsigned end (elf_out *, unsigned, unsigned *crc_ptr = NULLnullptr);

645public:
void align (unsigned boundary)
{
  if (unsigned pad = pos & (boundary - 1))
    write (boundary - pad);
}

652public:
char *write (unsigned count, bool exact = false)
{
  if (size < pos + count)
    memory->grow (*this, pos + count, exact);
  return use (count);
}

660public:
void u32 (unsigned);  /* Write uncompressed integer.  */

663public:
void b (bool);	/* Write bool.  */
void bflush ();	/* Finish block of bools.  */

667public:
void c (unsigned char); /* Write unsigned char.  */
void i (int);		/* Write signed int.  */
void u (unsigned);	/* Write unsigned int.  */
void z (size_t s);	/* Write size_t.  */
void wi (HOST_WIDE_INTlong); /* Write HOST_WIDE_INT.  */
void wu (unsigned HOST_WIDE_INTlong);  /* Write unsigned HOST_WIDE_INT.  */
void str (const char *ptr)
{
  str (ptr, strlen (ptr));
}
void cpp_node (const cpp_hashnode *node)
{
  str ((const char *)NODE_NAME (node)(((&(node)->ident))->str), NODE_LEN (node)(((&(node)->ident))->len));
}
void str (const char *, size_t);  /* Write string of known length.  */
void buf (const void *, size_t);  /* Write fixed length buffer.  */
void *buf (size_t); /* Create a writable buffer */

686public:
/* Format a NUL-terminated raw string.  */
void printf (const char *, ...) ATTRIBUTE_PRINTF_2__attribute__ ((__format__ (__printf__, 2, 3))) __attribute__
 ((__nonnull__ (2)));
void print_time (const char *, const tm *, const char *);

691public:
/* Dump instrumentation.  */
static void instrument ();

695protected:
/* Instrumentation.  */
static unsigned spans[4];
static unsigned lengths[4];
static int is_set;
700};

702/* Instrumentation.  */
703unsigned bytes_out::spans[4];
704unsigned bytes_out::lengths[4];
705int bytes_out::is_set = -1;

707/* If CRC_PTR non-null, set the CRC of the buffer.  Mix the CRC into
 that pointed to by CRC_PTR.  */

710void
711bytes_out::set_crc (unsigned *crc_ptr)
712{
if (crc_ptr)
  {
    gcc_checking_assert (pos >= 4)((void)(!(pos >= 4) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 715, __FUNCTION__), 0 : 0));

    unsigned crc = calc_crc (pos);
    unsigned accum = *crc_ptr;
    /* Only mix the existing *CRC_PTR if it is non-zero.  */
    accum = accum ? crc32_unsigned (accum, crc) : crc;
    *crc_ptr = accum;

    /* Buffer will be sufficiently aligned.  */
    *(unsigned *)buffer = crc;
  }
726}

728/* Finish a set of bools.  */

730void
731bytes_out::bflush ()
732{
if (bit_pos)
  {
    u32 (bit_val);
    lengths[2] += bit_flush ();
  }
spans[2]++;
is_set = -1;
740}

742void
743bytes_in::bflush ()
744{
if (bit_pos)
  bit_flush ();
747}

749/* When reading, we don't know how many bools we'll read in.  So read
 4 bytes-worth, and then rewind when flushing if we didn't need them
 all.  You can't have a block of bools closer than 4 bytes to the
 end of the buffer.  */

754void
755bytes_in::bfill ()
756{
bit_val = u32 ();
758}

760/* Bools are packed into bytes.  You cannot mix bools and non-bools.
 You must call bflush before emitting another type.  So batch your
 bools.

 It may be worth optimizing for most bools being zero.  Some kind of
 run-length encoding?  */

767void
768bytes_out::b (bool x)
769{
if (is_set != x)
3
←
Assuming 'is_set' is equal to 'x'→
4
←
Taking false branch→
  {
    is_set = x;
    spans[x]++;
  }
lengths[x]++;
bit_val |= unsigned (x) << bit_pos++;
5
←
The result of the '<<' expression is undefined
if (bit_pos == 32)
  {
    u32 (bit_val);
    lengths[2] += bit_flush ();
  }
782}

784bool
785bytes_in::b ()
786{
if (!bit_pos)
  bfill ();
bool v = (bit_val >> bit_pos++) & 1;
if (bit_pos == 32)
  bit_flush ();
return v;
793}

795/* Exactly 4 bytes.  Used internally for bool packing and a few other
 places.  We can't simply use uint32_t because (a) alignment and
 (b) we need little-endian for the bool streaming rewinding to make
 sense.  */

800void
801bytes_out::u32 (unsigned val)
802{
if (char *ptr = write (4))
  {
    ptr[0] = val;
    ptr[1] = val >> 8;
    ptr[2] = val >> 16;
    ptr[3] = val >> 24;
  }
810}

812unsigned
813bytes_in::u32 ()
814{
unsigned val = 0;
if (const char *ptr = read (4))
  {
    val |= (unsigned char)ptr[0];
    val |= (unsigned char)ptr[1] << 8;
    val |= (unsigned char)ptr[2] << 16;
    val |= (unsigned char)ptr[3] << 24;
  }

return val;
825}

827/* Chars are unsigned and written as single bytes. */

829void
830bytes_out::c (unsigned char v)
831{
if (char *ptr = write (1))
  *ptr = v;
834}

836int
837bytes_in::c ()
838{
int v = 0;
if (const char *ptr = read (1))
  v = (unsigned char)ptr[0];
return v;
843}

845/* Ints 7-bit as a byte. Otherwise a 3bit count of following bytes in
 big-endian form.  4 bits are in the first byte.  */

848void
849bytes_out::i (int v)
850{
if (char *ptr = write (1))
  {
    if (v <= 0x3f && v >= -0x40)
*ptr = v & 0x7f;
    else
{
 unsigned bytes = 0;
 int probe;
 if (v >= 0)
   for (probe = v >> 8; probe > 0x7; probe >>= 8)
     bytes++;
 else
   for (probe = v >> 8; probe < -0x8; probe >>= 8)
     bytes++;
 *ptr = 0x80 | bytes << 4 | (probe & 0xf);
 if ((ptr = write (++bytes)))
   for (; bytes--; v >>= 8)
     ptr[bytes] = v & 0xff;
}
  }
871}

873int
874bytes_in::i ()
875{
int v = 0;
if (const char *ptr = read (1))
  {
    v = *ptr & 0xff;
    if (v & 0x80)
{
 unsigned bytes = (v >> 4) & 0x7;
 v &= 0xf;
 if (v & 0x8)
   v |= -1 ^ 0x7;
 /* unsigned necessary due to left shifts of -ve values.  */
 unsigned uv = unsigned (v);
 if ((ptr = read (++bytes)))
   while (bytes--)
     uv = (uv << 8) | (*ptr++ & 0xff);
 v = int (uv);
}
    else if (v & 0x40)
v |= -1 ^ 0x3f;
  }

return v;
898}

900void
901bytes_out::u (unsigned v)
902{
if (char *ptr = write (1))
  {
    if (v <= 0x7f)
*ptr = v;
    else
{
 unsigned bytes = 0;
 unsigned probe;
 for (probe = v >> 8; probe > 0xf; probe >>= 8)
   bytes++;
 *ptr = 0x80 | bytes << 4 | probe;
 if ((ptr = write (++bytes)))
   for (; bytes--; v >>= 8)
     ptr[bytes] = v & 0xff;
}
  }
919}

921unsigned
922bytes_in::u ()
923{
unsigned v = 0;

if (const char *ptr = read (1))
  {
    v = *ptr & 0xff;
    if (v & 0x80)
{
 unsigned bytes = (v >> 4) & 0x7;
 v &= 0xf;
 if ((ptr = read (++bytes)))
   while (bytes--)
     v = (v << 8) | (*ptr++ & 0xff);
}
  }

return v;
940}

942void
943bytes_out::wi (HOST_WIDE_INTlong v)
944{
if (char *ptr = write (1))
  {
    if (v <= 0x3f && v >= -0x40)
*ptr = v & 0x7f;
    else
{
 unsigned bytes = 0;
 HOST_WIDE_INTlong probe;
 if (v >= 0)
   for (probe = v >> 8; probe > 0x7; probe >>= 8)
     bytes++;
 else
   for (probe = v >> 8; probe < -0x8; probe >>= 8)
     bytes++;
 *ptr = 0x80 | bytes << 4 | (probe & 0xf);
 if ((ptr = write (++bytes)))
   for (; bytes--; v >>= 8)
     ptr[bytes] = v & 0xff;
}
  }
965}

967HOST_WIDE_INTlong
968bytes_in::wi ()
969{
HOST_WIDE_INTlong v = 0;
if (const char *ptr = read (1))
  {
    v = *ptr & 0xff;
    if (v & 0x80)
{
 unsigned bytes = (v >> 4) & 0x7;
 v &= 0xf;
 if (v & 0x8)
   v |= -1 ^ 0x7;
 /* unsigned necessary due to left shifts of -ve values.  */
 unsigned HOST_WIDE_INTlong uv = (unsigned HOST_WIDE_INTlong) v;
 if ((ptr = read (++bytes)))
   while (bytes--)
     uv = (uv << 8) | (*ptr++ & 0xff);
 v = (HOST_WIDE_INTlong) uv;
}
    else if (v & 0x40)
v |= -1 ^ 0x3f;
  }

return v;
992}

994/* unsigned wide ints are just written as signed wide ints.  */

996inline void
997bytes_out::wu (unsigned HOST_WIDE_INTlong v)
998{
wi ((HOST_WIDE_INTlong) v);
1000}

1002inline unsigned HOST_WIDE_INTlong
1003bytes_in::wu ()
1004{
return (unsigned HOST_WIDE_INTlong) wi ();
1006}

1008/* size_t written as unsigned or unsigned wide int.  */

1010inline void
1011bytes_out::z (size_t s)
1012{
if (sizeof (s) == sizeof (unsigned))
  u (s);
else
  wu (s);
1017}

1019inline size_t
1020bytes_in::z ()
1021{
if (sizeof (size_t) == sizeof (unsigned))
  return u ();
else
  return wu ();
1026}

1028/* Buffer simply memcpied.  */
1029void *
1030bytes_out::buf (size_t len)
1031{
align (sizeof (void *) * 2);
return write (len);
1034}

1036void
1037bytes_out::buf (const void *src, size_t len)
1038{
if (void *ptr = buf (len))
  memcpy (ptr, src, len);
1041}

1043const void *
1044bytes_in::buf (size_t len)
1045{
align (sizeof (void *) * 2);
const char *ptr = read (len);

return ptr;
1050}

1052/* strings as an size_t length, followed by the buffer.  Make sure
 there's a NUL terminator on read.  */

1055void
1056bytes_out::str (const char *string, size_t len)
1057{
z (len);
if (len)
  {
    gcc_checking_assert (!string[len])((void)(!(!string[len]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1061, __FUNCTION__), 0 : 0));
    buf (string, len + 1);
  }
1064}

1066const char *
1067bytes_in::str (size_t *len_p)
1068{
size_t len = z ();

/* We're about to trust some user data.  */
if (overrun)
  len = 0;
if (len_p)
  *len_p = len;
const char *str = NULLnullptr;
if (len)
  {
    str = reinterpret_cast<const char *> (buf (len + 1));
    if (!str || str[len])
{
 set_overrun ();
 str = NULLnullptr;
}
  }
return str ? str : "";
1087}

1089cpp_hashnode *
1090bytes_in::cpp_node ()
1091{
size_t len;
const char *s = str (&len);
if (!len)
  return NULLnullptr;
return ::cpp_node (get_identifier_with_length (s, len));
1097}

1099/* Format a string directly to the buffer, including a terminating
 NUL.  Intended for human consumption.  */

1102void
1103bytes_out::printf (const char *format, ...)
1104{
va_list args;
/* Exercise buffer expansion.  */
size_t len = EXPERIMENT (10, 500)((((2301211953U)) >= (1U << 20)) ? (10) : (500));

while (char *ptr = write (len))
  {
    va_start (args, format)__builtin_va_start(args, format);
    size_t actual = vsnprintf (ptr, len, format, args) + 1;
    va_end (args)__builtin_va_end(args);
    if (actual <= len)
{
 unuse (len - actual);
 break;
}
    unuse (len);
    len = actual;
  }
1122}

1124void
1125bytes_out::print_time (const char *kind, const tm *time, const char *tz)
1126{
printf ("%stime: %4u/%02u/%02u %02u:%02u:%02u %s",
 kind, time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
 time->tm_hour, time->tm_min, time->tm_sec, tz);
1130}

1132/* Encapsulated Lazy Records Of Named Declarations.
 Header: Stunningly Elf32_Ehdr-like
 Sections: Sectional data
   [1-N) : User data sections
   N .strtab  : strings, stunningly ELF STRTAB-like
 Index: Section table, stunningly ELF32_Shdr-like.   */

1139class elf {
1140protected:
/* Constants used within the format.  */
enum private_constants {
  /* File kind. */
  ET_NONE = 0,
  EM_NONE = 0,
  OSABI_NONE = 0,

  /* File format. */
  EV_CURRENT = 1,
  CLASS32 = 1,
  DATA2LSB = 1,
  DATA2MSB = 2,

  /* Section numbering.  */
  SHN_UNDEF = 0,
  SHN_LORESERVE = 0xff00,
  SHN_XINDEX = 0xffff,

  /* Section types.  */
  SHT_NONE = 0,	/* No contents.  */
  SHT_PROGBITS = 1, /* Random bytes.  */
  SHT_STRTAB = 3,	/* A string table.  */

  /* Section flags.  */
  SHF_NONE = 0x00,	/* Nothing.  */
  SHF_STRINGS = 0x20,  /* NUL-Terminated strings.  */

  /* I really hope we do not get CMI files larger than 4GB.  */
  MY_CLASS = CLASS32,
  /* It is host endianness that is relevant.  */
  MY_ENDIAN = DATA2LSB
1172#ifdef WORDS_BIGENDIAN
  ^ DATA2LSB ^ DATA2MSB
1174#endif
};

1177public:
/* Constants visible to users.  */
enum public_constants {
  /* Special error codes.  Breaking layering a bit.  */
  E_BAD_DATA = -1,  /* Random unexpected data errors.  */
  E_BAD_LAZY = -2,  /* Badly ordered laziness.  */
  E_BAD_IMPORT = -3 /* A nested import failed.  */
};

1186protected:
/* File identification.  On-disk representation.  */
struct ident {
  uint8_t magic[4];	/* 0x7f, 'E', 'L', 'F' */
  uint8_t klass;	/* 4:CLASS32 */
  uint8_t data;	/* 5:DATA2[LM]SB */
  uint8_t version;	/* 6:EV_CURRENT  */
  uint8_t osabi;	/* 7:OSABI_NONE */
  uint8_t abiver;	/* 8: 0 */
  uint8_t pad[7];	/* 9-15 */
};
/* File header.  On-disk representation.  */
struct header {
  struct ident ident;
  uint16_t type;	/* ET_NONE */
  uint16_t machine;	/* EM_NONE */
  uint32_t version;	/* EV_CURRENT */
  uint32_t entry;	/* 0 */
  uint32_t phoff;	/* 0 */
  uint32_t shoff;	/* Section Header Offset in file */
  uint32_t flags; 
  uint16_t ehsize;	/* ELROND Header SIZE -- sizeof (header) */
  uint16_t phentsize; /* 0 */
  uint16_t phnum;	/* 0 */
  uint16_t shentsize; /* Section Header SIZE -- sizeof (section) */
  uint16_t shnum;	/* Section Header NUM */
  uint16_t shstrndx;	/* Section Header STRing iNDeX */
};
/* File section.  On-disk representation.  */
struct section {
  uint32_t name;	/* String table offset.  */
  uint32_t type;	/* SHT_* */
  uint32_t flags;	/* SHF_* */
  uint32_t addr;	/* 0 */
  uint32_t offset;	/* OFFSET in file */
  uint32_t size;	/* SIZE of section */
  uint32_t link;	/* 0 */
  uint32_t info;	/* 0 */
  uint32_t addralign; /* 0 */
  uint32_t entsize;	/* ENTry SIZE, usually 0 */
};

1228protected:
data hdr;	/* The header.  */
data sectab; 	/* The section table.  */
data strtab;  /* String table.  */
int fd;   	/* File descriptor we're reading or writing.  */
int err; 	/* Sticky error code.  */

1235public:
/* Construct from STREAM.  E is errno if STREAM NULL.  */
elf (int fd, int e)
  :hdr (), sectab (), strtab (), fd (fd), err (fd >= 0 ? 0 : e)
{}
~elf ()
{
  gcc_checking_assert (fd < 0 && !hdr.buffer((void)(!(fd < 0 && !hdr.buffer && !sectab
.buffer && !strtab.buffer) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1243, __FUNCTION__), 0 : 0))
	 && !sectab.buffer && !strtab.buffer)((void)(!(fd < 0 && !hdr.buffer && !sectab
.buffer && !strtab.buffer) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1243, __FUNCTION__), 0 : 0));
}

1246public:
/* Return the error, if we have an error.  */
int get_error () const
{
  return err;
}
/* Set the error, unless it's already been set.  */
void set_error (int e = E_BAD_DATA)
{
  if (!err)
    err = e;
}
/* Get an error string.  */
const char *get_error (const char *) const;

1261public:
/* Begin reading/writing file.  Return false on error.  */
bool begin () const
{
  return !get_error ();
}
/* Finish reading/writing file.  Return false on error.  */
bool end ();
1269};

1271/* Return error string.  */

1273const char *
1274elf::get_error (const char *name) const
1275{
if (!name)
  return "Unknown CMI mapping";

switch (err)
  {
  case 0:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1282, __FUNCTION__));
  case E_BAD_DATA:
    return "Bad file data";
  case E_BAD_IMPORT:
    return "Bad import dependency";
  case E_BAD_LAZY:
    return "Bad lazy ordering";
  default:
    return xstrerror (err);
  }
1292}

1294/* Finish file, return true if there's an error.  */

1296bool
1297elf::end ()
1298{
/* Close the stream and free the section table.  */
if (fd >= 0 && close (fd))
  set_error (errno(*__errno_location ()));
fd = -1;

return !get_error ();
1305}

1307/* ELROND reader.  */

1309class elf_in : public elf {
typedef elf parent;

1312private:
/* For freezing & defrosting.  */
1314#if !defined (HOST_LACKS_INODE_NUMBERS)
dev_t device;
ino_t inode;
1317#endif

1319public:
elf_in (int fd, int e)
  :parent (fd, e)
{
}
~elf_in ()
{
}

1328public:
bool is_frozen () const
{
  return fd < 0 && hdr.pos;
}
bool is_freezable () const
{
  return fd >= 0 && hdr.pos;
}
void freeze ();
bool defrost (const char *);

/* If BYTES is in the mmapped area, allocate a new buffer for it.  */
void preserve (bytes_in &bytes ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
{
1343#if MAPPED_READING1
  if (hdr.buffer && bytes.buffer >= hdr.buffer
&& bytes.buffer < hdr.buffer + hdr.pos)
    {
char *buf = bytes.buffer;
bytes.buffer = data::simple_memory.grow (NULLnullptr, bytes.size);
memcpy (bytes.buffer, buf, bytes.size);
    }
1351#endif
}
/* If BYTES is not in SELF's mmapped area, free it.  SELF might be
   NULL. */
static void release (elf_in *self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), bytes_in &bytes)
{
1357#if MAPPED_READING1
  if (!(self && self->hdr.buffer && bytes.buffer >= self->hdr.buffer
 && bytes.buffer < self->hdr.buffer + self->hdr.pos))
1360#endif
    data::simple_memory.shrink (bytes.buffer);
  bytes.buffer = NULLnullptr;
  bytes.size = 0;
}

1366public:
static void grow (data &data, unsigned needed)
{
  gcc_checking_assert (!data.buffer)((void)(!(!data.buffer) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1369, __FUNCTION__), 0 : 0));
1370#if !MAPPED_READING1
  data.buffer = XNEWVEC (char, needed)((char *) xmalloc (sizeof (char) * (needed)));
1372#endif
  data.size = needed;
}
static void shrink (data &data)
{
1377#if !MAPPED_READING1
  XDELETEVEC (data.buffer)free ((void*) (data.buffer));
1379#endif
  data.buffer = NULLnullptr;
  data.size = 0;
}

1384public:
const section *get_section (unsigned s) const
{
  if (s * sizeof (section) < sectab.size)
    return reinterpret_cast<const section *>
(&sectab.buffer[s * sizeof (section)]);
  else
    return NULLnullptr;
}
unsigned get_section_limit () const
{
  return sectab.size / sizeof (section);
}

1398protected:
const char *read (data *, unsigned, unsigned);

1401public:
/* Read section by number.  */
bool read (data *d, const section *s)
{
  return s && read (d, s->offset, s->size);
}

/* Find section by name.  */
unsigned find (const char *name);
/* Find section by index.  */
const section *find (unsigned snum, unsigned type = SHT_PROGBITS);

1413public:
/* Release the string table, when we're done with it.  */
void release ()
{
  shrink (strtab);
}

1420public:
bool begin (location_t);
bool end ()
{
  release ();
1425#if MAPPED_READING1
  if (hdr.buffer)
    munmap (hdr.buffer, hdr.pos);
  hdr.buffer = NULLnullptr;
1429#endif
  shrink (sectab);

  return parent::end ();
}

1435public:
/* Return string name at OFFSET.  Checks OFFSET range.  Always
   returns non-NULL.  We know offset 0 is an empty string.  */
const char *name (unsigned offset)
{
  return &strtab.buffer[offset < strtab.size ? offset : 0];
}
1442};

1444/* ELROND writer.  */

1446class elf_out : public elf, public data::allocator {
typedef elf parent;
/* Desired section alignment on disk.  */
static const int SECTION_ALIGN = 16;

1451private:
ptr_int_hash_map identtab;	/* Map of IDENTIFIERS to strtab offsets. */
unsigned pos;			/* Write position in file.  */
1454#if MAPPED_WRITING1
unsigned offset;		/* Offset of the mapping.  */
unsigned extent;		/* Length of mapping.  */
unsigned page_size;		/* System page size.  */
1458#endif

1460public:
elf_out (int fd, int e)
  :parent (fd, e), identtab (500), pos (0)
{
1464#if MAPPED_WRITING1
  offset = extent = 0;
  page_size = sysconf (_SC_PAGE_SIZE_SC_PAGESIZE);
  if (page_size < SECTION_ALIGN)
    /* Something really strange.  */
    set_error (EINVAL22);
1470#endif
}
~elf_out ()
{
  data::simple_memory.shrink (hdr);
  data::simple_memory.shrink (sectab);
  data::simple_memory.shrink (strtab);
}

1479#if MAPPED_WRITING1
1480private:
void create_mapping (unsigned ext, bool extending = true);
void remove_mapping ();
1483#endif

1485protected:
using allocator::grow;
char *grow (char *, unsigned needed) final override;
1488#if MAPPED_WRITING1
using allocator::shrink;
void shrink (char *) final override;
1491#endif

1493public:
unsigned get_section_limit () const
{
  return sectab.pos / sizeof (section);
}

1499protected:
unsigned add (unsigned type, unsigned name = 0,
unsigned off = 0, unsigned size = 0, unsigned flags = SHF_NONE);
unsigned write (const data &);
1503#if MAPPED_WRITING1
unsigned write (const bytes_out &);
1505#endif

1507public:
/* IDENTIFIER to strtab offset.  */
unsigned name (tree ident);
/* String literal to strtab offset.  */
unsigned name (const char *n);
/* Qualified name of DECL to strtab offset.  */
unsigned qualified_name (tree decl, bool is_defn);

1515private:
unsigned strtab_write (const char *s, unsigned l);
void strtab_write (tree decl, int);

1519public:
/* Add a section with contents or strings.  */
unsigned add (const bytes_out &, bool string_p, unsigned name);

1523public:
/* Begin and end writing.  */
bool begin ();
bool end ();
1527};

1529/* Begin reading section NAME (of type PROGBITS) from SOURCE.
 Data always checked for CRC.  */

1532bool
1533bytes_in::begin (location_t loc, elf_in *source, const char *name)
1534{
unsigned snum = source->find (name);

return begin (loc, source, snum, name);
1538}

1540/* Begin reading section numbered SNUM with NAME (may be NULL).  */

1542bool
1543bytes_in::begin (location_t loc, elf_in *source, unsigned snum, const char *name)
1544{
if (!source->read (this, source->find (snum))
    || !size || !check_crc ())
  {
    source->set_error (elf::E_BAD_DATA);
    source->shrink (*this);
    if (name)
error_at (loc, "section %qs is missing or corrupted", name);
    else
error_at (loc, "section #%u is missing or corrupted", snum);
    return false;
  }
pos = 4;
return true;
1558}

1560/* Finish reading a section.  */

1562bool
1563bytes_in::end (elf_in *src)
1564{
if (more_p ())
  set_overrun ();
if (overrun)
  src->set_error ();

src->shrink (*this);

return !overrun;
1573}

1575/* Begin writing buffer.  */

1577void
1578bytes_out::begin (bool need_crc)
1579{
if (need_crc)
  pos = 4;
memory->grow (*this, 0, false);
1583}

1585/* Finish writing buffer.  Stream out to SINK as named section NAME.
 Return section number or 0 on failure.  If CRC_PTR is true, crc
 the data.  Otherwise it is a string section.  */

1589unsigned
1590bytes_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
1591{
lengths[3] += pos;
spans[3]++;

set_crc (crc_ptr);
unsigned sec_num = sink->add (*this, !crc_ptr, name);
memory->shrink (*this);

return sec_num;
1600}

1602/* Close and open the file, without destroying it.  */

1604void
1605elf_in::freeze ()
1606{
gcc_checking_assert (!is_frozen ())((void)(!(!is_frozen ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1607, __FUNCTION__), 0 : 0));
1608#if MAPPED_READING1
if (munmap (hdr.buffer, hdr.pos) < 0)
  set_error (errno(*__errno_location ()));
1611#endif
if (close (fd) < 0)
  set_error (errno(*__errno_location ()));
fd = -1;
1615}

1617bool
1618elf_in::defrost (const char *name)
1619{
gcc_checking_assert (is_frozen ())((void)(!(is_frozen ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1620, __FUNCTION__), 0 : 0));
struct stat stat;

fd = open (name, O_RDONLY00 | O_CLOEXEC02000000 | O_BINARY0);
if (fd < 0 || fstat (fd, &stat) < 0)
  set_error (errno(*__errno_location ()));
else
  {
    bool ok = hdr.pos == unsigned (stat.st_size);
1629#ifndef HOST_LACKS_INODE_NUMBERS
    if (device != stat.st_dev
 || inode != stat.st_ino)
ok = false;
1633#endif
    if (!ok)
set_error (EMFILE24);
1636#if MAPPED_READING1
    if (ok)
{
 char *mapping = reinterpret_cast<char *>
   (mmap (NULLnullptr, hdr.pos, PROT_READ0x1, MAP_SHARED0x01, fd, 0));
 if (mapping == MAP_FAILED((void *) -1))
 fail:
     set_error (errno(*__errno_location ()));
 else
   {
     if (madvise (mapping, hdr.pos, MADV_RANDOM1))
goto fail;

     /* These buffers are never NULL in this case.  */
     strtab.buffer = mapping + strtab.pos;
     sectab.buffer = mapping + sectab.pos;
     hdr.buffer = mapping;
   }
}
1655#endif
  }

return !get_error ();
1659}

1661/* Read at current position into BUFFER.  Return true on success.  */

1663const char *
1664elf_in::read (data *data, unsigned pos, unsigned length)
1665{
1666#if MAPPED_READING1
if (pos + length > hdr.pos)
  {
    set_error (EINVAL22);
    return NULLnullptr;
  }
1672#else
if (pos != ~0u && lseek (fd, pos, SEEK_SET0) < 0)
  {
    set_error (errno(*__errno_location ()));
    return NULLnullptr;
  }
1678#endif
grow (*data, length);
1680#if MAPPED_READING1  
data->buffer = hdr.buffer + pos;
1682#else
if (::read (fd, data->buffer, data->size) != ssize_t (length))
  {
    set_error (errno(*__errno_location ()));
    shrink (*data);
    return NULLnullptr;
  }
1689#endif

return data->buffer;
1692}

1694/* Read section SNUM of TYPE.  Return section pointer or NULL on error.  */

1696const elf::section *
1697elf_in::find (unsigned snum, unsigned type)
1698{
const section *sec = get_section (snum);
if (!snum || !sec || sec->type != type)
  return NULLnullptr;
return sec;
1703}

1705/* Find a section NAME and TYPE.  Return section number, or zero on
 failure.  */

1708unsigned
1709elf_in::find (const char *sname)
1710{
for (unsigned pos = sectab.size; pos -= sizeof (section); )
  {
    const section *sec
= reinterpret_cast<const section *> (&sectab.buffer[pos]);

    if (0 == strcmp (sname, name (sec->name)))
return pos / sizeof (section);
  }

return 0;
1721}

1723/* Begin reading file.  Verify header.  Pull in section and string
 tables.  Return true on success.  */

1726bool
1727elf_in::begin (location_t loc)
1728{
if (!parent::begin ())
  return false;

struct stat stat;
unsigned size = 0;
if (!fstat (fd, &stat))
  {
1736#if !defined (HOST_LACKS_INODE_NUMBERS)
    device = stat.st_dev;
    inode = stat.st_ino;
1739#endif
    /* Never generate files > 4GB, check we've not been given one.  */
    if (stat.st_size == unsigned (stat.st_size))
size = unsigned (stat.st_size);
  }

1745#if MAPPED_READING1
/* MAP_SHARED so that the file is backing store.  If someone else
   concurrently writes it, they're wrong.  */
void *mapping = mmap (NULLnullptr, size, PROT_READ0x1, MAP_SHARED0x01, fd, 0);
if (mapping == MAP_FAILED((void *) -1))
  {
  fail:
    set_error (errno(*__errno_location ()));
    return false;
  }
/* We'll be hopping over this randomly.  Some systems declare the
   first parm as char *, and other declare it as void *.  */
if (madvise (reinterpret_cast <char *> (mapping), size, MADV_RANDOM1))
  goto fail;

hdr.buffer = (char *)mapping;
1761#else
read (&hdr, 0, sizeof (header));
1763#endif
hdr.pos = size; /* Record size of the file.  */

const header *h = reinterpret_cast<const header *> (hdr.buffer);
if (!h)
  return false;

if (h->ident.magic[0] != 0x7f
    || h->ident.magic[1] != 'E'
    || h->ident.magic[2] != 'L'
    || h->ident.magic[3] != 'F')
  {
    error_at (loc, "not Encapsulated Lazy Records of Named Declarations");
  failed:
    shrink (hdr);
    return false;
  }

/* We expect a particular format -- the ELF is not intended to be
   distributable.  */
if (h->ident.klass != MY_CLASS
    || h->ident.data != MY_ENDIAN
    || h->ident.version != EV_CURRENT
    || h->type != ET_NONE
    || h->machine != EM_NONE
    || h->ident.osabi != OSABI_NONE)
  {
    error_at (loc, "unexpected encapsulation format or type");
    goto failed;
  }

int e = -1;
if (!h->shoff || h->shentsize != sizeof (section))
  {
  malformed:
    set_error (e);
    error_at (loc, "encapsulation is malformed");
    goto failed;
  }

unsigned strndx = h->shstrndx;
unsigned shnum = h->shnum;
if (shnum == SHN_XINDEX)
  {
    if (!read (&sectab, h->shoff, sizeof (section)))
{
section_table_fail:
 e = errno(*__errno_location ());
 goto malformed;
}
    shnum = get_section (0)->size;
    /* Freeing does mean we'll re-read it in the case we're not
mapping, but this is going to be rare.  */
    shrink (sectab);
  }

if (!shnum)
  goto malformed;

if (!read (&sectab, h->shoff, shnum * sizeof (section)))
  goto section_table_fail;

if (strndx == SHN_XINDEX)
  strndx = get_section (0)->link;

if (!read (&strtab, find (strndx, SHT_STRTAB)))
  goto malformed;

/* The string table should be at least one byte, with NUL chars
   at either end.  */
if (!(strtab.size && !strtab.buffer[0]
&& !strtab.buffer[strtab.size - 1]))
  goto malformed;

1837#if MAPPED_READING1
/* Record the offsets of the section and string tables.  */
sectab.pos = h->shoff;
strtab.pos = shnum * sizeof (section);
1841#else
shrink (hdr);
1843#endif

return true;
1846}

1848/* Create a new mapping.  */

1850#if MAPPED_WRITING1
1851void
1852elf_out::create_mapping (unsigned ext, bool extending)
1853{
1854#ifndef HAVE_POSIX_FALLOCATE1
1855#define posix_fallocate(fd,off,len) ftruncate (fd, off + len)
1856#endif
void *mapping = MAP_FAILED((void *) -1);
if (extending && ext < 1024 * 1024)
  {
    if (!posix_fallocate (fd, offset, ext * 2))
mapping = mmap (NULLnullptr, ext * 2, PROT_READ0x1 | PROT_WRITE0x2,
	MAP_SHARED0x01, fd, offset);
    if (mapping != MAP_FAILED((void *) -1))
ext *= 2;
  }
if (mapping == MAP_FAILED((void *) -1))
  {
    if (!extending || !posix_fallocate (fd, offset, ext))
mapping = mmap (NULLnullptr, ext, PROT_READ0x1 | PROT_WRITE0x2,
	MAP_SHARED0x01, fd, offset);
    if (mapping == MAP_FAILED((void *) -1))
{
 set_error (errno(*__errno_location ()));
 mapping = NULLnullptr;
 ext = 0;
}
  }
1878#undef posix_fallocate
hdr.buffer = (char *)mapping;
extent = ext;
1881}
1882#endif

1884/* Flush out the current mapping.  */

1886#if MAPPED_WRITING1
1887void
1888elf_out::remove_mapping ()
1889{
if (hdr.buffer)
  {
    /* MS_ASYNC dtrt with the removed mapping, including a
subsequent overlapping remap.  */
    if (msync (hdr.buffer, extent, MS_ASYNC1)
 || munmap (hdr.buffer, extent))
/* We're somewhat screwed at this point.  */
set_error (errno(*__errno_location ()));
  }

hdr.buffer = NULLnullptr;
1901}
1902#endif

1904/* Grow a mapping of PTR to be NEEDED bytes long.  This gets
 interesting if the new size grows the EXTENT.  */

1907char *
1908elf_out::grow (char *data, unsigned needed)
1909{
if (!data)
  {
    /* First allocation, check we're aligned.  */
    gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)))((void)(!(!(pos & (SECTION_ALIGN - 1))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1913, __FUNCTION__), 0 : 0));
1914#if MAPPED_WRITING1
    data = hdr.buffer + (pos - offset);
1916#endif
  }

1919#if MAPPED_WRITING1
unsigned off = data - hdr.buffer;
if (off + needed > extent)
  {
    /* We need to grow the mapping.  */
    unsigned lwm = off & ~(page_size - 1);
    unsigned hwm = (off + needed + page_size - 1) & ~(page_size - 1);

    gcc_checking_assert (hwm > extent)((void)(!(hwm > extent) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1927, __FUNCTION__), 0 : 0));

    remove_mapping ();

    offset += lwm;
    create_mapping (extent < hwm - lwm ? hwm - lwm : extent);

    data = hdr.buffer + (off - lwm);
  }
1936#else
data = allocator::grow (data, needed);
1938#endif

return data;
1941}

1943#if MAPPED_WRITING1
1944/* Shrinking is a NOP.  */
1945void
1946elf_out::shrink (char *)
1947{
1948}
1949#endif

1951/* Write S of length L to the strtab buffer.  L must include the ending
 NUL, if that's what you want.  */

1954unsigned
1955elf_out::strtab_write (const char *s, unsigned l)
1956{
if (strtab.pos + l > strtab.size)
  data::simple_memory.grow (strtab, strtab.pos + l, false);
memcpy (strtab.buffer + strtab.pos, s, l);
unsigned res = strtab.pos;
strtab.pos += l;
return res;
1963}

1965/* Write qualified name of decl.  INNER >0 if this is a definition, <0
 if this is a qualifier of an outer name.  */

1968void
1969elf_out::strtab_write (tree decl, int inner)
1970{
tree ctx = CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1971, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1971, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1971, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]);
if (TYPE_P (ctx)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (ctx)->base.code))] == tcc_type))
  ctx = TYPE_NAME (ctx)((tree_class_check ((ctx), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1973, __FUNCTION__))->type_common.name);
if (ctx != global_namespacecp_global_trees[CPTI_GLOBAL])
  strtab_write (ctx, -1);

tree name = DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1977, __FUNCTION__))->decl_minimal.name);
if (!name)
  name = DECL_ASSEMBLER_NAME_RAW (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1979, __FUNCTION__))->decl_with_vis.assembler_name);
strtab_write (IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1980, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), IDENTIFIER_LENGTH (name)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1980, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
));

if (inner)
  strtab_write (&"::{}"[inner+1], 2);
1984}

1986/* Map IDENTIFIER IDENT to strtab offset.  Inserts into strtab if not
 already there.  */

1989unsigned
1990elf_out::name (tree ident)
1991{
unsigned res = 0;
if (ident)
  {
    bool existed;
    int *slot = &identtab.get_or_insert (ident, &existed);
    if (!existed)
*slot = strtab_write (IDENTIFIER_POINTER (ident)((const char *) (tree_check ((ident), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1998, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
),
	      IDENTIFIER_LENGTH (ident)((tree_check ((ident), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 1999, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
) + 1);
    res = *slot;
  }
return res;
2003}

2005/* Map LITERAL to strtab offset.  Does not detect duplicates and
 expects LITERAL to remain live until strtab is written out.  */

2008unsigned
2009elf_out::name (const char *literal)
2010{
return strtab_write (literal, strlen (literal) + 1);
2012}

2014/* Map a DECL's qualified name to strtab offset.  Does not detect
 duplicates.  */

2017unsigned
2018elf_out::qualified_name (tree decl, bool is_defn)
2019{
gcc_checking_assert (DECL_P (decl) && decl != global_namespace)((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (decl)->base.code))] == tcc_declaration
) && decl != cp_global_trees[CPTI_GLOBAL]) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2020, __FUNCTION__), 0 : 0));
unsigned result = strtab.pos;

strtab_write (decl, is_defn);
strtab_write ("", 1);

return result;
2027}

2029/* Add section to file.  Return section number.  TYPE & NAME identify
 the section.  OFF and SIZE identify the file location of its
 data.  FLAGS contains additional info.  */

2033unsigned
2034elf_out::add (unsigned type, unsigned name, unsigned off, unsigned size,
     unsigned flags)
2036{
gcc_checking_assert (!(off & (SECTION_ALIGN - 1)))((void)(!(!(off & (SECTION_ALIGN - 1))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2037, __FUNCTION__), 0 : 0));
if (sectab.pos + sizeof (section) > sectab.size)
  data::simple_memory.grow (sectab, sectab.pos + sizeof (section), false);
section *sec = reinterpret_cast<section *> (sectab.buffer + sectab.pos);
memset (sec, 0, sizeof (section));
sec->type = type;
sec->flags = flags;
sec->name = name;
sec->offset = off;
sec->size = size;
if (flags & SHF_STRINGS)
  sec->entsize = 1;

unsigned res = sectab.pos;
sectab.pos += sizeof (section);
return res / sizeof (section);
2053}

2055/* Pad to the next alignment boundary, then write BUFFER to disk.
 Return the position of the start of the write, or zero on failure.   */

2058unsigned
2059elf_out::write (const data &buffer)
2060{
2061#if MAPPED_WRITING1
/* HDR is always mapped.  */
if (&buffer != &hdr)
  {
    bytes_out out (this);
    grow (out, buffer.pos, true);
    if (out.buffer)
memcpy (out.buffer, buffer.buffer, buffer.pos);
    shrink (out);
  }
else
  /* We should have been aligned during the first allocation.  */
  gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)))((void)(!(!(pos & (SECTION_ALIGN - 1))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2073, __FUNCTION__), 0 : 0));
2074#else
if (::write (fd, buffer.buffer, buffer.pos) != ssize_t (buffer.pos))
  {
    set_error (errno(*__errno_location ()));
    return 0;
  }
2080#endif
unsigned res = pos;
pos += buffer.pos;

if (unsigned padding = -pos & (SECTION_ALIGN - 1))
  {
2086#if !MAPPED_WRITING1
    /* Align the section on disk, should help the necessary copies.
fseeking to extend is non-portable.  */
    static char zero[SECTION_ALIGN];
    if (::write (fd, &zero, padding) != ssize_t (padding))
set_error (errno(*__errno_location ()));
2092#endif
    pos += padding;
  }
return res;
2096}

2098/* Write a streaming buffer.  It must be using us as an allocator.  */

2100#if MAPPED_WRITING1
2101unsigned
2102elf_out::write (const bytes_out &buf)
2103{
gcc_checking_assert (buf.memory == this)((void)(!(buf.memory == this) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2104, __FUNCTION__), 0 : 0));
/* A directly mapped buffer.  */
gcc_checking_assert (buf.buffer - hdr.buffer >= 0((void)(!(buf.buffer - hdr.buffer >= 0 && buf.buffer
 - hdr.buffer + buf.size <= extent) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2107, __FUNCTION__), 0 : 0))
       && buf.buffer - hdr.buffer + buf.size <= extent)((void)(!(buf.buffer - hdr.buffer >= 0 && buf.buffer
 - hdr.buffer + buf.size <= extent) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2107, __FUNCTION__), 0 : 0));
unsigned res = pos;
pos += buf.pos;

/* Align up.  We're not going to advance into the next page. */
pos += -pos & (SECTION_ALIGN - 1);

return res;
2115}
2116#endif

2118/* Write data and add section.  STRING_P is true for a string
 section, false for PROGBITS.  NAME identifies the section (0 is the
 empty name).  DATA is the contents.  Return section number or 0 on
 failure (0 is the undef section).  */

2123unsigned
2124elf_out::add (const bytes_out &data, bool string_p, unsigned name)
2125{
unsigned off = write (data);

return add (string_p ? SHT_STRTAB : SHT_PROGBITS, name,
     off, data.pos, string_p ? SHF_STRINGS : SHF_NONE);
2130}

2132/* Begin writing the file.  Initialize the section table and write an
 empty header.  Return false on failure.  */

2135bool
2136elf_out::begin ()
2137{
if (!parent::begin ())
  return false;

/* Let the allocators pick a default.  */
data::simple_memory.grow (strtab, 0, false);
data::simple_memory.grow (sectab, 0, false);

/* The string table starts with an empty string.  */
name ("");

/* Create the UNDEF section.  */
add (SHT_NONE);

2151#if MAPPED_WRITING1
/* Start a mapping.  */
create_mapping (EXPERIMENT (page_size,((((2301211953U)) >= (1U << 20)) ? (page_size) : ((32767
 + page_size) & ~(page_size - 1)))
	      (32767 + page_size) & ~(page_size - 1))((((2301211953U)) >= (1U << 20)) ? (page_size) : ((32767
 + page_size) & ~(page_size - 1))));
if (!hdr.buffer)
  return false;
2157#endif

/* Write an empty header.  */
grow (hdr, sizeof (header), true);
header *h = reinterpret_cast<header *> (hdr.buffer);
memset (h, 0, sizeof (header));
hdr.pos = hdr.size;
write (hdr);
return !get_error ();
2166}

2168/* Finish writing the file.  Write out the string & section tables.
 Fill in the header.  Return true on error.  */

2171bool
2172elf_out::end ()
2173{
if (fd >= 0)
  {
    /* Write the string table.  */
    unsigned strnam = name (".strtab");
    unsigned stroff = write (strtab);
    unsigned strndx = add (SHT_STRTAB, strnam, stroff, strtab.pos,
	     SHF_STRINGS);

    /* Store escape values in section[0].  */
    if (strndx >= SHN_LORESERVE)
{
 reinterpret_cast<section *> (sectab.buffer)->link = strndx;
 strndx = SHN_XINDEX;
}
    unsigned shnum = sectab.pos / sizeof (section);
    if (shnum >= SHN_LORESERVE)
{
 reinterpret_cast<section *> (sectab.buffer)->size = shnum;
 shnum = SHN_XINDEX;
}

    unsigned shoff = write (sectab);

2197#if MAPPED_WRITING1
    if (offset)
{
 remove_mapping ();
 offset = 0;
 create_mapping ((sizeof (header) + page_size - 1) & ~(page_size - 1),
	  false);
}
    unsigned length = pos;
2206#else
    if (lseek (fd, 0, SEEK_SET0) < 0)
set_error (errno(*__errno_location ()));
2209#endif
    /* Write header.  */
    if (!get_error ())
{
 /* Write the correct header now.  */
 header *h = reinterpret_cast<header *> (hdr.buffer);
 h->ident.magic[0] = 0x7f;
 h->ident.magic[1] = 'E';	/* Elrond */
 h->ident.magic[2] = 'L';	/* is an */
 h->ident.magic[3] = 'F';	/* elf.  */
 h->ident.klass = MY_CLASS;
 h->ident.data =  MY_ENDIAN;
 h->ident.version = EV_CURRENT;
 h->ident.osabi = OSABI_NONE;
 h->type = ET_NONE;
 h->machine = EM_NONE;
 h->version = EV_CURRENT;
 h->shoff = shoff;
 h->ehsize = sizeof (header);
 h->shentsize = sizeof (section);
 h->shnum = shnum;
 h->shstrndx = strndx;

 pos = 0;
 write (hdr);
}

2236#if MAPPED_WRITING1
    remove_mapping ();
    if (ftruncate (fd, length))
set_error (errno(*__errno_location ()));
2240#endif
  }

data::simple_memory.shrink (sectab);
data::simple_memory.shrink (strtab);

return parent::end ();
2247}

2249/********************************************************************/

2251/* A dependency set.  This is used during stream out to determine the
 connectivity of the graph.  Every namespace-scope declaration that
 needs writing has a depset.  The depset is filled with the (depsets
 of) declarations within this module that it references.  For a
 declaration that'll generally be named types.  For definitions
 it'll also be declarations in the body.

 From that we can convert the graph to a DAG, via determining the
 Strongly Connected Clusters.  Each cluster is streamed
 independently, and thus we achieve lazy loading.

 Other decls that get a depset are namespaces themselves and
 unnameable declarations.   */

2265class depset {
2266private:
tree entity;  /* Entity, or containing namespace.  */
uintptr_t discriminator;  /* Flags or identifier.  */

2270public:
/* The kinds of entity the depset could describe.  The ordering is
   significant, see entity_kind_name.  */
enum entity_kind
{
  EK_DECL,		/* A decl.  */
  EK_SPECIALIZATION,  /* A specialization.  */
  EK_PARTIAL,		/* A partial specialization.  */
  EK_USING,		/* A using declaration (at namespace scope).  */
  EK_NAMESPACE,	/* A namespace.  */
  EK_REDIRECT,	/* Redirect to a template_decl.  */
  EK_EXPLICIT_HWM,  
  EK_BINDING = EK_EXPLICIT_HWM, /* Implicitly encoded.  */
  EK_FOR_BINDING,	/* A decl being inserted for a binding.  */
  EK_INNER_DECL,	/* A decl defined outside of its imported
	   context.  */
  EK_DIRECT_HWM = EK_PARTIAL + 1,

  EK_BITS = 3		/* Only need to encode below EK_EXPLICIT_HWM.  */
};

2291private:
/* Placement of bit fields in discriminator.  */
enum disc_bits 
{
  DB_ZERO_BIT, /* Set to disambiguate identifier from flags  */
  DB_SPECIAL_BIT, /* First dep slot is special.  */
  DB_KIND_BIT, /* Kind of the entity.  */
  DB_KIND_BITS = EK_BITS,
  DB_DEFN_BIT = DB_KIND_BIT + DB_KIND_BITS,
  DB_IS_MEMBER_BIT,		/* Is an out-of-class member.  */
  DB_IS_INTERNAL_BIT,		/* It is an (erroneous)
		   internal-linkage entity.  */
  DB_REFS_INTERNAL_BIT,	/* Refers to an internal-linkage
		   entity. */
  DB_IMPORTED_BIT,		/* An imported entity.  */
  DB_UNREACHED_BIT,		/* A yet-to-be reached entity.  */
  DB_HIDDEN_BIT,		/* A hidden binding.  */
  /* The following bits are not independent, but enumerating them is
     awkward.  */
  DB_ALIAS_TMPL_INST_BIT,	/* An alias template instantiation. */
  DB_ALIAS_SPEC_BIT,		/* Specialization of an alias template
		   (in both spec tables).  */
  DB_TYPE_SPEC_BIT,		/* Specialization in the type table.
		   */
  DB_FRIEND_SPEC_BIT,		/* An instantiated template friend.  */
};

2318public:
/* The first slot is special for EK_SPECIALIZATIONS it is a
   spec_entry pointer.  It is not relevant for the SCC
   determination.  */
vec<depset *> deps;  /* Depsets we reference.  */

2324public:
unsigned cluster; /* Strongly connected cluster, later entity number  */
unsigned section; /* Section written to.  */
/* During SCC construction, section is lowlink, until the depset is
   removed from the stack.  See Tarjan algorithm for details.  */

2330private:
/* Construction via factories.  Destruction via hash traits.  */
depset (tree entity);
~depset ();

2335public:
static depset *make_binding (tree, tree);
static depset *make_entity (tree, entity_kind, bool = false);
/* Late setting a binding name -- /then/ insert into hash!  */
inline void set_binding_name (tree name)
{
  gcc_checking_assert (!get_name ())((void)(!(!get_name ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2341, __FUNCTION__), 0 : 0));
  discriminator = reinterpret_cast<uintptr_t> (name);
}

2345private:
template<unsigned I> void set_flag_bit ()
{
  gcc_checking_assert (I < 2 || !is_binding ())((void)(!(I < 2 || !is_binding ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2348, __FUNCTION__), 0 : 0));
  discriminator |= 1u << I;
}
template<unsigned I> void clear_flag_bit ()
{
  gcc_checking_assert (I < 2 || !is_binding ())((void)(!(I < 2 || !is_binding ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2353, __FUNCTION__), 0 : 0));
  discriminator &= ~(1u << I);
}
template<unsigned I> bool get_flag_bit () const
{
  gcc_checking_assert (I < 2 || !is_binding ())((void)(!(I < 2 || !is_binding ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2358, __FUNCTION__), 0 : 0));
  return bool ((discriminator >> I) & 1);
}

2362public:
bool is_binding () const
{
  return !get_flag_bit<DB_ZERO_BIT> ();
}
entity_kind get_entity_kind () const
{
  if (is_binding ())
    return EK_BINDING;
  return entity_kind ((discriminator >> DB_KIND_BIT) & ((1u << EK_BITS) - 1));
}
const char *entity_kind_name () const;

2375public:
bool has_defn () const
{
  return get_flag_bit<DB_DEFN_BIT> ();
}

2381public:
/* This class-member is defined here, but the class was imported.  */
bool is_member () const
{
  gcc_checking_assert (get_entity_kind () == EK_DECL)((void)(!(get_entity_kind () == EK_DECL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2385, __FUNCTION__), 0 : 0));
  return get_flag_bit<DB_IS_MEMBER_BIT> ();
}
2388public:
bool is_internal () const
{
  return get_flag_bit<DB_IS_INTERNAL_BIT> ();
}
bool refs_internal () const
{
  return get_flag_bit<DB_REFS_INTERNAL_BIT> ();
}
bool is_import () const
{
  return get_flag_bit<DB_IMPORTED_BIT> ();
}
bool is_unreached () const
{
  return get_flag_bit<DB_UNREACHED_BIT> ();
}
bool is_alias_tmpl_inst () const
{
  return get_flag_bit<DB_ALIAS_TMPL_INST_BIT> ();
}
bool is_alias () const
{
  return get_flag_bit<DB_ALIAS_SPEC_BIT> ();
}
bool is_hidden () const
{
  return get_flag_bit<DB_HIDDEN_BIT> ();
}
bool is_type_spec () const
{
  return get_flag_bit<DB_TYPE_SPEC_BIT> ();
}
bool is_friend_spec () const
{
  return get_flag_bit<DB_FRIEND_SPEC_BIT> ();
}

2426public:
/* We set these bit outside of depset.  */
void set_hidden_binding ()
{
  set_flag_bit<DB_HIDDEN_BIT> ();
}
void clear_hidden_binding ()
{
  clear_flag_bit<DB_HIDDEN_BIT> ();
}

2437public:
bool is_special () const
{
  return get_flag_bit<DB_SPECIAL_BIT> ();
}
void set_special ()
{
  set_flag_bit<DB_SPECIAL_BIT> ();
}

2447public:
tree get_entity () const
{
  return entity;
}
tree get_name () const
{
  gcc_checking_assert (is_binding ())((void)(!(is_binding ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2454, __FUNCTION__), 0 : 0));
  return reinterpret_cast <tree> (discriminator);
}

2458public:
/* Traits for a hash table of pointers to bindings.  */
struct traits {
  /* Each entry is a pointer to a depset. */
  typedef depset *value_type;
  /* We lookup by container:maybe-identifier pair.  */
  typedef std::pair<tree,tree> compare_type;

  static const bool empty_zero_p = true;

  /* hash and equality for compare_type.  */
  inline static hashval_t hash (const compare_type &p)
  {
    hashval_t h = pointer_hash<tree_node>::hash (p.first);
    if (p.second)
{
 hashval_t nh = IDENTIFIER_HASH_VALUE (p.second)((tree_check ((p.second), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2474, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
);
 h = iterative_hash_hashval_t (h, nh);
}
    return h;
  }
  inline static bool equal (const value_type b, const compare_type &p)
  {
    if (b->entity != p.first)
return false;

    if (p.second)
return b->discriminator == reinterpret_cast<uintptr_t> (p.second);
    else
return !b->is_binding ();
  }

  /* (re)hasher for a binding itself.  */
  inline static hashval_t hash (const value_type b)
  {
    hashval_t h = pointer_hash<tree_node>::hash (b->entity);
    if (b->is_binding ())
{
 hashval_t nh = IDENTIFIER_HASH_VALUE (b->get_name ())((tree_check ((b->get_name ()), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2496, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
);
 h = iterative_hash_hashval_t (h, nh);
}
    return h;
  }

  /* Empty via NULL.  */
  static inline void mark_empty (value_type &p) {p = NULLnullptr;}
  static inline bool is_empty (value_type p) {return !p;}

  /* Nothing is deletable.  Everything is insertable.  */
  static bool is_deleted (value_type) { return false; }
  static void mark_deleted (value_type) { gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2508, __FUNCTION__)); }

  /* We own the entities in the hash table.  */
  static void remove (value_type p)
  {
    delete (p);
  }
};

2517public:
class hash : public hash_table<traits> {
  typedef traits::compare_type key_t;
  typedef hash_table<traits> parent;

public:
  vec<depset *> worklist;  /* Worklist of decls to walk.  */
  hash *chain;	     /* Original table.  */
  depset *current;         /* Current depset being depended.  */
  unsigned section;	     /* When writing out, the section.  */
  bool sneakoscope;        /* Detecting dark magic (of a voldemort).  */
  bool reached_unreached;  /* We reached an unreached entity.  */

public:
  hash (size_t size, hash *c = NULLnullptr)
    : parent (size), chain (c), current (NULLnullptr), section (0),
sneakoscope (false), reached_unreached (false)
  {
    worklist.create (size);
  }
  ~hash ()
  {
    worklist.release ();
  }

public:
  bool is_key_order () const
  {
    return chain != NULLnullptr;
  }

private:
  depset **entity_slot (tree entity, bool = true);
  depset **binding_slot (tree ctx, tree name, bool = true);
  depset *maybe_add_declaration (tree decl);

public:
  depset *find_dependency (tree entity);
  depset *find_binding (tree ctx, tree name);
  depset *make_dependency (tree decl, entity_kind);
  void add_dependency (depset *);

public:
  void add_mergeable (depset *);
  depset *add_dependency (tree decl, entity_kind);
  void add_namespace_context (depset *, tree ns);

private:
  static bool add_binding_entity (tree, WMB_Flags, void *);

public:
  bool add_namespace_entities (tree ns, bitmap partitions);
  void add_specializations (bool decl_p);
  void add_partial_entities (vec<tree, va_gc> *);
  void add_class_entities (vec<tree, va_gc> *);

public:    
  void find_dependencies (module_state *);
  bool finalize_dependencies ();
  vec<depset *> connect ();
};

2579public:
struct tarjan {
  vec<depset *> result;
  vec<depset *> stack;
  unsigned index;

  tarjan (unsigned size)
    : index (0)
  {
    result.create (size);
    stack.create (50);
  }
  ~tarjan () 
  {
    gcc_assert (!stack.length ())((void)(!(!stack.length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2593, __FUNCTION__), 0 : 0));
    stack.release ();
  }

public:
  void connect (depset *);
};
2600};

2602inline
2603depset::depset (tree entity)
:entity (entity), discriminator (0), cluster (0), section (0)
2605{
deps.create (0);
2607}

2609inline
2610depset::~depset ()
2611{
deps.release ();
2613}

2615const char *
2616depset::entity_kind_name () const
2617{
/* Same order as entity_kind.  */
static const char *const names[] = 
  {"decl", "specialization", "partial", "using",
   "namespace", "redirect", "binding"};
entity_kind kind = get_entity_kind ();
gcc_checking_assert (kind < ARRAY_SIZE (names))((void)(!(kind < (sizeof (names) / sizeof ((names)[0]))) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2623, __FUNCTION__), 0 : 0));
return names[kind];
2625}

2627/* Create a depset for a namespace binding NS::NAME.  */

2629depset *depset::make_binding (tree ns, tree name)
2630{
depset *binding = new depset (ns);

binding->discriminator = reinterpret_cast <uintptr_t> (name);

return binding;
2636}

2638depset *depset::make_entity (tree entity, entity_kind ek, bool is_defn)
2639{
depset *r = new depset (entity);

r->discriminator = ((1 << DB_ZERO_BIT)
      | (ek << DB_KIND_BIT)
      | is_defn << DB_DEFN_BIT);

return r;
2647}

2649class pending_key
2650{
2651public:
tree ns;
tree id;
2654};

2656template<>
2657struct default_hash_traits<pending_key>
2658{
using value_type = pending_key;

static const bool empty_zero_p = false;
static hashval_t hash (const value_type &k)
{
  hashval_t h = IDENTIFIER_HASH_VALUE (k.id)((tree_check ((k.id), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2664, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
);
  h = iterative_hash_hashval_t (DECL_UID (k.ns)((contains_struct_check ((k.ns), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2665, __FUNCTION__))->decl_minimal.uid), h);

  return h;
}
static bool equal (const value_type &k, const value_type &l)
{
  return k.ns == l.ns && k.id == l.id;
}
static void mark_empty (value_type &k)
{
  k.ns = k.id = NULL_TREE(tree) nullptr;
}
static void mark_deleted (value_type &k)
{
  k.ns = NULL_TREE(tree) nullptr;
  gcc_checking_assert (k.id)((void)(!(k.id) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 2680, __FUNCTION__), 0 : 0));
}
static bool is_empty (const value_type &k)
{
  return k.ns == NULL_TREE(tree) nullptr && k.id == NULL_TREE(tree) nullptr;
}
static bool is_deleted (const value_type &k)
{
  return k.ns == NULL_TREE(tree) nullptr && k.id != NULL_TREE(tree) nullptr;
}
static void remove (value_type &)
{
}
2693};

2695typedef hash_map<pending_key, auto_vec<unsigned>> pending_map_t;

2697/* Not-loaded entities that are keyed to a namespace-scope
 identifier.  See module_state::write_pendings for details.  */
2699pending_map_t *pending_table;

2701/* Decls that need some post processing once a batch of lazy loads has
 completed.  */
2703vec<tree, va_heap, vl_embed> *post_load_decls;

2705/* Some entities are keyed to another entitity for ODR purposes.
 For example, at namespace scope, 'inline auto var = []{};', that
 lambda is keyed to 'var', and follows its ODRness.  */
2708typedef hash_map<tree, auto_vec<tree>> keyed_map_t;
2709static keyed_map_t *keyed_table;

2711/********************************************************************/
2712/* Tree streaming.   The tree streaming is very specific to the tree
 structures themselves.  A tag indicates the kind of tree being
 streamed.  -ve tags indicate backreferences to already-streamed
 trees.  Backreferences are auto-numbered.  */

2717/* Tree tags.  */
2718enum tree_tag {
tt_null,		/* NULL_TREE.  */
tt_fixed,		/* Fixed vector index.  */

tt_node,		/* By-value node.  */
tt_decl,		/* By-value mergeable decl.  */
tt_tpl_parm,		/* Template parm.  */

/* The ordering of the following 4 is relied upon in
   trees_out::tree_node.  */
tt_id,  		/* Identifier node.  */
tt_conv_id,		/* Conversion operator name.  */
tt_anon_id,		/* Anonymous name.  */
tt_lambda_id,		/* Lambda name.  */

tt_typedef_type,	/* A (possibly implicit) typedefed type.  */
tt_derived_type,	/* A type derived from another type.  */
tt_variant_type,	/* A variant of another type.  */

tt_tinfo_var,		/* Typeinfo object. */
tt_tinfo_typedef,	/* Typeinfo typedef.  */
tt_ptrmem_type,	/* Pointer to member type.  */
tt_nttp_var,		/* NTTP_OBJECT VAR_DECL.  */

tt_parm,		/* Function parameter or result.  */
tt_enum_value,	/* An enum value.  */
tt_enum_decl,		/* An enum decl.  */
tt_data_member,	/* Data member/using-decl.  */

tt_binfo,		/* A BINFO.  */
tt_vtable,		/* A vtable.  */
tt_thunk,		/* A thunk.  */
tt_clone_ref,

tt_entity,		/* A extra-cluster entity.  */

tt_template,		/* The TEMPLATE_RESULT of a template.  */
2755};

2757enum walk_kind {
WK_none,	/* No walk to do (a back- or fixed-ref happened).  */
WK_normal,	/* Normal walk (by-name if possible).  */

WK_value,	/* By-value walk.  */
2762};

2764enum merge_kind
2765{
MK_unique,	/* Known unique.  */
MK_named,	/* Found by CTX, NAME + maybe_arg types etc.  */
MK_field,	/* Found by CTX and index on TYPE_FIELDS  */
MK_vtable,	/* Found by CTX and index on TYPE_VTABLES  */
MK_as_base,	/* Found by CTX.  */

MK_partial,

MK_enum,	/* Found by CTX, & 1stMemberNAME.  */
MK_keyed,     /* Found by key & index.  */

MK_friend_spec,  /* Like named, but has a tmpl & args too.  */
MK_local_friend, /* Found by CTX, index.  */

MK_indirect_lwm = MK_enum,

/* Template specialization kinds below. These are all found via
   primary template and specialization args.  */
MK_template_mask = 0x10,  /* A template specialization.  */

MK_tmpl_decl_mask = 0x4, /* In decl table.  */
MK_tmpl_alias_mask = 0x2, /* Also in type table  */

MK_tmpl_tmpl_mask = 0x1, /* We want TEMPLATE_DECL.  */

MK_type_spec = MK_template_mask,
MK_decl_spec = MK_template_mask | MK_tmpl_decl_mask,
MK_alias_spec = MK_decl_spec | MK_tmpl_alias_mask,

MK_hwm = 0x20
2796};
2797/* This is more than a debugging array.  NULLs are used to determine
 an invalid merge_kind number.  */
2799static char const *const merge_kind_name[MK_hwm] =
{
  "unique", "named", "field", "vtable",	/* 0...3  */
  "asbase", "partial", "enum", "attached",	/* 4...7  */

  "friend spec", "local friend", NULLnullptr, NULLnullptr,  /* 8...11 */
  NULLnullptr, NULLnullptr, NULLnullptr, NULLnullptr,

  "type spec", "type tmpl spec",	/* 16,17 type (template).  */
  NULLnullptr, NULLnullptr,

  "decl spec", "decl tmpl spec",	/* 20,21 decl (template).  */
  "alias spec", "alias tmpl spec",	/* 22,23 alias (template). */
  NULLnullptr, NULLnullptr, NULLnullptr, NULLnullptr,
  NULLnullptr, NULLnullptr, NULLnullptr, NULLnullptr,
};

2816/* Mergeable entity location data.  */
2817struct merge_key {
cp_ref_qualifier ref_q : 2;
unsigned index;

tree ret;  /* Return type, if appropriate.  */
tree args; /* Arg types, if appropriate.  */

tree constraints;  /* Constraints.  */

merge_key ()
  :ref_q (REF_QUAL_NONE), index (0),
   ret (NULL_TREE(tree) nullptr), args (NULL_TREE(tree) nullptr),
   constraints (NULL_TREE(tree) nullptr)
{
}
2832};

2834/* Hashmap of merged duplicates.  Usually decls, but can contain
 BINFOs.  */
2836typedef hash_map<tree,uintptr_t,
 simple_hashmap_traits<nodel_ptr_hash<tree_node>,uintptr_t> >
2838duplicate_hash_map;

2840/* Tree stream reader.  Note that reading a stream doesn't mark the
 read trees with TREE_VISITED.  Thus it's quite safe to have
 multiple concurrent readers.  Which is good, because lazy
 loading. */
2844class trees_in : public bytes_in {
typedef bytes_in parent;

2847private:
module_state *state;		/* Module being imported.  */
vec<tree> back_refs;		/* Back references.  */
duplicate_hash_map *duplicates;	/* Map from existings to duplicate.  */
vec<tree> post_decls;		/* Decls to post process.  */
unsigned unused;		/* Inhibit any interior TREE_USED
		   marking.  */

2855public:
trees_in (module_state *);
~trees_in ();

2859public:
int insert (tree);
tree back_ref (int);

2863private:
tree start (unsigned = 0);

2866public:
/* Needed for binfo writing  */
bool core_bools (tree);

2870private:
/* Stream tree_core, lang_decl_specific and lang_type_specific
   bits.  */
bool core_vals (tree);
bool lang_type_bools (tree);
bool lang_type_vals (tree);
bool lang_decl_bools (tree);
bool lang_decl_vals (tree);
bool lang_vals (tree);
bool tree_node_bools (tree);
bool tree_node_vals (tree);
tree tree_value ();
tree decl_value ();
tree tpl_parm_value ();

2885private:
tree chained_decls ();  /* Follow DECL_CHAIN.  */
vec<tree, va_heap> *vec_chained_decls ();
vec<tree, va_gc> *tree_vec (); /* vec of tree.  */
vec<tree_pair_s, va_gc> *tree_pair_vec (); /* vec of tree_pair.  */
tree tree_list (bool has_purpose);

2892public:
/* Read a tree node.  */
tree tree_node (bool is_use = false);

2896private:
bool install_entity (tree decl);
tree tpl_parms (unsigned &tpl_levels);
bool tpl_parms_fini (tree decl, unsigned tpl_levels);
bool tpl_header (tree decl, unsigned *tpl_levels);
int fn_parms_init (tree);
void fn_parms_fini (int tag, tree fn, tree existing, bool has_defn);
unsigned add_indirect_tpl_parms (tree);
2904public:
bool add_indirects (tree);

2907public:
/* Serialize various definitions. */
bool read_definition (tree decl);

2911private:
bool is_matching_decl (tree existing, tree decl, bool is_typedef);
static bool install_implicit_member (tree decl);
bool read_function_def (tree decl, tree maybe_template);
bool read_var_def (tree decl, tree maybe_template);
bool read_class_def (tree decl, tree maybe_template);
bool read_enum_def (tree decl, tree maybe_template);

2919public:
tree decl_container ();
tree key_mergeable (int tag, merge_kind, tree decl, tree inner, tree type,
      tree container, bool is_attached);
unsigned binfo_mergeable (tree *);

2925private:
uintptr_t *find_duplicate (tree existing);
void register_duplicate (tree decl, tree existing);
/* Mark as an already diagnosed bad duplicate.  */
void unmatched_duplicate (tree existing)
{
  *find_duplicate (existing) |= 1;
}

2934public:
bool is_duplicate (tree decl)
{
  return find_duplicate (decl) != NULLnullptr;
}
tree maybe_duplicate (tree decl)
{
  if (uintptr_t *dup = find_duplicate (decl))
    return reinterpret_cast<tree> (*dup & ~uintptr_t (1));
  return decl;
}
tree odr_duplicate (tree decl, bool has_defn);

2947public:
/* Return the next decl to postprocess, or NULL.  */
tree post_process ()
{
  return post_decls.length () ? post_decls.pop () : NULL_TREE(tree) nullptr;
}
2953private:
/* Register DECL for postprocessing.  */
void post_process (tree decl)
{
  post_decls.safe_push (decl);
}

2960private:
void assert_definition (tree, bool installing);
2962};

2964trees_in::trees_in (module_state *state)
:parent (), state (state), unused (0)
2966{
duplicates = NULLnullptr;
back_refs.create (500);
post_decls.create (0);
2970}

2972trees_in::~trees_in ()
2973{
delete (duplicates);
back_refs.release ();
post_decls.release ();
2977}

2979/* Tree stream writer.  */
2980class trees_out : public bytes_out {
typedef bytes_out parent;

2983private:
module_state *state;		/* The module we are writing.  */
ptr_int_hash_map tree_map; 	/* Trees to references */
depset::hash *dep_hash;    	/* Dependency table.  */
int ref_num;			/* Back reference number.  */
unsigned section;
2989#if CHECKING_P1
int importedness;		/* Checker that imports not occurring
		   inappropriately.  +ve imports ok,
		   -ve imports not ok.  */
2993#endif

2995public:
trees_out (allocator *, module_state *, depset::hash &deps, unsigned sec = 0);
~trees_out ();

2999private:
void mark_trees ();
void unmark_trees ();

3003public:
/* Hey, let's ignore the well known STL iterator idiom.  */
void begin ();
unsigned end (elf_out *sink, unsigned name, unsigned *crc_ptr);
void end ();

3009public:
enum tags 
{
  tag_backref = -1,	/* Upper bound on the backrefs.  */
  tag_value = 0,	/* Write by value.  */
  tag_fixed		/* Lower bound on the fixed trees.  */
};

3017public:
bool is_key_order () const
{
  return dep_hash->is_key_order ();
}

3023public:
int insert (tree, walk_kind = WK_normal);

3026private:
void start (tree, bool = false);

3029private:
walk_kind ref_node (tree);
3031public:
int get_tag (tree);
void set_importing (int i ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
{
3035#if CHECKING_P1
  importedness = i;
3037#endif
}

3040private:
void core_bools (tree);
void core_vals (tree);
void lang_type_bools (tree);
void lang_type_vals (tree);
void lang_decl_bools (tree);
void lang_decl_vals (tree);
void lang_vals (tree);
void tree_node_bools (tree);
void tree_node_vals (tree);

3051private:
void chained_decls (tree);
void vec_chained_decls (tree);
void tree_vec (vec<tree, va_gc> *);
void tree_pair_vec (vec<tree_pair_s, va_gc> *);
void tree_list (tree, bool has_purpose);

3058public:
/* Mark a node for by-value walking.  */
void mark_by_value (tree);

3062public:
void tree_node (tree);

3065private:
void install_entity (tree decl, depset *);
void tpl_parms (tree parms, unsigned &tpl_levels);
void tpl_parms_fini (tree decl, unsigned tpl_levels);
void fn_parms_fini (tree) {}
unsigned add_indirect_tpl_parms (tree);
3071public:
void add_indirects (tree);
void fn_parms_init (tree);
void tpl_header (tree decl, unsigned *tpl_levels);

3076public:
merge_kind get_merge_kind (tree decl, depset *maybe_dep);
tree decl_container (tree decl);
void key_mergeable (int tag, merge_kind, tree decl, tree inner,
      tree container, depset *maybe_dep);
void binfo_mergeable (tree binfo);

3083private:
bool decl_node (tree, walk_kind ref);
void type_node (tree);
void tree_value (tree);
void tpl_parm_value (tree);

3089public:
void decl_value (tree, depset *);

3092public:
/* Serialize various definitions. */
void write_definition (tree decl);
void mark_declaration (tree decl, bool do_defn);

3097private:
void mark_function_def (tree decl);
void mark_var_def (tree decl);
void mark_class_def (tree decl);
void mark_enum_def (tree decl);
void mark_class_member (tree decl, bool do_defn = true);
void mark_binfos (tree type);

3105private:
void write_var_def (tree decl);
void write_function_def (tree decl);
void write_class_def (tree decl);
void write_enum_def (tree decl);

3111private:
static void assert_definition (tree);

3114public:
static void instrument ();

3117private:
/* Tree instrumentation. */
static unsigned tree_val_count;
static unsigned decl_val_count;
static unsigned back_ref_count;
static unsigned null_count;
3123};

3125/* Instrumentation counters.  */
3126unsigned trees_out::tree_val_count;
3127unsigned trees_out::decl_val_count;
3128unsigned trees_out::back_ref_count;
3129unsigned trees_out::null_count;

3131trees_out::trees_out (allocator *mem, module_state *state, depset::hash &deps,
      unsigned section)
:parent (mem), state (state), tree_map (500),
 dep_hash (&deps), ref_num (0), section (section)
3135{
3136#if CHECKING_P1
importedness = 0;
3138#endif
3139}

3141trees_out::~trees_out ()
3142{
3143}

3145/********************************************************************/
3146/* Location.  We're aware of the line-map concept and reproduce it
 here.  Each imported module allocates a contiguous span of ordinary
 maps, and of macro maps.  adhoc maps are serialized by contents,
 not pre-allocated.   The scattered linemaps of a module are
 coalesced when writing.  */


3153/* I use half-open [first,second) ranges.  */
3154typedef std::pair<unsigned,unsigned> range_t;

3156/* A range of locations.  */
3157typedef std::pair<location_t,location_t> loc_range_t;

3159/* Spans of the line maps that are occupied by this TU.  I.e. not
 within imports.  Only extended when in an interface unit.
 Interval zero corresponds to the forced header linemap(s).  This
 is a singleton object.  */

3164class loc_spans {
3165public:
/* An interval of line maps.  The line maps here represent a contiguous
   non-imported range.  */
struct span {
  loc_range_t ordinary;	/* Ordinary map location range. */
  loc_range_t macro;		/* Macro map location range.  */
  int ordinary_delta;	/* Add to ordinary loc to get serialized loc.  */
  int macro_delta;	/* Likewise for macro loc.  */
};

3175private:
vec<span> *spans;

3178public:
loc_spans ()
  /* Do not preallocate spans, as that causes
     --enable-detailed-mem-stats problems.  */
  : spans (nullptr)
{
}
~loc_spans ()
{
  delete spans;
}

3190public:
span &operator[] (unsigned ix)
{
  return (*spans)[ix];
}
unsigned length () const
{
  return spans->length ();
}

3200public:
bool init_p () const
{
  return spans != nullptr;
}
/* Initializer.  */
void init (const line_maps *lmaps, const line_map_ordinary *map);

/* Slightly skewed preprocessed files can cause us to miss an
   initialization in some places.  Fallback initializer.  */
void maybe_init ()
{
  if (!init_p ())
    init (line_table, nullptr);
}

3216public:
enum {
  SPAN_RESERVED = 0,	/* Reserved (fixed) locations.  */
  SPAN_FIRST = 1,	/* LWM of locations to stream  */
  SPAN_MAIN = 2	/* Main file and onwards.  */
};

3223public:
location_t main_start () const
{
  return (*spans)[SPAN_MAIN].ordinary.first;
}

3229public:
void open (location_t);
void close ();

3233public:
/* Propagate imported linemaps to us, if needed.  */
bool maybe_propagate (module_state *import, location_t loc);

3237public:
const span *ordinary (location_t);
const span *macro (location_t);
3240};

3242static loc_spans spans;

3244/* Information about ordinary locations we stream out.  */
3245struct ord_loc_info
3246{
const line_map_ordinary *src; // line map we're based on
unsigned offset;	// offset to this line
unsigned span;	// number of locs we span
unsigned remap;	// serialization

static int compare (const void *a_, const void *b_)
{
  auto *a = static_cast<const ord_loc_info *> (a_);
  auto *b = static_cast<const ord_loc_info *> (b_);

  if (a->src != b->src)
    return a->src < b->src ? -1 : +1;

  // Ensure no overlap
  gcc_checking_assert (a->offset + a->span <= b->offset((void)(!(a->offset + a->span <= b->offset || b->
offset + b->span <= a->offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3262, __FUNCTION__), 0 : 0))
	 || b->offset + b->span <= a->offset)((void)(!(a->offset + a->span <= b->offset || b->
offset + b->span <= a->offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3262, __FUNCTION__), 0 : 0));

  gcc_checking_assert (a->offset != b->offset)((void)(!(a->offset != b->offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3264, __FUNCTION__), 0 : 0));
  return a->offset < b->offset ? -1 : +1;
}
3267};
3268struct ord_loc_traits
3269{
typedef ord_loc_info value_type;
typedef value_type compare_type;

static const bool empty_zero_p = false;

static hashval_t hash (const value_type &v)
{
  auto h = pointer_hash<const line_map_ordinary>::hash (v.src);
  return iterative_hash_hashval_t (v.offset, h);
}
static bool equal (const value_type &v, const compare_type p)
{
  return v.src == p.src && v.offset == p.offset;
}

static void mark_empty (value_type &v)
{
  v.src = nullptr;
}
static bool is_empty (value_type &v)
{
  return !v.src;
}

static bool is_deleted (value_type &) { return false; }
static void mark_deleted (value_type &) { gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3295, __FUNCTION__)); }

static void remove (value_type &) {}
3298};
3299/* Table keyed by ord_loc_info, used for noting.  */
3300static  hash_table<ord_loc_traits> *ord_loc_table;
3301/* Sorted vector, used for writing.  */
3302static vec<ord_loc_info> *ord_loc_remap;

3304/* Information about macro locations we stream out.  */
3305struct macro_loc_info
3306{
const line_map_macro *src;    // original expansion
unsigned remap;	  // serialization

static int compare (const void *a_, const void *b_)
{
  auto *a = static_cast<const macro_loc_info *> (a_);
  auto *b = static_cast<const macro_loc_info *> (b_);

  gcc_checking_assert (MAP_START_LOCATION (a->src)((void)(!(MAP_START_LOCATION (a->src) != MAP_START_LOCATION
 (b->src)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3316, __FUNCTION__), 0 : 0))
	 != MAP_START_LOCATION (b->src))((void)(!(MAP_START_LOCATION (a->src) != MAP_START_LOCATION
 (b->src)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3316, __FUNCTION__), 0 : 0));
  if (MAP_START_LOCATION (a->src) < MAP_START_LOCATION (b->src))
    return -1;
  else
    return +1;
}
3322};
3323struct macro_loc_traits
3324{
typedef macro_loc_info value_type;
typedef const line_map_macro *compare_type;

static const bool empty_zero_p = false;

static hashval_t hash (compare_type p)
{
  return pointer_hash<const line_map_macro>::hash (p);
}
static hashval_t hash (const value_type &v)
{
  return hash (v.src);
}
static bool equal (const value_type &v, const compare_type p)
{
  return v.src == p;
}

static void mark_empty (value_type &v)
{
  v.src = nullptr;
}
static bool is_empty (value_type &v)
{
  return !v.src;
}

static bool is_deleted (value_type &) { return false; }
static void mark_deleted (value_type &) { gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3353, __FUNCTION__)); }

static void remove (value_type &) {}
3356};
3357/* Table keyed by line_map_macro, used for noting.  */
3358static  hash_table<macro_loc_traits> *macro_loc_table;
3359/* Sorted vector, used for writing.  */
3360static vec<macro_loc_info> *macro_loc_remap;

3362/* Indirection to allow bsearching imports by ordinary location.  */
3363static vec<module_state *> *ool;

3365/********************************************************************/
3366/* Data needed by a module during the process of loading.  */
3367struct GTY(()) slurping {

/* Remap import's module numbering to our numbering.  Values are
   shifted by 1.  Bit0 encodes if the import is direct.  */
vec<unsigned, va_heap, vl_embed> *
  GTY((skip)) remap;			/* Module owner remapping.  */

elf_in *GTY((skip)) from;     	/* The elf loader.  */

/* This map is only for header imports themselves -- the global
   headers bitmap hold it for the current TU.  */
bitmap headers;	/* Transitive set of direct imports, including
	   self.  Used for macro visibility and
	   priority.  */

/* These objects point into the mmapped area, unless we're not doing
   that, or we got frozen or closed.  In those cases they point to
   buffers we own.  */
bytes_in macro_defs;	/* Macro definitions.  */
bytes_in macro_tbl;	/* Macro table.  */

/* Location remapping.  first->ordinary, second->macro.  */
range_t GTY((skip)) loc_deltas;

unsigned current;	/* Section currently being loaded.  */
unsigned remaining;	/* Number of lazy sections yet to read.  */
unsigned lru;		/* An LRU counter.  */

public:
slurping (elf_in *);
~slurping ();

public:
/* Close the ELF file, if it's open.  */
void close ()
{
  if (from)
    {
from->end ();
delete from;
from = NULLnullptr;
    }
}

public:
void release_macros ();

public:
void alloc_remap (unsigned size)
{
  gcc_assert (!remap)((void)(!(!remap) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3417, __FUNCTION__), 0 : 0));
  vec_safe_reserve (remap, size);
  for (unsigned ix = size; ix--;)
    remap->quick_push (0);
}
unsigned remap_module (unsigned owner)
{
  if (owner < remap->length ())
    return (*remap)[owner] >> 1;
  return 0;
}

public:
/* GC allocation.  But we must explicitly delete it.   */
static void *operator new (size_t x)
{
  return ggc_alloc_atomic (x);
}
static void operator delete (void *p)
{
  ggc_free (p);
}
3439};

3441slurping::slurping (elf_in *from)
: remap (NULLnullptr), from (from),
  headers (BITMAP_GGC_ALLOCbitmap_gc_alloc ()), macro_defs (), macro_tbl (),
  loc_deltas (0, 0),
  current (~0u), remaining (0), lru (0)
3446{
3447}

3449slurping::~slurping ()
3450{
vec_free (remap);
remap = NULLnullptr;
release_macros ();
close ();
3455}

3457void slurping::release_macros ()
3458{
if (macro_defs.size)
  elf_in::release (from, macro_defs);
if (macro_tbl.size)
  elf_in::release (from, macro_tbl);
3463}

3465/* Flags for extensions that end up being streamed.  */

3467enum streamed_extensions {
SE_OPENMP = 1 << 0,
SE_BITS = 1
3470};

3472/* Counter indices.  */
3473enum module_state_counts
3474{
MSC_sec_lwm,
MSC_sec_hwm,
MSC_pendings,
MSC_entities,
MSC_namespaces,
MSC_bindings,
MSC_macros,
MSC_inits,
MSC_HWM
3484};

3486/********************************************************************/
3487struct module_state_config;

3489/* Increasing levels of loadedness.  */
3490enum module_loadedness {
ML_NONE,		/* Not loaded.  */
ML_CONFIG,		/* Config loaed.  */
ML_PREPROCESSOR,	/* Preprocessor loaded.  */
ML_LANGUAGE,		/* Language loaded.  */
3495};

3497/* Increasing levels of directness (toplevel) of import.  */
3498enum module_directness {
MD_NONE,  		/* Not direct.  */
MD_PARTITION_DIRECT,	/* Direct import of a partition.  */
MD_DIRECT,		/* Direct import.  */
MD_PURVIEW_DIRECT,	/* direct import in purview.  */
3503};

3505/* State of a particular module. */

3507class GTY((chain_next ("%h.parent"), for_user)) module_state {
public:
/* We always import & export ourselves.  */
bitmap imports;	/* Transitive modules we're importing.  */
bitmap exports;	/* Subset of that, that we're exporting.  */

module_state *parent;
tree name;		/* Name of the module.  */

slurping *slurp;	/* Data for loading.  */

const char *flatname;	/* Flatname of module.  */
char *filename;	/* CMI Filename */

/* Indices into the entity_ary.  */
unsigned entity_lwm;
unsigned entity_num;

/* Location ranges for this module.  adhoc-locs are decomposed, so
   don't have a range.  */
loc_range_t GTY((skip)) ordinary_locs;
loc_range_t GTY((skip)) macro_locs; // [lwm,num)

/* LOC is first set too the importing location.  When initially
   loaded it refers to a module loc whose parent is the importing
   location.  */
location_t loc; 	/* Location referring to module itself.  */
unsigned crc;		/* CRC we saw reading it in. */

unsigned mod;		/* Module owner number.  */
unsigned remap;	/* Remapping during writing.  */

unsigned short subst;	/* Mangle subst if !0.  */

/* How loaded this module is.  */
enum module_loadedness loadedness : 2;

bool module_p : 1;    /* /The/ module of this TU.  */
bool header_p : 1;	/* Is a header unit.  */
bool interface_p : 1; /* An interface.  */
bool partition_p : 1; /* A partition.  */

/* How directly this module is imported.  */
enum module_directness directness : 2;

bool exported_p : 1;	/* directness != MD_NONE && exported.  */
bool cmi_noted_p : 1; /* We've told the user about the CMI, don't
	   do it again  */
bool active_init_p : 1; /* This module's global initializer needs
	   calling.  */
bool inform_cmi_p : 1; /* Inform of a read/write.  */
bool visited_p : 1;    /* A walk-once flag. */
/* Record extensions emitted or permitted.  */
unsigned extensions : SE_BITS;
/* 14 bits used, 2 bits remain  */

public:
module_state (tree name, module_state *, bool);
~module_state ();

public:
void release ()
{
  imports = exports = NULLnullptr;
  slurped ();
}
void slurped ()
{
  delete slurp;
  slurp = NULLnullptr;
}
elf_in *from () const
{
  return slurp->from;
}

public:
/* Kind of this module.  */
bool is_module () const
{
  return module_p;
}
bool is_header () const
{
  return header_p;
}
bool is_interface () const
{
  return interface_p;
}
bool is_partition () const
{
  return partition_p;
}

/* How this module is used in the current TU.  */
bool is_exported () const
{
  return exported_p;
}
bool is_direct () const
{
  return directness >= MD_DIRECT;
}
bool is_purview_direct () const
{
  return directness == MD_PURVIEW_DIRECT;
}
bool is_partition_direct () const
{
  return directness == MD_PARTITION_DIRECT;
}

public:
/* Is this a real module?  */
bool has_location () const
{
  return loc != UNKNOWN_LOCATION((location_t) 0);
}

public:
bool check_not_purview (location_t loc);

public:
void mangle (bool include_partition);

public:
void set_import (module_state const *, bool is_export);
void announce (const char *) const;

public:
/* Read and write module.  */
void write_begin (elf_out *to, cpp_reader *,
    module_state_config &, unsigned &crc);
void write_end (elf_out *to, cpp_reader *,
  module_state_config &, unsigned &crc);
bool read_initial (cpp_reader *);
bool read_preprocessor (bool);
bool read_language (bool);

public:
/* Read a section.  */
bool load_section (unsigned snum, binding_slot *mslot);
/* Lazily read a section.  */
bool lazy_load (unsigned index, binding_slot *mslot);

public:
/* Juggle a limited number of file numbers.  */
static void freeze_an_elf ();
bool maybe_defrost ();

public:
void maybe_completed_reading ();
bool check_read (bool outermost, bool ok);

private:
/* The README, for human consumption.  */
void write_readme (elf_out *to, cpp_reader *, const char *dialect);
void write_env (elf_out *to);

private:
/* Import tables. */
void write_imports (bytes_out &cfg, bool direct);
unsigned read_imports (bytes_in &cfg, cpp_reader *, line_maps *maps);

private:
void write_imports (elf_out *to, unsigned *crc_ptr);
bool read_imports (cpp_reader *, line_maps *);

private:
void write_partitions (elf_out *to, unsigned, unsigned *crc_ptr);
bool read_partitions (unsigned);

private:
void write_config (elf_out *to, struct module_state_config &, unsigned crc);
bool read_config (struct module_state_config &);
static void write_counts (elf_out *to, unsigned [MSC_HWM], unsigned *crc_ptr);
bool read_counts (unsigned *);

public:
void note_cmi_name ();

private:
static unsigned write_bindings (elf_out *to, vec<depset *> depsets,
		  unsigned *crc_ptr);
bool read_bindings (unsigned count, unsigned lwm, unsigned hwm);

static void write_namespace (bytes_out &sec, depset *ns_dep);
tree read_namespace (bytes_in &sec);

void write_namespaces (elf_out *to, vec<depset *> spaces,
	 unsigned, unsigned *crc_ptr);
bool read_namespaces (unsigned);

void intercluster_seed (trees_out &sec, unsigned index, depset *dep);
unsigned write_cluster (elf_out *to, depset *depsets[], unsigned size,
	  depset::hash &, unsigned *counts, unsigned *crc_ptr);
bool read_cluster (unsigned snum);

private:
unsigned write_inits (elf_out *to, depset::hash &, unsigned *crc_ptr);
bool read_inits (unsigned count);

private:
unsigned write_pendings (elf_out *to, vec<depset *> depsets,
	   depset::hash &, unsigned *crc_ptr);
bool read_pendings (unsigned count);

private:
void write_entities (elf_out *to, vec<depset *> depsets,
       unsigned count, unsigned *crc_ptr);
bool read_entities (unsigned count, unsigned lwm, unsigned hwm);

private:
void write_init_maps ();
range_t write_prepare_maps (module_state_config *, bool);
bool read_prepare_maps (const module_state_config *);

void write_ordinary_maps (elf_out *to, range_t &,
	    bool, unsigned *crc_ptr);
bool read_ordinary_maps (unsigned, unsigned);
void write_macro_maps (elf_out *to, range_t &, unsigned *crc_ptr);
bool read_macro_maps (unsigned);

private:
void write_define (bytes_out &, const cpp_macro *);
cpp_macro *read_define (bytes_in &, cpp_reader *) const;
vec<cpp_hashnode *> *prepare_macros (cpp_reader *);
unsigned write_macros (elf_out *to, vec<cpp_hashnode *> *, unsigned *crc_ptr);
bool read_macros ();
void install_macros ();

public:
void import_macros ();

public:
static void undef_macro (cpp_reader *, location_t, cpp_hashnode *);
static cpp_macro *deferred_macro (cpp_reader *, location_t, cpp_hashnode *);

public:
static bool note_location (location_t);
static void write_location (bytes_out &, location_t);
location_t read_location (bytes_in &) const;

public:
void set_flatname ();
const char *get_flatname () const
{
  return flatname;
}
location_t imported_from () const;

public:
void set_filename (const Cody::Packet &);
bool do_import (cpp_reader *, bool outermost);
3762};

3764/* Hash module state by name.  This cannot be a member of
 module_state, because of GTY restrictions.  We never delete from
 the hash table, but ggc_ptr_hash doesn't support that
 simplification.  */

3769struct module_state_hash : ggc_ptr_hash<module_state> {
typedef std::pair<tree,uintptr_t> compare_type; /* {name,parent} */

static inline hashval_t hash (const value_type m);
static inline hashval_t hash (const compare_type &n);
static inline bool equal (const value_type existing,
	    const compare_type &candidate);
3776};

3778module_state::module_state (tree name, module_state *parent, bool partition)
: imports (BITMAP_GGC_ALLOCbitmap_gc_alloc ()), exports (BITMAP_GGC_ALLOCbitmap_gc_alloc ()),
  parent (parent), name (name), slurp (NULLnullptr),
  flatname (NULLnullptr), filename (NULLnullptr),
  entity_lwm (~0u >> 1), entity_num (0),
  ordinary_locs (0, 0), macro_locs (0, 0),
  loc (UNKNOWN_LOCATION((location_t) 0)),
  crc (0), mod (MODULE_UNKNOWN(~0U)), remap (0), subst (0)
3786{
loadedness = ML_NONE;

module_p = header_p = interface_p = partition_p = false;

directness = MD_NONE;
exported_p = false;

cmi_noted_p = false;
active_init_p = false;

partition_p = partition;

inform_cmi_p = false;
visited_p = false;

extensions = 0;
if (name && TREE_CODE (name)((enum tree_code) (name)->base.code) == STRING_CST)
  {
    header_p = true;

    const char *string = TREE_STRING_POINTER (name)((const char *)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3807, __FUNCTION__, (STRING_CST)))->string.str));
    gcc_checking_assert (string[0] == '.'((void)(!(string[0] == '.' ? (((string[1]) == '/') || (((string
[1]) == '\\') && (0))) : (((((string)[0]) == '/') || (
(((string)[0]) == '\\') && (0))) || ((string)[0] &&
 ((string)[1] == ':') && (0)))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3810, __FUNCTION__), 0 : 0))
	   ? IS_DIR_SEPARATOR (string[1])((void)(!(string[0] == '.' ? (((string[1]) == '/') || (((string
[1]) == '\\') && (0))) : (((((string)[0]) == '/') || (
(((string)[0]) == '\\') && (0))) || ((string)[0] &&
 ((string)[1] == ':') && (0)))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3810, __FUNCTION__), 0 : 0))
	   : IS_ABSOLUTE_PATH (string))((void)(!(string[0] == '.' ? (((string[1]) == '/') || (((string
[1]) == '\\') && (0))) : (((((string)[0]) == '/') || (
(((string)[0]) == '\\') && (0))) || ((string)[0] &&
 ((string)[1] == ':') && (0)))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3810, __FUNCTION__), 0 : 0));
  }

gcc_checking_assert (!(parent && header_p))((void)(!(!(parent && header_p)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3813, __FUNCTION__), 0 : 0));
3814}

3816module_state::~module_state ()
3817{
release ();
3819}

3821/* Hash module state.  */
3822static hashval_t
3823module_name_hash (const_tree name)
3824{
if (TREE_CODE (name)((enum tree_code) (name)->base.code) == STRING_CST)
  return htab_hash_string (TREE_STRING_POINTER (name)((const char *)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3826, __FUNCTION__, (STRING_CST)))->string.str)));
else
  return IDENTIFIER_HASH_VALUE (name)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3828, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
);
3829}

3831hashval_t
3832module_state_hash::hash (const value_type m)
3833{
hashval_t ph = pointer_hash<void>::hash
  (reinterpret_cast<void *> (reinterpret_cast<uintptr_t> (m->parent)
	       | m->is_partition ()));
hashval_t nh = module_name_hash (m->name);
return iterative_hash_hashval_t (ph, nh);
3839}

3841/* Hash a name.  */
3842hashval_t
3843module_state_hash::hash (const compare_type &c)
3844{
hashval_t ph = pointer_hash<void>::hash (reinterpret_cast<void *> (c.second));
hashval_t nh = module_name_hash (c.first);

return iterative_hash_hashval_t (ph, nh);
3849}

3851bool
3852module_state_hash::equal (const value_type existing,
	  const compare_type &candidate)
3854{
uintptr_t ep = (reinterpret_cast<uintptr_t> (existing->parent)
  | existing->is_partition ());
if (ep != candidate.second)
  return false;

/* Identifier comparison is by pointer.  If the string_csts happen
   to be the same object, then they're equal too.  */
if (existing->name == candidate.first)
  return true;

/* If neither are string csts, they can't be equal.  */
if (TREE_CODE (candidate.first)((enum tree_code) (candidate.first)->base.code) != STRING_CST
    || TREE_CODE (existing->name)((enum tree_code) (existing->name)->base.code) != STRING_CST)
  return false;

/* String equality.  */
if (TREE_STRING_LENGTH (existing->name)((tree_check ((existing->name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3871, __FUNCTION__, (STRING_CST)))->string.length)
    == TREE_STRING_LENGTH (candidate.first)((tree_check ((candidate.first), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3872, __FUNCTION__, (STRING_CST)))->string.length)
    && !memcmp (TREE_STRING_POINTER (existing->name)((const char *)((tree_check ((existing->name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3873, __FUNCTION__, (STRING_CST)))->string.str)),
  TREE_STRING_POINTER (candidate.first)((const char *)((tree_check ((candidate.first), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3874, __FUNCTION__, (STRING_CST)))->string.str)),
  TREE_STRING_LENGTH (existing->name)((tree_check ((existing->name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3875, __FUNCTION__, (STRING_CST)))->string.length)))
  return true;

return false;
3879}

3881/********************************************************************/
3882/* Global state */

3884/* Mapper name.  */
3885static const char *module_mapper_name;

3887/* Deferred import queue (FIFO).  */
3888static vec<module_state *, va_heap, vl_embed> *pending_imports;

3890/* CMI repository path and workspace.  */
3891static char *cmi_repo;
3892static size_t cmi_repo_length;
3893static char *cmi_path;
3894static size_t cmi_path_alloc;

3896/* Count of available and loaded clusters.  */
3897static unsigned available_clusters;
3898static unsigned loaded_clusters;

3900/* What the current TU is.  */
3901unsigned module_kind;

3903/* Global trees.  */
3904static const std::pair<tree *, unsigned> global_tree_arys[] =
{
  std::pair<tree *, unsigned> (sizetype_tab, stk_type_kind_last),
  std::pair<tree *, unsigned> (integer_types, itk_none),
  std::pair<tree *, unsigned> (global_trees, TI_MODULE_HWM),
  std::pair<tree *, unsigned> (c_global_trees, CTI_MODULE_HWM),
  std::pair<tree *, unsigned> (cp_global_trees, CPTI_MODULE_HWM),
  std::pair<tree *, unsigned> (NULLnullptr, 0)
};
3913static GTY(()) vec<tree, va_gc> *fixed_trees;
3914static unsigned global_crc;

3916/* Lazy loading can open many files concurrently, there are
 per-process limits on that.  We pay attention to the process limit,
 and attempt to increase it when we run out.  Otherwise we use an
 LRU scheme to figure out who to flush.  Note that if the import
 graph /depth/ exceeds lazy_limit, we'll exceed the limit.  */
3921static unsigned lazy_lru;  /* LRU counter.  */
3922static unsigned lazy_open; /* Number of open modules */
3923static unsigned lazy_limit; /* Current limit of open modules.  */
3924static unsigned lazy_hard_limit; /* Hard limit on open modules.  */
3925/* Account for source, assembler and dump files & directory searches.
 We don't keep the source file's open, so we don't have to account
 for #include depth.  I think dump files are opened and closed per
 pass, but ICBW.  */
3929#define LAZY_HEADROOM15 15 /* File descriptor headroom.  */

3931/* Vector of module state.  Indexed by OWNER.  Has at least 2 slots.  */
3932static GTY(()) vec<module_state *, va_gc> *modules;

3934/* Hash of module state, findable by {name, parent}. */
3935static GTY(()) hash_table<module_state_hash> *modules_hash;

3937/* Map of imported entities.  We map DECL_UID to index of entity
 vector.  */
3939typedef hash_map<unsigned/*UID*/, unsigned/*index*/,
 simple_hashmap_traits<int_hash<unsigned,0>, unsigned>
 > entity_map_t;
3942static entity_map_t *entity_map;
3943/* Doesn't need GTYing, because any tree referenced here is also
 findable by, symbol table, specialization table, return type of
 reachable function.  */
3946static vec<binding_slot, va_heap, vl_embed> *entity_ary;

3948/* Members entities of imported classes that are defined in this TU.
 These are where the entity's context is not from the current TU.
 We need to emit the definition (but not the enclosing class).

 We could find these by walking ALL the imported classes that we
 could provide a member definition.  But that's expensive,
 especially when you consider lazy implicit member declarations,
 which could be ANY imported class.  */
3956static GTY(()) vec<tree, va_gc> *class_members;

3958/* The same problem exists for class template partial
 specializations.  Now that we have constraints, the invariant of
 expecting them in the instantiation table no longer holds.  One of
 the constrained partial specializations will be there, but the
 others not so much.  It's not even an unconstrained partial
 spacialization in the table :(  so any partial template declaration
 is added to this list too.  */
3965static GTY(()) vec<tree, va_gc> *partial_specializations;

3967/********************************************************************/

3969/* Our module mapper (created lazily).  */
3970module_client *mapper;

3972static module_client *make_mapper (location_t loc);
3973inline module_client *get_mapper (location_t loc)
3974{
auto *res = mapper;
if (!res)
  res = make_mapper (loc);
return res;
3979}

3981/********************************************************************/
3982static tree
3983get_clone_target (tree decl)
3984{
tree target;

if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TEMPLATE_DECL)
  {
    tree res_orig = DECL_CLONED_FUNCTION (DECL_TEMPLATE_RESULT (decl))(((contains_struct_check (((tree_check ((((struct tree_template_decl
 *)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3989, __FUNCTION__, (TEMPLATE_DECL))))))))->result), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3989, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3989, __FUNCTION__))->decl_common.lang_specific)->u.fn
.u5.cloned_function);
    
    target = DECL_TI_TEMPLATE (res_orig)((struct tree_template_info*)(tree_check (((((contains_struct_check
 ((template_info_decl_check ((res_orig), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3991, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3991, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3991, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
  }
else
  target = DECL_CLONED_FUNCTION (decl)(((contains_struct_check (((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3994, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3994, __FUNCTION__))->decl_common.lang_specific)->u.fn
.u5.cloned_function);

gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (target))((void)(!(((((contains_struct_check ((target), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3996, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((target)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3996, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER]))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 3996, __FUNCTION__), 0 : 0));

return target;
3999}

4001/* Like FOR_EACH_CLONE, but will walk cloned templates.  */
4002#define FOR_EVERY_CLONE(CLONE, FN)if (!((((contains_struct_check ((FN), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((FN), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER]))); else for (CLONE = (((contains_struct_check
 (((contains_struct_check ((FN), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->common.chain)); CLONE && (
((contains_struct_check ((CLONE), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name) && ((!(
(tree_not_check2 (((tree_check ((((contains_struct_check ((CLONE
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
 ((CLONE), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) && !((((contains_struct_check ((CLONE)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((CLONE),
 (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER]))); CLONE = (((contains_struct_check (
((contains_struct_check ((CLONE), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4002, __FUNCTION__))->common.chain)))			\
if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)((((contains_struct_check ((FN), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4003, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((FN), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4003, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER])));		\
else							\
  for (CLONE = DECL_CHAIN (FN)(((contains_struct_check (((contains_struct_check ((FN), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4005, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4005, __FUNCTION__))->common.chain));			\
CLONE && DECL_CLONED_FUNCTION_P (CLONE)(((contains_struct_check ((CLONE), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__))->decl_minimal.name) && ((!(
(tree_not_check2 (((tree_check ((((contains_struct_check ((CLONE
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
 ((CLONE), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) && !((((contains_struct_check ((CLONE)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((CLONE),
 (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4006, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER])));	\
CLONE = DECL_CHAIN (CLONE)(((contains_struct_check (((contains_struct_check ((CLONE), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4007, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4007, __FUNCTION__))->common.chain)))

4009/* It'd be nice if USE_TEMPLATE was a field of template_info
 (a) it'd solve the enum case dealt with below,
 (b) both class templates and decl templates would store this in the
 same place
 (c) this function wouldn't need the by-ref arg, which is annoying.  */

4015static tree
4016node_template_info (tree decl, int &use)
4017{
tree ti = NULL_TREE(tree) nullptr;
int use_tpl = -1;
if (DECL_IMPLICIT_TYPEDEF_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL &&
 ((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4020, __FUNCTION__))->decl_common.lang_flag_2)))
  {
    tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4022, __FUNCTION__))->typed.type);

    ti = TYPE_TEMPLATE_INFO (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
 || (((enum tree_code) (type)->base.code) == RECORD_TYPE ||
 ((enum tree_code) (type)->base.code) == UNION_TYPE || ((enum
 tree_code) (type)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
 ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4024, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
);
    if (ti)
{
 if (TYPE_LANG_SPECIFIC (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4027, __FUNCTION__))->type_with_lang_specific.lang_specific
))
   use_tpl = CLASSTYPE_USE_TEMPLATE (type)((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4028, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template);
 else
   {
     /* An enum, where we don't explicitly encode use_tpl.
 If the containing context (a type or a function), is
 an ({im,ex}plicit) instantiation, then this is too.
 If it's a partial or explicit specialization, then
 this is not!.  */
     tree ctx = CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4036, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4036, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4036, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]);
     if (TYPE_P (ctx)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (ctx)->base.code))] == tcc_type))
ctx = TYPE_NAME (ctx)((tree_class_check ((ctx), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4038, __FUNCTION__))->type_common.name);
     node_template_info (ctx, use);
     use_tpl = use != 2 ? use : 0;
   }
}
  }
else if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4044, __FUNCTION__))->decl_common.lang_specific)
  && (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == VAR_DECL
      || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL
      || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL
      || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FIELD_DECL
      || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == CONCEPT_DECL
      || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TEMPLATE_DECL))
  {
    use_tpl = DECL_USE_TEMPLATE (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4052, __FUNCTION__))->decl_common.lang_specific)->u.base
.use_template);
    ti = DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4053, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4053, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info);
  }

use = use_tpl;
return ti;
4058}

4060/* Find the index in entity_ary for an imported DECL.  It should
 always be there, but bugs can cause it to be missing, and that can
 crash the crash reporting -- let's not do that!  When streaming
 out we place entities from this module there too -- with negated
 indices.  */

4066static unsigned
4067import_entity_index (tree decl, bool null_ok = false)
4068{
if (unsigned *slot = entity_map->get (DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4069, __FUNCTION__))->decl_minimal.uid)))
  return *slot;

gcc_checking_assert (null_ok)((void)(!(null_ok) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4072, __FUNCTION__), 0 : 0));
return ~(~0u >> 1);
4074}

4076/* Find the module for an imported entity at INDEX in the entity ary.
 There must be one.  */

4079static module_state *
4080import_entity_module (unsigned index)
4081{
if (index > ~(~0u >> 1))
  /* This is an index for an exported entity.  */
  return (*modules)[0];

/* Do not include the current TU (not an off-by-one error).  */
unsigned pos = 1;
unsigned len = modules->length () - pos;
while (len)
  {
    unsigned half = len / 2;
    module_state *probe = (*modules)[pos + half];
    if (index < probe->entity_lwm)
len = half;
    else if (index < probe->entity_lwm + probe->entity_num)
return probe;
    else
{
 pos += half + 1;
 len = len - (half + 1);
}
  }
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4103, __FUNCTION__));
4104}


4107/********************************************************************/
4108/* A dumping machinery.  */

4110class dumper {
4111public:
enum {
  LOCATION = TDF_LINENO,  /* -lineno:Source location streaming.  */
  DEPEND = TDF_GRAPH,	/* -graph:Dependency graph construction.  */
  CLUSTER = TDF_BLOCKS,   /* -blocks:Clusters.  */
  TREE = TDF_UID, 	/* -uid:Tree streaming.  */
  MERGE = TDF_ALIAS,	/* -alias:Mergeable Entities.  */
  ELF = TDF_ASMNAME,	/* -asmname:Elf data.  */
  MACRO = TDF_VOPS	/* -vops:Macros.  */
};

4122private:
struct impl {
  typedef vec<module_state *, va_heap, vl_embed> stack_t;

  FILE *stream;	/* Dump stream.  */
  unsigned indent; 	/* Local indentation.  */
  bool bol; 		/* Beginning of line.  */
  stack_t stack;	/* Trailing array of module_state.  */

  bool nested_name (tree);  /* Dump a name following DECL_CONTEXT.  */
};

4134public:
/* The dumper.  */
impl *dumps;
dump_flags_t flags;

4139public:
/* Push/pop module state dumping.  */
unsigned push (module_state *);
void pop (unsigned);

4144public:
/* Change local indentation.  */
void indent ()
{
  if (dumps)
    dumps->indent++;
}
void outdent ()
{
  if (dumps)
    {
gcc_checking_assert (dumps->indent)((void)(!(dumps->indent) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4155, __FUNCTION__), 0 : 0));
dumps->indent--;
    }
}

4160public:
/* Is dump enabled?.  */
bool operator () (int mask = 0)
{
  if (!dumps || !dumps->stream)
    return false;
  if (mask && !(mask & flags))
    return false;
  return true;
}
/* Dump some information.  */
bool operator () (const char *, ...);
4172};

4174/* The dumper.  */
4175static dumper dump = {0, dump_flags_t (0)};

4177/* Push to dumping M.  Return previous indentation level.  */

4179unsigned
4180dumper::push (module_state *m)
4181{
FILE *stream = NULLnullptr;
if (!dumps || !dumps->stack.length ())
  {
    stream = dump_begin (module_dump_id, &flags);
    if (!stream)
return 0;
  }

if (!dumps || !dumps->stack.space (1))
  {
    /* Create or extend the dump implementor.  */
    unsigned current = dumps ? dumps->stack.length () : 0;
    unsigned count = current ? current * 2 : EXPERIMENT (1, 20)((((2301211953U)) >= (1U << 20)) ? (1) : (20));
    size_t alloc = (offsetof (impl, stack)__builtin_offsetof(impl, stack)
      + impl::stack_t::embedded_size (count));
    dumps = XRESIZEVAR (impl, dumps, alloc)((impl *) xrealloc ((dumps), (alloc)));
    dumps->stack.embedded_init (count, current);
  }
if (stream)
  dumps->stream = stream;

unsigned n = dumps->indent;
dumps->indent = 0;
dumps->bol = true;
dumps->stack.quick_push (m);
if (m)
  {
    module_state *from = NULLnullptr;

    if (dumps->stack.length () > 1)
from = dumps->stack[dumps->stack.length () - 2];
    else
dump ("");
    dump (from ? "Starting module %M (from %M)"
   : "Starting module %M", m, from);
  }

return n;
4220}

4222/* Pop from dumping.  Restore indentation to N.  */

4224void dumper::pop (unsigned n)
4225{
if (!dumps)
  return;

gcc_checking_assert (dump () && !dumps->indent)((void)(!(dump () && !dumps->indent) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4229, __FUNCTION__), 0 : 0));
if (module_state *m = dumps->stack[dumps->stack.length () - 1])
  {
    module_state *from = (dumps->stack.length () > 1
	    ? dumps->stack[dumps->stack.length () - 2] : NULLnullptr);
    dump (from ? "Finishing module %M (returning to %M)"
   : "Finishing module %M", m, from);
  }
dumps->stack.pop ();
dumps->indent = n;
if (!dumps->stack.length ())
  {
    dump_end (module_dump_id, dumps->stream);
    dumps->stream = NULLnullptr;
  }
4244}

4246/* Dump a nested name for arbitrary tree T.  Sometimes it won't have a
 name.  */

4249bool
4250dumper::impl::nested_name (tree t)
4251{
tree ti = NULL_TREE(tree) nullptr;
int origin = -1;
tree name = NULL_TREE(tree) nullptr;

if (t && TREE_CODE (t)((enum tree_code) (t)->base.code) == TREE_BINFO)
  t = BINFO_TYPE (t)((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4257, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4257, __FUNCTION__))->typed.type);

if (t && TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type))
  t = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4260, __FUNCTION__))->type_common.name);

if (t && DECL_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_declaration))
  {
    if (t == global_namespacecp_global_trees[CPTI_GLOBAL] || DECL_TEMPLATE_PARM_P (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4264, __FUNCTION__))->decl_common.lang_flag_0) &&
 (((enum tree_code) (t)->base.code) == CONST_DECL || ((enum
 tree_code) (t)->base.code) == PARM_DECL || ((enum tree_code
) (t)->base.code) == TYPE_DECL || ((enum tree_code) (t)->
base.code) == TEMPLATE_DECL)))
;
    else if (tree ctx = DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4266, __FUNCTION__))->decl_minimal.context))
if (TREE_CODE (ctx)((enum tree_code) (ctx)->base.code) == TRANSLATION_UNIT_DECL
   || nested_name (ctx))
 fputs ("::", stream);

    int use_tpl;
    ti = node_template_info (t, use_tpl);
    if (ti && TREE_CODE (TI_TEMPLATE (ti))((enum tree_code) (((struct tree_template_info*)(tree_check (
(ti), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4273, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)->base.code
) == TEMPLATE_DECL
 && (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti))((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((((struct tree_template_info*)(tree_check
 ((ti), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4274, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4274, __FUNCTION__, (TEMPLATE_DECL))))))))->result == t))
t = TI_TEMPLATE (ti)((struct tree_template_info*)(tree_check ((ti), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4275, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
    tree not_tmpl = t;
    if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TEMPLATE_DECL)
{
 fputs ("template ", stream);
 not_tmpl = DECL_TEMPLATE_RESULT (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4280, __FUNCTION__, (TEMPLATE_DECL))))))))->result;
}

    if (not_tmpl
 && DECL_P (not_tmpl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (not_tmpl)->base.code))] == tcc_declaration)
 && DECL_LANG_SPECIFIC (not_tmpl)((contains_struct_check ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4285, __FUNCTION__))->decl_common.lang_specific)
 && DECL_MODULE_IMPORT_P (not_tmpl)(((contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4286, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4286, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p))
{
 /* We need to be careful here, so as to not explode on
    inconsistent data -- we're probably debugging, because
    Something Is Wrong.  */
 unsigned index = import_entity_index (t, true);
 if (!(index & ~(~0u >> 1)))
   origin = import_entity_module (index)->mod;
 else if (index > ~(~0u >> 1))
   /* An imported partition member that we're emitting.  */
   origin = 0;
 else
   origin = -2;
}

    name = DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4301, __FUNCTION__))->decl_minimal.name) ? DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4301, __FUNCTION__))->decl_minimal.name)
: HAS_DECL_ASSEMBLER_NAME_P (t)((tree_contains_struct[(((enum tree_code) (t)->base.code))
][(TS_DECL_WITH_VIS)])) ? DECL_ASSEMBLER_NAME_RAW (t)((contains_struct_check ((t), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4302, __FUNCTION__))->decl_with_vis.assembler_name)
: NULL_TREE(tree) nullptr;
  }
else
  name = t;

if (name)
  switch (TREE_CODE (name)((enum tree_code) (name)->base.code))
    {
    default:
fputs ("#unnamed#", stream);
break;

    case IDENTIFIER_NODE:
fwrite (IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4316, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), 1, IDENTIFIER_LENGTH (name)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4316, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
), stream);
break;

    case INTEGER_CST:
print_hex (wi::to_wide (name), stream);
break;

    case STRING_CST:
/* If TREE_TYPE is NULL, this is a raw string.  */
fwrite (TREE_STRING_POINTER (name)((const char *)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4325, __FUNCTION__, (STRING_CST)))->string.str)), 1,
TREE_STRING_LENGTH (name)((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4326, __FUNCTION__, (STRING_CST)))->string.length) - (TREE_TYPE (name)((contains_struct_check ((name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4326, __FUNCTION__))->typed.type) != NULL_TREE(tree) nullptr),
stream);
break;
    }
else
  fputs ("#null#", stream);

if (origin >= 0)
  {
    const module_state *module = (*modules)[origin];
    fprintf (stream, "@%s:%d", !module ? "" : !module->name ? "(unnamed)"
      : module->get_flatname (), origin);
  }
else if (origin == -2)
  fprintf (stream, "@???");

if (ti)
  {
    tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (ti))(get_innermost_template_args ((((struct tree_template_info*)(
tree_check ((ti), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4344, __FUNCTION__, (TEMPLATE_INFO))))->args), 1));
    fputs ("<", stream);
    if (args)
for (int ix = 0; ix != TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4347, __FUNCTION__, (TREE_VEC)))->base.u.length); ix++)
 {
   if (ix)
     fputs (",", stream);
   nested_name (TREE_VEC_ELT (args, ix)(*((const_cast<tree *> (tree_vec_elt_check ((args), (ix
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4351, __FUNCTION__))))));
 }
    fputs (">", stream);
  }

return true;
4357}

4359/* Formatted dumping.  FORMAT begins with '+' do not emit a trailing
 new line.  (Normally it is appended.)
 Escapes:
    %C - tree_code
    %I - identifier
    %M - module_state
    %N - name -- DECL_NAME
    %P - context:name pair
    %R - unsigned:unsigned ratio
    %S - symbol -- DECL_ASSEMBLER_NAME
    %U - long unsigned
    %V - version
    --- the following are printf-like, but without its flexibility
    %d - decimal int
    %p - pointer
    %s - string
    %u - unsigned int
    %x - hex int

We do not implement the printf modifiers.  */

4380bool
4381dumper::operator () (const char *format, ...)
4382{
if (!(*this) ())
  return false;

bool no_nl = format[0] == '+';
format += no_nl;

if (dumps->bol)
  {
    /* Module import indent.  */
    if (unsigned depth = dumps->stack.length () - 1)
{
 const char *prefix = ">>>>";
 fprintf (dumps->stream, (depth <= strlen (prefix)
		   ? &prefix[strlen (prefix) - depth]
		   : ">.%d.>"), depth);
}

    /* Local indent.  */
    if (unsigned indent = dumps->indent)
{
 const char *prefix = "      ";
 fprintf (dumps->stream, (indent <= strlen (prefix)
		   ? &prefix[strlen (prefix) - indent]
		   : "  .%d.  "), indent);
}
    dumps->bol = false;
  }

va_list args;
va_start (args, format)__builtin_va_start(args, format);
while (const char *esc = strchr (format, '%'))
  {
    fwrite (format, 1, (size_t)(esc - format), dumps->stream);
    format = ++esc;
    switch (*format++)
{
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4420, __FUNCTION__));

case '%':
 fputc ('%', dumps->stream);
 break;

case 'C': /* Code */
 {
   tree_code code = (tree_code)va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   fputs (get_tree_code_name (code), dumps->stream);
 }
 break;

case 'I': /* Identifier.  */
 {
   tree t = va_arg (args, tree)__builtin_va_arg(args, tree);
   dumps->nested_name (t);
 }
 break;

case 'M': /* Module. */
 {
   const char *str = "(none)";
   if (module_state *m = va_arg (args, module_state *)__builtin_va_arg(args, module_state *))
     {
if (!m->has_location ())
  str = "(detached)";
else
  str = m->get_flatname ();
     }
   fputs (str, dumps->stream);
 }
 break;

case 'N': /* Name.  */
 {
   tree t = va_arg (args, tree)__builtin_va_arg(args, tree);
   while (t && TREE_CODE (t)((enum tree_code) (t)->base.code) == OVERLOAD)
     t = OVL_FUNCTION (t)(((struct tree_overload*)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4458, __FUNCTION__, (OVERLOAD))))->function);
   fputc ('\'', dumps->stream);
   dumps->nested_name (t);
   fputc ('\'', dumps->stream);
 }
 break;

case 'P': /* Pair.  */
 {
   tree ctx = va_arg (args, tree)__builtin_va_arg(args, tree);
   tree name = va_arg (args, tree)__builtin_va_arg(args, tree);
   fputc ('\'', dumps->stream);
   dumps->nested_name (ctx);
   if (ctx && ctx != global_namespacecp_global_trees[CPTI_GLOBAL])
     fputs ("::", dumps->stream);
   dumps->nested_name (name);
   fputc ('\'', dumps->stream);
 }
 break;

case 'R': /* Ratio */
 {
   unsigned a = va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   unsigned b = va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   fprintf (dumps->stream, "%.1f", (float) a / (b + !b));
 }
 break;

case 'S': /* Symbol name */
 {
   tree t = va_arg (args, tree)__builtin_va_arg(args, tree);
   if (t && TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type))
     t = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4490, __FUNCTION__))->type_common.name);
   if (t && HAS_DECL_ASSEMBLER_NAME_P (t)((tree_contains_struct[(((enum tree_code) (t)->base.code))
][(TS_DECL_WITH_VIS)]))
&& DECL_ASSEMBLER_NAME_SET_P (t)(((contains_struct_check ((t), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4492, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr))
     {
fputc ('(', dumps->stream);
fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t))((const char *) (tree_check ((decl_assembler_name (t)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4495, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
),
       dumps->stream);
fputc (')', dumps->stream);
     }
 }
 break;

case 'U': /* long unsigned.  */
 {
   unsigned long u = va_arg (args, unsigned long)__builtin_va_arg(args, unsigned long);
   fprintf (dumps->stream, "%lu", u);
 }
 break;

case 'V': /* Verson.  */
 {
   unsigned v = va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   verstr_t string;

   version2string (v, string);
   fputs (string, dumps->stream);
 }
 break;

case 'c': /* Character.  */
 {
   int c = va_arg (args, int)__builtin_va_arg(args, int);
   fputc (c, dumps->stream);
 }
 break;

case 'd': /* Decimal Int.  */
 {
   int d = va_arg (args, int)__builtin_va_arg(args, int);
   fprintf (dumps->stream, "%d", d);
 }
 break;

case 'p': /* Pointer. */
 {
   void *p = va_arg (args, void *)__builtin_va_arg(args, void *);
   fprintf (dumps->stream, "%p", p);
 }
 break;

case 's': /* String. */
 {
   const char *s = va_arg (args, char *)__builtin_va_arg(args, char *);
   gcc_checking_assert (s)((void)(!(s) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4543, __FUNCTION__), 0 : 0));
   fputs (s, dumps->stream);
 }
 break;

case 'u': /* Unsigned.  */
 {
   unsigned u = va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   fprintf (dumps->stream, "%u", u);
 }
 break;

case 'x': /* Hex. */
 {
   unsigned x = va_arg (args, unsigned)__builtin_va_arg(args, unsigned);
   fprintf (dumps->stream, "%x", x);
 }
 break;
}
  }
fputs (format, dumps->stream);
va_end (args)__builtin_va_end(args);
if (!no_nl)
  {
    dumps->bol = true;
    fputc ('\n', dumps->stream);
  }
return true;
4571}

4573struct note_def_cache_hasher : ggc_cache_ptr_hash<tree_node>
4574{
static int keep_cache_entry (tree t)
{
  if (!CHECKING_P1)
    /* GTY is unfortunately not clever enough to conditionalize
this.  */
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4580, __FUNCTION__));

  if (ggc_marked_p (t))
    return -1;

  unsigned n = dump.push (NULLnullptr);
  /* This might or might not be an error.  We should note its
     dropping whichever.  */
  dump () && dump ("Dropping %N from note_defs table", t);
  dump.pop (n);

  return 0;
}
4593};

4595/* We should stream each definition at most once.
 This needs to be a cache because there are cases where a definition
 ends up being not retained, and we need to drop those so we don't
 get confused if memory is reallocated.  */
4599typedef hash_table<note_def_cache_hasher> note_defs_table_t;
4600static GTY((cache)) note_defs_table_t *note_defs;

4602void
4603trees_in::assert_definition (tree decl ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	     bool installing ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4605{
4606#if CHECKING_P1
tree *slot = note_defs->find_slot (decl, installing ? INSERT : NO_INSERT);
tree not_tmpl = STRIP_TEMPLATE (decl)(((enum tree_code) (decl)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4608, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
);
if (installing)
  {
    /* We must be inserting for the first time.  */
    gcc_assert (!*slot)((void)(!(!*slot) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4612, __FUNCTION__), 0 : 0));
    *slot = decl;
  }
else
  /* If this is not the mergeable entity, it should not be in the
     table.  If it is a non-global-module mergeable entity, it
     should be in the table.  Global module entities could have been
     defined textually in the current TU and so might or might not
     be present.  */
  gcc_assert (!is_duplicate (decl)((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
? !slot((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
: (slot((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
   || !DECL_LANG_SPECIFIC (not_tmpl)((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
   || !DECL_MODULE_PURVIEW_P (not_tmpl)((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
   || (!DECL_MODULE_IMPORT_P (not_tmpl)((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0))
       && header_module_p ())))((void)(!(!is_duplicate (decl) ? !slot : (slot || !((contains_struct_check
 ((not_tmpl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4624, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check (((tree_not_check ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4625, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_purview_p) || (!(((contains_struct_check (((tree_not_check
 ((not_tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__, (TEMPLATE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4626, __FUNCTION__))->decl_common.lang_specific)->u.base
.module_import_p) && header_module_p ()))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4627, __FUNCTION__), 0 : 0));

if (not_tmpl != decl)
  gcc_assert (!note_defs->find_slot (not_tmpl, NO_INSERT))((void)(!(!note_defs->find_slot (not_tmpl, NO_INSERT)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4630, __FUNCTION__), 0 : 0));
4631#endif
4632}

4634void
4635trees_out::assert_definition (tree decl ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4636{
4637#if CHECKING_P1
tree *slot = note_defs->find_slot (decl, INSERT);
gcc_assert (!*slot)((void)(!(!*slot) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4639, __FUNCTION__), 0 : 0));
*slot = decl;
if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TEMPLATE_DECL)
  gcc_assert (!note_defs->find_slot (DECL_TEMPLATE_RESULT (decl), NO_INSERT))((void)(!(!note_defs->find_slot (((struct tree_template_decl
 *)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4642, __FUNCTION__, (TEMPLATE_DECL))))))))->result, NO_INSERT
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4642, __FUNCTION__), 0 : 0));
4643#endif
4644}

4646/********************************************************************/
4647static bool
4648noisy_p ()
4649{
if (quiet_flagglobal_options.x_quiet_flag)
  return false;

pp_needs_newline (global_dc->printer)(global_dc->printer)->need_newline = true;
diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL)(global_dc)->x_data = ((((diagnostic_info *) nullptr) &&
 ((tree) ((diagnostic_info *) nullptr)->x_data)) ? ((tree)
 ((diagnostic_info *) nullptr)->x_data) : current_function_decl
);

return true;
4657}

4659/* Set the cmi repo.  Strip trailing '/', '.' becomes NULL.  */

4661static void
4662set_cmi_repo (const char *r)
4663{
XDELETEVEC (cmi_repo)free ((void*) (cmi_repo));
XDELETEVEC (cmi_path)free ((void*) (cmi_path));
cmi_path_alloc = 0;

cmi_repo = NULLnullptr;
cmi_repo_length = 0;

if (!r || !r[0])
  return;

size_t len = strlen (r);
cmi_repo = XNEWVEC (char, len + 1)((char *) xmalloc (sizeof (char) * (len + 1)));
memcpy (cmi_repo, r, len + 1);

if (len > 1 && IS_DIR_SEPARATOR (cmi_repo[len-1])(((cmi_repo[len-1]) == '/') || (((cmi_repo[len-1]) == '\\') &&
 (0))))
  len--;
if (len == 1 && cmi_repo[0] == '.')
  len--;
cmi_repo[len] = 0;
cmi_repo_length = len;
4684}

4686/* TO is a repo-relative name.  Provide one that we may use from where
 we are.  */

4689static const char *
4690maybe_add_cmi_prefix (const char *to, size_t *len_p = NULLnullptr)
4691{
size_t len = len_p || cmi_repo_length ? strlen (to) : 0;

if (cmi_repo_length && !IS_ABSOLUTE_PATH (to)(((((to)[0]) == '/') || ((((to)[0]) == '\\') && (0)))
 || ((to)[0] && ((to)[1] == ':') && (0))))
  {
    if (cmi_path_alloc < cmi_repo_length + len + 2)
{
 XDELETEVEC (cmi_path)free ((void*) (cmi_path));
 cmi_path_alloc = cmi_repo_length + len * 2 + 2;
 cmi_path = XNEWVEC (char, cmi_path_alloc)((char *) xmalloc (sizeof (char) * (cmi_path_alloc)));

 memcpy (cmi_path, cmi_repo, cmi_repo_length);
 cmi_path[cmi_repo_length] = DIR_SEPARATOR'/';
}

    memcpy (&cmi_path[cmi_repo_length + 1], to, len + 1);
    len += cmi_repo_length + 1;
    to = cmi_path;
  }

if (len_p)
  *len_p = len;

return to;
4715}

4717/* Try and create the directories of PATH.  */

4719static void
4720create_dirs (char *path)
4721{
/* Try and create the missing directories.  */
for (char *base = path; *base; base++)
  if (IS_DIR_SEPARATOR (*base)(((*base) == '/') || (((*base) == '\\') && (0))))
    {
char sep = *base;
*base = 0;
int failed = mkdir (path, S_IRWXU(0400|0200|0100) | S_IRWXG((0400|0200|0100) >> 3) | S_IRWXO(((0400|0200|0100) >> 3) >> 3));
dump () && dump ("Mkdir ('%s') errno:=%u", path, failed ? errno(*__errno_location ()) : 0);
*base = sep;
if (failed
   /* Maybe racing with another creator (of a *different*
      module).  */
   && errno(*__errno_location ()) != EEXIST17)
 break;
    }
4737}

4739/* Given a CLASSTYPE_DECL_LIST VALUE get the template friend decl,
 if that's what this is.  */

4742static tree
4743friend_from_decl_list (tree frnd)
4744{
tree res = frnd;

if (TREE_CODE (frnd)((enum tree_code) (frnd)->base.code) != TEMPLATE_DECL)
  {
    tree tmpl = NULL_TREE(tree) nullptr;
    if (TYPE_P (frnd)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (frnd)->base.code))] == tcc_type))
{
 res = TYPE_NAME (frnd)((tree_class_check ((frnd), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4752, __FUNCTION__))->type_common.name);
 if (CLASS_TYPE_P (frnd)(((((enum tree_code) (frnd)->base.code)) == RECORD_TYPE ||
 (((enum tree_code) (frnd)->base.code)) == UNION_TYPE) &&
 ((tree_class_check ((frnd), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4753, __FUNCTION__))->type_common.lang_flag_5))
     && CLASSTYPE_TEMPLATE_INFO (frnd)(((tree_class_check (((tree_check3 ((frnd), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4754, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4754, __FUNCTION__))->type_non_common.lang_1)))
   tmpl = CLASSTYPE_TI_TEMPLATE (frnd)((struct tree_template_info*)(tree_check (((((tree_class_check
 (((tree_check3 ((frnd), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4755, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4755, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4755, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
}
    else if (DECL_TEMPLATE_INFO (frnd)(((contains_struct_check ((template_info_decl_check ((frnd), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4757, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4757, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info))
{
 tmpl = DECL_TI_TEMPLATE (frnd)((struct tree_template_info*)(tree_check (((((contains_struct_check
 ((template_info_decl_check ((frnd), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4759, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4759, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4759, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
 if (TREE_CODE (tmpl)((enum tree_code) (tmpl)->base.code) != TEMPLATE_DECL)
   tmpl = NULL_TREE(tree) nullptr;
}

    if (tmpl && DECL_TEMPLATE_RESULT (tmpl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4764, __FUNCTION__, (TEMPLATE_DECL))))))))->result == res)
res = tmpl;
  }

return res;
4769}

4771static tree
4772find_enum_member (tree ctx, tree name)
4773{
for (tree values = TYPE_VALUES (ctx)((tree_check ((ctx), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4774, __FUNCTION__, (ENUMERAL_TYPE)))->type_non_common.values
);
     values; values = TREE_CHAIN (values)((contains_struct_check ((values), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4775, __FUNCTION__))->common.chain))
  if (DECL_NAME (TREE_VALUE (values))((contains_struct_check ((((tree_check ((values), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4776, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4776, __FUNCTION__))->decl_minimal.name) == name)
    return TREE_VALUE (values)((tree_check ((values), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4777, __FUNCTION__, (TREE_LIST)))->list.value);

return NULL_TREE(tree) nullptr;
4780}

4782/********************************************************************/
4783/* Instrumentation gathered writing bytes.  */

4785void
4786bytes_out::instrument ()
4787{
dump ("Wrote %u bytes in %u blocks", lengths[3], spans[3]);
dump ("Wrote %u bits in %u bytes", lengths[0] + lengths[1], lengths[2]);
for (unsigned ix = 0; ix < 2; ix++)
  dump ("  %u %s spans of %R bits", spans[ix],
 ix ? "one" : "zero", lengths[ix], spans[ix]);
dump ("  %u blocks with %R bits padding", spans[2],
lengths[2] * 8 - (lengths[0] + lengths[1]), spans[2]);
4795}

4797/* Instrumentation gathered writing trees.  */
4798void
4799trees_out::instrument ()
4800{
if (dump (""))
  {
    bytes_out::instrument ();
    dump ("Wrote:");
    dump ("  %u decl trees", decl_val_count);
    dump ("  %u other trees", tree_val_count);
    dump ("  %u back references", back_ref_count);
    dump ("  %u null trees", null_count);
  }
4810}

4812/* Setup and teardown for a tree walk.  */

4814void
4815trees_out::begin ()
4816{
gcc_assert (!streaming_p () || !tree_map.elements ())((void)(!(!streaming_p () || !tree_map.elements ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4817, __FUNCTION__), 0 : 0));

mark_trees ();
if (streaming_p ())
  parent::begin ();
4822}

4824unsigned
4825trees_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
4826{
gcc_checking_assert (streaming_p ())((void)(!(streaming_p ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4827, __FUNCTION__), 0 : 0));

unmark_trees ();
return parent::end (sink, name, crc_ptr);
4831}

4833void
4834trees_out::end ()
4835{
gcc_assert (!streaming_p ())((void)(!(!streaming_p ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4836, __FUNCTION__), 0 : 0));

unmark_trees ();
/* Do not parent::end -- we weren't streaming.  */
4840}

4842void
4843trees_out::mark_trees ()
4844{
if (size_t size = tree_map.elements ())
  {
    /* This isn't our first rodeo, destroy and recreate the
tree_map.  I'm a bad bad man.  Use the previous size as a
guess for the next one (so not all bad).  */
    tree_map.~ptr_int_hash_map ();
    new (&tree_map) ptr_int_hash_map (size);
  }

/* Install the fixed trees, with +ve references.  */
unsigned limit = fixed_trees->length ();
for (unsigned ix = 0; ix != limit; ix++)
  {
    tree val = (*fixed_trees)[ix];
    bool existed = tree_map.put (val, ix + tag_fixed);
    gcc_checking_assert (!TREE_VISITED (val) && !existed)((void)(!(!((val)->base.visited) && !existed) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4860, __FUNCTION__), 0 : 0));
    TREE_VISITED (val)((val)->base.visited) = true;
  }

ref_num = 0;
4865}

4867/* Unmark the trees we encountered  */

4869void
4870trees_out::unmark_trees ()
4871{
ptr_int_hash_map::iterator end (tree_map.end ());
for (ptr_int_hash_map::iterator iter (tree_map.begin ()); iter != end; ++iter)
  {
    tree node = reinterpret_cast<tree> ((*iter).first);
    int ref = (*iter).second;
    /* We should have visited the node, and converted its mergeable
reference to a regular reference.  */
    gcc_checking_assert (TREE_VISITED (node)((void)(!(((node)->base.visited) && (ref <= tag_backref
 || ref >= tag_fixed)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4880, __FUNCTION__), 0 : 0))
	   && (ref <= tag_backref || ref >= tag_fixed))((void)(!(((node)->base.visited) && (ref <= tag_backref
 || ref >= tag_fixed)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4880, __FUNCTION__), 0 : 0));
    TREE_VISITED (node)((node)->base.visited) = false;
  }
4883}

4885/* Mark DECL for by-value walking.  We do this by inserting it into
 the tree map with a reference of zero.  May be called multiple
 times on the same node.  */

4889void
4890trees_out::mark_by_value (tree decl)
4891{
gcc_checking_assert (DECL_P (decl)((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (decl)->base.code))] == tcc_declaration
) || ((enum tree_code) (decl)->base.code) == INTEGER_CST ||
 ((enum tree_code) (decl)->base.code) == TREE_BINFO) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4895, __FUNCTION__), 0 : 0))
       /* Enum consts are INTEGER_CSTS.  */((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (decl)->base.code))] == tcc_declaration
) || ((enum tree_code) (decl)->base.code) == INTEGER_CST ||
 ((enum tree_code) (decl)->base.code) == TREE_BINFO) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4895, __FUNCTION__), 0 : 0))
       || TREE_CODE (decl) == INTEGER_CST((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (decl)->base.code))] == tcc_declaration
) || ((enum tree_code) (decl)->base.code) == INTEGER_CST ||
 ((enum tree_code) (decl)->base.code) == TREE_BINFO) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4895, __FUNCTION__), 0 : 0))
       || TREE_CODE (decl) == TREE_BINFO)((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (decl)->base.code))] == tcc_declaration
) || ((enum tree_code) (decl)->base.code) == INTEGER_CST ||
 ((enum tree_code) (decl)->base.code) == TREE_BINFO) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4895, __FUNCTION__), 0 : 0));

if (TREE_VISITED (decl)((decl)->base.visited))
  /* Must already be forced or fixed.  */
  gcc_checking_assert (*tree_map.get (decl) >= tag_value)((void)(!(*tree_map.get (decl) >= tag_value) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4899, __FUNCTION__), 0 : 0));
else
  {
    bool existed = tree_map.put (decl, tag_value);
    gcc_checking_assert (!existed)((void)(!(!existed) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4903, __FUNCTION__), 0 : 0));
    TREE_VISITED (decl)((decl)->base.visited) = true;
  }
4906}

4908int
4909trees_out::get_tag (tree t)
4910{
gcc_checking_assert (TREE_VISITED (t))((void)(!(((t)->base.visited)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4911, __FUNCTION__), 0 : 0));
return *tree_map.get (t);
4913}

4915/* Insert T into the map, return its tag number.    */

4917int
4918trees_out::insert (tree t, walk_kind walk)
4919{
gcc_checking_assert (walk != WK_normal || !TREE_VISITED (t))((void)(!(walk != WK_normal || !((t)->base.visited)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4920, __FUNCTION__), 0 : 0));
int tag = --ref_num;
bool existed;
int &slot = tree_map.get_or_insert (t, &existed);
gcc_checking_assert (TREE_VISITED (t) == existed((void)(!(((t)->base.visited) == existed && (!existed
 || (walk == WK_value && slot == tag_value))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4926, __FUNCTION__), 0 : 0))
       && (!existed((void)(!(((t)->base.visited) == existed && (!existed
 || (walk == WK_value && slot == tag_value))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4926, __FUNCTION__), 0 : 0))
	   || (walk == WK_value && slot == tag_value)))((void)(!(((t)->base.visited) == existed && (!existed
 || (walk == WK_value && slot == tag_value))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4926, __FUNCTION__), 0 : 0));
TREE_VISITED (t)((t)->base.visited) = true;
slot = tag;

return tag;
4931}

4933/* Insert T into the backreference array.  Return its back reference
 number.  */

4936int
4937trees_in::insert (tree t)
4938{
gcc_checking_assert (t || get_overrun ())((void)(!(t || get_overrun ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4939, __FUNCTION__), 0 : 0));
back_refs.safe_push (t);
return -(int)back_refs.length ();
4942}

4944/* A chained set of decls.  */

4946void
4947trees_out::chained_decls (tree decls)
4948{
for (; decls; decls = DECL_CHAIN (decls)(((contains_struct_check (((contains_struct_check ((decls), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4949, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4949, __FUNCTION__))->common.chain)))
  {
    if (VAR_OR_FUNCTION_DECL_P (decls)(((enum tree_code) (decls)->base.code) == VAR_DECL || ((enum
 tree_code) (decls)->base.code) == FUNCTION_DECL)
 && DECL_LOCAL_DECL_P (decls)((contains_struct_check (((tree_check2 ((decls), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4952, __FUNCTION__, (VAR_DECL), (FUNCTION_DECL)))), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4952, __FUNCTION__))->decl_common.lang_flag_0))
{
 /* Make sure this is the first encounter, and mark for
    walk-by-value.  */
 gcc_checking_assert (!TREE_VISITED (decls)((void)(!(!((decls)->base.visited) && !(((contains_struct_check
 ((template_info_decl_check ((decls), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__), 0 : 0))
	       && !DECL_TEMPLATE_INFO (decls))((void)(!(!((decls)->base.visited) && !(((contains_struct_check
 ((template_info_decl_check ((decls), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4957, __FUNCTION__), 0 : 0));
 mark_by_value (decls);
}
    tree_node (decls);
  }
tree_node (NULL_TREE(tree) nullptr);
4963}

4965tree
4966trees_in::chained_decls ()
4967{
tree decls = NULL_TREE(tree) nullptr;
for (tree *chain = &decls;;)
  if (tree decl = tree_node ())
    {
if (!DECL_P (decl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (decl)->base.code))] == tcc_declaration) || DECL_CHAIN (decl)(((contains_struct_check (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4972, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4972, __FUNCTION__))->common.chain)))
 {
   set_overrun ();
   break;
 }
*chain = decl;
chain = &DECL_CHAIN (decl)(((contains_struct_check (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4978, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4978, __FUNCTION__))->common.chain));
    }
  else
    break;

return decls;
4984}

4986/* A vector of decls following DECL_CHAIN.  */

4988void
4989trees_out::vec_chained_decls (tree decls)
4990{
if (streaming_p ())
  {
    unsigned len = 0;

    for (tree decl = decls; decl; decl = DECL_CHAIN (decl)(((contains_struct_check (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4995, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 4995, __FUNCTION__))->common.chain)))
len++;
    u (len);
  }

for (tree decl = decls; decl; decl = DECL_CHAIN (decl)(((contains_struct_check (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5000, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5000, __FUNCTION__))->common.chain)))
  {
    if (DECL_IMPLICIT_TYPEDEF_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL &&
 ((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5002, __FUNCTION__))->decl_common.lang_flag_2))
 && TYPE_NAME (TREE_TYPE (decl))((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5003, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5003, __FUNCTION__))->type_common.name) != decl)
/* An anonynmous struct with a typedef name.  An odd thing to
  write.  */
tree_node (NULL_TREE(tree) nullptr);
    else
tree_node (decl);
  }
5010}

5012vec<tree, va_heap> *
5013trees_in::vec_chained_decls ()
5014{
vec<tree, va_heap> *v = NULLnullptr;

if (unsigned len = u ())
  {
    vec_alloc (v, len);

    for (unsigned ix = 0; ix < len; ix++)
{
 tree decl = tree_node ();
 if (decl && !DECL_P (decl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (decl)->base.code))] == tcc_declaration))
   {
     set_overrun ();
     break;
   }
 v->quick_push (decl);
}

    if (get_overrun ())
{
 vec_free (v);
 v = NULLnullptr;
}
  }

return v;
5040}

5042/* A vector of trees.  */

5044void
5045trees_out::tree_vec (vec<tree, va_gc> *v)
5046{
unsigned len = vec_safe_length (v);
if (streaming_p ())
  u (len);
for (unsigned ix = 0; ix != len; ix++)
  tree_node ((*v)[ix]);
5052}

5054vec<tree, va_gc> *
5055trees_in::tree_vec ()
5056{
vec<tree, va_gc> *v = NULLnullptr;
if (unsigned len = u ())
  {
    vec_alloc (v, len);
    for (unsigned ix = 0; ix != len; ix++)
v->quick_push (tree_node ());
  }
return v;
5065}

5067/* A vector of tree pairs.  */

5069void
5070trees_out::tree_pair_vec (vec<tree_pair_s, va_gc> *v)
5071{
unsigned len = vec_safe_length (v);
if (streaming_p ())
  u (len);
if (len)
  for (unsigned ix = 0; ix != len; ix++)
    {
tree_pair_s const &s = (*v)[ix];
tree_node (s.purpose);
tree_node (s.value);
    }
5082}

5084vec<tree_pair_s, va_gc> *
5085trees_in::tree_pair_vec ()
5086{
vec<tree_pair_s, va_gc> *v = NULLnullptr;
if (unsigned len = u ())
  {
    vec_alloc (v, len);
    for (unsigned ix = 0; ix != len; ix++)
{
 tree_pair_s s;
 s.purpose = tree_node ();
 s.value = tree_node ();
 v->quick_push (s);
    }
  }
return v;
5100}

5102void
5103trees_out::tree_list (tree list, bool has_purpose)
5104{
for (; list; list = TREE_CHAIN (list)((contains_struct_check ((list), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5105, __FUNCTION__))->common.chain))
  {
    gcc_checking_assert (TREE_VALUE (list))((void)(!(((tree_check ((list), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5107, __FUNCTION__, (TREE_LIST)))->list.value)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5107, __FUNCTION__), 0 : 0));
    tree_node (TREE_VALUE (list)((tree_check ((list), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5108, __FUNCTION__, (TREE_LIST)))->list.value));
    if (has_purpose)
tree_node (TREE_PURPOSE (list)((tree_check ((list), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5110, __FUNCTION__, (TREE_LIST)))->list.purpose));
  }
tree_node (NULL_TREE(tree) nullptr);
5113}

5115tree
5116trees_in::tree_list (bool has_purpose)
5117{
tree res = NULL_TREE(tree) nullptr;

for (tree *chain = &res; tree value = tree_node ();
     chain = &TREE_CHAIN (*chain)((contains_struct_check ((*chain), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5121, __FUNCTION__))->common.chain))
  {
    tree purpose = has_purpose ? tree_node () : NULL_TREE(tree) nullptr;
    *chain = build_tree_list (purpose, value);
  }

return res;
5128}
5129/* Start tree write.  Write information to allocate the receiving
 node.  */

5132void
5133trees_out::start (tree t, bool code_streamed)
5134{
if (TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type))
  {
    enum tree_code code = TREE_CODE (t)((enum tree_code) (t)->base.code);
    gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t)((void)(!(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5138, __FUNCTION__))->type_common.main_variant) == t) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5138, __FUNCTION__), 0 : 0));
    /* All these types are TYPE_NON_COMMON.  */
    gcc_checking_assert (code == RECORD_TYPE((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0))
	   || code == UNION_TYPE((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0))
	   || code == ENUMERAL_TYPE((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0))
	   || code == TEMPLATE_TYPE_PARM((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0))
	   || code == TEMPLATE_TEMPLATE_PARM((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0))
	   || code == BOUND_TEMPLATE_TEMPLATE_PARM)((void)(!(code == RECORD_TYPE || code == UNION_TYPE || code ==
 ENUMERAL_TYPE || code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
 || code == BOUND_TEMPLATE_TEMPLATE_PARM) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5145, __FUNCTION__), 0 : 0));
  }

if (!code_streamed)
  u (TREE_CODE (t)((enum tree_code) (t)->base.code));

switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
  {
  default:
    if (TREE_CODE_CLASS (TREE_CODE (t))tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_vl_exp)
u (VL_EXP_OPERAND_LENGTH (t)((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
 ((t), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5155, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5155, __FUNCTION__)))));
    break;

  case INTEGER_CST:
    u (TREE_INT_CST_NUNITS (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5159, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended
));
    u (TREE_INT_CST_EXT_NUNITS (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5160, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.extended
));
    u (TREE_INT_CST_OFFSET_NUNITS (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5161, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset
));
    break;

  case OMP_CLAUSE:
    state->extensions |= SE_OPENMP;
    u (OMP_CLAUSE_CODE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5166, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.code);
    break;

  case STRING_CST:
    str (TREE_STRING_POINTER (t)((const char *)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5170, __FUNCTION__, (STRING_CST)))->string.str)), TREE_STRING_LENGTH (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5170, __FUNCTION__, (STRING_CST)))->string.length));
    break;

  case VECTOR_CST:
    u (VECTOR_CST_LOG2_NPATTERNS (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5174, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
));
    u (VECTOR_CST_NELTS_PER_PATTERN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5175, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
));
    break;

  case TREE_BINFO:
    u (BINFO_N_BASE_BINFOS (t)((&(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5179, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
length ()));
    break;

  case TREE_VEC:
    u (TREE_VEC_LENGTH (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5183, __FUNCTION__, (TREE_VEC)))->base.u.length));
    break;

  case FIXED_CST:
  case POLY_INT_CST:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5188, __FUNCTION__)); /* Not supported in C++.  */
    break;

  case IDENTIFIER_NODE:
  case SSA_NAME:
  case TARGET_MEM_REF:
  case TRANSLATION_UNIT_DECL:
    /* We shouldn't meet these.  */
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5196, __FUNCTION__));
    break;
  }
5199}

5201/* Start tree read.  Allocate the receiving node.  */

5203tree
5204trees_in::start (unsigned code)
5205{
tree t = NULL_TREE(tree) nullptr;

if (!code)
  code = u ();

switch (code)
  {
  default:
    if (code >= MAX_TREE_CODES)
{
fail:
 set_overrun ();
 return NULL_TREE(tree) nullptr;
}
    else if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] == tcc_vl_exp)
{
 unsigned ops = u ();
 t = build_vl_exp (tree_code (code), ops);
}
    else
t = make_node (tree_code (code));
    break;

  case INTEGER_CST:
    {
unsigned n = u ();
unsigned e = u ();
t = make_int_cst (n, e);
TREE_INT_CST_OFFSET_NUNITS(t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5234, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset
) = u ();
    }
    break;

  case OMP_CLAUSE:
    {
if (!(state->extensions & SE_OPENMP))
 goto fail;

unsigned omp_code = u ();
t = build_omp_clause (UNKNOWN_LOCATION((location_t) 0), omp_clause_code (omp_code));
    }
    break;

  case STRING_CST:
    {
size_t l;
const char *chars = str (&l);
t = build_string (l, chars);
    }
    break;

  case VECTOR_CST:
    {
unsigned log2_npats = u ();
unsigned elts_per = u ();
t = make_vector (log2_npats, elts_per);
    }
    break;

  case TREE_BINFO:
    t = make_tree_binfo (u ());
    break;

  case TREE_VEC:
    t = make_tree_vec (u ());
    break;

  case FIXED_CST:
  case IDENTIFIER_NODE:
  case POLY_INT_CST:
  case SSA_NAME:
  case TARGET_MEM_REF:
  case TRANSLATION_UNIT_DECL:
    goto fail;
  }

return t;
5282}

5284/* The structure streamers access the raw fields, because the
 alternative, of using the accessor macros can require using
 different accessors for the same underlying field, depending on the
 tree code.  That's both confusing and annoying.  */

5289/* Read & write the core boolean flags.  */

5291void
5292trees_out::core_bools (tree t)
5293{
5294#define WB(X) (b (X))
tree_code code = TREE_CODE (t)((enum tree_code) (t)->base.code);

WB (t->base.side_effects_flag);
WB (t->base.constant_flag);
WB (t->base.addressable_flag);
WB (t->base.volatile_flag);
WB (t->base.readonly_flag);
/* base.asm_written_flag is a property of the current TU's use of
   this decl.  */
WB (t->base.nowarning_flag);
/* base.visited read as zero (it's set for writer, because that's
   how we mark nodes).  */
/* base.used_flag is not streamed.  Readers may set TREE_USED of
   decls they use.  */
WB (t->base.nothrow_flag);
WB (t->base.static_flag);
if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] != tcc_type)
  /* This is TYPE_CACHED_VALUES_P for types.  */
  WB (t->base.public_flag);
WB (t->base.private_flag);
WB (t->base.protected_flag);
WB (t->base.deprecated_flag);
WB (t->base.default_def_flag);

switch (code)
  {
  case CALL_EXPR:
  case INTEGER_CST:
  case SSA_NAME:
  case TARGET_MEM_REF:
  case TREE_VEC:
    /* These use different base.u fields.  */
    break;

  default:
    WB (t->base.u.bits.lang_flag_0);
    bool flag_1 = t->base.u.bits.lang_flag_1;
    if (!flag_1)
;
    else if (code == TEMPLATE_INFO)
/* This is TI_PENDING_TEMPLATE_FLAG, not relevant to reader.  */
flag_1 = false;
    else if (code == VAR_DECL)
{
 /* This is DECL_INITIALIZED_P.  */
 if (TREE_CODE (DECL_CONTEXT (t))((enum tree_code) (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5340, __FUNCTION__))->decl_minimal.context))->base.code
) != FUNCTION_DECL)
   /* We'll set this when reading the definition.  */
   flag_1 = false;
}
    WB (flag_1);
    WB (t->base.u.bits.lang_flag_2);
    WB (t->base.u.bits.lang_flag_3);
    WB (t->base.u.bits.lang_flag_4);
    WB (t->base.u.bits.lang_flag_5);
    WB (t->base.u.bits.lang_flag_6);
    WB (t->base.u.bits.saturating_flag);
    WB (t->base.u.bits.unsigned_flag);
    WB (t->base.u.bits.packed_flag);
    WB (t->base.u.bits.user_align);
    WB (t->base.u.bits.nameless_flag);
    WB (t->base.u.bits.atomic_flag);
    break;
  }

if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)(tree_contains_struct[(code)][(TS_TYPE_COMMON)]))
  {
    WB (t->type_common.no_force_blk_flag);
    WB (t->type_common.needs_constructing_flag);
    WB (t->type_common.transparent_aggr_flag);
    WB (t->type_common.restrict_flag);
    WB (t->type_common.string_flag);
    WB (t->type_common.lang_flag_0);
    WB (t->type_common.lang_flag_1);
    WB (t->type_common.lang_flag_2);
    WB (t->type_common.lang_flag_3);
    WB (t->type_common.lang_flag_4);
    WB (t->type_common.lang_flag_5);
    WB (t->type_common.lang_flag_6);
    WB (t->type_common.typeless_storage);
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)(tree_contains_struct[(code)][(TS_DECL_COMMON)]))
  {
    WB (t->decl_common.nonlocal_flag);
    WB (t->decl_common.virtual_flag);
    WB (t->decl_common.ignored_flag);
    WB (t->decl_common.abstract_flag);
    WB (t->decl_common.artificial_flag);
    WB (t->decl_common.preserve_flag);
    WB (t->decl_common.debug_expr_is_from);
    WB (t->decl_common.lang_flag_0);
    WB (t->decl_common.lang_flag_1);
    WB (t->decl_common.lang_flag_2);
    WB (t->decl_common.lang_flag_3);
    WB (t->decl_common.lang_flag_4);
    WB (t->decl_common.lang_flag_5);
    WB (t->decl_common.lang_flag_6);
    WB (t->decl_common.lang_flag_7);
    WB (t->decl_common.lang_flag_8);
    WB (t->decl_common.decl_flag_0);

    {
/* DECL_EXTERNAL -> decl_flag_1
    == it is defined elsewhere
  DECL_NOT_REALLY_EXTERN -> base.not_really_extern
    == that was a lie, it is here  */

bool is_external = t->decl_common.decl_flag_1;
if (!is_external)
 /* decl_flag_1 is DECL_EXTERNAL. Things we emit here, might
    well be external from the POV of an importer.  */
 // FIXME: Do we need to know if this is a TEMPLATE_RESULT --
 // a flag from the caller?
 switch (code)
   {
   default:
     break;

   case VAR_DECL:
     if (TREE_PUBLIC (t)((t)->base.public_flag)
  && !(TREE_STATIC (t)((t)->base.static_flag)
       && DECL_FUNCTION_SCOPE_P (t)(((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5416, __FUNCTION__))->decl_minimal.context) && (
(enum tree_code) (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5416, __FUNCTION__))->decl_minimal.context))->base.code
) == FUNCTION_DECL)
       && DECL_DECLARED_INLINE_P (DECL_CONTEXT (t))((tree_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5417, __FUNCTION__))->decl_minimal.context)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5417, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
))
  && !DECL_VAR_DECLARED_INLINE_P (t)(((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5418, __FUNCTION__, (VAR_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5418, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
 ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5418, __FUNCTION__))->decl_common.lang_specific)->u.base
.var_declared_inline_p : false))
is_external = true;
     break;

   case FUNCTION_DECL:
     if (TREE_PUBLIC (t)((t)->base.public_flag)
  && !DECL_DECLARED_INLINE_P (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5424, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
))
is_external = true;
     break;
   }
WB (is_external);
    }

    WB (t->decl_common.decl_flag_2);
    WB (t->decl_common.decl_flag_3);
    WB (t->decl_common.not_gimple_reg_flag);
    WB (t->decl_common.decl_by_reference_flag);
    WB (t->decl_common.decl_read_flag);
    WB (t->decl_common.decl_nonshareable_flag);
    WB (t->decl_common.decl_not_flexarray);
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)(tree_contains_struct[(code)][(TS_DECL_WITH_VIS)]))
  {
    WB (t->decl_with_vis.defer_output);
    WB (t->decl_with_vis.hard_register);
    WB (t->decl_with_vis.common_flag);
    WB (t->decl_with_vis.in_text_section);
    WB (t->decl_with_vis.in_constant_pool);
    WB (t->decl_with_vis.dllimport_flag);
    WB (t->decl_with_vis.weak_flag);
    WB (t->decl_with_vis.seen_in_bind_expr);
    WB (t->decl_with_vis.comdat_flag);
    WB (t->decl_with_vis.visibility_specified);
    WB (t->decl_with_vis.init_priority_p);
    WB (t->decl_with_vis.shadowed_for_var_p);
    WB (t->decl_with_vis.cxx_constructor);
    WB (t->decl_with_vis.cxx_destructor);
    WB (t->decl_with_vis.final);
    WB (t->decl_with_vis.regdecl_flag);
  }

if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)(tree_contains_struct[(code)][(TS_FUNCTION_DECL)]))
  {
    WB (t->function_decl.static_ctor_flag);
    WB (t->function_decl.static_dtor_flag);
    WB (t->function_decl.uninlinable);
    WB (t->function_decl.possibly_inlined);
    WB (t->function_decl.novops_flag);
    WB (t->function_decl.returns_twice_flag);
    WB (t->function_decl.malloc_flag);
    WB (t->function_decl.declared_inline_flag);
    WB (t->function_decl.no_inline_warning_flag);
    WB (t->function_decl.no_instrument_function_entry_exit);
    WB (t->function_decl.no_limit_stack);
    WB (t->function_decl.disregard_inline_limits);
    WB (t->function_decl.pure_flag);
    WB (t->function_decl.looping_const_or_pure_flag);

    WB (t->function_decl.has_debug_args_flag);
    WB (t->function_decl.versioned_function);

    /* decl_type is a (misnamed) 2 bit discriminator.	 */
    unsigned kind = t->function_decl.decl_type;
    WB ((kind >> 0) & 1);
    WB ((kind >> 1) & 1);
  }
5485#undef WB
5486}

5488bool
5489trees_in::core_bools (tree t)
5490{
5491#define RB(X) ((X) = b ())
tree_code code = TREE_CODE (t)((enum tree_code) (t)->base.code);

RB (t->base.side_effects_flag);
RB (t->base.constant_flag);
RB (t->base.addressable_flag);
RB (t->base.volatile_flag);
RB (t->base.readonly_flag);
/* base.asm_written_flag is not streamed.  */
RB (t->base.nowarning_flag);
/* base.visited is not streamed.  */
/* base.used_flag is not streamed.  */
RB (t->base.nothrow_flag);
RB (t->base.static_flag);
if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] != tcc_type)
  RB (t->base.public_flag);
RB (t->base.private_flag);
RB (t->base.protected_flag);
RB (t->base.deprecated_flag);
RB (t->base.default_def_flag);

switch (code)
  {
  case CALL_EXPR:
  case INTEGER_CST:
  case SSA_NAME:
  case TARGET_MEM_REF:
  case TREE_VEC:
    /* These use different base.u fields.  */
    break;

  default:
    RB (t->base.u.bits.lang_flag_0);
    RB (t->base.u.bits.lang_flag_1);
    RB (t->base.u.bits.lang_flag_2);
    RB (t->base.u.bits.lang_flag_3);
    RB (t->base.u.bits.lang_flag_4);
    RB (t->base.u.bits.lang_flag_5);
    RB (t->base.u.bits.lang_flag_6);
    RB (t->base.u.bits.saturating_flag);
    RB (t->base.u.bits.unsigned_flag);
    RB (t->base.u.bits.packed_flag);
    RB (t->base.u.bits.user_align);
    RB (t->base.u.bits.nameless_flag);
    RB (t->base.u.bits.atomic_flag);
    break;
  }

if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)(tree_contains_struct[(code)][(TS_TYPE_COMMON)]))
  {
    RB (t->type_common.no_force_blk_flag);
    RB (t->type_common.needs_constructing_flag);
    RB (t->type_common.transparent_aggr_flag);
    RB (t->type_common.restrict_flag);
    RB (t->type_common.string_flag);
    RB (t->type_common.lang_flag_0);
    RB (t->type_common.lang_flag_1);
    RB (t->type_common.lang_flag_2);
    RB (t->type_common.lang_flag_3);
    RB (t->type_common.lang_flag_4);
    RB (t->type_common.lang_flag_5);
    RB (t->type_common.lang_flag_6);
    RB (t->type_common.typeless_storage);
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)(tree_contains_struct[(code)][(TS_DECL_COMMON)]))
  {
    RB (t->decl_common.nonlocal_flag);
    RB (t->decl_common.virtual_flag);
    RB (t->decl_common.ignored_flag);
    RB (t->decl_common.abstract_flag);
    RB (t->decl_common.artificial_flag);
    RB (t->decl_common.preserve_flag);
    RB (t->decl_common.debug_expr_is_from);
    RB (t->decl_common.lang_flag_0);
    RB (t->decl_common.lang_flag_1);
    RB (t->decl_common.lang_flag_2);
    RB (t->decl_common.lang_flag_3);
    RB (t->decl_common.lang_flag_4);
    RB (t->decl_common.lang_flag_5);
    RB (t->decl_common.lang_flag_6);
    RB (t->decl_common.lang_flag_7);
    RB (t->decl_common.lang_flag_8);
    RB (t->decl_common.decl_flag_0);
    RB (t->decl_common.decl_flag_1);
    RB (t->decl_common.decl_flag_2);
    RB (t->decl_common.decl_flag_3);
    RB (t->decl_common.not_gimple_reg_flag);
    RB (t->decl_common.decl_by_reference_flag);
    RB (t->decl_common.decl_read_flag);
    RB (t->decl_common.decl_nonshareable_flag);
    RB (t->decl_common.decl_not_flexarray);
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)(tree_contains_struct[(code)][(TS_DECL_WITH_VIS)]))
  {
    RB (t->decl_with_vis.defer_output);
    RB (t->decl_with_vis.hard_register);
    RB (t->decl_with_vis.common_flag);
    RB (t->decl_with_vis.in_text_section);
    RB (t->decl_with_vis.in_constant_pool);
    RB (t->decl_with_vis.dllimport_flag);
    RB (t->decl_with_vis.weak_flag);
    RB (t->decl_with_vis.seen_in_bind_expr);
    RB (t->decl_with_vis.comdat_flag);
    RB (t->decl_with_vis.visibility_specified);
    RB (t->decl_with_vis.init_priority_p);
    RB (t->decl_with_vis.shadowed_for_var_p);
    RB (t->decl_with_vis.cxx_constructor);
    RB (t->decl_with_vis.cxx_destructor);
    RB (t->decl_with_vis.final);
    RB (t->decl_with_vis.regdecl_flag);
  }

if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)(tree_contains_struct[(code)][(TS_FUNCTION_DECL)]))
  {
    RB (t->function_decl.static_ctor_flag);
    RB (t->function_decl.static_dtor_flag);
    RB (t->function_decl.uninlinable);
    RB (t->function_decl.possibly_inlined);
    RB (t->function_decl.novops_flag);
    RB (t->function_decl.returns_twice_flag);
    RB (t->function_decl.malloc_flag);
    RB (t->function_decl.declared_inline_flag);
    RB (t->function_decl.no_inline_warning_flag);
    RB (t->function_decl.no_instrument_function_entry_exit);
    RB (t->function_decl.no_limit_stack);
    RB (t->function_decl.disregard_inline_limits);
    RB (t->function_decl.pure_flag);
    RB (t->function_decl.looping_const_or_pure_flag);
    
    RB (t->function_decl.has_debug_args_flag);
    RB (t->function_decl.versioned_function);

    /* decl_type is a (misnamed) 2 bit discriminator.	 */
    unsigned kind = 0;
    kind |= unsigned (b ()) << 0;
    kind |= unsigned (b ()) << 1;
    t->function_decl.decl_type = function_decl_type (kind);
  }
5631#undef RB
return !get_overrun ();
5633}

5635void
5636trees_out::lang_decl_bools (tree t)
5637{
5638#define WB(X) (b (X))
const struct lang_decl *lang = DECL_LANG_SPECIFIC (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5639, __FUNCTION__))->decl_common.lang_specific);

WB (lang->u.base.language == lang_cplusplus);
1
Assuming field 'language' is not equal to lang_cplusplus→
WB ((lang->u.base.use_template >> 0) & 1);
WB ((lang->u.base.use_template >> 1) & 1);
2
←
Calling 'bytes_out::b'→
/* Do not write lang->u.base.not_really_extern, importer will set
   when reading the definition (if any).  */
WB (lang->u.base.initialized_in_class);
WB (lang->u.base.threadprivate_or_deleted_p);
/* Do not write lang->u.base.anticipated_p, it is a property of the
   current TU.  */
WB (lang->u.base.friend_or_tls);
WB (lang->u.base.unknown_bound_p);
/* Do not write lang->u.base.odr_used, importer will recalculate if
   they do ODR use this decl.  */
WB (lang->u.base.concept_p);
WB (lang->u.base.var_declared_inline_p);
WB (lang->u.base.dependent_init_p);
/* When building a header unit, everthing is marked as purview, (so
   we know which decls to write).  But when we import them we do not
   want to mark them as in module purview.  */
WB (lang->u.base.module_purview_p && !header_module_p ());
WB (lang->u.base.module_attach_p);
if (VAR_OR_FUNCTION_DECL_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL || ((enum tree_code
) (t)->base.code) == FUNCTION_DECL))
  WB (lang->u.base.module_keyed_decls_p);
switch (lang->u.base.selector)
  {
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5667, __FUNCTION__));

  case lds_fn:  /* lang_decl_fn.  */
    WB (lang->u.fn.global_ctor_p);
    WB (lang->u.fn.global_dtor_p);
    WB (lang->u.fn.static_function);
    WB (lang->u.fn.pure_virtual);
    WB (lang->u.fn.defaulted_p);
    WB (lang->u.fn.has_in_charge_parm_p);
    WB (lang->u.fn.has_vtt_parm_p);
    /* There shouldn't be a pending inline at this point.  */
    gcc_assert (!lang->u.fn.pending_inline_p)((void)(!(!lang->u.fn.pending_inline_p) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5678, __FUNCTION__), 0 : 0));
    WB (lang->u.fn.nonconverting);
    WB (lang->u.fn.thunk_p);
    WB (lang->u.fn.this_thunk_p);
    /* Do not stream lang->u.hidden_friend_p, it is a property of
the TU.  */
    WB (lang->u.fn.omp_declare_reduction_p);
    WB (lang->u.fn.has_dependent_explicit_spec_p);
    WB (lang->u.fn.immediate_fn_p);
    WB (lang->u.fn.maybe_deleted);
    goto lds_min;

  case lds_decomp:  /* lang_decl_decomp.  */
    /* No bools.  */
    goto lds_min;

  case lds_min:  /* lang_decl_min.  */
  lds_min:
    /* No bools.  */
    break;

  case lds_ns:  /* lang_decl_ns.  */
    /* No bools.  */
    break;

  case lds_parm:  /* lang_decl_parm.  */
    /* No bools.  */
    break;
  }
5707#undef WB
5708}

5710bool
5711trees_in::lang_decl_bools (tree t)
5712{
5713#define RB(X) ((X) = b ())
struct lang_decl *lang = DECL_LANG_SPECIFIC (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5714, __FUNCTION__))->decl_common.lang_specific);

lang->u.base.language = b () ? lang_cplusplus : lang_c;
unsigned v;
v = b () << 0;
v |= b () << 1;
lang->u.base.use_template = v;
/* lang->u.base.not_really_extern is not streamed.  */
RB (lang->u.base.initialized_in_class);
RB (lang->u.base.threadprivate_or_deleted_p);
/* lang->u.base.anticipated_p is not streamed.  */
RB (lang->u.base.friend_or_tls);
RB (lang->u.base.unknown_bound_p);
/* lang->u.base.odr_used is not streamed.  */
RB (lang->u.base.concept_p);
RB (lang->u.base.var_declared_inline_p);
RB (lang->u.base.dependent_init_p);
RB (lang->u.base.module_purview_p);
RB (lang->u.base.module_attach_p);
if (VAR_OR_FUNCTION_DECL_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL || ((enum tree_code
) (t)->base.code) == FUNCTION_DECL))
  RB (lang->u.base.module_keyed_decls_p);
switch (lang->u.base.selector)
  {
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5738, __FUNCTION__));

  case lds_fn:  /* lang_decl_fn.  */
    RB (lang->u.fn.global_ctor_p);
    RB (lang->u.fn.global_dtor_p);
    RB (lang->u.fn.static_function);
    RB (lang->u.fn.pure_virtual);
    RB (lang->u.fn.defaulted_p);
    RB (lang->u.fn.has_in_charge_parm_p);
    RB (lang->u.fn.has_vtt_parm_p);
    RB (lang->u.fn.nonconverting);
    RB (lang->u.fn.thunk_p);
    RB (lang->u.fn.this_thunk_p);
    /* lang->u.fn.hidden_friend_p is not streamed.  */
    RB (lang->u.fn.omp_declare_reduction_p);
    RB (lang->u.fn.has_dependent_explicit_spec_p);
    RB (lang->u.fn.immediate_fn_p);
    RB (lang->u.fn.maybe_deleted);
    goto lds_min;

  case lds_decomp:  /* lang_decl_decomp.  */
    /* No bools.  */
    goto lds_min;

  case lds_min:  /* lang_decl_min.  */
  lds_min:
    /* No bools.  */
    break;

  case lds_ns:  /* lang_decl_ns.  */
    /* No bools.  */
    break;

  case lds_parm:  /* lang_decl_parm.  */
    /* No bools.  */
    break;
  }
5775#undef RB
return !get_overrun ();
5777}

5779void
5780trees_out::lang_type_bools (tree t)
5781{
5782#define WB(X) (b (X))
const struct lang_type *lang = TYPE_LANG_SPECIFIC (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5783, __FUNCTION__))->type_with_lang_specific.lang_specific
);

WB (lang->has_type_conversion);
WB (lang->has_copy_ctor);
WB (lang->has_default_ctor);
WB (lang->const_needs_init);
WB (lang->ref_needs_init);
WB (lang->has_const_copy_assign);
WB ((lang->use_template >> 0) & 1);
WB ((lang->use_template >> 1) & 1);

WB (lang->has_mutable);
WB (lang->com_interface);
WB (lang->non_pod_class);
WB (lang->nearly_empty_p);
WB (lang->user_align);
WB (lang->has_copy_assign);
WB (lang->has_new);
WB (lang->has_array_new);

WB ((lang->gets_delete >> 0) & 1);
WB ((lang->gets_delete >> 1) & 1);
// Interfaceness is recalculated upon reading.  May have to revisit?
// How do dllexport and dllimport interact across a module?
// lang->interface_only
// lang->interface_unknown
WB (lang->contains_empty_class_p);
WB (lang->anon_aggr);
WB (lang->non_zero_init);
WB (lang->empty_p);

WB (lang->vec_new_uses_cookie);
WB (lang->declared_class);
WB (lang->diamond_shaped);
WB (lang->repeated_base);
gcc_assert (!lang->being_defined)((void)(!(!lang->being_defined) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5818, __FUNCTION__), 0 : 0));
// lang->debug_requested
WB (lang->fields_readonly);
WB (lang->ptrmemfunc_flag);

WB (lang->lazy_default_ctor);
WB (lang->lazy_copy_ctor);
WB (lang->lazy_copy_assign);
WB (lang->lazy_destructor);
WB (lang->has_const_copy_ctor);
WB (lang->has_complex_copy_ctor);
WB (lang->has_complex_copy_assign);
WB (lang->non_aggregate);

WB (lang->has_complex_dflt);
WB (lang->has_list_ctor);
WB (lang->non_std_layout);
WB (lang->is_literal);
WB (lang->lazy_move_ctor);
WB (lang->lazy_move_assign);
WB (lang->has_complex_move_ctor);
WB (lang->has_complex_move_assign);

WB (lang->has_constexpr_ctor);
WB (lang->unique_obj_representations);
WB (lang->unique_obj_representations_set);
5844#undef WB
5845}

5847bool
5848trees_in::lang_type_bools (tree t)
5849{
5850#define RB(X) ((X) = b ())
struct lang_type *lang = TYPE_LANG_SPECIFIC (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5851, __FUNCTION__))->type_with_lang_specific.lang_specific
);

RB (lang->has_type_conversion);
RB (lang->has_copy_ctor);
RB (lang->has_default_ctor);
RB (lang->const_needs_init);
RB (lang->ref_needs_init);
RB (lang->has_const_copy_assign);
unsigned v;
v = b () << 0;
v |= b () << 1;
lang->use_template = v;

RB (lang->has_mutable);
RB (lang->com_interface);
RB (lang->non_pod_class);
RB (lang->nearly_empty_p);
RB (lang->user_align);
RB (lang->has_copy_assign);
RB (lang->has_new);
RB (lang->has_array_new);

v = b () << 0;
v |= b () << 1;
lang->gets_delete = v;
// lang->interface_only
// lang->interface_unknown
lang->interface_unknown = true; // Redetermine interface
RB (lang->contains_empty_class_p);
RB (lang->anon_aggr);
RB (lang->non_zero_init);
RB (lang->empty_p);

RB (lang->vec_new_uses_cookie);
RB (lang->declared_class);
RB (lang->diamond_shaped);
RB (lang->repeated_base);
gcc_assert (!lang->being_defined)((void)(!(!lang->being_defined) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5888, __FUNCTION__), 0 : 0));
gcc_assert (!lang->debug_requested)((void)(!(!lang->debug_requested) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5889, __FUNCTION__), 0 : 0));
RB (lang->fields_readonly);
RB (lang->ptrmemfunc_flag);

RB (lang->lazy_default_ctor);
RB (lang->lazy_copy_ctor);
RB (lang->lazy_copy_assign);
RB (lang->lazy_destructor);
RB (lang->has_const_copy_ctor);
RB (lang->has_complex_copy_ctor);
RB (lang->has_complex_copy_assign);
RB (lang->non_aggregate);

RB (lang->has_complex_dflt);
RB (lang->has_list_ctor);
RB (lang->non_std_layout);
RB (lang->is_literal);
RB (lang->lazy_move_ctor);
RB (lang->lazy_move_assign);
RB (lang->has_complex_move_ctor);
RB (lang->has_complex_move_assign);

RB (lang->has_constexpr_ctor);
RB (lang->unique_obj_representations);
RB (lang->unique_obj_representations_set);
5914#undef RB
return !get_overrun ();
5916}

5918/* Read & write the core values and pointers.  */

5920void
5921trees_out::core_vals (tree t)
5922{
5923#define WU(X) (u (X))
5924#define WT(X) (tree_node (X))
tree_code code = TREE_CODE (t)((enum tree_code) (t)->base.code);

/* First by shape of the tree.  */

if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)(tree_contains_struct[(code)][(TS_DECL_MINIMAL)]))
  {
    /* Write this early, for better log information.  */
    WT (t->decl_minimal.name);
    if (!DECL_TEMPLATE_PARM_P (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5933, __FUNCTION__))->decl_common.lang_flag_0) &&
 (((enum tree_code) (t)->base.code) == CONST_DECL || ((enum
 tree_code) (t)->base.code) == PARM_DECL || ((enum tree_code
) (t)->base.code) == TYPE_DECL || ((enum tree_code) (t)->
base.code) == TEMPLATE_DECL)))
WT (t->decl_minimal.context);

    if (state)
state->write_location (*this, t->decl_minimal.locus);
  }

if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)(tree_contains_struct[(code)][(TS_TYPE_COMMON)]))
  {
    /* The only types we write also have TYPE_NON_COMMON.  */
    gcc_checking_assert (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))((void)(!((tree_contains_struct[(code)][(TS_TYPE_NON_COMMON)]
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5943, __FUNCTION__), 0 : 0));

    /* We only stream the main variant.  */
    gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t)((void)(!(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5946, __FUNCTION__))->type_common.main_variant) == t) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5946, __FUNCTION__), 0 : 0));

    /* Stream the name & context first, for better log information  */
    WT (t->type_common.name);
    WT (t->type_common.context);

    /* By construction we want to make sure we have the canonical
and main variants already in the type table, so emit them
now.  */
    WT (t->type_common.main_variant);

    tree canonical = t->type_common.canonical;
    if (canonical && DECL_TEMPLATE_PARM_P (TYPE_NAME (t))(((contains_struct_check ((((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->decl_common.lang_flag_0) &&
 (((enum tree_code) (((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->type_common.name))->base.code) ==
 CONST_DECL || ((enum tree_code) (((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->type_common.name))->base.code) ==
 PARM_DECL || ((enum tree_code) (((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->type_common.name))->base.code) ==
 TYPE_DECL || ((enum tree_code) (((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/module.cc"
, 5958, __FUNCTION__))->type_common.name))->base.code) ==
 TEMPLATE_DECL)))
/* We do not want to wander into different templates.
  Reconstructed on stream in.  */
canonical = t;
    WT (canonical);

    /* type_common.next_variant is internally manipulated.  */
    /* type_common.pointer_to, type_common.reference_to.  */

    if (streaming_p ())
{
 WU (t->type_common.precision);
 WU (t->type_common.contains_placeholder_bits);
 WU (t->type_common.mode);
 WU (t->type_common.align);
}

    if (!RECORD_OR_UNION_CODE_P (code)((code) == RECORD_TYPE || (code) == UNION_TYPE))
{
 WT (t->type_common.size);
 WT (t->type_common.size_unit);
}
    WT (t->type_common.attributes);

    WT (t->type_common.common.chain); /* TYPE_STUB_DECL.  */
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)(tree_contains_struct[(code)][(TS_DECL_COMMON)]))
  {
    if (streaming_p ())
{
 WU (t->decl_common.mode);
 WU (t->decl_common.off_align);
 WU (t->decl_common.align);
}

    /* For templates these hold instantiation (partial and/or
specialization) information.  */
    if (code != TEMPLATE_DECL)
{
 WT (t->decl_common.size);
 WT (t->decl_common.size_unit);
}

    WT (t->decl_common.attributes);
    // FIXME: Does this introduce cross-decl links?  For instance
    // from instantiation to the template.  If so, we'll need more
    // deduplication logic.  I think we'll need to walk the blocks
    // of the owning function_decl's abstract origin in tandem, to
    // generate the locating data needed?
    WT (t->decl_common.abstract_origin);
  }

if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)(tree_contains_struct[(code)][(TS_DECL_WITH_VIS)]))
  {
    WT (t->decl_with_vis.assembler_name);
    if (streaming_p ())
WU (t->decl_with_vis.visibility);
  }

if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)(tree_contains_struct[(code)][(TS_TYPE_NON_COMMON)]))
  {
    if (code == ENUMERAL_TYPE)
{
 /* These fields get set even for opaque enums that lack a
    definition, so we stream them directly for each ENUMERAL_TYPE.
    We stream TYPE_VALUES as part of the definition.  */
 WT (t->type_non_common.maxval);
 WT (t->type_non_common.minval);
}
    /* Records and unions hold FIELDS, VFIELD & BINFO on these
things.  */
    else if (!RECORD_OR_UNION_CODE_P (code)((code) == RECORD_TYPE || (code) == UNION_TYPE))
{
 // FIXME: These are from tpl_parm_value's 'type' writing.
 // Perhaps it should just be doing them directly?